-=[ Mr. Bumblebee ]=-
_Indonesia_

Path : /usr/lib/python2.7/dist-packages/bzrlib/
Current File : //usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyc
ó
€5ÈQc@@sÞdZddlmZddlZddlZddlZddlZddlmZddlZddl	Z	ddl
Z
ddlZddlm
Z
mZmZmZmZmZmZmZmZmZdZdZdefd	„ƒYZd
efd„ƒYZdefd
„ƒYZejd„Zdefd„ƒYZy>ddl m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z(m)Z)WnZe*k
rÙZ+ej,e+ƒddl-m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&eZ)eZ(nXdS(s#"DirState objects record the state of a directory and its bzr metadata.

Pseudo EBNF grammar for the state file. Fields are separated by NULLs, and
lines by NL. The field delimiters are ommitted in the grammar, line delimiters
are not - this is done for clarity of reading. All string data is in utf8.

::

    MINIKIND = "f" | "d" | "l" | "a" | "r" | "t";
    NL = "\n";
    NULL = "\0";
    WHOLE_NUMBER = {digit}, digit;
    BOOLEAN = "y" | "n";
    REVISION_ID = a non-empty utf8 string;
    
    dirstate format = header line, full checksum, row count, parent details,
     ghost_details, entries;
    header line = "#bazaar dirstate flat format 3", NL;
    full checksum = "crc32: ", ["-"], WHOLE_NUMBER, NL;
    row count = "num_entries: ", WHOLE_NUMBER, NL;
    parent_details = WHOLE NUMBER, {REVISION_ID}* NL;
    ghost_details = WHOLE NUMBER, {REVISION_ID}*, NL;
    entries = {entry};
    entry = entry_key, current_entry_details, {parent_entry_details};
    entry_key = dirname,  basename, fileid;
    current_entry_details = common_entry_details, working_entry_details;
    parent_entry_details = common_entry_details, history_entry_details;
    common_entry_details = MINIKIND, fingerprint, size, executable
    working_entry_details = packed_stat
    history_entry_details = REVISION_ID;
    executable = BOOLEAN;
    size = WHOLE_NUMBER;
    fingerprint = a nonempty utf8 sequence with meaning defined by minikind.

Given this definition, the following is useful to know::

    entry (aka row) - all the data for a given key.
    entry[0]: The key (dirname, basename, fileid)
    entry[0][0]: dirname
    entry[0][1]: basename
    entry[0][2]: fileid
    entry[1]: The tree(s) data for this path and id combination.
    entry[1][0]: The current tree
    entry[1][1]: The second tree

For an entry for a tree, we have (using tree 0 - current tree) to demonstrate::

    entry[1][0][0]: minikind
    entry[1][0][1]: fingerprint
    entry[1][0][2]: size
    entry[1][0][3]: executable
    entry[1][0][4]: packed_stat

OR (for non tree-0)::

    entry[1][1][4]: revision_id

There may be multiple rows at the root, one per id present in the root, so the
in memory root row is now::

    self._dirblocks[0] -> ('', [entry ...]),

and the entries in there are::

    entries[0][0]: ''
    entries[0][1]: ''
    entries[0][2]: file_id
    entries[1][0]: The tree data for the current tree for this fileid at /
    etc.

Kinds::

    'r' is a relocated entry: This path is not present in this tree with this
        id, but the id can be found at another location. The fingerprint is
        used to point to the target location.
    'a' is an absent entry: In that tree the id is not present at this path.
    'd' is a directory entry: This path in this tree is a directory with the
        current file id. There is no fingerprint for directories.
    'f' is a file entry: As for directory, but it's a file. The fingerprint is
        the sha1 value of the file's canonical form, i.e. after any read
        filters have been applied to the convenience form stored in the working
        tree.
    'l' is a symlink entry: As for directory, but a symlink. The fingerprint is
        the link target.
    't' is a reference to a nested subtree; the fingerprint is the referenced
        revision.

Ordering:

The entries on disk and in memory are ordered according to the following keys::

    directory, as a list of components
    filename
    file-id

--- Format 1 had the following different definition: ---

::

    rows = dirname, NULL, basename, NULL, MINIKIND, NULL, fileid_utf8, NULL,
        WHOLE NUMBER (* size *), NULL, packed stat, NULL, sha1|symlink target,
        {PARENT ROW}
    PARENT ROW = NULL, revision_utf8, NULL, MINIKIND, NULL, dirname, NULL,
        basename, NULL, WHOLE NUMBER (* size *), NULL, "y" | "n", NULL,
        SHA1

PARENT ROW's are emitted for every parent that is not in the ghosts details
line. That is, if the parents are foo, bar, baz, and the ghosts are bar, then
each row will have a PARENT ROW for foo and baz, but not for bar.


In any tree, a kind of 'moved' indicates that the fingerprint field
(which we treat as opaque data specific to the 'kind' anyway) has the
details for the id of this row in that tree.

I'm strongly tempted to add a id->path index as well, but I think that
where we need id->path mapping; we also usually read the whole file, so
I'm going to skip that for the moment, as we have the ability to locate
via bisect any path in any tree, and if we lookup things by path, we can
accumulate an id->path mapping as we go, which will tend to match what we
looked for.

I plan to implement this asap, so please speak up now to alter/tweak the
design - and once we stabilise on this, I'll update the wiki page for
it.

The rationale for all this is that we want fast operations for the
common case (diff/status/commit/merge on all files) and extremely fast
operations for the less common but still occurs a lot status/diff/commit
on specific files). Operations on specific files involve a scan for all
the children of a path, *in every involved tree*, which the current
format did not accommodate.
----

Design priorities:
 1. Fast end to end use for bzr's top 5 uses cases. (commmit/diff/status/merge/???)
 2. fall back current object model as needed.
 3. scale usably to the largest trees known today - say 50K entries. (mozilla
    is an example of this)


Locking:

 Eventually reuse dirstate objects across locks IFF the dirstate file has not
 been modified, but will require that we flush/ignore cached stat-hit data
 because we won't want to restat all files on disk just because a lock was
 acquired, yet we cannot trust the data after the previous lock was released.

Memory representation::

 vector of all directories, and vector of the childen ?
   i.e.
     root_entrie = (direntry for root, [parent_direntries_for_root]),
     dirblocks = [
     ('', ['data for achild', 'data for bchild', 'data for cchild'])
     ('dir', ['achild', 'cchild', 'echild'])
     ]
    - single bisect to find N subtrees from a path spec
    - in-order for serialisation - this is 'dirblock' grouping.
    - insertion of a file '/a' affects only the '/' child-vector, that is, to
      insert 10K elements from scratch does not generates O(N^2) memoves of a
      single vector, rather each individual, which tends to be limited to a
      manageable number. Will scale badly on trees with 10K entries in a
      single directory. compare with Inventory.InventoryDirectory which has
      a dictionary for the children. No bisect capability, can only probe for
      exact matches, or grab all elements and sort.
    - What's the risk of error here? Once we have the base format being processed
      we should have a net win regardless of optimality. So we are going to
      go with what seems reasonable.

open questions:

Maybe we should do a test profile of the core structure - 10K simulated
searches/lookups/etc?

Objects for each row?
The lifetime of Dirstate objects is current per lock, but see above for
possible extensions. The lifetime of a row from a dirstate is expected to be
very short in the optimistic case: which we are optimising for. For instance,
subtree status will determine from analysis of the disk data what rows need to
be examined at all, and will be able to determine from a single row whether
that file has altered or not, so we are aiming to process tens of thousands of
entries each second within the dirstate context, before exposing anything to
the larger codebase. This suggests we want the time for a single file
comparison to be < 0.1 milliseconds. That would give us 10000 paths per second
processed, and to scale to 100 thousand we'll another order of magnitude to do
that. Now, as the lifetime for all unchanged entries is the time to parse, stat
the file on disk, and then immediately discard, the overhead of object creation
becomes a significant cost.

Figures: Creating a tuple from 3 elements was profiled at 0.0625
microseconds, whereas creating a object which is subclassed from tuple was
0.500 microseconds, and creating an object with 3 elements and slots was 3
microseconds long. 0.1 milliseconds is 100 microseconds, and ideally we'll get
down to 10 microseconds for the total processing - having 33% of that be object
creation is a huge overhead. There is a potential cost in using tuples within
each row which is that the conditional code to do comparisons may be slower
than method invocation, but method invocation is known to be slow due to stack
frame creation, so avoiding methods in these tight inner loops in unfortunately
desirable. We can consider a pyrex version of this with objects in future if
desired.

i(tabsolute_importN(tS_IEXEC(
t
cache_utf8tconfigtdebugterrorst	inventorytlocktosutilststatic_tuplettraceturlutilsiitSHA1ProvidercB@s eZdZd„Zd„ZRS(s)An interface for getting sha1s of a file.cC@st|jƒ‚dS(sŸReturn the sha1 of a file given its absolute path.

        :param abspath:  May be a filesystem encoded absolute path
             or a unicode path.
        N(tNotImplementedErrortsha1(tselftabspath((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRscC@st|jƒ‚dS(s/Return the stat and sha1 of a file given its absolute path.
        
        :param abspath:  May be a filesystem encoded absolute path
             or a unicode path.

        Note: the stat should be the stat of the physical file
        while the sha may be the sha of its canonical content.
        N(R
t
stat_and_sha1(RR((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR	s	(t__name__t
__module__t__doc__RR(((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRþs	tDefaultSHA1ProvidercB@s eZdZd„Zd„ZRS(s7A SHA1Provider that reads directly from the filesystem.cC@s
tj|ƒS(s2Return the sha1 of a file given its absolute path.(Rtsha_file_by_name(RR((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRscC@sOt|dƒ}z(tj|jƒƒ}tj|ƒ}Wd|jƒX||fS(s;Return the stat and sha1 of a file given its absolute path.trbN(tfiletostfstattfilenoRtsha_filetclose(RRtfile_objt	statvalueR((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRs(RRRRR(((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRs	tDirStatecB@s=eZdZidd6dd6dd6dd6d	d
6dd6Zidd6dd6dd6d
d	6dd6dd6Zidej6dej6d	ej6Z	id
e
6de6ZdZ
dZdZdZdZddZejdddedƒZdZdZdd„Zd„Zdled„Zd„Zd„Zd„Zd„Zd „Z d!„Z!d"„Z"d#„Z#d$„Z$d%„Z%d&„Z&d'„Z'd(„Z(ed)„Z)d*„Z*d+„Z+e,dld,„ƒZ-d-„Z.d.„Z/d/„Z0d0„Z1d1„Z2d2„Z3d3„Z4d4„Z5d5„Z6d6„Z7d7„Z8e	d8„Z9d9„Z:d:„Z;d;„Z<d<„Z=d=„Z>e?j@d>krpe>Z=nd?„ZAd@„ZBdA„ZCdB„ZDdC„ZEdD„ZFdE„ZGdF„ZHdG„ZIdldledH„ZJeKdldI„ƒZLe,dJ„ƒZMdK„ZNdL„ZOdM„ZPdN„ZQdO„ZRdP„ZSdQ„ZTdR„ZUeKdlddS„ƒZVdT„ZWdU„ZXdV„ZYdW„ZZdX„Z[dY„Z\dZ„Z]d[„Z^d\„Z_d]„Z`d^„Zad_„Zbd`„Zcda„Zddb„Zedc„Zfeddlddledd„Zgde„Zhdf„Zidg„Zjdh„Zkdi„Zldj„Zmdk„ZnRS(ms¢Record directory and metadata state for fast access.

    A dirstate is a specialised data structure for managing local working
    tree state information. Its not yet well defined whether it is platform
    specific, and if it is how we detect/parameterize that.

    Dirstates use the usual lock_write, lock_read and unlock mechanisms.
    Unlike most bzr disk formats, DirStates must be locked for reading, using
    lock_read.  (This is an os file lock internally.)  This is necessary
    because the file can be rewritten in place.

    DirStates must be explicitly written with save() to commit changes; just
    unlocking them does not write the changes to disk.
    tatabsenttfRtdt	directorytrt	relocatedtltsymlinkttstree-referencetytniiiiitxi ts#bazaar dirstate flat format 2
s#bazaar dirstate flat format 3
cC@stj|_tj|_t|_g|_g|_g|_d|_
||_d|_d|_
d|_d|_d|_d|_i|_tj|_||_dtjkrÀ|j|_n|jj|_d|_d|_tƒ|_||_t j!t"j#|ƒƒ|_$dS(sÒCreate a  DirState object.

        :param path: The path at which the dirstate file on disk should live.
        :param sha1_provider: an object meeting the SHA1Provider interface.
        :param worth_saving_limit: when the exact number of hash changed
            entries is known, only bother saving the dirstate if more than
            this count of entries have changed.
            -1 means never save hash changes, 0 means always save hash changes.
        t	hashcacheN(%R t
NOT_IN_MEMORYt
_header_statet_dirblock_statetFalset_changes_abortedt
_dirblockst_ghostst_parentstNonet_state_filet	_filenamet_lock_tokent_lock_statet	_id_indext_packed_stat_indext_end_of_headert_cutoff_timet_split_path_cachetBISECT_PAGE_SIZEt_bisect_page_sizet_sha1_providerRtdebug_flagst_sha1_file_and_muttert
_sha1_fileRt_last_block_indext_last_entry_indextsett_known_hash_changest_worth_saving_limitRt
LocationStackRtlocal_path_to_urlt
_config_stack(Rtpatht
sha1_providertworth_saving_limit((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt__init__bs4																	cC@sd|jj|jfS(Ns%s(%r)(t	__class__RR:(R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt__repr__œscC@s|rZ|jjg|D]}|d^qƒ|jtjtjfkrftj|_qfntj|_|r{tj|_ndS(sMark this dirstate as modified.

        :param hash_changed_entries: if non-None, mark just these entries as
            having their hash modified.
        :param header_modified: mark the header modified as well, not just the
            dirblocks.
        iN(	RKtupdateR2R R0tIN_MEMORY_UNMODIFIEDtIN_MEMORY_HASH_MODIFIEDtIN_MEMORY_MODIFIEDR1(Rthash_changed_entriestheader_modifiedte((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_mark_modified s	'cC@s(tj|_tj|_tƒ|_dS(s!Mark this dirstate as unmodified.N(R RWR1R2RJRK(R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_mark_unmodified¹sc 	C@sdtj|ƒ\}}tj|ƒ\}}	||krW|	rE|}qWtj|ƒ‚n|dkso|dkrtj|ƒ‚n|d|jdƒjdƒ}
tj|
ƒ\}}|jt	k	rát
dt|ƒfƒ‚nd}|j
dd|dtƒ}|dkrÜ|d	ddd
kr||d|||fkrÙ|j|dddd
dd
d|
ƒ|ddd!}qÙqÜtj|dd|dd	ƒ}tj|d	dd}d||f}
tj||
ƒ‚n||d
f}|j|ƒ\}}|rŸ|j|d	}|j||ƒ\}}x×|t|ƒkr›||ddd!|dd!kr›||d	dddkrŽtd‚n|d	7}q2Wnjtj|ƒ\}}|j||dƒ\}}}}|sötj|t	|ƒƒ‚n|j|||ƒ|j|d	}|||f}|dkrGd}tj}n|j}t|ƒ}|jƒ}tj |}|dk	r¾|dr˜d|}n
|d	}d|dt!d
f|d<n|dkrï||||t!|fg|f}n¦|dkr ||d
dt!|fg|f}nu|dkrQ||||t!|fg|f}nD|dkr‚|||dt!|fg|f}ntj"d|ƒ‚|j||ƒ\}}|sÆ|j#||ƒnO||d	ddd
krût
d||fƒ‚n|d	d||d	d<|dkr7|j|||
ƒn|j$ƒ|j%r`|j&|j%|ƒndS(sÃAdd a path to be tracked.

        :param path: The path within the dirstate - '' is the root, 'foo' is the
            path foo within the root, 'foo/bar' is the path bar within foo
            within the root.
        :param file_id: The file id of the path being added.
        :param kind: The kind of the path, as a string like 'file',
            'directory', etc.
        :param stat: The output of os.lstat for the path.
        :param fingerprint: The sha value of the file's canonical form (i.e.
            after any read filters have been applied),
            or the target of a symlink,
            or the referenced revision id for tree-references,
            or '' for directories.
        t.s..t/tutf8smust be a utf8 file_id not %sitfileid_utf8tinclude_deletediR!R&t	path_utf8R.tpacked_stattfingerprintis%s:%starsadding already added path!s%s/%sRR%R)stree-referencesunknown kind %rs %r(%r) already addedN(NN('Rtsplittnormalized_filenameRtInvalidNormalizationtInvalidEntryNametstriptencodeRTtstrtAssertionErrorttypeR8t
_get_entrytTruetupdate_minimaltpathjoinR t_minikind_to_kindtDuplicateFileIdt_find_block_index_from_keyR5t_find_entry_indextlent	Exceptiont_get_block_entry_indextNotVersionedErrort
_ensure_blocktNULLSTATtst_sizet	pack_statt_empty_parent_infot_kind_to_minikindR3tBzrErrortinsertR]R=t_add_to_id_index( RRPtfile_idtkindtstatRftdirnametbasenamet	norm_namet
can_accesstutf8pathtrename_fromt
file_id_entrytinfot	first_keytblock_indextpresenttblocktentry_indext_t
parent_dirtparent_basetparent_block_idxtparent_entry_idxtparent_presentt	entry_keytsizeRetparent_infotminikindt
old_path_utf8t
entry_data((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pytadd¿sª	 
""!	







	c#C@s4|jƒ|jƒ|jtjkr<td|jƒ‚n|j}tj|j	ƒƒj
}|jƒd}|j}|d}i}dt
|ƒ}d}	|||fg}
|j}|jƒ}xj|
r/|
jƒ\}}}
|
sÆ||krúqÆn|	d7}	|	|kr"tjdƒ‚nt||||dƒ}|j|ƒt|||dƒ}|j|ƒ}|}|jdƒ}t
|ƒdkr½|d9}|
j|||
fƒqÆnd}|djdƒ}t
|ƒ|kr|t
|dƒd7}|djdƒ}d}nt
|ƒdkrT|d9}|
j|||
fƒqÆnV|}|dr}|dd	|d}n
|d}t|
|ƒ}|
| }|
|}|rêt
|ƒ|krêt
|ƒd}||jdƒ}t
|ƒ|kr5|t
|ƒt
|d
ƒ}|d8}||jdƒ}n|t
|ƒ}|drh|dd	|d}n
|d}t||ƒ}|| }||}|rê|d|kr»|j|ƒn|d
|krÞ|jd|ƒni|g|6}||kr|j|gƒj|ƒnxtt|d|ƒD]_}||jdƒ} | drf| dd	| d}!n
| d}!|j|!gƒj| ƒq*WxW|D]L}!xC|j|!gƒD]/} || dƒ}"|j|!gƒj|"ƒqWq”Wqên|r	|
j|||fƒn|rÆ|
j||d|fƒqÆqÆW|S(s^Bisect through the disk structure for specific rows.

        :param paths: A list of paths to find
        :return: A dict mapping path => entries for found entries. Missing
                 entries will not be in the map.
                 The list is not sorted, and entries will be populated
                 based on when they were read.
        sbad dirblock state %riiis"Too many seeks, most likely a bug.is
tR`iÿÿÿÿ(t_requires_lockt_read_header_if_neededR2R R0RoR9RRRRt_fields_per_entryR?RyRCt_get_fields_to_entrytpopRRƒtmaxtseektmintreadRhtappendt_bisect_path_leftt_bisect_path_rightR„t
setdefaulttxrangetget(#Rtpathst
state_filet	file_sizetentry_field_counttlowthightfoundt	max_counttcounttpendingt	page_sizetfields_to_entryt	cur_filestmidt	read_sizeR”tstarttentriestfirst_entry_numtfirst_fieldstaftert
first_patht	first_loctpretposttlast_entry_numtlast_fieldst	last_pathtlast_loctmiddle_filestnumtfieldsRPtentry((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_bisectFs¬	

		
		


	












'!c$C@sË|jƒ|jƒ|jtjkr<td|jƒ‚n|j}tj|j	ƒƒj
}|jƒd}|j}|d}i}dt
|ƒ}d}	|||fg}
|j}|jƒ}x|
rÆ|
jƒ\}}}
|
sÆ||krúqÆn|	d7}	|	|kr"tjdƒ‚nt||||dƒ}|j|ƒt|||dƒ}|j|ƒ}|}|jdƒ}t
|ƒdkr½|d9}|
j|||
fƒqÆnd}|djdƒ}t
|ƒ|kr|t
|dƒd7}|djdƒ}d}nt
|ƒdkrT|d9}|
j|||
fƒqÆn6|}|d}tj|
|ƒ}|
| }|
|}|rt
|ƒ|krt
|ƒd}||jdƒ}t
|ƒ|kr|t
|ƒt
|d	ƒ}|d8}||jdƒ}n|t
|ƒ}|d}tj||ƒ}|| }||}|r|d|kr{|j|ƒn|d	|krž|jd|ƒni|g|6}||krÖ|j|gƒj|ƒnxKt|d|ƒD]6} || jdƒ}!|j|!dgƒj|!ƒqêWxW|D]L}"xC|j|"gƒD]/}!||!dƒ}#|j|"gƒj|#ƒqDWq+Wqn|r |
j|||fƒn|rÆ|
j||d|fƒqÆqÆW|S(
s]Bisect through the disk structure to find entries in given dirs.

        _bisect_dirblocks is meant to find the contents of directories, which
        differs from _bisect, which only finds individual entries.

        :param dir_list: A sorted list of directory names ['', 'dir', 'foo'].
        :return: A map from dir => entries_for_dir
        sbad dirblock state %riiis"Too many seeks, most likely a bug.is
R£iÿÿÿÿ( R¤R¥R2R R0RoR9RRRRR¦R?RyRCR§R¨RRƒR©RªR«R¬RhRtbisecttbisect_lefttbisect_rightR„R°R±R²($Rtdir_listR´RµR¶R·R¸R¹RºR»R¼R½R¾tcur_dirsRÀRÁR”RÂRÃRÄRÅRÆt	first_dirRÈRÉRÊRËRÌtlast_dirRÎRÏR³RÐRÑtcur_dirRÒ((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_bisect_dirblockssž

		
		


	







!
'!cC@s¨i}tƒ}tƒ}|j|ƒ}xz|r£tƒ}tƒ}x|jƒD]}x|D]þ\}	}
|
||	<|j|	d ƒt}xÎ|
D]Æ}|d}
|
dkrþ|r¸qn|	\}}}tj||ƒ}t}||krV|j|ƒqVq|
dkrtj|dƒ}|d|kr3qn||krV|j|dƒqVqqWq\WqOW|jt	|ƒƒ}|j
|jt	|ƒƒƒ|j
|ƒq*W|S(s±Bisect for entries for all paths and their children.

        This will use bisect to find all records for the supplied paths. It
        will then continue to bisect for any records which are marked as
        directories. (and renames?)

        :param paths: A sorted list of (dir, name) pairs
             eg: [('', 'a'), ('', 'f'), ('a/b', 'c')]
        :return: A dictionary mapping (dir, name, file_id) => [tree_info]
        iiR$R&i(RJRÓt
itervaluesR¢R3RRtRrRhtsortedRVRÜ(RR³R¹tfound_dir_namestprocessed_dirstnewly_foundtpending_dirstpaths_to_searcht
entry_listtdir_name_idt
trees_infotis_dirt	tree_infoRŸtsubdirtnameR†RPtdir_name((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_bisect_recursive¶s@					

#c@sóˆjƒˆjƒ}t|ƒdkr,dSˆjƒtd	d
ddgƒ‰‡‡fd†}|dˆjƒkr§tjg}xA|ƒD]}||dd)qŒWnx|ƒD]}|dd3q±Wgˆ_|dgˆ_	ˆj
dtƒdS(
sÚDiscard any parents trees beyond the first.

        Note that if this fails the dirstate is corrupted.

        After this function returns the dirstate contains 2 trees, neither of
        which are ghosted.
        iNR!R&c3@sÐxÉˆjD]¾}g}x]t|dƒD]K\}}|V|ddd|dddfˆkr'|j|ƒq'q'W|r
t|ƒt|dƒkr£|d2qÈx"t|ƒD]}|d|=q°Wq
q
WdS(Nii(R5t	enumerateRRytreversed(R”tdeleted_positionstposRÒ(t
dead_patternsR(s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pytiter_entries_removables*iiR[(R!R&(R!R!(R&R&(R&R!(R¥tget_parent_idsRyt_read_dirblocks_if_neededRJt
get_ghostsR tNULL_PARENT_DETAILSR6R7R]Rr(RtparentsRòtempty_parentRÒ((RñRs3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_discard_merge_parentsós 

	cC@s$tjgt|jƒt|jƒS(N(R RöRyR7R6(R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRscC@sÌ|dkr(|dkr(|dkr(dS|dkoI|dkoI|dksˆ|j|j|d|ddƒsˆtd|ƒ‚qˆn|j|ddfƒ\}}|sÈ|jj||gfƒn|S(sžEnsure a block for dirname exists.

        This function exists to let callers which know that there is a
        directory dirname ensure that the block for it exists. This block can
        fail to exist because of demand loading, or because a directory had no
        children. In either case it is not an error. It is however an error to
        call this if there is no parent entry for the directory, and thus the
        function requires the coordinates of such an entry to be provided.

        The root row is special cased and can be indicated with a parent block
        and row index of -1

        :param parent_block_index: The index of the block in which dirname's row
            exists.
        :param parent_row_index: The index in the parent block where the row
            exists.
        :param dirname: The utf8 dirname to ensure there is a block for.
        :return: The index for the block.
        R.iiiÿÿÿÿsbad dirname %r(tendswithR5RoRwR„(Rtparent_block_indextparent_row_indexR‰R’R“((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR} s$ cC@sí|dddd!dkr9td|ddfƒ‚ndgfdgfg|_|jdd}d}d}|j}xb|D]Z}|dd|krÑg}|dd}|jj||fƒ|j}n||ƒqW|jƒdS(	s‘Load new_entries into self.dirblocks.

        Process new_entries into the current state object, making them the active
        state.  The entries are grouped together by directory to form dirblocks.

        :param new_entries: A sorted list of entries. This function does not sort
            to prevent unneeded overhead when callers have a sorted list already.
        :return: Nothing.
        iiR.sMissing root row %riN(R.R.(R.R.(RoR5Rt"_split_root_dirblock_into_contents(Rtnew_entriest
current_blocktcurrent_dirnametroot_keytappend_entryRÒ((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_entries_to_current_stateEs 
	
cC@s³|jddgfkr6td|jdfƒ‚ng}g}xD|jddD]1}|ddsx|j|ƒqT|j|ƒqTWd|f|jd<d|f|jd<dS(sÖSplit the root dirblocks into root and contents-of-root.

        After parsing by path, we end up with root entries and contents-of-root
        entries in the same block. This loop splits them out again.
        iR.sbad dirblock start %riN(R5t
ValueErrorR(Rt
root_blocktcontents_of_root_blockRÒ((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRýds	cC@sÏtjj|ƒ\}}||df}|j|ƒ\}}|sFgSg}|j|d}|j||ƒ\}	}
xS|	t|ƒkrÊ||	ddd!|dd!krÊ|j||	ƒ|	d7}	qxW|S(s?Return a list with all the entries that match path for all ids.R.iii(RRPRhRwR5RxRyR(RRPR‰RŠtkeyR’R“tresultR”R•R–((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_entries_for_pathys"cC@sœt|dƒ}x|t|dƒD]j\}}|j|ƒd|d}|d||d<t|dƒ||d<tj|d||d<q!Wdj|ƒS(s˜Serialize entry to a NULL delimited line ready for _get_output_lines.

        :param entry: An entry_tuple as defined in the module docstring.
        iiiiiR£(tlistRítextendRnR t	_to_yesnotjoin(RRÒtentire_entryttree_numbert	tree_datattree_offset((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_entry_to_line‹s
cC@s d|jƒ}dd|dS(s1How many null separated fields should be in each entry row.

        Each line now has an extra '\n' field which is not used
        so we just skip over it

        entry size::
            3 fields for the key
            + number of fields per tree_data (5) * tree count
            + newline
         iii(t_num_present_parents(Rt
tree_count((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR¦žscC@s£|j|ƒ\}}|s˜|sxtj|dƒ\}}|j||dƒdsxtj|dd!t|ƒƒ‚qxn|jj||dgfƒn|j|S(s…Return the block that key should be present in.

        :param key: A dirstate entry key.
        :return: The block tuple.
        iii(	RwRRhR{RR|RnR5R„(RRtadd_if_missingR’R“R˜tparent_name((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_find_block¬s% cC@sÝ|dd!dkrdtfSy>|jdk	rZ|j|jd|dkrZ|jtfSWntk
rnnXt|j|ddd|jƒ}|t|jƒko¾|j|d|dk}||_d|_||fS(	sxFind the dirblock index for a key.

        :return: The block index, True if the block for the key is present.
        iiR.itcacheiÿÿÿÿ(R.R.N(	RrRHR8R5t
IndexErrortbisect_dirblockRARyRI(RRR’R“((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRwÂs

		cC@sít|ƒ}y‚|jdk	r|jd}|dkr||dd|kr|||dkr||_||d|k}||fSnWntk
r¡nXtj||gfƒ}||ko×||d|k}||_||fS(s€Find the entry index for a key in a block.

        :return: The entry index, True if the entry for the key is present.
        iiN(RyRIR8RRÔRÕ(RRR”t	len_blockR•R“((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRxÞs 
$	
	c
C@sòtj|d|ƒ}yÂ|jƒz…|jƒ}t|ƒ}g}x@|D]8}|jjj|ƒ}|j||fƒ|jƒqJW|j	|gƒ|j
|jƒWdx|D]\}	}|jƒq±W|jƒXWn|jƒ‚nX|S(sŽCreate a dirstate from a bzr Tree.

        :param tree: The tree which should provide parent information and
            inventory ids.
        :param sha1_provider: an object meeting the SHA1Provider interface.
            If None, a DefaultSHA1Provider is used.
        :return: a DirState object which is currently locked for writing.
            (it was locked by DirState.initialize)
        RQN(
R t
initializet	lock_readRóRytbrancht
repositoryt
revision_treeRtset_parent_treestset_state_from_inventorytroot_inventorytunlock(
ttreetdir_state_filenameRQRt
parent_idstnum_parentstparent_treest	parent_idtparent_treetrevid((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt	from_tree÷s*	


cC@s@ttjtjtjtjtjtj|ƒƒƒƒƒƒƒS(N(R
Rt_check_delta_unique_idst_check_delta_unique_old_pathst_check_delta_unique_new_pathst_check_delta_ids_match_entryt_check_delta_ids_are_validt(_check_delta_new_path_entry_both_or_None(Rtdelta((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_check_delta_is_valids	cC@sƒ|jƒtj}i}i}tƒ}tƒ}t|j|ƒdtƒ}x|D]ˆ\}}}	}
|	|ks}|	|kr™|j|pŒ||	dƒn|dk	rÁ|jdƒ}|||	<n
|j	|	ƒ|dk	r¡|
dkrü|j||	dƒn|jdƒ}t
j|ƒ\}}|r?|j	||
jfƒn|||	f}
t
j|
j}|dkr||
jpvd}nd}|
||
j||f||	<nd||fkrSx%|jd|ƒD]}|dd|ksÆ|dd|krúqÆn|dd}|dd	}|d	dd}|d	dd
}|d	dd}t
j||ƒ}|||dd<|t|ƒ}||}|||ddf}
t
j||ƒ}|
||||f||dd<qÆWqSqSW|j||dƒy:|j|jƒƒ|j|jƒƒ|j|dƒWnPtjk
r~}t|_dt|ƒkrb‚ntj|d
|fƒ‚nXdS(sõApply an inventory delta to the dirstate for tree 0

        This is the workhorse for apply_inventory_delta in dirstate based
        trees.

        :param delta: An inventory delta.  See Inventory.apply_delta for
            details.
        treversesrepeated file_idsutf-8snew_path with no entryR*R.iiiiisintegrity errorserror from _get_entry. %sN( RôRRmRJRÞR5Rrt_raise_invalidR8R¢RRhR*R R‚R‡treference_revisiont
executablet_iter_child_entriesRtRyt_check_delta_ids_absentt_apply_removalst	iteritemst_apply_insertionstvaluest_after_delta_check_parentsRRƒR4RntInconsistentDeltaDelta(RR4Rmt
insertionstremovalsR÷tnew_idstold_pathtnew_pathR†t	inv_entrytdirname_utf8RŠRRŸRftchildt
child_dirnametchild_basenameR9told_child_pathtchild_suffixtnew_child_dirnametnew_child_pathR\((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pytupdate_by_delta#sx	
			



(		
			#		cC@s x™t|dtdtjdƒƒD]v\}}tj|ƒ\}}|j||dƒ\}}}}	y|j|d|}
Wn$tk
r£|j	||dƒnX|	sÃ|
ddddkrÙ|j	||dƒn||
ddkr|j	||d|
ddƒn|j
|
ƒ|j|d	dƒ\}}}}	|r"xR|j|dD]<}|dddd
krU|j	||
dddƒqUqUWq"q"WdS(NR6RiisWrong path for old path.Rgis/Attempt to remove path has wrong id - found %r.R.R&R!s:The file id was deleted but its children were not deleted.(R&R!(RÞRrtoperatort
itemgetterRRhR{R5RR7t_make_absent(RRCR†RPR‰RŠtblock_itentry_it	d_presentt	f_presentRÒtchild_entry((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR<xs.!


!cC@syFx?t|ƒD]1\}}}}}|j||||d|ƒqWWn4tjk
r||j|jdƒ|ddƒnXdS(NRdRaisMissing parent(RÞRsRR|R7tdecode(RtaddsRRŸR9RfRd((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR>›s"cC@sƒ|jƒ|jƒ|jgkr5t|jƒ‚nt|jƒdkrŽtj}x%|j	ƒD]}|dj
|ƒq`W|jj
|ƒn||jd<t|j|ƒdt
ƒ}g}g}g}tj}|j}	d}
tƒ}tƒ}xÐ|D]È\}
}}}|d
k	r@||jkr@|j||d|ƒn|d
krUd
}nb|d
krw|j||dƒn||ƒ}tj|ƒ\}}|r·|j||jfƒn|
d
krÌd
}n||
ƒ}|
d
kr|j
d
|||	|ƒt
fƒ|j|ƒqù|d
krA|j
|d
|d
t
fƒqù|
|f|
kru|j
||||	|ƒfƒqù|j|ƒg}|j
||||	|ƒtfƒtt|jd|ƒƒƒ}xÚ|D]Ò}|d\}}}|rÿ|d|}n|}|r"||t|ƒ}n/|dkr=tdƒ‚n|t|ƒd}|j
d
||dd	|ddtfƒ|j
|||dd	d
tfƒqÏW|j
|||d
tfƒqùW|j||dƒy;|j|ƒ|j |ƒ|j!|ƒ|j"|dƒWnPt#j$k
re}t
|_%d
t&|ƒkrI‚nt#j'|d|fƒ‚nX|j(dt
ƒd
|_)d
S(s§Update the parents of this tree after a commit.

        This gives the tree one parent, with revision id new_revid. The
        inventory delta is applied to the current basis tree to generate the
        inventory for the parent new_revid, and all other parent trees are
        discarded.

        Note that an exception during the operation of this method will leave
        the dirstate in a corrupt state where it should not be saved.

        :param new_revid: The new revision id for the trees parent.
        :param delta: An inventory delta (see apply_inventory_delta) describing
            the changes from the current left most parent revision to new_revid.
        iiR6R.smismatched entry file_id %rsnew_path with no entryR`s!cannot rename directory to itselfisintegrity errorserror from _get_entry. %sR[N(R.R.(*RôRùR6R
tupdate_basis_by_deltaRyR7R Röt
_iter_entriesRRÞR5RrRRmt_inv_entry_to_detailsRJR8R†R7RRhR¢R*t_update_basis_apply_deletesR3RîR
R:RoR;t_update_basis_apply_addst_update_basis_apply_changesR@RRƒR4RnRAR]R=(RR4t	new_revidRøRÒRZtchangestdeletesRmtinv_to_entryt	root_onlyR÷RDRERFR†RGt
new_path_utf8RHt
basename_utf8R tnew_deletesRJRKt
child_file_idtsource_pathttarget_pathR\((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR[¤s 

	
						
		

,"


			cC@sÓ|s
dS|jƒ}x¶|D]®}x¥|j|dƒD]‘}|j|d|d|ƒ\}}}	}
|
sqq6n|j|d|}|dd|kr q6n|jd|dd!jdƒ|dƒq6WqWdS(	sACheck that none of the file_ids in new_ids are present in a tree.Niiis%s/%sRasBThis file_id is new in the delta but already present in the target((t
_get_id_indexR²R{R5R7RY(RRDR4t
tree_indextid_indexR†RRTRURVRWRÒ((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR;As
) cC@s"t|_tj|||ƒ‚dS(N(RrR4RtInconsistentDelta(RRPR†treason((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR7Us	c(C@sW|jdd„ƒd}tj}x.|D]&\}}}}}tj|ƒ\}	}
||	|
|ƒ}|j|ƒ\}}
|
sètj|	ƒ\}}|j||dƒ\}}}}|sÒ|j||dƒn|j|||	ƒn|j	|d}|j
||ƒ\}}
|rC|dk	rC|j||d|fƒqCn|
r°||}|ddd}|dkr‚||dd<q²|d	krštƒ‚q²|j||d
ƒnxÚt
|d|dƒD]Á}|dksÈ|t|ƒkròqÈn||}|dd |	|
fkrqÈn|dd|krFtd|fƒ‚n|ddd}|dkrÈ|j||d
|ddfƒqÈqÈW|tj|gf}|j||ƒ|ddd}|dkr|jƒ}|j|dƒ}x2|D]}|j|d|ddƒ\}}} }!|!s0qõn|j	|d|}"|"dd|kr_qõn|"ddd}#|#dkr“|j||dƒn|"dd \}$}%|$r¾|$d|%}&n|%}&|d	|dtdƒ|"dd<|d	|&dtdƒ|dd<qõWn|d	kr#tƒ‚n|d}'|'dkr)|j|||ƒq)q)WdS(s¸Apply a sequence of adds to tree 1 during update_basis_by_delta.

        They may be adds, or renames that have been split into add/delete
        pairs.

        :param adds: A sequence of adds. Each add is a tuple:
            (None, new_path_utf8, file_id, (entry_details), real_add). real_add
            is False when the add is the second half of a remove-and-reinsert
            pair created to handle renames and deletes.
        RcS@s|dS(Ni((R-((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt<lambda>isRgis;Unable to find block for this record. Was the parent added?s2considered a real add but still had old_path at %siR!R&sEAn entry was marked as a new add but the basis target already existedisI_find_entry_index didnt find a key match but walking the data did, for %ssWwe have an add record for path, but the path is already present with another file_id %ss-We found a tree0 entry that doesnt make senseR`R.R$N((tsortR	tStaticTupleRRhRwR{R7R}R5RxR8R
trangeRyRoR RöR„RlR²R3((RRZR"tstRERFR†tnew_detailstreal_addR‰RŠRœR’R“R—R˜R™RšR–R›R”R•RÒt
basis_kindtmaybe_indextmaybe_entrytactive_kindRntkeysRRTRURVRWtactive_entrytreal_active_kindt
active_dirtactive_nametactive_pathtnew_kind((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR_Ys”	!



	
)
 '
cC@sˆd}x{|D]s\}}}}|jd||ƒ}|ddks\|ddddkrr|j||dƒn||dd<q
WdS(sÎApply a sequence of changes to tree 1 during update_basis_by_delta.

        :param adds: A sequence of changes. Each change is a tuple:
            (path_utf8, path_utf8, file_id, (entry_details))
        Rgiis$changed entry considered not presentN(RqR8R7(RRbR"RERFR†RvRÒ((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR`Ús(
cC@s¹tj}x©|D]¡\}}}}}||dkkrM|j||dƒntj|ƒ\}}	|j||	dƒ\}
}}}
|
sŸ|j||dƒn|j|
d|}|ddd}|dd|krð|j||dƒnd}|ddd}|dkr#|dkr´|ddd}|jd||ƒ}|ddddkru|j||d	ƒn.|ddddkr£|j||d
ƒn||dd<n|j|
d|=|dkrl|j	|ddfƒ\}}|r |j|d}|s|j|=qq qlnI||dd<|j|ddƒ\}}}}|rl|j|d}nxB|D]:}|ddd}|dkrs|j||d
ƒqsqsWqWdS(sApply a sequence of deletes to tree 1 during update_basis_by_delta.

        They may be deletes, or renames that have been split into add/delete
        pairs.

        :param deletes: A sequence of deletes. Each delete is a tuple:
            (old_path_utf8, new_path_utf8, file_id, None, real_delete).
            real_delete is True when the desired outcome is an actual deletion
            rather than the rename handling logic temporarily deleting a path
            during the replacement of a parent.
        sbad delete deltais)basis tree does not contain removed entryiismismatched file_id in tree 1RgR&s-Dirstate did not have matching rename entriess3Dirstate had a rename pointing at an inactive tree0R$R.s:The file id was deleted but its children were not deleted.N((
R RöR8R7RRhR{R5RqRw(RRctnullRERFR†R–treal_deleteR‰RŠR’R•tdir_presenttfile_presentRÒR{t	dir_blocktold_kindRR}tdir_block_indexR“RTRURVRWRXtchild_basis_kind((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR^ésX	!



!
cC@s–x|D]‡\}}|j|||ƒ}|ddkrW|j|jdƒ|dƒn|d|ddkr|j|jdƒ|dƒqqWdS(sQCheck that parents required by the delta are all intact.
        
        :param parents: An iterable of (path_utf8, file_id) tuples which are
            required to be present in tree 'index' at path_utf8 with id file_id
            and be a directory.
        :param index: The column in the dirstate to check for parents in.
        iRasThis parent is not present.iR$sThis parent is not a directory.N(RqR8R7RY(RR÷tindexRHR†RÒ((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR@6s
cC@sÂy||jd@}Wntk
r)dSX|dkr¾|jdkrR|jƒn|j|jkr¾|j|jkr¾d||j|dddt|ƒf|dd<|j	|gƒq¾ndS(s±Note the sha1 of a file.

        :param entry: The entry the sha1 is for.
        :param sha1: The observed sha1.
        :param stat_value: The os.lstat for the file.
        iðR#iiiN(
tst_modetKeyErrorR8R@t_sha_cutoff_timetst_mtimetst_ctimeRR€R](RRÒRt
stat_valuet_stat_to_minikindRŸ((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_observed_sha1Js

cC@s ttjƒƒd|_|jS(sœReturn cutoff time.

        Files modified more recently than this time are at risk of being
        undetectably modified and so can't be cached.
        i(tintttimeR@(R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRŽ`s
cC@s
tj|ƒS(s(Return the os.lstat value for this path.(Rtlstat(RRRÒ((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_lstatmscC@s!tjd|ƒ|jj|ƒS(Nsdirstate sha1 (R
tmutterRDR(RR((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRFqscC@stt|@ƒS(sIs this file executable?(tboolR(Rtmodetold_executable((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_is_executablewscC@s|S(s6On win32 the executable bit is stored in the dirstate.((RRšR›((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_is_executable_win32{stwin32cC@sdtj}t|tƒr*|j|ƒ}ntj|ƒ}|dkr`|j|ƒjdƒ}n|S(sRead the target of a symlinksutf-8tasciisUTF-8(sutf-8sascii(Rt_fs_enct
isinstancetunicodeRmRtreadlinkRY(RRtold_linktfs_encodingttarget((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt
_read_link‚s	cC@s|jƒ|jS(s>Return a list of the parent tree revision ids that are ghosts.(R¥R6(R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRõ•s
cC@sœ|jtjkrA|jtjkrA|jjdƒ|jjƒSg}|j|j|j	ƒƒƒ|j|j
|jƒƒ|j|j
ƒƒ|j|ƒS(s5Serialise the entire dirstate to a sequence of lines.i(R1R RWR2R9Rªt	readlinesRt_get_parents_lineRót_get_ghosts_lineR6Rt_get_entry_linest_get_output_lines(Rtlines((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt	get_linesšs
cC@s djtt|ƒƒg|ƒS(s7Create a line for the state file for ghost information.R£(R
RnRy(Rt	ghost_ids((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRª§scC@s djtt|ƒƒg|ƒS(s9Create a line for the state file for parents information.R£(R
RnRy(RR'((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR©«scC@st|j|jƒƒS(sCreate lines for entries.(tmapRR\(R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR«¯scC@st|jƒ}|dkr(td„}|S|dkrDtd„}|S|dkr`td„}|Std„}|SdS(	sGet a function which converts entry fields into a entry record.

        This handles size and executable, as well as parent records.

        :return: A function which takes a list of fields, and returns an
            appropriate record for storing in memory.
        icS@sW|d|d|df}||d|d||dƒ|ddk|d	fgfS(
NiiiiiiiR+i((RÑt_inttpath_name_file_id_key((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pytfields_to_entry_0_parents¾s

icS@s‰|d|d|df}||d|d||dƒ|ddk|d	f|d
|d||dƒ|d
dk|dfgfS(NiiiiiiiR+iii	i
ii((RÑR±R²((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pytfields_to_entry_1_parentÊs



ic	S@s»|d|d|df}||d|d||dƒ|ddk|d	f|d
|d||dƒ|d
dk|df|d|d||dƒ|ddk|dfgfS(NiiiiiiiR+iii	i
iii
iiii((RÑR±R²((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pytfields_to_entry_2_parentsÞs"





c	S@s“|d|d|df}gtdt|ƒddƒD]K}||||d|||dƒ||ddk||df^q8}||fS(NiiiiiR+i(R±Ry(RÑR±R²tcurttrees((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pytfields_to_entry_n_parentsùskN(RR”(Rtnum_present_parentsR³R´RµR¸((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR§³s	
	cC@s|jƒt|jƒS(s=Return a list of the parent tree ids for the directory state.(R¥R
R7(R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRós
c	C@sä|jƒ||df}|j|ƒ\}}|sD|dttfS|j|d}|j||ƒ\}}xd|t|ƒkrÓ||dd|krÓ||d|ddkrÆ||ttfS|d7}qpW||ttfS(swGet the coordinates for a path in the state structure.

        :param dirname: The utf8 dirname to lookup.
        :param basename: The utf8 basename to lookup.
        :param tree_index: The index of the tree for which this lookup should
            be attempted.
        :return: A tuple describing where the path is located, or should be
            inserted. The tuple contains four fields: the block index, the row
            index, the directory is present (boolean), the entire path is
            present (boolean).  There is no guarantee that either
            coordinate is currently reachable unless the found field for it is
            True. For instance, a directory not present in the searched tree
            may be returned with a value one greater than the current highest
            block offset. The directory present field will always be True when
            the path present field is True. The directory present field does
            NOT indicate that the directory is present in the searched tree,
            rather it indicates that there are at least some files in some
            tree present there.
        R.iiRg(RôRwR3R5RxRyRr(	RR‰RŠRmRR’R“R”R•((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR{	s
-cC@s]|jƒ|d
k	rt|ƒtk	rJtjdt|ƒ|fƒ‚ntj|ƒ\}}|j|||ƒ\}}}	}
|
sŠdS|j	|d|}|ddoÂ|d|ddksÔt
dƒ‚n|r|dd|krt|_tjdƒ‚qn|S|j
ƒj|dƒ}|s2dSx |D]}
|j|
ƒ\}}|s`q9n|j	|d}|j|
|ƒ\}}|r9|j	|d|}|d|dd	krÀ|S|d|ddkræ|râ|SdS|d|ddkr&t
d
||d|d|fƒ‚n|d|d}|j|d|d|ƒSq9WdSd
S(s«Get the dirstate entry for path in tree tree_index.

        If either file_id or path is supplied, it is used as the key to lookup.
        If both are supplied, the fastest lookup is used, and an error is
        raised if they do not both point at the same row.

        :param tree_index: The index of the tree we wish to locate this path
            in. If the path is present in that tree, the entry containing its
            details is returned, otherwise (None, None) is returned
            0 is the working tree, higher indexes are successive parent
            trees.
        :param fileid_utf8: A utf8 file_id to look up.
        :param path_utf8: An utf8 path to be looked up.
        :param include_deleted: If True, and performing a lookup via
            fileid_utf8 rather than path_utf8, return an entry for deleted
            (absent) paths.
        :return: The dirstate entry tuple for path, or (None, None)
        spath_utf8 is not a str: %s %riiiR!R&sunversioned entry?s<integrity error ? : mismatching tree_index, file_id and pathtfdlts,entry %r has invalid minikind %r for tree %rRbRdN(NN(R!R&((NN(NN(NN(RôR8RpRnRRƒRRhR{R5RoRrR4RlR²RwRxRq(RRmRbRdRcR‰RŠR’R•R…R†RÒt
possible_keysRR“R”t	real_path((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRq.sX
	!&	
cC@s¾|dkrtƒ}n|||ƒ}dgfdgfg}|ddjddtjfdddttjfgfƒ|jƒy|j	g|ƒ|j
ƒWn|jƒ‚nX|S(s—Create a new dirstate on path.

        The new dirstate will be an empty tree - that is it has no parents,
        and only a root node - which has id ROOT_ID.

        :param path: The name of the file for the dirstate.
        :param sha1_provider: an object meeting the SHA1Provider interface.
            If None, a DefaultSHA1Provider is used.
        :return: A write-locked DirState object.
        R.iiR$N(R8RRRtROOT_IDR3R R~t
lock_writet	_set_datatsaveR$(tclsRPRQRtempty_tree_dirblocks((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR~s

cC@s|j}tj|}|j}|dkr@d}d}t}nµ|dkr…|jd	krdd}n|jjdƒ}d}t}np|dkr»|jpd}|j	p¬d}|j
}n:|dkrå|jpÓd}d}t}ntd|ƒ‚t
j|||||ƒS(
s1Convert an inventory entry (from a revision tree) to state details.

        :param inv_entry: An inventory entry whose sha1 and link targets can be
            relied upon, and which has a revision set.
        :return: A details tuple - the details for a single tree at a path +
            id.
        R%R.iR)RaRstree-references
can't pack %sN(R‡R R‚trevisionR3tsymlink_targetR8Rmt	text_sha1t	text_sizeR9R8RzR	Rs(RGR‡RŸRRfRR9((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR]¢s0		
					cc@s<g}|g}d}x |r7|}g}x|D]ÿ}|j|ddfƒ\}}|dkrƒd}t|jƒdkrƒdSn|sq1n|j|}	x‘|	dD]…}
|
d|d}||krÓ|
Vn|dkr§|
ddr|
ddd|
dd}n|
dd}|j|ƒq§q§Wq1WqWdS(s©Iterate over all the entries that are children of path_utf.

        This only returns entries that are present (not in 'a', 'r') in
        tree_index. tree_index data is not refreshed, so if tree 0 is used,
        results may differ from that obtained if paths were statted to
        determine what ones were directories.

        Asking for the children of a non-directory will return an empty
        iterator.
        RgR.iiNR$R`(RwRyR5R(RRmRdRâtnext_pending_dirsR"RPR’R“R”RÒR‡((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR:Æs2		

!cc@s<|jƒx+|jD] }x|dD]}|Vq%WqWdS(s¨Iterate over all the entries in the dirstate.

        Each yelt item is an entry in the standard format described in the
        docstring of bzrlib.dirstate.
        iN(RôR5(RR%RÒ((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR\ïs
cC@sU|jdkrNi}x*|jƒD]\}}|j||ƒq"W||_n|jS(s¬Get an id index of self._dirblocks.

        This maps from file_id => [(directory, name, file_id)] entries where
        that file_id appears in one of the trees.
        N(R=R8R\R…(RRnRttree_details((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRlúscC@sl|d}tjj|ƒ}||kr>tj|ƒ||<n*||}||krh||f||<ndS(s(Add this entry to the _id_index mapping.iN(R	Rst
from_sequence(RRnRœR†t
entry_keys((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR…	s	

cC@sA|d}t||ƒ}|j|ƒtjj|ƒ||<dS(sšRemove this entry from the _id_index mapping.

        It is an programming error to call this when the entry_key is not
        already present.
        iN(R
tremoveR	RsRÉ(RRnRœR†RÊ((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_remove_from_id_index	s

cC@sztjg}|jdƒdj|ƒ}|jdtj|ƒfƒt|ƒd}|jd|fƒ|j|ƒ|S(sŽFormat lines for final output.

        :param lines: A sequence of lines containing the parents list and the
            path lines.
        R.t
s
crc32: %s
isnum_entries: %s
(R tHEADER_FORMAT_3RR
tzlibtcrc32Ry(RRtoutput_linestinventory_texttnum_entries((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR¬$	s

cC@s"ddd|dtjdf|fS(s%Return a deleted row for fileid_utf8.R`sRECYCLED.BINRiR.(R R~(RRbR÷((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_make_deleted_row4	scC@st|jƒt|jƒS(s0The number of parent entries in each record row.(RyR7R6(R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR9	scC@s1|dkrtƒ}n|||d|ƒ}|S(s/Construct a DirState on the file at path "path".

        :param path: The path at which the dirstate file on disk should live.
        :param sha1_provider: an object meeting the SHA1Provider interface.
            If None, a DefaultSHA1Provider is used.
        :param worth_saving_limit: when the exact number of hash changed
            entries is known, only bother saving the dirstate if more than
            this count of entries have changed. -1 means never save.
        :return: An unlocked DirState object, associated with the given path.
        RRN(R8R(RÁRPRQRRR((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyton_file=	s
	cC@s-|jƒ|jtjkr)t|ƒndS(sôRead in all the dirblocks from the file if they are not in memory.

        This populates self._dirblocks, and sets self._dirblock_state to
        IN_MEMORY_UNMODIFIED. It is not currently ready for incremental block
        loading.
        N(R¥R2R R0t_read_dirblocks(R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRôO	s
cC@s¨|jƒ|jjƒ}|jdƒ}t|dƒ}|dd!|_|jjƒ}|jdƒ}t|dƒ}|dd!|_tj|_	|jj
ƒ|_dS(s
This reads in the metadata header, and the parent ids.

        After reading in, the file should be positioned at the null
        just before the start of the first record in the file.

        :return: (expected crc checksum, number of entries, parent list)
        R£iiiÿÿÿÿiN(t
_read_preludeR9treadlineRhR”R7R6R RWR1ttellR?(Rtparent_lineRR(t
ghost_linet
num_ghosts((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_read_headerZ	s
cC@s>|jstj|ƒ‚n|jtjkr:|jƒndS(s/Read the header of the dirstate file if needed.N(R;RtObjectNotLockedR1R R0RÝ(R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR¥n	s	cC@s×|jjƒ}|tjkr7tjd|fƒ‚n|jjƒ}|jdƒsktjd|ƒ‚nt|tdƒd!ƒ|_	|jjƒ}|jdƒs·tjdƒ‚nt|tdƒd!ƒ|_
dS(srRead in the prelude header of the dirstate file.

        This only reads in the stuff that is not connected to the crc
        checksum. The position will be correct to read in the rest of
        the file and check the checksum after this point.
        The next entry in the file should be the number of parents,
        and their ids. Followed by a newline.
        sinvalid header line: %rscrc32: smissing crc32 checksum: %riÿÿÿÿs
num_entries: smissing num_entries lineN(R9RØR RÎRRƒt
startswithR”Rytcrc_expectedt_num_entries(Rtheadertcrc_linetnum_entries_line((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR×v	s	cC@s|jƒjt|ƒdƒS(s Find a sha1 given a stat lookup.N(t_get_packed_stat_indexR²R€R8(RRPtstat_result((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pytsha1_from_statŒ	scC@sv|jdkroi}xK|jƒD]=\}}|dddkr"|dd||dd<q"q"W||_n|jS(s+Get a packed_stat index of self._dirblocks.iR#iiN(R>R8R\(RR‹RRÈ((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRå	s!cC@s|jrtjdƒdS|jƒs*dSt}|jdkrv|jjƒ\}}||_|j|_	|svdSnz^|j
ƒ}|j	jdƒ|j	j|ƒ|j	j
ƒ|j	jƒ|jƒ|jƒWd|r|jjƒ|_|jj|_	nXdS(s¿Save any pending changes created during this session.

        We reuse the existing file, because that prevents race conditions with
        file creation, and use oslocks on it to prevent concurrent modification
        and reads - because dirstate's incremental data aggregation is not
        compatible with reading a modified file, and replacing a file in use by
        another process is impossible on Windows.

        A dirstate in read only mode should be smart enough though to validate
        that the file has not changed, and otherwise discard its cache and
        start over, to allow for fine grained read lock duration, so 'status'
        wont block 'commit' - for example.
        s4Not saving DirState because _changes_aborted is set.Ntwi(R4R
R˜t
_worth_savingR3R<R;ttemporary_write_lockR#R9R®Rªt
writelinesttruncatetflusht_maybe_fdatasyncR^trestore_read_lock(Rtgrabbed_write_locktnew_lockR((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRÀš	s.	
	

cC@s/|jjdƒr+tj|jjƒƒndS(s4Flush to disk if possible and if not configured off.sdirstate.fdatasyncN(ROR²Rt	fdatasyncR9R(R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRîÑ	scC@sp|jtjks$|jtjkr(tS|jtjkrl|jdkrMtSt|j	ƒ|jkrltSntS(s'Is it worth saving the dirstate or not?iÿÿÿÿ(
R1R RYR2RrRXRLR3RyRK(R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRéÖ	scC@s>||_|jdtƒt|ƒ|_d|_d|_dS(sÆSet the full dirstate data in memory.

        This is an internal function used to completely replace the objects
        in memory state. It puts the dirstate into state 'full-dirty'.

        :param parent_ids: A list of parent tree revision ids.
        :param dirblocks: A list containing one tuple for each directory in the
            tree. Each tuple contains the directory path and a list of entries
            found in that directory.
        R[N(R5R]RrR
R7R8R=R>(RR't	dirblocks((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR¿ê	s
		cC@s¡|jƒt|ƒr(t|jƒ‚n|jdd|ƒ}|dd|krUdS|j|ƒ|jdd|fdddd|ddd	ƒ|jƒdS(
s:Change the id of path to new_id in the current working tree.

        :param path: The path inside the tree to set - '' is the root, 'foo'
            is the path foo in the root.
        :param new_id: The new id to assign to the path. This must be a utf8
            file id (not unicode, and not None).
        iRdiNR.R$Reii(RôRyR
tset_path_idRqRSRsR](RRPtnew_idRÒ((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRôü	s

c
C@s_|jƒi}i}g|D]\}}||kr|^q}t|ƒ}tj}	xm|jƒD]_}
|
ddddkr‡qcn|
ddgtjg|||
d<|j||
dƒqcWx&t|ƒD]\}}|d}tjg||}d}
xå|j
ƒD]×\}}
|
j}|jdƒ}t
j|ƒ\}}||
kr^|
}n|}
|	|||ƒ}|j|dƒ}x=|D]5}||kr|	d|dtdƒ|||<qqW||krî|j|
ƒ|||<qg}x³t|ƒD]¥}t|ƒs&|jtjƒqt|ƒjƒ}|||dd
krh|j|||ƒqdj|dd	!ƒjdƒ}|j|	d|dtdƒƒqW|j|j|
ƒƒ|j|ƒ|||<|j||ƒqWqÓW|j|jƒƒ}|j|ƒg|D]\}}|^q|_t|ƒ|_|jd
t ƒ||_!dS(sLSet the parent trees for the dirstate.

        :param trees: A list of revision_id, tree tuples. tree must be provided
            even if the revision_id refers to a ghost: supply an empty tree in
            this case.
        :param ghosts: A list of the revision_ids that are ghosts at the time
            of setting.
        iiRgRaR&R.R!R`iR[N((R&R!("RôRyR	RsR\R RöR…RíR8titer_entries_by_dirR†RmRRhR²R3R]R±RtitertnextR
RlRt
_sort_entriestitemsRR7R
R6R]RrR=(RR·tghoststby_pathRntrev_idR%R)tparent_countRuRÒRmtnew_location_suffixtlast_dirnameRPR†RdR‰RŠt
new_entry_keyRÊRœRvtlookup_indexta_keyR¼Rþ((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR!
sf
+	

		


"cC@s(i}|tjd„}t|d|ƒS(s	Given a list of entries, sort them into the right order.

        This is done when constructing a new dirstate from trees - normally we
        try to keep everything in sorted blocks all the time, but sometimes
        it's easier to sort after the fact.
        cS@sg|d\}}}y||}Wn3tk
rV|j|jdƒƒ}|||<nX||||ƒS(NiR`(RRÉRh(RÒt_split_dirst_sttdirpathtfnameR†Rh((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_key¶
s
R(R	RsRÞ(RRät
split_dirsR((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRùª
s	cC@s.dtjkr"tjddƒndtjk}|rGtjdƒn|jƒ|jƒ}tt|j	ƒƒƒ}|j
ƒ}|j
ƒ}d„}x_|s¥|r÷|rÕ|ddddkrÕ||ƒ}q™n|r^|djd	ƒ}tj
|ƒ\}	}
|dj}|	|
|f}tj|dj}
|
d
krU|djpOd}qtd}nd}}	}
}}|sÚ|rœtjd|jd	ƒƒn|j||
d
|djd|d|dtƒ||ƒ}q™|s:|rtjd|ddjd	ƒ|ddjd	ƒƒn|j|ƒ||ƒ}q™||dkrô|ddd|djks|ddd|
krÙ|r£tjd|jd	ƒƒn|j|d|
d
|djd|d|dtƒn||ƒ}||ƒ}q™t|	|ddƒdks=|	|ddkr|d|ddkr|r_tjd|jd	ƒƒn|j||
d
|djd|d|dtƒ||ƒ}q™|rÛtjd|ddjd	ƒ|ddjd	ƒƒn|j|ƒ||ƒ}q™W|jƒd|_d|_|r*tjdƒndS(sÝSet new_inv as the current state.

        This API is called by tree transform, and will usually occur with
        existing parent trees.

        :param new_inv: The inventory object to set current state from.
        tevilis?set_state_from_inventory called; please mutate the tree insteadtdirstatesset_state_from_inventory trace:cS@s'y|jƒSWntk
r"dSXdS(N(Røt
StopIterationR8(titerator((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pytadvanceä
s
iRgRaR*R.sAppending from new '%s'.R9RdRftfullscansTruncating from old '%s/%s'.isUpdating in-place change '%s'.sInserting from new '%s'.sDeleting from old '%s/%s'.s"set_state_from_inventory complete.N(RRER
tmutter_callsiteR˜RôRöR÷R
R\RøRmRRhR†R R‚R‡R8R8RYRsR9RrRStcmp_by_dirsR]R=R>(Rtnew_invttracingtnew_iteratortold_iteratortcurrent_newtcurrent_oldRRftnew_dirnametnew_basenameRõRtcurrent_new_minikindRf((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR"Á
s˜	

	
		
	
	

	
	

		cC@sƒ|jƒddtjfdddttjfgf}d|gfdgfg}|jg|ƒ|j|ƒ|j||ƒdS(s…Wipe the currently stored state and set it to something new.

        This is a hard-reset for the data we are working with.
        R.R$iN(	R¤RR½R3R R~R¿R"R!(Rtworking_invR)t
parent_ghostst
empty_rootRÂ((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pytset_state_from_scratchGs

cC@s	tƒ}x||ddD]l}|ddkrB|j|dƒq|ddkr|jttj|dƒƒ|ddfƒqqW|d|k}|r*|j|dƒ}|j|d|dƒ\}}|sítd|fƒ‚n|dj|ƒ|j	d
k	r*|j|j	|dƒq*nxÎ|D]Æ}|j|ƒ\}	}|shtd|fƒ‚n|j||j
|	dƒ\}
}|s§td|fƒ‚n|j
|	d|
d}|dddkrêtd	|fƒ‚ntj|d<q1W|jƒ|S(s÷Mark current_old - an entry - as absent for tree 0.

        :return: True if this was the last details entry for the entry key:
            that is, if the underlying block has had the entry removed, thus
            shrinking in length.
        iiRgR&iscould not find entry for %sscould not find block for %sR!s
bad row %rN(RJR¢ttupleRRhRRxRoR¨R=R8RÌRwR5R RöR](RRtall_remaining_keystdetailstlast_referenceR”R•R“t
update_keytupdate_block_indextupdate_entry_indextupdate_tree_details((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRSXs8		6 
#
c	!C@sa|j|ƒd}	|dkr+tj}n|j||	ƒ\}
}|||||f}|jƒ}
|sÊ|s7|j|dd!d|	ƒ\}}x¡|t|	ƒkr3|	|}|ddd!|dd!kr/|ddddkr"|jd|dd!jdƒ|dd|ddƒn|d7}q–Pq–Wn|
j	|ddƒ}|so||g|j
ƒf}n8||gf}xüt|ƒD]î}|j|ƒ\}}|sÂt
d	|fƒ‚n|j|d}|j||ƒ\}}|st
d
|fƒ‚n|dkr"t
dƒ‚n||}d|dtdf|dd<|j|||
ƒr‹|j||	ƒ\}
}q‹q‹W|jƒ}|r¢t|ƒd}nxtd|dƒD]í}|j|ƒ\}}|sít
d	|fƒ‚n|j||j|dƒ\}}|s,t
d
|fƒ‚n|j|d|d|}|ddkrm|dj|ƒq¶tj|dd!Œ}|djd|dtdfƒq¶W|	j|
|ƒ|j|
|ƒn||	|
dd<|dkr÷t
dƒ‚n|
j	|ddƒ}||kr2t
d||fƒ‚nx±|D]©}||kr9|j|ƒ\}}|sxt
d|ƒ‚n|j||j|dƒ\}
}|s³t
d|ƒ‚nd|dtdf|j|d|
dd<q9q9W|ddkrStj|dd!Œddf} |j| ƒ\}}|sS|jj|| dgfƒqSn|jƒdS(sŒUpdate an entry to the state in tree 0.

        This will either create a new entry at 'key' or update an existing one.
        It also makes sure that any other records which might mention this are
        updated as well.

        :param key: (dir, name, file_id) for the new entry
        :param minikind: The type for the entry ('f' == 'file', 'd' ==
                'directory'), etc.
        :param executable: Should the executable bit be set?
        :param fingerprint: Simple fingerprint for new entry: canonical-form
            sha1 for files, referenced revision id for subtrees, etc.
        :param packed_stat: Packed stat value for new entry.
        :param size: Size information for new entry
        :param path_utf8: key[0] + '/' + key[1], just passed in to avoid doing
                extra computation.
        :param fullscan: If True then a complete scan of the dirstate is being
            done and checking for duplicate rows should not be done. This
            should only be set by set_state_from_inventory and similar methods.

        If packed_stat and fingerprint are not given, they're invalidated in
        the entry.
        iiiR.Rgs%s/%sRas5Attempt to add item at path already occupied by id %rscould not find block for %ss1update_minimal: could not find other entry for %ssno pathR&s+update_minimal: could not find entry for %ss`We found the entry in the blocks, but the key is not in the id_index. key: %s, existing_keys: %ssnot present: %rR$N(R.(((RR8R R~RxRlRyR7RYR²RRRwRoR5R3t_maybe_remove_rowRR
R±RRRtR„R…R](!RRRŸR9RfReRRdRR”R•R“RvRnt	low_indexR–RÒt
existing_keyst	new_entryt	other_keytother_block_indextother_blocktother_entry_indextother_entryR¹RR$R%tupdate_detailstpointer_pathRœR’t
subdir_key((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRsŒs¤#


	#$

#3#cC@snt}||}x,|dD] }|ddkrt}PqqW|sj|j|ƒ|j||dƒtStS(s±Remove index if it is absent or relocated across the row.
        
        id_index is updated accordingly.
        :return: True if we removed the row, False otherwise
        iiRg(R3RrR¨RÌ(RR”R‹Rntpresent_in_rowRÒtcolumn((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR':s

c@sddlm}ˆjƒtˆjƒdkreˆjdddksetd|ˆjƒƒ‚qentˆjƒdkr°ˆjdddks°td|ˆjƒƒ‚q°ngˆjdD]}|djdƒ^q¾}|t|ƒkrtd|ˆjƒd	||ƒƒ‚nxšˆjD]}xI|dD]=‰|dˆddkr4td
ˆ||ƒfƒ‚q4q4W|dt|dƒkr#td|d||ƒfƒ‚q#q#W‡‡‡‡fd†}ˆjƒd}gt	|ƒD]}t
ƒ^që}xˆjƒD]‰ˆdd
}	tj
ˆddˆddƒ‰tˆdƒ|krxtd|ˆƒ|fƒ‚nd}
xjtˆdƒD]X\‰}|ˆ}|d}
|
dkrÈ|
d7}
n|	|krŽ||	\}}|
dkr|dk	r‹td|	ˆ|fƒ‚q‹qç|
dkr\|d}||kr‹td|	ˆ|fƒ‚q‹qç|ˆkr„tdˆ||fƒ‚n|ƒq|
dkrdˆf||	<q|
dkrÐ|dˆf||	<qˆˆf||	<|ƒqW|
|kr
tdˆfƒ‚q
q
Wˆjdk	rxöˆjjƒD]â\}	}xŸ|D]—}|d
|	krrtd|	|fƒ‚nˆj|ƒ\}}|sŸtd|ƒ‚nˆj|ˆj|dƒ\}}|sCtd|ƒ‚qCqCWt|ƒtt|ƒƒkr0td|fƒ‚q0q0WndS(sÆCheck that invariants on the dirblock are correct.

        This can be useful in debugging; it shouldn't be necessary in
        normal code.

        This must be called with a lock held.
        i(tpformatR.s'dirblocks don't start with root block:
is"dirblocks missing root directory:
R`s#dir names are not in sorted order:
s
keys:
s2entry key for %rdoesn't match directory name in
%rs!dirblock for %r is not sorted:
%sc@s’ˆddd!d
krdSˆjˆdˆddƒ}|dkr]tdˆˆfƒ‚n|dˆddkrŽtd	ˆ|fƒ‚ndS(s Check that the current entry has a valid parent.

            This makes sure that the parent has a record,
            and that the parent isn't marked as "absent" in the
            current tree. (It is invalid to have a non-absent file in an absent
            directory.)
            iiR.NRds"no parent entry for: %s in tree %siR$s:Parent entry for %s is not marked as a valid directory. %s(R.R.(NN(RqR8Ro(tparent_entry(RÒRt	this_pathRm(s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pytcheck_valid_parent‚sis5wrong number of entry details for row
%s,
expected %dRgR!s2file %s is absent in row %r but also present at %rR&s+file %s relocation in row %r but also at %rs6entry %r inconsistent with previous path %r seen at %rs"entry %r has no data for any tree.s%file_id %r did not match entry key %ssmissing block for entry key: %rsmissing entry for key: %rs)id_index contained non-unique data for %sN(tpprintR5RôRyR5RoRhRÞRRttdictR\RRtRíR8R=R=RwRxRJ(RR5R$t	dir_namestdirblockR8Rtitid_path_mapsR†tabsent_positionst
tree_statet
this_tree_mapRŸt
previous_pathtprevious_locttarget_locationRÊRœR’R“R•((RÒRR7Rms3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt	_validateLs°
*!""





#cC@smtj|_tj|_t|_g|_g|_g|_d|_
d|_d|_d|_
i|_dS(s0Forget all state information about the dirstate.N(R R0R1R2R3R4R7R6R5R8R=R>R?R@RA(R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_wipe_stateís								cC@s_|jdk	r$tj|jƒ‚ntj|jƒ|_d|_|jj|_	|j
ƒdS(s$Acquire a read lock on the dirstate.R&N(R;R8RtLockContentionRtReadLockR:R<R#R9RF(R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRûs	cC@s_|jdk	r$tj|jƒ‚ntj|jƒ|_d|_|jj|_	|j
ƒdS(s%Acquire a write lock on the dirstate.RèN(R;R8RRGRt	WriteLockR:R<R#R9RF(R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR¾
s	cC@sV|jdkr!tj|ƒ‚nd|_d|_|jjƒd|_i|_dS(s$Drop any locks held on the dirstate.N(R;R8RtLockNotHeldR9R<R$RA(R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR$
s		
	cC@s|jstj|ƒ‚ndS(s?Check that a lock is currently held by someone on the dirstate.N(R;RRÞ(R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR¤#
s	N(oRRRR‚RuRˆtS_IFDIRtS_IFREGtS_IFLNKR’RrR3RRBR0RWRYRXR~R	RsRötHEADER_FORMAT_2RÎRSRUR8R]R^R¢RÓRÜRìRùRR}RRýR	RR¦RRwRxtstaticmethodR-R5RPR<R>R[R;R7R_R`R^R@R“RŽR—RFRœRtsystplatformR§RõR®RªR©R«R§RóR{RqtclassmethodRR]R:R\RlR…RÌR¬RÔRRÕRôRÝR¥R×RçRåRÀRîRéR¿RôR!RùR"RRSRsR'RERFRR¾R$R¤(((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR 'sì





:			‡	½	³	=	)		%							#		U	#								M		
								
				Q		%O#$	)		
											
	7					—		†		4		¡		
	
	cC@s+y||jd@}Wntk
r)d
SXt|ƒ}|dd\}}}	}
}|dkrt|dkrtd}n||kr²||kr²|dkrœd
S|	|jkr²|Snd
}t}
|dkr«|j|j|
ƒ}|jd
krû|jƒn|j	|jkr|j
|jkrt|dƒdkr|ddddkr|j|ƒ}d||j||f|dd<qdd|j|t
jf|dd<t}
nc|dkrRd
}dddt|f|dd<|dkrI|j|dd|dddƒ\}}}}|j||tj|dd|ddƒƒqt}
n¼|d	kr|d	krst}
n|j||ƒ}|jd
kr¡|jƒn|j	|jkrè|j
|jkrèd	||jt|f|dd<qd	d|jtt
jf|dd<n|
r'|j|gƒn|S(s@Update the entry based on what is actually on disk.

    This function only calculates the sha if it needs to - if the entry is
    uncachable, or clearly different to the first parent's entry, no sha
    is calculated, and None is returned.

    :param state: The dirstate this entry is in.
    :param entry: This is the dirblock entry for the file in question.
    :param abspath: The path on disk for this file.
    :param stat_value: The stat value done on the path.
    :return: None, or The sha1 hexdigest of the file (40 bytes) or link
        target of a symlink.
    iðiiR$R*R#R!R.R(N(RŒRR8R€RRrRœR@RŽRRRyRGR R~R3R{R}RRtR§R](tstateRÒRR‘R’RŸRetsaved_minikindtsaved_link_or_sha1tsaved_file_sizetsaved_executabletsaved_packed_stattlink_or_sha1tworth_savingR9R’R•R…R†((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pytpy_update_entry)
sl
		
	1&		
tProcessEntryPythoncB@s‰eZdddddddddd	d
ddd
ddddgZd„Zejd„Zd„Zd„Zd„Z	d„Z
d„ZRS(told_dirname_to_file_idtnew_dirname_to_file_idtlast_source_parenttlast_target_parenttinclude_unchangedtpartialtuse_filesystem_for_exectutf8_decodetsearched_specific_filestsearch_specific_filestsearched_exact_pathstsearch_specific_file_parentstseen_idsRStsource_indexttarget_indextwant_unversionedR%c		C@sîi|_i|_|tdgƒk|_ddg|_ddg|_||_||_t	j
|_tƒ|_tƒ|_
||_tƒ|_tƒ|_||_||_||_|dkrØtjdƒ‚n||_||_dS(NR.isunsupported target index(R]R^RJRbR8R_R`RaRcRt_utf8_decodeRdReRgRfRhRiRSRjRkRRƒRlR%(	RRaRcRfRSRjRkRlR%((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRS
s(									c	C@s5
|jdkrtj}n|d|j}|d|j}|d}|dk	r¾|dkr¾|jdksztƒ‚nt|j|d|dd|dƒ}|d|j}|d}nd}|dd}|d}	|	d	kr	|dkr	|	d
krñtj	|j
|dƒs0|jj|dƒn|d}
t
jj|
ƒ\}}||dd|ddƒ}
|jj|jd|
ƒ}|dkrÓtj|jjd|dd|dd|
|fƒ‚n|d|j}|d}	n&|dd}|dd}d}
}
|dkr8t}d}t}n¯|d}|d
kr¡|
dkrp|||ƒ}
}
n||j|
<|	dkr’t}nt}t}nF|dkrI|	dkrÂt}nT|dkr|jjj|dƒ\}}|jj|||ƒn||dk}|jr<ttj|dj@ƒ}qç|d}nž|dkrƒ|	dkrjt}n||dk}t}nd|dkr³|	dkr¤t}nt}t}n4|
dkrÑ|||ƒ}
ntj|
|dƒ‚|	dkr%|
dkr|||ƒ}
}
n||j |
<n|rN||j!dkrN|j!d}n…y|j |}Wn:t"k
r›|jj|jd|ƒ}|dd}nX||ddkr¹d}n||j!d<||j!d<|dd}|ddr||j#dkr|j#d}nªy|j|}Wn_t"k
r„|jj|jd|ƒ}|dkrstd||fƒ‚n|dd}nX||ddkr¢d}n||j#d<||j#d<|d}|põ||kpõ||ddkpõ||k}|r|j$rdtfS|
dkrN|||ƒ}
}
|j%|
ƒd}|}n;|j%|
ƒd}|
|
krv|}n|j%|
ƒd}tj&|	}|dd||f|ttf||f|j%|ƒd|j%|ddƒdf||f||ff|fSn(|	dkr»|dkr»||dd|ddƒ}
|jj|jd|ddƒdd}||ddkrˆd}n|dk	rN|jrÐttj'|djƒoÇtj|dj@ƒ}n
|d}|ddd|j%|
ƒdftttfd|fd|j%|ddƒdfd|dfd|fftfS|ddd|j%|
ƒdftttfd|fd|j%|ddƒdfddtfftfSnv|	dkrµ	|dkrµ	||dd|ddƒ}
|jj|jd|ddƒdd}||ddkr:	d}n|dd|j%|
ƒddftttf|df|j%|ddƒddftj&|	df|ddfftfS|	dkr
|d
kr
tj	|j
|dƒs1
|jj|dƒq1
n1|	dkr
|dkr
ntd|	|fƒ‚dS(s´Compare an entry and real disk to generate delta information.

        :param path_info: top_relpath, basename, kind, lstat, abspath for
            the path of entry. If None, then the path is considered absent in 
            the target (Perhaps we should pass in a concrete entry for this ?)
            Basename is returned as a utf8 string because we expect this
            tuple will be ignored, and don't want to take the time to
            decode.
        :return: (iter_changes_result, changed). If the entry has not been
            handled then changed is None. Otherwise it is False if no content
            or metadata changes have occurred, and True if any content or
            metadata change has occurred. If self.include_unchanged is True then
            if changed is not None, iter_changes_result will always be a result
            tuple. Otherwise, iter_changes_result is None unless changed is
            True.
        iiRºRiR‘iitfdltrR&RdsOentry '%s/%s' is considered renamed from %r but source does not exist
entry: %sR%R$RR#R)R(stree-referenceR*s4Could not find target parent in wt: %s
parent of: %sR!tras@don't know how to compare source_minikind=%r, target_minikind=%rN(NN(NN(NN(NN((RjR8R RöRkRotupdate_entryRSRt
is_inside_anyReRfR¢RRPRhRqRtCorruptDirstateR:RrR3R^RDRR“RcR™RˆRRŒtBadFileKindErrorR]R_RR`RaRdRutS_ISREG(RRÒt	path_infoRttsource_detailsttarget_detailsttarget_minikindRYR†tsource_minikindREtold_dirnametold_basenameRPt	old_entrytcontent_changettarget_kindttarget_execRtsource_parent_idtsource_parent_entryRttarget_parent_idttarget_parent_entrytsource_exectchangedt
old_path_utpath_utsource_kindR*((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_process_entryµ
sd




	)

	

			
	
				
		

!
		


		
			+			
		
		+			cC@s|S(N((R((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt__iter__ÀscC@sz|js|drdS|jj|dƒ|dd}|rv|jjtj|jdƒƒƒ|jjdƒndS(s¾Check a result we will yield to make sure we are consistent later.
        
        This gathers result's parents into a set to output later.

        :param result: A result tuple.
        iNiRaR.(RbRiR¢RhRVRtparent_directoriesRm(RRRF((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt_gather_result_for_consistencyÃs	c#	c@sòtj}t}|j}|j}|j}tj}xœ|rÑ|jƒ}|j	dƒ}|j
|ƒ|jj|ƒ}	|j
j|ƒ}
ytj|
ƒ}Wn1tk
rÎ}|jtjkrÈd}
q7‚niXd|tj|jƒ||
f}
|
ddkr7|j
j|j	dƒƒr7|
d d|
d}
q7n|	rK|
rKq6nt}xe|	D]]}|||
ƒ\}}|dk	rXt}|r›|j|ƒn|sª|jrµ|VqµqXqXW|jrK|rK|
rKttj|
djƒoùtj |
dj@ƒ}dd|ftttfdd||ƒdfd|
dfd|ffVn|ddf}|jj!|ƒ\}}|dkr‹|d	7}n|
rª|
ddkrªd}ntj"|
d
|ƒ}y|j#ƒ}Wn‘tk
rb}t$|ddƒ}t%t&f}|jtjtj'tj(fkr)d}q¿t)j*dkr\|j|ksS||kr\d}q¿‚n]X|dddkr¿t+j,|d	dƒ}|d	|dd
kr±t-ƒ‚n|d	|=n|t.|jj/ƒkr
tj0||jj/|dƒr
|jj/|}nd}x»|dk	s+|dk	rÍ|r©|r©|dd|dkr©||dd|dƒdkrâd}x<|t.|d	ƒkr´|d	|}|jr|ddkrñ|j
j|dj	dƒƒrñ|d d|d}qñnttj|djƒotj |dj@ƒ}dd||dƒdftttfdd||d	ƒdfd|dfd|ffVn|ddkr§|d	|=|d	8}n|d	7}qyWy|j#ƒ}Wq£t1k
rÞd}q£Xqxc|d	D]W}||dƒ\}}|dk	rí|r*|j|ƒn|s9|jrD|VqDqíqíW|d	7}|t.|jj/ƒkrtj0||jj/|dƒr|jj/|}qd}qnd}|rÜ|t.|d	ƒkrÜ|d	|}nd}t} d}|rf|t.|d	ƒkrf|d	|}|ddkrl|j
j|dj	dƒƒrc|d d|d}qcqlnd}t}!t}x¬|dk	s“|dk	r&|dkr¢ne|dkr|||ƒ\}}|dk	r	|rå|j|ƒn|sô|jrÿ|Vqÿq	n|dd	|d	ks5|d	|j2ddkr°|d	|dd	krVt} q	||dƒ\}}|dk	r§|r|j|ƒn|sœ|jr§|Vq§nt}!nW|||ƒ\}}|dk	r	t}|rí|j|ƒn|sü|jr	|Vq	n| rS	|dk	rS	|d	7}|t.|d	ƒkrJ	|d	|}qY	d}nt} |!r|dk	r|sj
|jr?
ttj|djƒo¤	tj |dj@ƒ}y||dƒd}"Wn*t3k
rî	t4j5|dtj6ƒ‚nXdd|"ftttfdd||d	ƒdfd|dfd|ffVn|ddkrj
|d	|=|d	8}qj
n|ddkr’
|d	|=|d	8}n|d	7}|t.|d	ƒkr|d	|}|ddkr|j
j|dj	dƒƒr|d d|d}qqnd}t}q{t}!q{W|dk	r‘|d	7}|t.|jj/ƒkrˆtj0||jj/|dƒrˆ|jj/|}q‘d}n|dk	ry|j#ƒ}WqÊt1k
rÆd}qÊXqqWq6Wx|j7ƒD]}|VqßWdS(sIterate over the changes.RaR.iR%stree-referenceiiÿÿÿÿiitprefixtwinerrorRžs.bzrRgN(stree-reference(NN(s.bzr(stree-reference(NN(s	directorystree-reference(stree-reference(NN(stree-reference(8RRmRR‰RfReRt	splitpathR¨RYR¢RSR	R%RRR–tOSErrorterrnotENOENTR8tfile_kind_from_stat_modeRŒt_directory_is_tree_referenceR3RrRŒRaRlR™RˆRtRRwt_walkdirs_utf8RøtgetattrtERROR_DIRECTORYtERROR_PATH_NOT_FOUNDtENOTDIRtEINVALRPRQRÔRÕRoRyR5t	is_insideRRktUnicodeDecodeErrorRtBadFilenameEncodingR t_iter_specific_file_parents(#RRdt_cmp_by_dirsR‰RfReRtcurrent_roottcurrent_root_unicodetroot_entriestroot_abspatht	root_statR\t
root_dir_infotpath_handledRÒRR…tnew_executabletinitial_keyR’R–tcurrent_dir_infotdir_iteratort
e_winerrort
win_errorst	bzr_indexRÿt
path_indextcurrent_path_infot
current_entryR•t
advance_entrytadvance_pathtrelpath_unicode((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pytiter_changesÖsº					'	
			
		

	!		 !
			
	


	
					
		
		

		

 	
cc@soxh|jrj|jjƒ}tj|j|ƒr6qn||jkrKqn|jj|ƒ}g}t}x¼|D]´}|d|j	ddkr§t
}|j|ƒqp|jd
k	rp|d|jddkrpt
}|d|j	ddkr|j|ƒq$|jj|d|j	dƒqpqpW|sGtd||fƒ‚n|j||jdƒƒ}xò|D]ê}|dd|jkrŒqin|j||ƒ\}}	|	d
krÌtd|||fƒ‚n|	r<|j|ƒ|d	dd
kr<|d	dd
kr<|d|jddkr:|d|jd}
n|}
|
ddf}|jj|ƒ\}}
|dkr€|d7}nd
}|t|jjƒkrÐ|jj|}tj|
|dƒsÐd
}qÐn|d
k	r9xW|dD]H}|d|jddkrqçn|jjtj|dd ŒƒqçWq9q<n|	sK|jri|VqiqiW|jj|ƒqWd
S(s$Iter over the specific file parents.iiRgR!s-Missing entry for specific path parent %r, %rRaisEGot entry<->path mismatch for specific path %r entry %r path_info %r iR%R&R.N(RhR¨RRqReRgRSR	R3RkRrRRjR8R¢Rot
_path_infoRYRiR‰RŒRwRyR5R›RtRa(RRdtpath_entriestselected_entriest
found_itemtcandidate_entryRuRÒRR…tentry_path_utf8R¨R’R–Rÿ((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRž/sx
	

	
	%cC@sÖ|jj|ƒ}ytj|ƒ}Wn,tk
rS}|jtjkrMdS‚nX|jddƒd}||t	j
|jƒ||f}|ddkrÒ|jj|ƒrÒ|j
d d	|j
d|_
qÒn|S(
szGenerate path_info for unicode_path.

        :return: None if unicode_path does not exist, or a path_info tuple.
        R`iiÿÿÿÿiR%stree-referenceiN(stree-reference(R%RRR–RR‘R’R8trsplitRR“RŒR”R¥(Rt	utf8_pathtunicode_pathRRˆR\t
utf8_basenametdir_info((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyRµŠs 			%(RRt	__slots__RSRRtR‰RŠRŒR´RžRµ(((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyR\‡
s				%ÿ			ÿZ	[(RÖRR®R¯RR€t
ProcessEntryCRp(RÖRR®R¯RR€(.Rt
__future__RRÔR‘RQRRˆRRPR•RÏtbzrlibRRRRRRRR	R
RR˜R—tobjectRRR R’R[R\tbzrlib._dirstate_helpers_pyxRÖRR®R¯RR€RÁR‰RptImportErrorR\tfailed_to_load_extensiontbzrlib._dirstate_helpers_py(((s3/usr/lib/python2.7/dist-packages/bzrlib/dirstate.pyt<module>ÛsPFÿÿÿÿÿÿÿÿÿÿÿÿ]ÿÿÿ!>

.
-=[ Mr. Bumblebee ]=- _Indonesia_

-=[ Mr. Bumblebee ]=-
_Indonesia_
