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

Revision 137, 4.3 KB checked in by xi, 9 years ago (diff)

Refactor resolver.

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):
70                for key in node.value:
71                    self.anchor_node(key)
72                    self.anchor_node(node.value[key])
73
74    def generate_anchor(self, node):
75        self.last_anchor_id += 1
76        return self.ANCHOR_TEMPLATE % self.last_anchor_id
77
[137]78    def serialize_node(self, node, parent, index):
[133]79        alias = self.anchors[node]
80        if node in self.serialized_nodes:
[136]81            self.emit(AliasEvent(alias))
[133]82        else:
83            self.serialized_nodes[node] = True
[137]84            self.descend_resolver(parent, index)
[133]85            if isinstance(node, ScalarNode):
[137]86                detected_tag = self.resolve(ScalarNode, node.value, (True, False))
87                default_tag = self.resolve(ScalarNode, node.value, (False, True))
88                implicit = (node.tag == detected_tag), (node.tag == default_tag)
[136]89                self.emit(ScalarEvent(alias, node.tag, implicit, node.value,
90                    style=node.style))
[133]91            elif isinstance(node, SequenceNode):
[137]92                implicit = (node.tag
93                            == self.resolve(SequenceNode, node.value, True))
94                self.emit(SequenceStartEvent(alias, node.tag, implicit,
[133]95                    flow_style=node.flow_style))
[137]96                index = 0
[133]97                for item in node.value:
[137]98                    self.serialize_node(item, node, index)
99                    index += 1
[136]100                self.emit(SequenceEndEvent())
[133]101            elif isinstance(node, MappingNode):
[137]102                implicit = (node.tag
103                            == self.resolve(MappingNode, node.value, True))
104                self.emit(MappingStartEvent(alias, node.tag, implicit,
[133]105                    flow_style=node.flow_style))
[136]106                if hasattr(node.value, 'keys'):
107                    for key in node.value.keys():
[137]108                        self.serialize_node(key, node, None)
109                        self.serialize_node(node.value[key], node, key)
[136]110                else:
111                    for key, value in node.value:
[137]112                        self.serialize_node(key, node, None)
113                        self.serialize_node(value, node, key)
[136]114                self.emit(MappingEndEvent())
[137]115            self.ascend_resolver()
[133]116
Note: See TracBrowser for help on using the repository browser.