/brz/remove-bazaar

# Copyright (C) 2008 Canonical Ltd

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

"""Serializer object for CHK based inventory storage."""

from cStringIO import (

    StringIO,

    )

from bzrlib import (

    cache_utf8,

    inventory,

    osutils,

    revision as _mod_revision,

    rio,

    xml5,

    xml6,

    )

class RIORevisionSerializer1(object):

    """Simple line-based revision serializer. 

    This writes simple key/value pairs for all elements on the revision, 

    each on a separate line and using colons to separate key and value. Newlines

    are backslash-escaped where necessary.

    The commit message is always serialized last and can span multiple lines.

    """

    def write_revision(self, rev, f):

        decode_utf8 = cache_utf8.decode

        w = rio.RioWriter(f)

        s = rio.Stanza()

        revision_id = rev.revision_id

        if isinstance(revision_id, str):

            revision_id = decode_utf8(revision_id)

        s.add("revision-id", revision_id)

        s.add("timestamp", "%.3f" % rev.timestamp)

        if rev.parent_ids:

            s.add("parent-ids", 

                " ".join([decode_utf8(p) for p in rev.parent_ids]))

        s.add("inventory-sha1", rev.inventory_sha1)

        s.add("committer", rev.committer)

        if rev.timezone is not None:

            s.add("timezone", str(rev.timezone))

        if rev.properties:

            revprops_stanza = rio.Stanza()

            for k, v in rev.properties.iteritems():

                if isinstance(v, str):

                    v = decode_utf8(v)

                revprops_stanza.add(decode_utf8(k), v)

            s.add("properties", revprops_stanza.to_unicode())

        s.add("message", rev.message)

        w.write_stanza(s)

    def write_revision_to_string(self, rev):

        f = StringIO()

        self.write_revision(rev, f)

        return f.getvalue()

    def read_revision(self, f):

        s = rio.read_stanza(f)

        rev = _mod_revision.Revision(None)

        for (field, value) in s.iter_pairs():

            if field == "revision-id":

                rev.revision_id = cache_utf8.encode(value)

            elif field == "parent-ids":

                rev.parent_ids = [cache_utf8.encode(p) for p in value.split(" ")]

            elif field == "committer":

                rev.committer = value

            elif field == "inventory-sha1":

                rev.inventory_sha1 = value

            elif field == "timezone":

                rev.timezone = int(value)

            elif field == "timestamp":

                rev.timestamp = float(value)

            elif field == "message":

                rev.message = value

            elif field == "properties":

                rev.properties = rio.read_stanza_unicode(

                    osutils.split_lines(value)).as_dict()

            else:

                raise AssertionError("Unknown field %s" % field)

            l = f.readline()

        return rev

    def read_revision_from_string(self, xml_string):

        f = StringIO(xml_string)

        rev = self.read_revision(f)

        return rev

class CHKSerializerSubtree(RIORevisionSerializer1,xml6.Serializer_v6):

    """A CHKInventory based serializer that supports tree references"""

    supported_kinds = set(['file', 'directory', 'symlink', 'tree-reference'])

    format_num = '9'

    revision_format_num = None

    support_altered_by_hack = False

    def _unpack_entry(self, elt):

        kind = elt.tag

        if not kind in self.supported_kinds:

            raise AssertionError('unsupported entry kind %s' % kind)

        if kind == 'tree-reference':

            file_id = elt.attrib['file_id']

            name = elt.attrib['name']

            parent_id = elt.attrib['parent_id']

            revision = elt.get('revision')

            reference_revision = elt.get('reference_revision')

            return inventory.TreeReference(file_id, name, parent_id, revision,

                                           reference_revision)

        else:

            return xml6.Serializer_v6._unpack_entry(self, elt)

    def __init__(self, node_size, search_key_name):

        self.maximum_size = node_size

        self.search_key_name = search_key_name

class CHKSerializer(RIORevisionSerializer1,xml5.Serializer_v5):

    """A CHKInventory based serializer with 'plain' behaviour."""

    format_num = '9'

    revision_format_num = None

    support_altered_by_hack = False

    def __init__(self, node_size, search_key_name):

        self.maximum_size = node_size

        self.search_key_name = search_key_name

chk_serializer_255_bigpage = CHKSerializer(65536, 'hash-255-way')