source: pyyaml/trunk/lib/yaml/serializer.py @ 139

Revision 139, 4.6 KB checked in by xi, 9 years ago (diff)

Add constructors for some simple python types.

RevLine 
[133]1
2__all__ = ['Serializer', 'SerializerError']
3
4from error import YAMLError
5from events import *
6from nodes import *
7
8class SerializerError(YAMLError):
9    pass
10
11class Serializer:
12
13    ANCHOR_TEMPLATE = u'id%03d'
14
[136]15    def __init__(self, encoding=None,
16            explicit_start=None, explicit_end=None, version=None, tags=None):
17        self.use_encoding = encoding
18        self.use_explicit_start = explicit_start
19        self.use_explicit_end = explicit_end
20        self.use_version = version
21        self.use_tags = tags
[133]22        self.serialized_nodes = {}
23        self.anchors = {}
24        self.last_anchor_id = 0
25        self.closed = None
26
[136]27    def open(self):
[133]28        if self.closed is None:
[136]29            self.emit(StreamStartEvent(encoding=self.use_encoding))
[133]30            self.closed = False
31        elif self.closed:
32            raise SerializerError("serializer is closed")
33        else:
34            raise SerializerError("serializer is already opened")
35
36    def close(self):
37        if self.closed is None:
38            raise SerializerError("serializer is not opened")
39        elif not self.closed:
[136]40            self.emit(StreamEndEvent())
[133]41            self.closed = True
42
[136]43    #def __del__(self):
44    #    self.close()
[133]45
[136]46    def serialize(self, node):
[133]47        if self.closed is None:
48            raise SerializerError("serializer is not opened")
49        elif self.closed:
50            raise SerializerError("serializer is closed")
[136]51        self.emit(DocumentStartEvent(explicit=self.use_explicit_start,
52            version=self.use_version, tags=self.use_tags))
[133]53        self.anchor_node(node)
[137]54        self.serialize_node(node, None, None)
[136]55        self.emit(DocumentEndEvent(explicit=self.use_explicit_end))
[133]56        self.serialized_nodes = {}
57        self.anchors = {}
58        self.last_alias_id = 0
59
60    def anchor_node(self, node):
61        if node in self.anchors:
62            if self.anchors[node] is None:
63                self.anchors[node] = self.generate_anchor(node)
64        else:
65            self.anchors[node] = None
66            if isinstance(node, SequenceNode):
67                for item in node.value:
68                    self.anchor_node(item)
69            elif isinstance(node, MappingNode):
[139]70                if hasattr(node.value, 'keys'):
71                    for key in node.value.keys():
72                        self.anchor_node(key)
73                        self.anchor_node(node.value[key])
74                else:
75                    for key, value in node.value:
76                        self.anchor_node(key)
77                        self.anchor_node(value)
[133]78
79    def generate_anchor(self, node):
80        self.last_anchor_id += 1
81        return self.ANCHOR_TEMPLATE % self.last_anchor_id
82
[137]83    def serialize_node(self, node, parent, index):
[133]84        alias = self.anchors[node]
85        if node in self.serialized_nodes:
[136]86            self.emit(AliasEvent(alias))
[133]87        else:
88            self.serialized_nodes[node] = True
[137]89            self.descend_resolver(parent, index)
[133]90            if isinstance(node, ScalarNode):
[137]91                detected_tag = self.resolve(ScalarNode, node.value, (True, False))
92                default_tag = self.resolve(ScalarNode, node.value, (False, True))
93                implicit = (node.tag == detected_tag), (node.tag == default_tag)
[136]94                self.emit(ScalarEvent(alias, node.tag, implicit, node.value,
95                    style=node.style))
[133]96            elif isinstance(node, SequenceNode):
[137]97                implicit = (node.tag
98                            == self.resolve(SequenceNode, node.value, True))
99                self.emit(SequenceStartEvent(alias, node.tag, implicit,
[133]100                    flow_style=node.flow_style))
[137]101                index = 0
[133]102                for item in node.value:
[137]103                    self.serialize_node(item, node, index)
104                    index += 1
[136]105                self.emit(SequenceEndEvent())
[133]106            elif isinstance(node, MappingNode):
[137]107                implicit = (node.tag
108                            == self.resolve(MappingNode, node.value, True))
109                self.emit(MappingStartEvent(alias, node.tag, implicit,
[133]110                    flow_style=node.flow_style))
[136]111                if hasattr(node.value, 'keys'):
112                    for key in node.value.keys():
[137]113                        self.serialize_node(key, node, None)
114                        self.serialize_node(node.value[key], node, key)
[136]115                else:
116                    for key, value in node.value:
[137]117                        self.serialize_node(key, node, None)
118                        self.serialize_node(value, node, key)
[136]119                self.emit(MappingEndEvent())
[137]120            self.ascend_resolver()
[133]121
Note: See TracBrowser for help on using the repository browser.