/brz/remove-bazaar

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

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

lifeless: the data file is made up of "delta records".  each delta record has a delta header 

that contains; (1) a version id, (2) the size of the delta (in lines), and (3)  the digest of 

the -expanded data- (ie, the delta applied to the parent).  the delta also ends with a 

end robertc@robertcollins.net-20051003014215-ee2990904cc4c7ad 

# TODOS:

# 10:16 < lifeless> make partial index writes safe

# 10:16 < lifeless> implement 'knit.check()' like weave.check()

# 10:17 < lifeless> record known ghosts so we can detect when they are filled in rather than the current 'reweave 

#                    always' approach.

# move sha1 out of the content so that join is faster at verifying parents

# record content length ?

                  

from itertools import izip, chain

        

    

        

        

    

    plus a flag saying if the final ending is really there or not, because that 

    

        # TODO: jam 20070209 We only do the caching thing to make sure that

        #       the origin is a valid utf-8 line, eventually we could remove it

        if type(key) == tuple:

        return annotator.annotate(key)

    

    

    :ivar _index: A _KnitGraphIndex or similar that can describe the 

        parents, graph, compression and data location of entries in this 

        KnitVersionedFiles.  Note that this is only the index for 

            parent_texts, left_matching_blocks, nostore_sha, random_id)

        left_matching_blocks, nostore_sha, random_id):

        line_bytes = ''.join(lines)

        if lines:

            if lines[-1][-1] != '\n':

                # copy the contents of lines.

                options.append('no-eol')

                lines[-1] = lines[-1] + '\n'

                line_bytes += '\n'

        for element in key:

            if type(element) != str:

        if 'no-eol' in options:

            if self._factory.__class__ == KnitPlainFactory:

                    lines, [line_bytes])

    def check(self, progress_bar=None):

        if contains_whitespace(version_id):

            raise InvalidRevisionId(version_id, self)

        self.check_not_reserved_id(version_id)

        

       

        

        :param allow_missing: If some records are missing, rather than 

        

        

    def _split_by_prefix(self, keys):

        :return: A dict of {prefix: [key_list]}

                split_by_prefix.setdefault('', []).append(key)

            else:

                split_by_prefix.setdefault(key[0], []).append(key)

        return split_by_prefix

            # Cannot topological order when no graph has been stored.

        if ordering == 'topological':

            # Global topological sort

            present_keys = tsort.topo_sort(global_map)

                    ' "unordered" or "topological" not: %r'

            prefix_split_keys = self._split_by_prefix(present_keys)

            prefix_split_non_local_keys = self._split_by_prefix(non_local_keys)

            for prefix, keys in prefix_split_keys.iteritems():

                non_local = prefix_split_non_local_keys.get(prefix, [])

                non_local = set(non_local)

                generator = _VFContentMapGenerator(self, keys, non_local,

                    global_map)

                    for key, raw_data, sha1 in self._read_records_iter_raw(records):

                            record_details, sha1, raw_data, self._factory.annotated, None)

        :param stream: A stream of records to insert. 

                buffered = False

            added_keys = [record.key]

            while added_keys:

                key = added_keys.pop(0)

                if key in buffered_index_entries:

                    index_entries = buffered_index_entries[key]

                    self._index.add_records(index_entries)

                    added_keys.extend(

                        [index_entry[0] for index_entry in index_entries])

                    del buffered_index_entries[key]

                self._index.add_records(index_entries,

                    missing_compression_parents=True)

            pb = progress.DummyProgress()

                    pb.update('Walking content.', key_idx, total)

                        # Delta 

        # anything.  

        pb.update('Walking content.', total, total)

        

                              'unexpected version end line %r, wanted %r' 

        # The transport optimizes the fetching as well 

        

        # Note: using a string copy here increases memory pressure with e.g.

        # ISO's, but it is about 3 seconds faster on a 1.2Ghz intel machine

        # when doing the initial commit of a mozilla tree. RBC 20070921

        bytes = ''.join(chain(

            ["version %s %d %s\n" % (key[-1],

                                     len(lines),

                                     digest)],

            dense_lines or lines,

            ["end %s\n" % key[-1]]))

        if type(bytes) != str:

            raise AssertionError(

                'data must be plain bytes was %s' % type(bytes))

        compressed_bytes = tuned_gzip.bytes_to_gzip(bytes)

        

                'unordered', True):

        self._raw_record_map = self.vf._get_record_map_unparsed(self.keys,

            allow_missing=True)

        # Have read and parsed records at this point.