/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

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

• reverse the comparison (4760.2.3 to 5200.3.2)
• stop comparing with revision 5200.3.2

Show diffs side-by-side

added

removed

bzrlib/inventory.py

1

 

# Copyright (C) 2005-2010 Canonical Ltd

 

1

# Copyright (C) 2005, 2006, 2007 Canonical Ltd

2

2

#

3

3

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

4

4

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

51

51

    )

52

52

from bzrlib.symbol_versioning import deprecated_in, deprecated_method

53

53

from bzrlib.trace import mutter

54

 

from bzrlib.static_tuple import StaticTuple

55

54

 

56

55

 

57

56

class InventoryEntry(object):

1600

1599

        interesting.add(None) # this will auto-filter it in the loop

1601

1600

        remaining_parents.discard(None) 

1602

1601

        while remaining_parents:

 

1602

            if None in remaining_parents:

 

1603

                import pdb; pdb.set_trace()

1603

1604

            next_parents = set()

1604

1605

            for entry in self._getitems(remaining_parents):

1605

1606

                next_parents.add(entry.parent_id)

1614

1615

        while directories_to_expand:

1615

1616

            # Expand directories by looking in the

1616

1617

            # parent_id_basename_to_file_id map

1617

 

            keys = [StaticTuple(f,).intern() for f in directories_to_expand]

 

1618

            keys = [(f,) for f in directories_to_expand]

1618

1619

            directories_to_expand = set()

1619

1620

            items = self.parent_id_basename_to_file_id.iteritems(keys)

1620

1621

            next_file_ids = set([item[1] for item in items])

1677

1678

        # to filter out empty names because of non rich-root...

1678

1679

        sections = bytes.split('\n')

1679

1680

        kind, file_id = sections[0].split(': ')

1680

 

        return (sections[2], intern(file_id), intern(sections[3]))

 

1681

        return (sections[2], file_id, sections[3])

1681

1682

 

1682

1683

    def _bytes_to_entry(self, bytes):

1683

1684

        """Deserialise a serialised entry."""

1705

1706

            result.reference_revision = sections[4]

1706

1707

        else:

1707

1708

            raise ValueError("Not a serialised entry %r" % bytes)

1708

 

        result.file_id = intern(result.file_id)

1709

 

        result.revision = intern(sections[3])

 

1709

        result.revision = sections[3]

1710

1710

        if result.parent_id == '':

1711

1711

            result.parent_id = None

1712

1712

        self._fileid_to_entry_cache[result.file_id] = result

1810

1810

                        pass

1811

1811

                deletes.add(file_id)

1812

1812

            else:

1813

 

                new_key = StaticTuple(file_id,)

 

1813

                new_key = (file_id,)

1814

1814

                new_value = result._entry_to_bytes(entry)

1815

1815

                # Update caches. It's worth doing this whether

1816

1816

                # we're propagating the old caches or not.

1819

1819

            if old_path is None:

1820

1820

                old_key = None

1821

1821

            else:

1822

 

                old_key = StaticTuple(file_id,)

 

1822

                old_key = (file_id,)

1823

1823

                if self.id2path(file_id) != old_path:

1824

1824

                    raise errors.InconsistentDelta(old_path, file_id,

1825

1825

                        "Entry was at wrong other path %r." %

1826

1826

                        self.id2path(file_id))

1827

1827

                altered.add(file_id)

1828

 

            id_to_entry_delta.append(StaticTuple(old_key, new_key, new_value))

 

1828

            id_to_entry_delta.append((old_key, new_key, new_value))

1829

1829

            if result.parent_id_basename_to_file_id is not None:

1830

1830

                # parent_id, basename changes

1831

1831

                if old_path is None:

1923

1923

        search_key_name = intern(info.get('search_key_name', 'plain'))

1924

1924

        parent_id_basename_to_file_id = intern(info.get(

1925

1925

            'parent_id_basename_to_file_id', None))

1926

 

        if not parent_id_basename_to_file_id.startswith('sha1:'):

1927

 

            raise ValueError('parent_id_basename_to_file_id should be a sha1'

1928

 

                             ' key not %r' % (parent_id_basename_to_file_id,))

1929

1926

        id_to_entry = info['id_to_entry']

1930

 

        if not id_to_entry.startswith('sha1:'):

1931

 

            raise ValueError('id_to_entry should be a sha1'

1932

 

                             ' key not %r' % (id_to_entry,))

1933

1927

 

1934

1928

        result = CHKInventory(search_key_name)

1935

1929

        result.revision_id = revision_id

1938

1932

                            result._search_key_name)

1939

1933

        if parent_id_basename_to_file_id is not None:

1940

1934

            result.parent_id_basename_to_file_id = chk_map.CHKMap(

1941

 

                chk_store, StaticTuple(parent_id_basename_to_file_id,),

 

1935

                chk_store, (parent_id_basename_to_file_id,),

1942

1936

                search_key_func=search_key_func)

1943

1937

        else:

1944

1938

            result.parent_id_basename_to_file_id = None

1945

1939

 

1946

 

        result.id_to_entry = chk_map.CHKMap(chk_store,

1947

 

                                            StaticTuple(id_to_entry,),

 

1940

        result.id_to_entry = chk_map.CHKMap(chk_store, (id_to_entry,),

1948

1941

                                            search_key_func=search_key_func)

1949

1942

        if (result.revision_id,) != expected_revision_id:

1950

1943

            raise ValueError("Mismatched revision id and expected: %r, %r" %

1972

1965

        id_to_entry_dict = {}

1973

1966

        parent_id_basename_dict = {}

1974

1967

        for path, entry in inventory.iter_entries():

1975

 

            key = StaticTuple(entry.file_id,).intern()

1976

 

            id_to_entry_dict[key] = entry_to_bytes(entry)

 

1968

            id_to_entry_dict[(entry.file_id,)] = entry_to_bytes(entry)

1977

1969

            p_id_key = parent_id_basename_key(entry)

1978

1970

            parent_id_basename_dict[p_id_key] = entry.file_id

1979

1971

 

2002

1994

            parent_id = entry.parent_id

2003

1995

        else:

2004

1996

            parent_id = ''

2005

 

        return StaticTuple(parent_id, entry.name.encode('utf8')).intern()

 

1997

        return parent_id, entry.name.encode('utf8')

2006

1998

 

2007

1999

    def __getitem__(self, file_id):

2008

2000

        """map a single file_id -> InventoryEntry."""

2013

2005

            return result

2014

2006

        try:

2015

2007

            return self._bytes_to_entry(

2016

 

                self.id_to_entry.iteritems([StaticTuple(file_id,)]).next()[1])

 

2008

                self.id_to_entry.iteritems([(file_id,)]).next()[1])

2017

2009

        except StopIteration:

2018

2010

            # really we're passing an inventory, not a tree...

2019

2011

            raise errors.NoSuchId(self, file_id)

2032

2024

                remaining.append(file_id)

2033

2025

            else:

2034

2026

                result.append(entry)

2035

 

        file_keys = [StaticTuple(f,).intern() for f in remaining]

 

2027

        file_keys = [(f,) for f in remaining]

2036

2028

        for file_key, value in self.id_to_entry.iteritems(file_keys):

2037

2029

            entry = self._bytes_to_entry(value)

2038

2030

            result.append(entry)

2043

2035

        # Perhaps have an explicit 'contains' method on CHKMap ?

2044

2036

        if self._fileid_to_entry_cache.get(file_id, None) is not None:

2045

2037

            return True

2046

 

        return len(list(

2047

 

            self.id_to_entry.iteritems([StaticTuple(file_id,)]))) == 1

 

2038

        return len(list(self.id_to_entry.iteritems([(file_id,)]))) == 1

2048

2039

 

2049

2040

    def is_root(self, file_id):

2050

2041

        return file_id == self.root_id

2202

2193

            basename_utf8 = basename.encode('utf8')

2203

2194

            file_id = self._path_to_fileid_cache.get(cur_path, None)

2204

2195

            if file_id is None:

2205

 

                key_filter = [StaticTuple(current_id, basename_utf8)]

 

2196

                key_filter = [(current_id, basename_utf8)]

2206

2197

                items = parent_id_index.iteritems(key_filter)

2207

2198

                for (parent_id, name_utf8), file_id in items:

2208

2199

                    if parent_id != current_id or name_utf8 != basename_utf8:

2224

2215

            lines.append('search_key_name: %s\n' % (self._search_key_name,))

2225

2216

            lines.append("root_id: %s\n" % self.root_id)

2226

2217

            lines.append('parent_id_basename_to_file_id: %s\n' %

2227

 

                (self.parent_id_basename_to_file_id.key()[0],))

 

2218

                self.parent_id_basename_to_file_id.key())

2228

2219

            lines.append("revision_id: %s\n" % self.revision_id)

2229

 

            lines.append("id_to_entry: %s\n" % (self.id_to_entry.key()[0],))

 

2220

            lines.append("id_to_entry: %s\n" % self.id_to_entry.key())

2230

2221

        else:

2231

2222

            lines.append("revision_id: %s\n" % self.revision_id)

2232

2223

            lines.append("root_id: %s\n" % self.root_id)

2233

2224

            if self.parent_id_basename_to_file_id is not None:

2234

2225

                lines.append('parent_id_basename_to_file_id: %s\n' %

2235

 

                    (self.parent_id_basename_to_file_id.key()[0],))

2236

 

            lines.append("id_to_entry: %s\n" % (self.id_to_entry.key()[0],))

 

2226

                    self.parent_id_basename_to_file_id.key())

 

2227

            lines.append("id_to_entry: %s\n" % self.id_to_entry.key())

2237

2228

        return lines

2238

2229

 

2239

2230

    @property

2280

2271

        parent_id_index = self._chk_inventory.parent_id_basename_to_file_id

2281

2272

        child_keys = set()

2282

2273

        for (parent_id, name_utf8), file_id in parent_id_index.iteritems(

2283

 

            key_filter=[StaticTuple(self.file_id,)]):

2284

 

            child_keys.add(StaticTuple(file_id,))

 

2274

            key_filter=[(self.file_id,)]):

 

2275

            child_keys.add((file_id,))

2285

2276

        cached = set()

2286

2277

        for file_id_key in child_keys:

2287

2278

            entry = self._chk_inventory._fileid_to_entry_cache.get(

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0