/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/serializer.py

  • Committer: Jelmer Vernooij
  • Date: 2017-06-08 23:30:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170608233031-3qavls2o7a1pqllj
Update imports.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/serializer.py
16
16
 
17
17
"""Inventory/revision serialization."""
18
18
 
19
 
from .. import errors, registry
20
 
 
21
 
 
22
 
class BadInventoryFormat(errors.BzrError):
23
 
 
24
 
    _fmt = "Root class for inventory serialization errors"
25
 
 
26
 
 
27
 
class UnexpectedInventoryFormat(BadInventoryFormat):
28
 
 
29
 
    _fmt = "The inventory was not in the expected format:\n %(msg)s"
30
 
 
31
 
    def __init__(self, msg):
32
 
        BadInventoryFormat.__init__(self, msg=msg)
33
 
 
34
 
 
35
 
class UnsupportedInventoryKind(errors.BzrError):
36
 
 
37
 
    _fmt = """Unsupported entry kind %(kind)s"""
38
 
 
39
 
    def __init__(self, kind):
40
 
        self.kind = kind
 
19
from __future__ import absolute_import
 
20
 
 
21
from . import registry
41
22
 
42
23
 
43
24
class Serializer(object):
53
34
        """
54
35
        raise NotImplementedError(self.write_inventory)
55
36
 
56
 
    def write_inventory_to_chunks(self, inv):
57
 
        """Produce a simple bytestring chunk representation of an inventory.
58
 
 
59
 
        Note: this is a *whole inventory* operation, and should only be used
60
 
        sparingly, as it does not scale well with large trees.
61
 
 
62
 
        The requirement for the contents of the string is that it can be passed
63
 
        to read_inventory_from_lines and the result is an identical inventory
64
 
        in memory.
65
 
        """
66
 
        raise NotImplementedError(self.write_inventory_to_chunks)
67
 
 
68
 
    def write_inventory_to_lines(self, inv):
69
 
        """Produce a simple lines representation of an inventory.
70
 
 
71
 
        Note: this is a *whole inventory* operation, and should only be used
72
 
        sparingly, as it does not scale well with large trees.
73
 
 
74
 
        The requirement for the contents of the string is that it can be passed
75
 
        to read_inventory_from_lines and the result is an identical inventory
76
 
        in memory.
77
 
        """
78
 
        raise NotImplementedError(self.write_inventory_to_lines)
79
 
 
80
 
    def read_inventory_from_lines(self, lines, revision_id=None,
81
 
                                  entry_cache=None, return_from_cache=False):
82
 
        """Read bytestring chunks into an inventory object.
83
 
 
84
 
        :param lines: The serialized inventory to read.
 
37
    def write_inventory_to_string(self, inv):
 
38
        """Produce a simple string representation of an inventory.
 
39
 
 
40
        Note: this is a *whole inventory* operation, and should only be used
 
41
        sparingly, as it does not scale well with large trees.
 
42
 
 
43
        The requirement for the contents of the string is that it can be passed
 
44
        to read_inventory_from_string and the result is an identical inventory
 
45
        in memory.
 
46
 
 
47
        (All serializers as of 2009-07-29 produce XML, but this is not mandated
 
48
        by the interface.)
 
49
        """
 
50
        raise NotImplementedError(self.write_inventory_to_string)
 
51
 
 
52
    def read_inventory_from_string(self, string, revision_id=None,
 
53
                                   entry_cache=None, return_from_cache=False):
 
54
        """Read string into an inventory object.
 
55
 
 
56
        :param string: The serialized inventory to read.
85
57
        :param revision_id: If not-None, the expected revision id of the
86
58
            inventory. Some serialisers use this to set the results' root
87
59
            revision. This should be supplied for deserialising all
97
69
            promises not to mutate the returned inventory entries, but it can
98
70
            make some operations significantly faster.
99
71
        """
100
 
        raise NotImplementedError(self.read_inventory_from_lines)
 
72
        raise NotImplementedError(self.read_inventory_from_string)
101
73
 
102
74
    def read_inventory(self, f, revision_id=None):
103
 
        """See read_inventory_from_lines."""
 
75
        """See read_inventory_from_string."""
104
76
        raise NotImplementedError(self.read_inventory)
105
77
 
 
78
    def write_revision(self, rev, f):
 
79
        raise NotImplementedError(self.write_revision)
 
80
 
106
81
    def write_revision_to_string(self, rev):
107
82
        raise NotImplementedError(self.write_revision_to_string)
108
83
 
109
 
    def write_revision_to_lines(self, rev):
110
 
        raise NotImplementedError(self.write_revision_to_lines)
111
 
 
112
84
    def read_revision(self, f):
113
85
        raise NotImplementedError(self.read_revision)
114
86
 
126
98
format_registry.register_lazy('7', 'breezy.bzr.xml7', 'serializer_v7')
127
99
format_registry.register_lazy('8', 'breezy.bzr.xml8', 'serializer_v8')
128
100
format_registry.register_lazy('9', 'breezy.bzr.chk_serializer',
129
 
                              'chk_serializer_255_bigpage')
 
101
    'chk_serializer_255_bigpage')
130
102
format_registry.register_lazy('10', 'breezy.bzr.chk_serializer',
131
 
                              'chk_bencode_serializer')
 
103
    'chk_bencode_serializer')