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.

Line 
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
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
22        self.serialized_nodes = {}
23        self.anchors = {}
24        self.last_anchor_id = 0
25        self.closed = None
26
27    def open(self):
28        if self.closed is None:
29            self.emit(StreamStartEvent(encoding=self.use_encoding))
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:
40            self.emit(StreamEndEvent())
41            self.closed = True
42
43    #def __del__(self):
44    #    self.close()
45
46    def serialize(self, node):
47        if self.closed is None:
48            raise SerializerError("serializer is not opened")
49        elif self.closed:
50            raise SerializerError("serializer is closed")
51        self.emit(DocumentStartEvent(explicit=self.use_explicit_start,
52            version=self.use_version, tags=self.use_tags))
53        self.anchor_node(node)
54        self.serialize_node(node, None, None)
55        self.emit(DocumentEndEvent(explicit=self.use_explicit_end))
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):
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)
78
79    def generate_anchor(self, node):
80        self.last_anchor_id += 1
81        return self.ANCHOR_TEMPLATE % self.last_anchor_id
82
83    def serialize_node(self, node, parent, index):
84        alias = self.anchors[node]
85        if node in self.serialized_nodes:
86            self.emit(AliasEvent(alias))
87        else:
88            self.serialized_nodes[node] = True
89            self.descend_resolver(parent, index)
90            if isinstance(node, ScalarNode):
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)
94                self.emit(ScalarEvent(alias, node.tag, implicit, node.value,
95                    style=node.style))
96            elif isinstance(node, SequenceNode):
97                implicit = (node.tag
98                            == self.resolve(SequenceNode, node.value, True))
99                self.emit(SequenceStartEvent(alias, node.tag, implicit,
100                    flow_style=node.flow_style))
101                index = 0
102                for item in node.value:
103                    self.serialize_node(item, node, index)
104                    index += 1
105                self.emit(SequenceEndEvent())
106            elif isinstance(node, MappingNode):
107                implicit = (node.tag
108                            == self.resolve(MappingNode, node.value, True))
109                self.emit(MappingStartEvent(alias, node.tag, implicit,
110                    flow_style=node.flow_style))
111                if hasattr(node.value, 'keys'):
112                    for key in node.value.keys():
113                        self.serialize_node(key, node, None)
114                        self.serialize_node(node.value[key], node, key)
115                else:
116                    for key, value in node.value:
117                        self.serialize_node(key, node, None)
118                        self.serialize_node(value, node, key)
119                self.emit(MappingEndEvent())
120            self.ascend_resolver()
121
Note: See TracBrowser for help on using the repository browser.