← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/groupcompress.py

  • Committer: Martin Pool
  • Date: 2010-04-01 04:41:18 UTC
  • mto: This revision was merged to the branch mainline in revision 5128.
  • Revision ID: mbp@sourcefrog.net-20100401044118-shyctqc02ob08ngz
ignore .testrepository

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/groupcompress.py
1631
1631
        keys_to_add = []
1632
1632
        def flush():
1633
1633
            bytes = self._compressor.flush().to_bytes()
1634
 
            self._compressor = GroupCompressor()
1635
1634
            index, start, length = self._access.add_raw_records(
1636
1635
                [(None, len(bytes))], bytes)[0]
1637
1636
            nodes = []
1640
1639
            self._index.add_records(nodes, random_id=random_id)
1641
1640
            self._unadded_refs = {}
1642
1641
            del keys_to_add[:]
 
1642
            self._compressor = GroupCompressor()
1643
1643
 
1644
1644
        last_prefix = None
1645
1645
        max_fulltext_len = 0
1809
1809
        return result
1810
1810
 
1811
1811
 
1812
 
class _GCBuildDetails(object):
1813
 
    """A blob of data about the build details.
1814
 
 
1815
 
    This stores the minimal data, which then allows compatibility with the old
1816
 
    api, without taking as much memory.
1817
 
    """
1818
 
 
1819
 
    __slots__ = ('_index', '_group_start', '_group_end', '_basis_end',
1820
 
                 '_delta_end', '_parents')
1821
 
 
1822
 
    method = 'group'
1823
 
    compression_parent = None
1824
 
 
1825
 
    def __init__(self, parents, position_info):
1826
 
        self._parents = parents
1827
 
        (self._index, self._group_start, self._group_end, self._basis_end,
1828
 
         self._delta_end) = position_info
1829
 
 
1830
 
    def __repr__(self):
1831
 
        return '%s(%s, %s)' % (self.__class__.__name__,
1832
 
            self.index_memo, self._parents)
1833
 
 
1834
 
    @property
1835
 
    def index_memo(self):
1836
 
        return (self._index, self._group_start, self._group_end,
1837
 
                self._basis_end, self._delta_end)
1838
 
 
1839
 
    @property
1840
 
    def record_details(self):
1841
 
        return static_tuple.StaticTuple(self.method, None)
1842
 
 
1843
 
    def __getitem__(self, offset):
1844
 
        """Compatibility thunk to act like a tuple."""
1845
 
        if offset == 0:
1846
 
            return self.index_memo
1847
 
        elif offset == 1:
1848
 
            return self.compression_parent # Always None
1849
 
        elif offset == 2:
1850
 
            return self._parents
1851
 
        elif offset == 3:
1852
 
            return self.record_details
1853
 
        else:
1854
 
            raise IndexError('offset out of range')
1855
 
            
1856
 
    def __len__(self):
1857
 
        return 4
1858
 
 
1859
 
 
1860
1812
class _GCGraphIndex(object):
1861
1813
    """Mapper from GroupCompressVersionedFiles needs into GraphIndex storage."""
1862
1814
 
2057
2009
                parents = None
2058
2010
            else:
2059
2011
                parents = entry[3][0]
2060
 
            details = _GCBuildDetails(parents, self._node_to_position(entry))
2061
 
            result[key] = details
 
2012
            method = 'group'
 
2013
            result[key] = (self._node_to_position(entry),
 
2014
                                  None, parents, (method, None))
2062
2015
        return result
2063
2016
 
2064
2017
    def keys(self):
2080
2033
        # each, or about 7MB. Note that it might be even more when you consider
2081
2034
        # how PyInt is allocated in separate slabs. And you can't return a slab
2082
2035
        # to the OS if even 1 int on it is in use. Note though that Python uses
2083
 
        # a LIFO when re-using PyInt slots, which might cause more
 
2036
        # a LIFO when re-using PyInt slots, which probably causes more
2084
2037
        # fragmentation.
2085
2038
        start = int(bits[0])
2086
2039
        start = self._int_cache.setdefault(start, start)