~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/_btree_serializer_py.py

• browse files at revision 4988.4.2
• compare with another revision
• download diff
• download tarball
• view history from revision 4988.4.2

• reverse the comparison (4988.4.2 to 2425.1.1)
• stop comparing with revision 2425.1.1

Show diffs side-by-side

added

removed

bzrlib/_btree_serializer_py.py

 

1

# Copyright (C) 2008 Canonical Ltd

 

2

#

 

3

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

 

4

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

 

5

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

 

6

# (at your option) any later version.

 

7

#

 

8

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

 

9

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

 

10

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 

11

# GNU General Public License for more details.

 

12

#

 

13

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

 

14

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

 

15

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

 

16

#

 

17

 

 

18

"""B+Tree index parsing."""

 

19

 

 

20

from bzrlib import static_tuple

 

21

 

 

22

 

 

23

def _parse_leaf_lines(bytes, key_length, ref_list_length):

 

24

    lines = bytes.split('\n')

 

25

    nodes = []

 

26

    as_st = static_tuple.StaticTuple.from_sequence

 

27

    stuple = static_tuple.StaticTuple

 

28

    for line in lines[1:]:

 

29

        if line == '':

 

30

            return nodes

 

31

        elements = line.split('\0', key_length)

 

32

        # keys are tuples

 

33

        key = as_st(elements[:key_length]).intern()

 

34

        line = elements[-1]

 

35

        references, value = line.rsplit('\0', 1)

 

36

        if ref_list_length:

 

37

            ref_lists = []

 

38

            for ref_string in references.split('\t'):

 

39

                ref_list = as_st([as_st(ref.split('\0')).intern()

 

40

                                  for ref in ref_string.split('\r') if ref])

 

41

                ref_lists.append(ref_list)

 

42

            ref_lists = as_st(ref_lists)

 

43

            node_value = stuple(value, ref_lists)

 

44

        else:

 

45

            node_value = stuple(value, stuple())

 

46

        # No need for StaticTuple here as it is put into a dict

 

47

        nodes.append((key, node_value))

 

48

    return nodes

 

49

 

 

50

 

 

51

def _flatten_node(node, reference_lists):

 

52

    """Convert a node into the serialized form.

 

53

 

 

54

    :param node: A tuple representing a node (key_tuple, value, references)

 

55

    :param reference_lists: Does this index have reference lists?

 

56

    :return: (string_key, flattened)

 

57

        string_key  The serialized key for referencing this node

 

58

        flattened   A string with the serialized form for the contents

 

59

    """

 

60

    if reference_lists:

 

61

        # TODO: Consider turning this back into the 'unoptimized' nested loop

 

62

        #       form. It is probably more obvious for most people, and this is

 

63

        #       just a reference implementation.

 

64

        flattened_references = ['\r'.join(['\x00'.join(reference)

 

65

                                           for reference in ref_list])

 

66

                                for ref_list in node[3]]

 

67

    else:

 

68

        flattened_references = []

 

69

    string_key = '\x00'.join(node[1])

 

70

    line = ("%s\x00%s\x00%s\n" % (string_key,

 

71

        '\t'.join(flattened_references), node[2]))

 

72

    return string_key, line

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1