mercurial-source: mercurial/revlog.py annotate

annotate mercurial/revlog.py @ 28078:8f016345e6b0

merge with stable

author	Matt Mackall <mpm@selenic.com>
date	Fri, 18 Dec 2015 14:40:11 -0600 (2015-12-18)
parents	29f50344fa83 e240e914d226
children	12f727a5b434

rev	line source
8226 8b2cd04a6e97 put license and copyright info into comment blocks Martin Geisler <mg@lazybytes.net> parents: 8225 diff changeset	1 # revlog.py - storage back-end for mercurial
8b2cd04a6e97 put license and copyright info into comment blocks Martin Geisler <mg@lazybytes.net> parents: 8225 diff changeset	2 #
8b2cd04a6e97 put license and copyright info into comment blocks Martin Geisler <mg@lazybytes.net> parents: 8225 diff changeset	3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
8b2cd04a6e97 put license and copyright info into comment blocks Martin Geisler <mg@lazybytes.net> parents: 8225 diff changeset	4 #
8b2cd04a6e97 put license and copyright info into comment blocks Martin Geisler <mg@lazybytes.net> parents: 8225 diff changeset	5 # This software may be used and distributed according to the terms of the
10263 25e572394f5c Update license to GPLv2+ Matt Mackall <mpm@selenic.com> parents: 10047 diff changeset	6 # GNU General Public License version 2 or any later version.
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	7
8227 0a9542703300 turn some comments back into module docstrings Martin Geisler <mg@lazybytes.net> parents: 8226 diff changeset	8 """Storage back-end for Mercurial.
0a9542703300 turn some comments back into module docstrings Martin Geisler <mg@lazybytes.net> parents: 8226 diff changeset	9
0a9542703300 turn some comments back into module docstrings Martin Geisler <mg@lazybytes.net> parents: 8226 diff changeset	10 This provides efficient delta storage with O(1) retrieve and append
0a9542703300 turn some comments back into module docstrings Martin Geisler <mg@lazybytes.net> parents: 8226 diff changeset	11 and O(changes) merge between branches.
0a9542703300 turn some comments back into module docstrings Martin Geisler <mg@lazybytes.net> parents: 8226 diff changeset	12 """
0a9542703300 turn some comments back into module docstrings Martin Geisler <mg@lazybytes.net> parents: 8226 diff changeset	13
28008 29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	14 from __future__ import absolute_import
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	15
25548 0ca8410ea345 util: drop alias for collections.deque Martin von Zweigbergk <martinvonz@google.com> parents: 24585 diff changeset	16 import collections
28008 29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	17 import errno
28077 e240e914d226 revlog: seek to end of file before writing (issue4943) Gregory Szorc <gregory.szorc@gmail.com> parents: 27345 diff changeset	18 import os
28008 29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	19 import struct
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	20 import zlib
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	21
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	22 # import stuff from node for others to import from revlog
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	23 from .node import (
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	24 bin,
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	25 hex,
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	26 nullid,
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	27 nullrev,
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	28 )
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	29 from .i18n import _
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	30 from . import (
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	31 ancestor,
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	32 error,
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	33 mdiff,
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	34 parsers,
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	35 templatefilters,
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	36 util,
29f50344fa83 revlog: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 27891 diff changeset	37 )
36 da28286bf6b7 Add smart node lookup by substring or by rev number mpm@selenic.com parents: 26 diff changeset	38
5008 3addf4531643 revlog: localize some fastpath functions Matt Mackall <mpm@selenic.com> parents: 5007 diff changeset	39 _pack = struct.pack
3addf4531643 revlog: localize some fastpath functions Matt Mackall <mpm@selenic.com> parents: 5007 diff changeset	40 _unpack = struct.unpack
3addf4531643 revlog: localize some fastpath functions Matt Mackall <mpm@selenic.com> parents: 5007 diff changeset	41 _compress = zlib.compress
3addf4531643 revlog: localize some fastpath functions Matt Mackall <mpm@selenic.com> parents: 5007 diff changeset	42 _decompress = zlib.decompress
6466 ac0bcd951c2c python 2.6 compatibility: compatibility wrappers for hash functions Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 6264 diff changeset	43 _sha = util.sha1
5008 3addf4531643 revlog: localize some fastpath functions Matt Mackall <mpm@selenic.com> parents: 5007 diff changeset	44
11746 46ac30b17978 revlog: add shallow header flag Vishakh H <vsh426@gmail.com> parents: 11745 diff changeset	45 # revlog header flags
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	46 REVLOGV0 = 0
74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	47 REVLOGNG = 1
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	48 REVLOGNGINLINEDATA = (1 << 16)
14253 c28d5200374c revlog: support reading generaldelta revlogs Sune Foldager <cryo@cyanite.org> parents: 14252 diff changeset	49 REVLOGGENERALDELTA = (1 << 17)
2222 c9e264b115e6 Use revlogng and inlined data files by default mason@suse.com parents: 2177 diff changeset	50 REVLOG_DEFAULT_FLAGS = REVLOGNGINLINEDATA
c9e264b115e6 Use revlogng and inlined data files by default mason@suse.com parents: 2177 diff changeset	51 REVLOG_DEFAULT_FORMAT = REVLOGNG
c9e264b115e6 Use revlogng and inlined data files by default mason@suse.com parents: 2177 diff changeset	52 REVLOG_DEFAULT_VERSION = REVLOG_DEFAULT_FORMAT \| REVLOG_DEFAULT_FLAGS
14253 c28d5200374c revlog: support reading generaldelta revlogs Sune Foldager <cryo@cyanite.org> parents: 14252 diff changeset	53 REVLOGNG_FLAGS = REVLOGNGINLINEDATA \| REVLOGGENERALDELTA
11746 46ac30b17978 revlog: add shallow header flag Vishakh H <vsh426@gmail.com> parents: 11745 diff changeset	54
46ac30b17978 revlog: add shallow header flag Vishakh H <vsh426@gmail.com> parents: 11745 diff changeset	55 # revlog index flags
23867 4f23081c901e revlog: define censored flag for revlogng index Mike Edgar <adgar@google.com> parents: 23338 diff changeset	56 REVIDX_ISCENSORED = (1 << 15) # revision has censor metadata, must be verified
4f23081c901e revlog: define censored flag for revlogng index Mike Edgar <adgar@google.com> parents: 23338 diff changeset	57 REVIDX_DEFAULT_FLAGS = 0
4f23081c901e revlog: define censored flag for revlogng index Mike Edgar <adgar@google.com> parents: 23338 diff changeset	58 REVIDX_KNOWN_FLAGS = REVIDX_ISCENSORED
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	59
10916 9c84395a338e add documentation for revlog._prereadsize Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10914 diff changeset	60 # max size of revlog with inline data
9c84395a338e add documentation for revlog._prereadsize Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10914 diff changeset	61 _maxinline = 131072
13253 61c9bc3da402 revlog: remove lazy index Matt Mackall <mpm@selenic.com> parents: 13239 diff changeset	62 _chunksize = 1048576
10913 f2ecc5733c89 revlog: factor out _maxinline global. Greg Ward <greg-hg@gerg.ca> parents: 10404 diff changeset	63
7633 08cabecfa8a8 errors: move revlog errors Matt Mackall <mpm@selenic.com> parents: 7365 diff changeset	64 RevlogError = error.RevlogError
08cabecfa8a8 errors: move revlog errors Matt Mackall <mpm@selenic.com> parents: 7365 diff changeset	65 LookupError = error.LookupError
22934 8a096d4d0862 revlog: support importing censored file revision tombstones Mike Edgar <adgar@google.com> parents: 22785 diff changeset	66 CensoredNodeError = error.CensoredNodeError
6703 bacfee67c1a9 LookupError should have same __str__ as RevlogError Alexander Solovyov <piranha@piranha.org.ua> parents: 6700 diff changeset	67
4987 8d30004ada40 revlog: some basic code reordering Matt Mackall <mpm@selenic.com> parents: 4986 diff changeset	68 def getoffset(q):
8d30004ada40 revlog: some basic code reordering Matt Mackall <mpm@selenic.com> parents: 4986 diff changeset	69 return int(q >> 16)
8d30004ada40 revlog: some basic code reordering Matt Mackall <mpm@selenic.com> parents: 4986 diff changeset	70
8d30004ada40 revlog: some basic code reordering Matt Mackall <mpm@selenic.com> parents: 4986 diff changeset	71 def gettype(q):
8d30004ada40 revlog: some basic code reordering Matt Mackall <mpm@selenic.com> parents: 4986 diff changeset	72 return int(q & 0xFFFF)
8d30004ada40 revlog: some basic code reordering Matt Mackall <mpm@selenic.com> parents: 4986 diff changeset	73
8d30004ada40 revlog: some basic code reordering Matt Mackall <mpm@selenic.com> parents: 4986 diff changeset	74 def offset_type(offset, type):
8d30004ada40 revlog: some basic code reordering Matt Mackall <mpm@selenic.com> parents: 4986 diff changeset	75 return long(long(offset) << 16 \| type)
8d30004ada40 revlog: some basic code reordering Matt Mackall <mpm@selenic.com> parents: 4986 diff changeset	76
22784 0f4e655136ef revlog: mark nullhash as module-private Augie Fackler <raf@durin42.com> parents: 22389 diff changeset	77 _nullhash = _sha(nullid)
7882 c63c30ae9e39 revlog: faster hash computation when one of the parent node is null Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 7873 diff changeset	78
1091 d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	79 def hash(text, p1, p2):
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	80 """generate a hash from the given text and its parent hashes
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	81
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	82 This hash combines both the current file contents and its history
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	83 in a manner that makes it easy to distinguish nodes with the same
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	84 content in the revision graph.
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	85 """
7882 c63c30ae9e39 revlog: faster hash computation when one of the parent node is null Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 7873 diff changeset	86 # As of now, if one of the parent node is null, p2 is null
c63c30ae9e39 revlog: faster hash computation when one of the parent node is null Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 7873 diff changeset	87 if p2 == nullid:
c63c30ae9e39 revlog: faster hash computation when one of the parent node is null Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 7873 diff changeset	88 # deep copy of a hash is faster than creating one
22784 0f4e655136ef revlog: mark nullhash as module-private Augie Fackler <raf@durin42.com> parents: 22389 diff changeset	89 s = _nullhash.copy()
7882 c63c30ae9e39 revlog: faster hash computation when one of the parent node is null Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 7873 diff changeset	90 s.update(p1)
c63c30ae9e39 revlog: faster hash computation when one of the parent node is null Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 7873 diff changeset	91 else:
c63c30ae9e39 revlog: faster hash computation when one of the parent node is null Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 7873 diff changeset	92 # none of the parent nodes are nullid
c63c30ae9e39 revlog: faster hash computation when one of the parent node is null Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 7873 diff changeset	93 l = [p1, p2]
c63c30ae9e39 revlog: faster hash computation when one of the parent node is null Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 7873 diff changeset	94 l.sort()
c63c30ae9e39 revlog: faster hash computation when one of the parent node is null Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 7873 diff changeset	95 s = _sha(l[0])
c63c30ae9e39 revlog: faster hash computation when one of the parent node is null Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 7873 diff changeset	96 s.update(l[1])
1091 d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	97 s.update(text)
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	98 return s.digest()
d62130f99a73 Move hash function back to revlog from node mpm@selenic.com parents: 1089 diff changeset	99
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	100 def decompress(bin):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	101 """ decompress the given input """
4980 fc44c8df9d99 revlog: some codingstyle cleanups Matt Mackall <mpm@selenic.com> parents: 4979 diff changeset	102 if not bin:
fc44c8df9d99 revlog: some codingstyle cleanups Matt Mackall <mpm@selenic.com> parents: 4979 diff changeset	103 return bin
112 aea6562add6c Make compression more intelligent: mpm@selenic.com parents: 98 diff changeset	104 t = bin[0]
4980 fc44c8df9d99 revlog: some codingstyle cleanups Matt Mackall <mpm@selenic.com> parents: 4979 diff changeset	105 if t == '\0':
fc44c8df9d99 revlog: some codingstyle cleanups Matt Mackall <mpm@selenic.com> parents: 4979 diff changeset	106 return bin
fc44c8df9d99 revlog: some codingstyle cleanups Matt Mackall <mpm@selenic.com> parents: 4979 diff changeset	107 if t == 'x':
16844 5e3a1b96dbb0 revlog: zlib.error sent to the user (issue3424) Brad Hall <bhall@fb.com> parents: 16834 diff changeset	108 try:
5e3a1b96dbb0 revlog: zlib.error sent to the user (issue3424) Brad Hall <bhall@fb.com> parents: 16834 diff changeset	109 return _decompress(bin)
26214 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25993 diff changeset	110 except zlib.error as e:
16844 5e3a1b96dbb0 revlog: zlib.error sent to the user (issue3424) Brad Hall <bhall@fb.com> parents: 16834 diff changeset	111 raise RevlogError(_("revlog decompress error: %s") % str(e))
4980 fc44c8df9d99 revlog: some codingstyle cleanups Matt Mackall <mpm@selenic.com> parents: 4979 diff changeset	112 if t == 'u':
fc44c8df9d99 revlog: some codingstyle cleanups Matt Mackall <mpm@selenic.com> parents: 4979 diff changeset	113 return bin[1:]
1853 5ac811b720de Fix some problems when working on broken repositories: Thomas Arendsen Hein <thomas@intevation.de> parents: 1784 diff changeset	114 raise RevlogError(_("unknown compression type %r") % t)
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	115
18585 b280f3bfc8a0 revlog: document v0 format Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 18090 diff changeset	116 # index v0:
b280f3bfc8a0 revlog: document v0 format Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 18090 diff changeset	117 # 4 bytes: offset
b280f3bfc8a0 revlog: document v0 format Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 18090 diff changeset	118 # 4 bytes: compressed length
b280f3bfc8a0 revlog: document v0 format Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 18090 diff changeset	119 # 4 bytes: base rev
b280f3bfc8a0 revlog: document v0 format Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 18090 diff changeset	120 # 4 bytes: link rev
26475 c73fada78589 revlog: correct comment about size of v0 index format Yuya Nishihara <yuya@tcha.org> parents: 26382 diff changeset	121 # 20 bytes: parent 1 nodeid
c73fada78589 revlog: correct comment about size of v0 index format Yuya Nishihara <yuya@tcha.org> parents: 26382 diff changeset	122 # 20 bytes: parent 2 nodeid
c73fada78589 revlog: correct comment about size of v0 index format Yuya Nishihara <yuya@tcha.org> parents: 26382 diff changeset	123 # 20 bytes: nodeid
4987 8d30004ada40 revlog: some basic code reordering Matt Mackall <mpm@selenic.com> parents: 4986 diff changeset	124 indexformatv0 = ">4l20s20s20s"
4962 e017d3a82e1d revlog: raise offset/type helpers to global scope Matt Mackall <mpm@selenic.com> parents: 4781 diff changeset	125
4972 8d0cf46e0dc6 revlog: add revlogio interface Matt Mackall <mpm@selenic.com> parents: 4971 diff changeset	126 class revlogoldio(object):
8d0cf46e0dc6 revlog: add revlogio interface Matt Mackall <mpm@selenic.com> parents: 4971 diff changeset	127 def __init__(self):
4977 6cb30bc4ca32 revlog: parse revlogv0 indexes into v1 internally Matt Mackall <mpm@selenic.com> parents: 4976 diff changeset	128 self.size = struct.calcsize(indexformatv0)
4972 8d0cf46e0dc6 revlog: add revlogio interface Matt Mackall <mpm@selenic.com> parents: 4971 diff changeset	129
13264 8439526fb407 revlog/parseindex: no need to pass the file around Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 13259 diff changeset	130 def parseindex(self, data, inline):
4977 6cb30bc4ca32 revlog: parse revlogv0 indexes into v1 internally Matt Mackall <mpm@selenic.com> parents: 4976 diff changeset	131 s = self.size
4972 8d0cf46e0dc6 revlog: add revlogio interface Matt Mackall <mpm@selenic.com> parents: 4971 diff changeset	132 index = []
8d0cf46e0dc6 revlog: add revlogio interface Matt Mackall <mpm@selenic.com> parents: 4971 diff changeset	133 nodemap = {nullid: nullrev}
4973 a386a6e4fe46 revlog: simplify the v0 parser Matt Mackall <mpm@selenic.com> parents: 4972 diff changeset	134 n = off = 0
a386a6e4fe46 revlog: simplify the v0 parser Matt Mackall <mpm@selenic.com> parents: 4972 diff changeset	135 l = len(data)
a386a6e4fe46 revlog: simplify the v0 parser Matt Mackall <mpm@selenic.com> parents: 4972 diff changeset	136 while off + s <= l:
a386a6e4fe46 revlog: simplify the v0 parser Matt Mackall <mpm@selenic.com> parents: 4972 diff changeset	137 cur = data[off:off + s]
a386a6e4fe46 revlog: simplify the v0 parser Matt Mackall <mpm@selenic.com> parents: 4972 diff changeset	138 off += s
5008 3addf4531643 revlog: localize some fastpath functions Matt Mackall <mpm@selenic.com> parents: 5007 diff changeset	139 e = _unpack(indexformatv0, cur)
4977 6cb30bc4ca32 revlog: parse revlogv0 indexes into v1 internally Matt Mackall <mpm@selenic.com> parents: 4976 diff changeset	140 # transform to revlogv1 format
6cb30bc4ca32 revlog: parse revlogv0 indexes into v1 internally Matt Mackall <mpm@selenic.com> parents: 4976 diff changeset	141 e2 = (offset_type(e[0], 0), e[1], -1, e[2], e[3],
5549 686899a7de5b revlog: make revlogv0 loading more robust against corruption Matt Mackall <mpm@selenic.com> parents: 5453 diff changeset	142 nodemap.get(e[4], nullrev), nodemap.get(e[5], nullrev), e[6])
4977 6cb30bc4ca32 revlog: parse revlogv0 indexes into v1 internally Matt Mackall <mpm@selenic.com> parents: 4976 diff changeset	143 index.append(e2)
6cb30bc4ca32 revlog: parse revlogv0 indexes into v1 internally Matt Mackall <mpm@selenic.com> parents: 4976 diff changeset	144 nodemap[e[6]] = n
4973 a386a6e4fe46 revlog: simplify the v0 parser Matt Mackall <mpm@selenic.com> parents: 4972 diff changeset	145 n += 1
4972 8d0cf46e0dc6 revlog: add revlogio interface Matt Mackall <mpm@selenic.com> parents: 4971 diff changeset	146
13265 04b302ce2781 revlog: always add the magic nullid/nullrev entry in parseindex Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 13264 diff changeset	147 # add the magic null revision at -1
04b302ce2781 revlog: always add the magic nullid/nullrev entry in parseindex Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 13264 diff changeset	148 index.append((0, 0, 0, -1, -1, -1, -1, nullid))
04b302ce2781 revlog: always add the magic nullid/nullrev entry in parseindex Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 13264 diff changeset	149
4983 4dbcfc6e359e revlog: pull chunkcache back into revlog Matt Mackall <mpm@selenic.com> parents: 4982 diff changeset	150 return index, nodemap, None
4972 8d0cf46e0dc6 revlog: add revlogio interface Matt Mackall <mpm@selenic.com> parents: 4971 diff changeset	151
5338 f87685355c9c revlog: fix revlogio.packentry corner case Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5325 diff changeset	152 def packentry(self, entry, node, version, rev):
10395 ea52a2d4f42c revlog: don't silently discard revlog flags on revlogv0 Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10329 diff changeset	153 if gettype(entry[0]):
ea52a2d4f42c revlog: don't silently discard revlog flags on revlogv0 Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10329 diff changeset	154 raise RevlogError(_("index entry flags need RevlogNG"))
4986 58cc017ec7e0 revlog: abstract out index entry packing Matt Mackall <mpm@selenic.com> parents: 4985 diff changeset	155 e2 = (getoffset(entry[0]), entry[1], entry[3], entry[4],
58cc017ec7e0 revlog: abstract out index entry packing Matt Mackall <mpm@selenic.com> parents: 4985 diff changeset	156 node(entry[5]), node(entry[6]), entry[7])
5008 3addf4531643 revlog: localize some fastpath functions Matt Mackall <mpm@selenic.com> parents: 5007 diff changeset	157 return _pack(indexformatv0, *e2)
4986 58cc017ec7e0 revlog: abstract out index entry packing Matt Mackall <mpm@selenic.com> parents: 4985 diff changeset	158
4987 8d30004ada40 revlog: some basic code reordering Matt Mackall <mpm@selenic.com> parents: 4986 diff changeset	159 # index ng:
11323 d65b74106113 revlog: fix inconsistent comment formatting Martin Geisler <mg@aragost.com> parents: 11155 diff changeset	160 # 6 bytes: offset
d65b74106113 revlog: fix inconsistent comment formatting Martin Geisler <mg@aragost.com> parents: 11155 diff changeset	161 # 2 bytes: flags
d65b74106113 revlog: fix inconsistent comment formatting Martin Geisler <mg@aragost.com> parents: 11155 diff changeset	162 # 4 bytes: compressed length
d65b74106113 revlog: fix inconsistent comment formatting Martin Geisler <mg@aragost.com> parents: 11155 diff changeset	163 # 4 bytes: uncompressed length
d65b74106113 revlog: fix inconsistent comment formatting Martin Geisler <mg@aragost.com> parents: 11155 diff changeset	164 # 4 bytes: base rev
d65b74106113 revlog: fix inconsistent comment formatting Martin Geisler <mg@aragost.com> parents: 11155 diff changeset	165 # 4 bytes: link rev
d65b74106113 revlog: fix inconsistent comment formatting Martin Geisler <mg@aragost.com> parents: 11155 diff changeset	166 # 4 bytes: parent 1 rev
d65b74106113 revlog: fix inconsistent comment formatting Martin Geisler <mg@aragost.com> parents: 11155 diff changeset	167 # 4 bytes: parent 2 rev
4987 8d30004ada40 revlog: some basic code reordering Matt Mackall <mpm@selenic.com> parents: 4986 diff changeset	168 # 32 bytes: nodeid
8d30004ada40 revlog: some basic code reordering Matt Mackall <mpm@selenic.com> parents: 4986 diff changeset	169 indexformatng = ">Qiiiiii20s12x"
8d30004ada40 revlog: some basic code reordering Matt Mackall <mpm@selenic.com> parents: 4986 diff changeset	170 versionformat = ">I"
8d30004ada40 revlog: some basic code reordering Matt Mackall <mpm@selenic.com> parents: 4986 diff changeset	171
25944 eee88912db0a revlog: raise an exception earlier if an entry is too large (issue4675) Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 25845 diff changeset	172 # corresponds to uncompressed length of indexformatng (2 gigs, 4-byte
eee88912db0a revlog: raise an exception earlier if an entry is too large (issue4675) Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 25845 diff changeset	173 # signed integer)
eee88912db0a revlog: raise an exception earlier if an entry is too large (issue4675) Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 25845 diff changeset	174 _maxentrysize = 0x7fffffff
eee88912db0a revlog: raise an exception earlier if an entry is too large (issue4675) Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 25845 diff changeset	175
4972 8d0cf46e0dc6 revlog: add revlogio interface Matt Mackall <mpm@selenic.com> parents: 4971 diff changeset	176 class revlogio(object):
8d0cf46e0dc6 revlog: add revlogio interface Matt Mackall <mpm@selenic.com> parents: 4971 diff changeset	177 def __init__(self):
4977 6cb30bc4ca32 revlog: parse revlogv0 indexes into v1 internally Matt Mackall <mpm@selenic.com> parents: 4976 diff changeset	178 self.size = struct.calcsize(indexformatng)
4972 8d0cf46e0dc6 revlog: add revlogio interface Matt Mackall <mpm@selenic.com> parents: 4971 diff changeset	179
13264 8439526fb407 revlog/parseindex: no need to pass the file around Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 13259 diff changeset	180 def parseindex(self, data, inline):
7109 528b7fc1216c use the new parseindex implementation C in parsers Bernhard Leiner <bleiner@gmail.com> parents: 7089 diff changeset	181 # call the C implementation to parse the index data
13254 5ef5eb1f3515 revlog: only build the nodemap on demand Matt Mackall <mpm@selenic.com> parents: 13253 diff changeset	182 index, cache = parsers.parse_index2(data, inline)
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16375 diff changeset	183 return index, getattr(index, 'nodemap', None), cache
4972 8d0cf46e0dc6 revlog: add revlogio interface Matt Mackall <mpm@selenic.com> parents: 4971 diff changeset	184
5338 f87685355c9c revlog: fix revlogio.packentry corner case Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5325 diff changeset	185 def packentry(self, entry, node, version, rev):
5008 3addf4531643 revlog: localize some fastpath functions Matt Mackall <mpm@selenic.com> parents: 5007 diff changeset	186 p = _pack(indexformatng, *entry)
5338 f87685355c9c revlog: fix revlogio.packentry corner case Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 5325 diff changeset	187 if rev == 0:
5008 3addf4531643 revlog: localize some fastpath functions Matt Mackall <mpm@selenic.com> parents: 5007 diff changeset	188 p = _pack(versionformat, version) + p[4:]
4986 58cc017ec7e0 revlog: abstract out index entry packing Matt Mackall <mpm@selenic.com> parents: 4985 diff changeset	189 return p
58cc017ec7e0 revlog: abstract out index entry packing Matt Mackall <mpm@selenic.com> parents: 4985 diff changeset	190
1559 59b3639df0a9 Convert all classes to new-style classes by deriving them from object. Eric Hopper <hopper@omnifarious.org> parents: 1551 diff changeset	191 class revlog(object):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	192 """
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	193 the underlying revision storage object
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	194
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	195 A revlog consists of two parts, an index and the revision data.
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	196
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	197 The index is a file with a fixed record size containing
6912 b92baef99ebf Fixed docstring typos Martin Geisler <mg@daimi.au.dk> parents: 6891 diff changeset	198 information on each revision, including its nodeid (hash), the
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	199 nodeids of its parents, the position and offset of its data within
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	200 the data file, and the revision it's based on. Finally, each entry
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	201 contains a linkrev entry that can serve as a pointer to external
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	202 data.
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	203
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	204 The revision data itself is a linear collection of data chunks.
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	205 Each chunk represents a revision and is usually represented as a
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	206 delta against the previous chunk. To bound lookup time, runs of
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	207 deltas are limited to about 2 times the length of the original
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	208 version data. This makes retrieval of a version proportional to
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	209 its size, or O(1) relative to the number of revisions.
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	210
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	211 Both pieces of the revlog are written to in an append-only
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	212 fashion, which means we never need to rewrite a file to insert or
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	213 remove data, and can use some simple techniques to avoid the need
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	214 for locking while reading.
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	215 """
14251 258fbccf22f5 revlog: remove the last bits of punched/shallow Sune Foldager <cryo@cyanite.org> parents: 14213 diff changeset	216 def __init__(self, opener, indexfile):
1083 30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	217 """
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	218 create a revlog object
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	219
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	220 opener is a function that abstracts the file opening operation
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	221 and can be used to implement COW semantics or the like.
30974cf73435 Add some docstrings to revlog.py mpm@selenic.com parents: 1074 diff changeset	222 """
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	223 self.indexfile = indexfile
4266 1b5c38e9d7aa revlog: don't pass datafile as an argument Matt Mackall <mpm@selenic.com> parents: 4224 diff changeset	224 self.datafile = indexfile[:-2] + ".d"
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	225 self.opener = opener
27710 7860366b46c9 revlog: improve documentation Gregory Szorc <gregory.szorc@gmail.com> parents: 27547 diff changeset	226 # 3-tuple of (node, rev, text) for a raw revision.
4984 b4066fcbd6ba revlog: mark cache private Matt Mackall <mpm@selenic.com> parents: 4983 diff changeset	227 self._cache = None
27710 7860366b46c9 revlog: improve documentation Gregory Szorc <gregory.szorc@gmail.com> parents: 27547 diff changeset	228 # 2-tuple of (rev, baserev) defining the base revision the delta chain
7860366b46c9 revlog: improve documentation Gregory Szorc <gregory.szorc@gmail.com> parents: 27547 diff changeset	229 # begins at for a revision.
19768 e92650e39f1c generaldelta: initialize basecache properly Wojciech Lopata <lopek@fb.com> parents: 19471 diff changeset	230 self._basecache = None
27710 7860366b46c9 revlog: improve documentation Gregory Szorc <gregory.szorc@gmail.com> parents: 27547 diff changeset	231 # 2-tuple of (offset, data) of raw data from the revlog at an offset.
8323 d593922cf480 revlog: clean up the chunk caching code Matt Mackall <mpm@selenic.com> parents: 8322 diff changeset	232 self._chunkcache = (0, '')
27710 7860366b46c9 revlog: improve documentation Gregory Szorc <gregory.szorc@gmail.com> parents: 27547 diff changeset	233 # How much data to read and cache into the raw revlog data cache.
20180 969148b49fc6 revlog: allow tuning of the chunk cache size (via format.chunkcachesize) Brodie Rao <brodie@sf.io> parents: 20179 diff changeset	234 self._chunkcachesize = 65536
23255 76effa770ff9 revlog: add config variable for limiting delta-chain length Mateusz Kwapich <mitrandir@fb.com> parents: 23254 diff changeset	235 self._maxchainlen = None
26705 049005de325e revlog: add an aggressivemergedelta option Durham Goode <durham@fb.com> parents: 26704 diff changeset	236 self._aggressivemergedeltas = False
4985 e6525e459157 revlog: simplify revlog.__init__ Matt Mackall <mpm@selenic.com> parents: 4984 diff changeset	237 self.index = []
27710 7860366b46c9 revlog: improve documentation Gregory Szorc <gregory.szorc@gmail.com> parents: 27547 diff changeset	238 # Mapping of partial identifiers to full nodes.
13258 c2661863f16f revlog: introduce a cache for partial lookups Matt Mackall <mpm@selenic.com> parents: 13254 diff changeset	239 self._pcache = {}
27710 7860366b46c9 revlog: improve documentation Gregory Szorc <gregory.szorc@gmail.com> parents: 27547 diff changeset	240 # Mapping of revision integer to full node.
13275 68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	241 self._nodecache = {nullid: nullrev}
68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	242 self._nodepos = None
4985 e6525e459157 revlog: simplify revlog.__init__ Matt Mackall <mpm@selenic.com> parents: 4984 diff changeset	243
e6525e459157 revlog: simplify revlog.__init__ Matt Mackall <mpm@selenic.com> parents: 4984 diff changeset	244 v = REVLOG_DEFAULT_VERSION
14961 497819817307 revlog: use getattr instead of hasattr Augie Fackler <durin42@gmail.com> parents: 14549 diff changeset	245 opts = getattr(opener, 'options', None)
497819817307 revlog: use getattr instead of hasattr Augie Fackler <durin42@gmail.com> parents: 14549 diff changeset	246 if opts is not None:
497819817307 revlog: use getattr instead of hasattr Augie Fackler <durin42@gmail.com> parents: 14549 diff changeset	247 if 'revlogv1' in opts:
497819817307 revlog: use getattr instead of hasattr Augie Fackler <durin42@gmail.com> parents: 14549 diff changeset	248 if 'generaldelta' in opts:
14333 31a5973fcf96 revlog: get rid of defversion Sune Foldager <cryo@cyanite.org> parents: 14325 diff changeset	249 v \|= REVLOGGENERALDELTA
31a5973fcf96 revlog: get rid of defversion Sune Foldager <cryo@cyanite.org> parents: 14325 diff changeset	250 else:
31a5973fcf96 revlog: get rid of defversion Sune Foldager <cryo@cyanite.org> parents: 14325 diff changeset	251 v = 0
20180 969148b49fc6 revlog: allow tuning of the chunk cache size (via format.chunkcachesize) Brodie Rao <brodie@sf.io> parents: 20179 diff changeset	252 if 'chunkcachesize' in opts:
969148b49fc6 revlog: allow tuning of the chunk cache size (via format.chunkcachesize) Brodie Rao <brodie@sf.io> parents: 20179 diff changeset	253 self._chunkcachesize = opts['chunkcachesize']
23255 76effa770ff9 revlog: add config variable for limiting delta-chain length Mateusz Kwapich <mitrandir@fb.com> parents: 23254 diff changeset	254 if 'maxchainlen' in opts:
76effa770ff9 revlog: add config variable for limiting delta-chain length Mateusz Kwapich <mitrandir@fb.com> parents: 23254 diff changeset	255 self._maxchainlen = opts['maxchainlen']
26705 049005de325e revlog: add an aggressivemergedelta option Durham Goode <durham@fb.com> parents: 26704 diff changeset	256 if 'aggressivemergedeltas' in opts:
049005de325e revlog: add an aggressivemergedelta option Durham Goode <durham@fb.com> parents: 26704 diff changeset	257 self._aggressivemergedeltas = opts['aggressivemergedeltas']
27547 dfab6edb98e3 format: introduce 'format.usegeneraldelta` Pierre-Yves David <pierre-yves.david@fb.com> parents: 27345 diff changeset	258 self._lazydeltabase = bool(opts.get('lazydeltabase', False))
20180 969148b49fc6 revlog: allow tuning of the chunk cache size (via format.chunkcachesize) Brodie Rao <brodie@sf.io> parents: 20179 diff changeset	259
969148b49fc6 revlog: allow tuning of the chunk cache size (via format.chunkcachesize) Brodie Rao <brodie@sf.io> parents: 20179 diff changeset	260 if self._chunkcachesize <= 0:
969148b49fc6 revlog: allow tuning of the chunk cache size (via format.chunkcachesize) Brodie Rao <brodie@sf.io> parents: 20179 diff changeset	261 raise RevlogError(_('revlog chunk cache size %r is not greater '
969148b49fc6 revlog: allow tuning of the chunk cache size (via format.chunkcachesize) Brodie Rao <brodie@sf.io> parents: 20179 diff changeset	262 'than 0') % self._chunkcachesize)
969148b49fc6 revlog: allow tuning of the chunk cache size (via format.chunkcachesize) Brodie Rao <brodie@sf.io> parents: 20179 diff changeset	263 elif self._chunkcachesize & (self._chunkcachesize - 1):
969148b49fc6 revlog: allow tuning of the chunk cache size (via format.chunkcachesize) Brodie Rao <brodie@sf.io> parents: 20179 diff changeset	264 raise RevlogError(_('revlog chunk cache size %r is not a power '
969148b49fc6 revlog: allow tuning of the chunk cache size (via format.chunkcachesize) Brodie Rao <brodie@sf.io> parents: 20179 diff changeset	265 'of 2') % self._chunkcachesize)
11928 b69899dbad40 revlog: parentdelta flags for revlog index Pradeepkumar Gayam <in3xes@gmail.com> parents: 11759 diff changeset	266
26859 eb97d49768cc revlog: rename generic "i" variable to "indexdata" Gregory Szorc <gregory.szorc@gmail.com> parents: 26705 diff changeset	267 indexdata = ''
14334 85c82ebc96a3 changelog: don't use generaldelta Sune Foldager <cryo@cyanite.org> parents: 14333 diff changeset	268 self._initempty = True
0 9117c6561b0b Add back links from file revisions to changeset revisions mpm@selenic.com parents: diff changeset	269 try:
1784 2e0a288ca93e revalidate revlog data after locking the repo (issue132) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 1749 diff changeset	270 f = self.opener(self.indexfile)
26859 eb97d49768cc revlog: rename generic "i" variable to "indexdata" Gregory Szorc <gregory.szorc@gmail.com> parents: 26705 diff changeset	271 indexdata = f.read()
13400 14f3795a5ed7 explicitly close files Dan Villiom Podlaski Christiansen <danchr@gmail.com> parents: 13284 diff changeset	272 f.close()
26859 eb97d49768cc revlog: rename generic "i" variable to "indexdata" Gregory Szorc <gregory.szorc@gmail.com> parents: 26705 diff changeset	273 if len(indexdata) > 0:
eb97d49768cc revlog: rename generic "i" variable to "indexdata" Gregory Szorc <gregory.szorc@gmail.com> parents: 26705 diff changeset	274 v = struct.unpack(versionformat, indexdata[:4])[0]
14334 85c82ebc96a3 changelog: don't use generaldelta Sune Foldager <cryo@cyanite.org> parents: 14333 diff changeset	275 self._initempty = False
26214 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25993 diff changeset	276 except IOError as inst:
1322 b3d44e9b3092 Make revlog constructor more discerning in its treatment of errors. Bryan O'Sullivan <bos@serpentine.com> parents: 1232 diff changeset	277 if inst.errno != errno.ENOENT:
b3d44e9b3092 Make revlog constructor more discerning in its treatment of errors. Bryan O'Sullivan <bos@serpentine.com> parents: 1232 diff changeset	278 raise
4985 e6525e459157 revlog: simplify revlog.__init__ Matt Mackall <mpm@selenic.com> parents: 4984 diff changeset	279
e6525e459157 revlog: simplify revlog.__init__ Matt Mackall <mpm@selenic.com> parents: 4984 diff changeset	280 self.version = v
e6525e459157 revlog: simplify revlog.__init__ Matt Mackall <mpm@selenic.com> parents: 4984 diff changeset	281 self._inline = v & REVLOGNGINLINEDATA
14253 c28d5200374c revlog: support reading generaldelta revlogs Sune Foldager <cryo@cyanite.org> parents: 14252 diff changeset	282 self._generaldelta = v & REVLOGGENERALDELTA
2073 1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	283 flags = v & ~0xFFFF
1e6745f78989 Implement data inlined with the index file mason@suse.com parents: 2072 diff changeset	284 fmt = v & 0xFFFF
4985 e6525e459157 revlog: simplify revlog.__init__ Matt Mackall <mpm@selenic.com> parents: 4984 diff changeset	285 if fmt == REVLOGV0 and flags:
e6525e459157 revlog: simplify revlog.__init__ Matt Mackall <mpm@selenic.com> parents: 4984 diff changeset	286 raise RevlogError(_("index %s unknown flags %#04x for format v0")
e6525e459157 revlog: simplify revlog.__init__ Matt Mackall <mpm@selenic.com> parents: 4984 diff changeset	287 % (self.indexfile, flags >> 16))
11746 46ac30b17978 revlog: add shallow header flag Vishakh H <vsh426@gmail.com> parents: 11745 diff changeset	288 elif fmt == REVLOGNG and flags & ~REVLOGNG_FLAGS:
4985 e6525e459157 revlog: simplify revlog.__init__ Matt Mackall <mpm@selenic.com> parents: 4984 diff changeset	289 raise RevlogError(_("index %s unknown flags %#04x for revlogng")
e6525e459157 revlog: simplify revlog.__init__ Matt Mackall <mpm@selenic.com> parents: 4984 diff changeset	290 % (self.indexfile, flags >> 16))
e6525e459157 revlog: simplify revlog.__init__ Matt Mackall <mpm@selenic.com> parents: 4984 diff changeset	291 elif fmt > REVLOGNG:
3744 3a099154b110 Make revlog error slightly less scary Matt Mackall <mpm@selenic.com> parents: 3683 diff changeset	292 raise RevlogError(_("index %s unknown format %d")
3680 69cf255a55a1 Indentation cleanups for 2956948b81f3. Thomas Arendsen Hein <thomas@intevation.de> parents: 3679 diff changeset	293 % (self.indexfile, fmt))
4985 e6525e459157 revlog: simplify revlog.__init__ Matt Mackall <mpm@selenic.com> parents: 4984 diff changeset	294
4972 8d0cf46e0dc6 revlog: add revlogio interface Matt Mackall <mpm@selenic.com> parents: 4971 diff changeset	295 self._io = revlogio()
4971 3e6dae278c99 revlog: regroup parsing code Matt Mackall <mpm@selenic.com> parents: 4964 diff changeset	296 if self.version == REVLOGV0:
4972 8d0cf46e0dc6 revlog: add revlogio interface Matt Mackall <mpm@selenic.com> parents: 4971 diff changeset	297 self._io = revlogoldio()
13265 04b302ce2781 revlog: always add the magic nullid/nullrev entry in parseindex Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 13264 diff changeset	298 try:
26859 eb97d49768cc revlog: rename generic "i" variable to "indexdata" Gregory Szorc <gregory.szorc@gmail.com> parents: 26705 diff changeset	299 d = self._io.parseindex(indexdata, self._inline)
13265 04b302ce2781 revlog: always add the magic nullid/nullrev entry in parseindex Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 13264 diff changeset	300 except (ValueError, IndexError):
04b302ce2781 revlog: always add the magic nullid/nullrev entry in parseindex Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 13264 diff changeset	301 raise RevlogError(_("index %s is corrupted") % (self.indexfile))
13268 fff12b3d953a revlog: explicit test and explicit variable names Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 13267 diff changeset	302 self.index, nodemap, self._chunkcache = d
fff12b3d953a revlog: explicit test and explicit variable names Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 13267 diff changeset	303 if nodemap is not None:
13275 68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	304 self.nodemap = self._nodecache = nodemap
13265 04b302ce2781 revlog: always add the magic nullid/nullrev entry in parseindex Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 13264 diff changeset	305 if not self._chunkcache:
04b302ce2781 revlog: always add the magic nullid/nullrev entry in parseindex Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 13264 diff changeset	306 self._chunkclear()
23306 f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	307 # revnum -> (chain-length, sum-delta-length)
f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	308 self._chaininfocache = {}
116 e484cd5ec282 Only use lazy indexing for big indices and avoid the overhead of the mpm@selenic.com parents: 115 diff changeset	309
4980 fc44c8df9d99 revlog: some codingstyle cleanups Matt Mackall <mpm@selenic.com> parents: 4979 diff changeset	310 def tip(self):
fc44c8df9d99 revlog: some codingstyle cleanups Matt Mackall <mpm@selenic.com> parents: 4979 diff changeset	311 return self.node(len(self.index) - 2)
24042 828dc8db5515 revlog: add __contains__ for fast membership test Yuya Nishihara <yuya@tcha.org> parents: 23869 diff changeset	312 def __contains__(self, rev):
828dc8db5515 revlog: add __contains__ for fast membership test Yuya Nishihara <yuya@tcha.org> parents: 23869 diff changeset	313 return 0 <= rev < len(self)
6752 fb42030d79d6 add __len__ and __iter__ methods to repo and revlog Matt Mackall <mpm@selenic.com> parents: 6703 diff changeset	314 def __len__(self):
4980 fc44c8df9d99 revlog: some codingstyle cleanups Matt Mackall <mpm@selenic.com> parents: 4979 diff changeset	315 return len(self.index) - 1
6752 fb42030d79d6 add __len__ and __iter__ methods to repo and revlog Matt Mackall <mpm@selenic.com> parents: 6703 diff changeset	316 def __iter__(self):
17951 6f79c32c0bdf commit: increase perf by avoiding unnecessary filteredrevs check Durham Goode <durham@fb.com> parents: 17674 diff changeset	317 return iter(xrange(len(self)))
17672 474047947b8f clfilter: make the revlog class responsible of all its iteration Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	318 def revs(self, start=0, stop=None):
474047947b8f clfilter: make the revlog class responsible of all its iteration Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	319 """iterate over all rev in this revlog (from start to stop)"""
17971 c56b5b65430d revlog: allow reverse iteration with revlog.revs Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17968 diff changeset	320 step = 1
c56b5b65430d revlog: allow reverse iteration with revlog.revs Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17968 diff changeset	321 if stop is not None:
c56b5b65430d revlog: allow reverse iteration with revlog.revs Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17968 diff changeset	322 if start > stop:
c56b5b65430d revlog: allow reverse iteration with revlog.revs Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17968 diff changeset	323 step = -1
c56b5b65430d revlog: allow reverse iteration with revlog.revs Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17968 diff changeset	324 stop += step
17672 474047947b8f clfilter: make the revlog class responsible of all its iteration Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	325 else:
17971 c56b5b65430d revlog: allow reverse iteration with revlog.revs Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17968 diff changeset	326 stop = len(self)
c56b5b65430d revlog: allow reverse iteration with revlog.revs Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17968 diff changeset	327 return xrange(start, stop, step)
13275 68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	328
68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	329 @util.propertycache
68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	330 def nodemap(self):
14064 e4bfb9c337f3 remove unused imports and variables Alexander Solovyov <alexander@solovyov.net> parents: 13831 diff changeset	331 self.rev(self.node(0))
13275 68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	332 return self._nodecache
13259 3b616dfa4b17 revlog: do revlog node->rev mapping by scanning Matt Mackall <mpm@selenic.com> parents: 13258 diff changeset	333
16374 29c2ff719715 revlog: add hasnode helper method Matt Mackall <mpm@selenic.com> parents: 15890 diff changeset	334 def hasnode(self, node):
29c2ff719715 revlog: add hasnode helper method Matt Mackall <mpm@selenic.com> parents: 15890 diff changeset	335 try:
29c2ff719715 revlog: add hasnode helper method Matt Mackall <mpm@selenic.com> parents: 15890 diff changeset	336 self.rev(node)
29c2ff719715 revlog: add hasnode helper method Matt Mackall <mpm@selenic.com> parents: 15890 diff changeset	337 return True
29c2ff719715 revlog: add hasnode helper method Matt Mackall <mpm@selenic.com> parents: 15890 diff changeset	338 except KeyError:
29c2ff719715 revlog: add hasnode helper method Matt Mackall <mpm@selenic.com> parents: 15890 diff changeset	339 return False
29c2ff719715 revlog: add hasnode helper method Matt Mackall <mpm@selenic.com> parents: 15890 diff changeset	340
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16375 diff changeset	341 def clearcaches(self):
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16375 diff changeset	342 try:
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16375 diff changeset	343 self._nodecache.clearcaches()
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16375 diff changeset	344 except AttributeError:
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16375 diff changeset	345 self._nodecache = {nullid: nullrev}
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16375 diff changeset	346 self._nodepos = None
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16375 diff changeset	347
13259 3b616dfa4b17 revlog: do revlog node->rev mapping by scanning Matt Mackall <mpm@selenic.com> parents: 13258 diff changeset	348 def rev(self, node):
13275 68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	349 try:
68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	350 return self._nodecache[node]
22282 4092d12ba18a repoview: fix 0L with pack/unpack for 2.4 Matt Mackall <mpm@selenic.com> parents: 21752 diff changeset	351 except TypeError:
4092d12ba18a repoview: fix 0L with pack/unpack for 2.4 Matt Mackall <mpm@selenic.com> parents: 21752 diff changeset	352 raise
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16375 diff changeset	353 except RevlogError:
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16375 diff changeset	354 # parsers.c radix tree lookup failed
e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16375 diff changeset	355 raise LookupError(node, self.indexfile, _('no node'))
13275 68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	356 except KeyError:
16414 e8d37b78acfb parsers: use base-16 trie for faster node->rev mapping Bryan O'Sullivan <bryano@fb.com> parents: 16375 diff changeset	357 # pure python cache lookup failed
13275 68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	358 n = self._nodecache
68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	359 i = self.index
68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	360 p = self._nodepos
68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	361 if p is None:
68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	362 p = len(i) - 2
68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	363 for r in xrange(p, -1, -1):
68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	364 v = i[r][7]
68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	365 n[v] = r
68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	366 if v == node:
68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	367 self._nodepos = r - 1
68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	368 return r
68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	369 raise LookupError(node, self.indexfile, _('no node'))
68da048b4c88 revlog: incrementally build node cache with linear searches Matt Mackall <mpm@selenic.com> parents: 13268 diff changeset	370
4980 fc44c8df9d99 revlog: some codingstyle cleanups Matt Mackall <mpm@selenic.com> parents: 4979 diff changeset	371 def node(self, rev):
fc44c8df9d99 revlog: some codingstyle cleanups Matt Mackall <mpm@selenic.com> parents: 4979 diff changeset	372 return self.index[rev][7]
7361 9fe97eea5510 linkrev: take a revision number rather than a hash Matt Mackall <mpm@selenic.com> parents: 7233 diff changeset	373 def linkrev(self, rev):
9fe97eea5510 linkrev: take a revision number rather than a hash Matt Mackall <mpm@selenic.com> parents: 7233 diff changeset	374 return self.index[rev][4]
2 ecf3fd948051 Handle nullid better for ancestor mpm@selenic.com parents: 0 diff changeset	375 def parents(self, node):
7363 9d28ff207030 revlog: speed up parents() Matt Mackall <mpm@selenic.com> parents: 7362 diff changeset	376 i = self.index
9d28ff207030 revlog: speed up parents() Matt Mackall <mpm@selenic.com> parents: 7362 diff changeset	377 d = i[self.rev(node)]
9d28ff207030 revlog: speed up parents() Matt Mackall <mpm@selenic.com> parents: 7362 diff changeset	378 return i[d[5]][7], i[d[6]][7] # map revisions to nodes inline
2489 568e58eed096 Add revlog.parentrevs function. Alexis S. L. Carvalho <alexis@cecm.usp.br> parents: 2354 diff changeset	379 def parentrevs(self, rev):
4979 06abdaf78788 revlog: add a magic null revision to our index Matt Mackall <mpm@selenic.com> parents: 4978 diff changeset	380 return self.index[rev][5:7]
2072 74d3f5336b66 Implement revlogng. mason@suse.com parents: 2002 diff changeset	381 def start(self, rev):
5007 c2febf5420e9 revlog: minor chunk speed-up Matt Mackall <mpm@selenic.com> parents: 5006 diff changeset	382 return int(self.index[rev][0] >> 16)
4980 fc44c8df9d99 revlog: some codingstyle cleanups Matt Mackall <mpm@selenic.com> parents: 4979 diff changeset	383 def end(self, rev):
fc44c8df9d99 revlog: some codingstyle cleanups Matt Mackall <mpm@selenic.com> parents: 4979 diff changeset	384 return self.start(rev) + self.length(rev)
fc44c8df9d99 revlog: some codingstyle cleanups Matt Mackall <mpm@selenic.com> parents: 4979 diff changeset	385 def length(self, rev):
fc44c8df9d99 revlog: some codingstyle cleanups Matt Mackall <mpm@selenic.com> parents: 4979 diff changeset	386 return self.index[rev][1]
14252 19067884c5f5 revlog: calculate base revisions iteratively Sune Foldager <cryo@cyanite.org> parents: 14251 diff changeset	387 def chainbase(self, rev):
19067884c5f5 revlog: calculate base revisions iteratively Sune Foldager <cryo@cyanite.org> parents: 14251 diff changeset	388 index = self.index
19067884c5f5 revlog: calculate base revisions iteratively Sune Foldager <cryo@cyanite.org> parents: 14251 diff changeset	389 base = index[rev][3]
19067884c5f5 revlog: calculate base revisions iteratively Sune Foldager <cryo@cyanite.org> parents: 14251 diff changeset	390 while base != rev:
19067884c5f5 revlog: calculate base revisions iteratively Sune Foldager <cryo@cyanite.org> parents: 14251 diff changeset	391 rev = base
19067884c5f5 revlog: calculate base revisions iteratively Sune Foldager <cryo@cyanite.org> parents: 14251 diff changeset	392 base = index[rev][3]
19067884c5f5 revlog: calculate base revisions iteratively Sune Foldager <cryo@cyanite.org> parents: 14251 diff changeset	393 return base
23254 d23834b871ac debugrevlog: fix computing chain length in debugrevlog -d Mateusz Kwapich <mitrandir@fb.com> parents: 22934 diff changeset	394 def chainlen(self, rev):
23286 40e0067899d4 revlog: compute length of compressed deltas along with chain length Siddharth Agarwal <sid0@fb.com> parents: 23285 diff changeset	395 return self._chaininfo(rev)[0]
23306 f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	396
23286 40e0067899d4 revlog: compute length of compressed deltas along with chain length Siddharth Agarwal <sid0@fb.com> parents: 23285 diff changeset	397 def _chaininfo(self, rev):
23306 f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	398 chaininfocache = self._chaininfocache
f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	399 if rev in chaininfocache:
f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	400 return chaininfocache[rev]
23254 d23834b871ac debugrevlog: fix computing chain length in debugrevlog -d Mateusz Kwapich <mitrandir@fb.com> parents: 22934 diff changeset	401 index = self.index
d23834b871ac debugrevlog: fix computing chain length in debugrevlog -d Mateusz Kwapich <mitrandir@fb.com> parents: 22934 diff changeset	402 generaldelta = self._generaldelta
d23834b871ac debugrevlog: fix computing chain length in debugrevlog -d Mateusz Kwapich <mitrandir@fb.com> parents: 22934 diff changeset	403 iterrev = rev
d23834b871ac debugrevlog: fix computing chain length in debugrevlog -d Mateusz Kwapich <mitrandir@fb.com> parents: 22934 diff changeset	404 e = index[iterrev]
d23834b871ac debugrevlog: fix computing chain length in debugrevlog -d Mateusz Kwapich <mitrandir@fb.com> parents: 22934 diff changeset	405 clen = 0
23286 40e0067899d4 revlog: compute length of compressed deltas along with chain length Siddharth Agarwal <sid0@fb.com> parents: 23285 diff changeset	406 compresseddeltalen = 0
23254 d23834b871ac debugrevlog: fix computing chain length in debugrevlog -d Mateusz Kwapich <mitrandir@fb.com> parents: 22934 diff changeset	407 while iterrev != e[3]:
d23834b871ac debugrevlog: fix computing chain length in debugrevlog -d Mateusz Kwapich <mitrandir@fb.com> parents: 22934 diff changeset	408 clen += 1
23286 40e0067899d4 revlog: compute length of compressed deltas along with chain length Siddharth Agarwal <sid0@fb.com> parents: 23285 diff changeset	409 compresseddeltalen += e[1]
23254 d23834b871ac debugrevlog: fix computing chain length in debugrevlog -d Mateusz Kwapich <mitrandir@fb.com> parents: 22934 diff changeset	410 if generaldelta:
d23834b871ac debugrevlog: fix computing chain length in debugrevlog -d Mateusz Kwapich <mitrandir@fb.com> parents: 22934 diff changeset	411 iterrev = e[3]
d23834b871ac debugrevlog: fix computing chain length in debugrevlog -d Mateusz Kwapich <mitrandir@fb.com> parents: 22934 diff changeset	412 else:
d23834b871ac debugrevlog: fix computing chain length in debugrevlog -d Mateusz Kwapich <mitrandir@fb.com> parents: 22934 diff changeset	413 iterrev -= 1
23306 f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	414 if iterrev in chaininfocache:
f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	415 t = chaininfocache[iterrev]
f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	416 clen += t[0]
f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	417 compresseddeltalen += t[1]
f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	418 break
23254 d23834b871ac debugrevlog: fix computing chain length in debugrevlog -d Mateusz Kwapich <mitrandir@fb.com> parents: 22934 diff changeset	419 e = index[iterrev]
23306 f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	420 else:
f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	421 # Add text length of base since decompressing that also takes
f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	422 # work. For cache hits the length is already included.
f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	423 compresseddeltalen += e[1]
f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	424 r = (clen, compresseddeltalen)
f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	425 chaininfocache[rev] = r
f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	426 return r
f7a42f8e82bd revlog: cache chain info after calculating it for a rev (issue4452) Siddharth Agarwal <sid0@fb.com> parents: 23288 diff changeset	427
11705 ff33f937a7da revlog: add a flags method that returns revision flags Pradeepkumar Gayam <in3xes@gmail.com> parents: 11670 diff changeset	428 def flags(self, rev):
ff33f937a7da revlog: add a flags method that returns revision flags Pradeepkumar Gayam <in3xes@gmail.com> parents: 11670 diff changeset	429 return self.index[rev][0] & 0xFFFF
12024 56a7721ee3ec revlog: add rawsize(), identical to size() but not subclassed by filelog Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 12023 diff changeset	430 def rawsize(self, rev):
2078 441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	431 """return the length of the uncompressed text for a given revision"""
4977 6cb30bc4ca32 revlog: parse revlogv0 indexes into v1 internally Matt Mackall <mpm@selenic.com> parents: 4976 diff changeset	432 l = self.index[rev][2]
2078 441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	433 if l >= 0:
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	434 return l
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	435
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	436 t = self.revision(self.node(rev))
441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	437 return len(t)
12024 56a7721ee3ec revlog: add rawsize(), identical to size() but not subclassed by filelog Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 12023 diff changeset	438 size = rawsize
2078 441ea218414e Fill in the uncompressed size during revlog.addgroup mason@suse.com parents: 2077 diff changeset	439
18081 f88c60e740a1 revlog.ancestors: add support for including revs Siddharth Agarwal <sid0@fb.com> parents: 17971 diff changeset	440 def ancestors(self, revs, stoprev=0, inclusive=False):
10047 27267b1f68b4 revlog: rewrite several method docstrings Greg Ward <greg-hg@gerg.ca> parents: 9679 diff changeset	441 """Generate the ancestors of 'revs' in reverse topological order.
16869 eb88ed4269c5 revlog: add optional stoprev arg to revlog.ancestors() Joshua Redstone <joshua.redstone@fb.com> parents: 16868 diff changeset	442 Does not generate revs lower than stoprev.
10047 27267b1f68b4 revlog: rewrite several method docstrings Greg Ward <greg-hg@gerg.ca> parents: 9679 diff changeset	443
18090 9abc55ef85b5 revlog: move ancestor generation out to a new class Siddharth Agarwal <sid0@fb.com> parents: 18083 diff changeset	444 See the documentation for ancestor.lazyancestors for more details."""
18081 f88c60e740a1 revlog.ancestors: add support for including revs Siddharth Agarwal <sid0@fb.com> parents: 17971 diff changeset	445
23328 3a7d9c0c57a5 ancestor.lazyancestors: take parentrevs function rather than changelog Siddharth Agarwal <sid0@fb.com> parents: 23306 diff changeset	446 return ancestor.lazyancestors(self.parentrevs, revs, stoprev=stoprev,
18090 9abc55ef85b5 revlog: move ancestor generation out to a new class Siddharth Agarwal <sid0@fb.com> parents: 18083 diff changeset	447 inclusive=inclusive)
6872 c7cc40fd74f6 Add ancestors and descendants to revlog Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 6752 diff changeset	448
16868 1093ad1e8903 revlog: descendants(revs) becomes descendants(revs) (API) Bryan O'Sullivan <bryano@fb.com>* parents: 16867 diff changeset	449 def descendants(self, revs):
10047 27267b1f68b4 revlog: rewrite several method docstrings Greg Ward <greg-hg@gerg.ca> parents: 9679 diff changeset	450 """Generate the descendants of 'revs' in revision order.
27267b1f68b4 revlog: rewrite several method docstrings Greg Ward <greg-hg@gerg.ca> parents: 9679 diff changeset	451
27267b1f68b4 revlog: rewrite several method docstrings Greg Ward <greg-hg@gerg.ca> parents: 9679 diff changeset	452 Yield a sequence of revision numbers starting with a child of
27267b1f68b4 revlog: rewrite several method docstrings Greg Ward <greg-hg@gerg.ca> parents: 9679 diff changeset	453 some rev in revs, i.e., each revision is not considered a
27267b1f68b4 revlog: rewrite several method docstrings Greg Ward <greg-hg@gerg.ca> parents: 9679 diff changeset	454 descendant of itself. Results are ordered by revision number (a
27267b1f68b4 revlog: rewrite several method docstrings Greg Ward <greg-hg@gerg.ca> parents: 9679 diff changeset	455 topological sort)."""
12946 2405b4a5964a revlog: fix descendants() if nullrev is in revs Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 12945 diff changeset	456 first = min(revs)
2405b4a5964a revlog: fix descendants() if nullrev is in revs Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 12945 diff changeset	457 if first == nullrev:
2405b4a5964a revlog: fix descendants() if nullrev is in revs Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 12945 diff changeset	458 for i in self:
2405b4a5964a revlog: fix descendants() if nullrev is in revs Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 12945 diff changeset	459 yield i
2405b4a5964a revlog: fix descendants() if nullrev is in revs Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 12945 diff changeset	460 return
2405b4a5964a revlog: fix descendants() if nullrev is in revs Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 12945 diff changeset	461
8150 bbc24c0753a0 util: use built-in set and frozenset Martin Geisler <mg@lazybytes.net> parents: 8073 diff changeset	462 seen = set(revs)
17672 474047947b8f clfilter: make the revlog class responsible of all its iteration Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17537 diff changeset	463 for i in self.revs(start=first + 1):
6872 c7cc40fd74f6 Add ancestors and descendants to revlog Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 6752 diff changeset	464 for x in self.parentrevs(i):
c7cc40fd74f6 Add ancestors and descendants to revlog Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 6752 diff changeset	465 if x != nullrev and x in seen:
c7cc40fd74f6 Add ancestors and descendants to revlog Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 6752 diff changeset	466 seen.add(i)
c7cc40fd74f6 Add ancestors and descendants to revlog Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 6752 diff changeset	467 yield i
c7cc40fd74f6 Add ancestors and descendants to revlog Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 6752 diff changeset	468 break
c7cc40fd74f6 Add ancestors and descendants to revlog Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 6752 diff changeset	469
13741 b51bf961b3cb wireproto: add getbundle() function Peter Arrenbrecht <peter.arrenbrecht@gmail.com> parents: 13400 diff changeset	470 def findcommonmissing(self, common=None, heads=None):
b51bf961b3cb wireproto: add getbundle() function Peter Arrenbrecht <peter.arrenbrecht@gmail.com> parents: 13400 diff changeset	471 """Return a tuple of the ancestors of common and the ancestors of heads
15835 fa15869bf95c revlog: improve docstring for findcommonmissing Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15827 diff changeset	472 that are not ancestors of common. In revset terminology, we return the
fa15869bf95c revlog: improve docstring for findcommonmissing Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15827 diff changeset	473 tuple:
10047 27267b1f68b4 revlog: rewrite several method docstrings Greg Ward <greg-hg@gerg.ca> parents: 9679 diff changeset	474
15835 fa15869bf95c revlog: improve docstring for findcommonmissing Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15827 diff changeset	475 ::common, (::heads) - (::common)
7233 9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	476
10047 27267b1f68b4 revlog: rewrite several method docstrings Greg Ward <greg-hg@gerg.ca> parents: 9679 diff changeset	477 The list is sorted by revision number, meaning it is
27267b1f68b4 revlog: rewrite several method docstrings Greg Ward <greg-hg@gerg.ca> parents: 9679 diff changeset	478 topologically sorted.
27267b1f68b4 revlog: rewrite several method docstrings Greg Ward <greg-hg@gerg.ca> parents: 9679 diff changeset	479
27267b1f68b4 revlog: rewrite several method docstrings Greg Ward <greg-hg@gerg.ca> parents: 9679 diff changeset	480 'heads' and 'common' are both lists of node IDs. If heads is
27267b1f68b4 revlog: rewrite several method docstrings Greg Ward <greg-hg@gerg.ca> parents: 9679 diff changeset	481 not supplied, uses all of the revlog's heads. If common is not
27267b1f68b4 revlog: rewrite several method docstrings Greg Ward <greg-hg@gerg.ca> parents: 9679 diff changeset	482 supplied, uses nullid."""
7233 9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	483 if common is None:
9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	484 common = [nullid]
9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	485 if heads is None:
9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	486 heads = self.heads()
9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	487
9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	488 common = [self.rev(n) for n in common]
9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	489 heads = [self.rev(n) for n in heads]
9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	490
9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	491 # we want the ancestors, but inclusive
20073 eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	492 class lazyset(object):
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	493 def __init__(self, lazyvalues):
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	494 self.addedvalues = set()
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	495 self.lazyvalues = lazyvalues
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	496
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	497 def __contains__(self, value):
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	498 return value in self.addedvalues or value in self.lazyvalues
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	499
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	500 def __iter__(self):
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	501 added = self.addedvalues
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	502 for r in added:
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	503 yield r
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	504 for r in self.lazyvalues:
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	505 if not r in added:
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	506 yield r
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	507
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	508 def add(self, value):
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	509 self.addedvalues.add(value)
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	510
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	511 def update(self, values):
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	512 self.addedvalues.update(values)
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	513
eeba4eaf0716 revlog: return lazy set from findcommonmissing Durham Goode <durham@fb.com> parents: 19776 diff changeset	514 has = lazyset(self.ancestors(common))
8152 08e1baf924ca replace set-like dictionaries with real sets Martin Geisler <mg@lazybytes.net> parents: 8150 diff changeset	515 has.add(nullrev)
08e1baf924ca replace set-like dictionaries with real sets Martin Geisler <mg@lazybytes.net> parents: 8150 diff changeset	516 has.update(common)
7233 9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	517
9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	518 # take all ancestors from heads that aren't in has
8451 d1ca637b0773 revlog.missing(): use sets instead of a dict Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 8391 diff changeset	519 missing = set()
25548 0ca8410ea345 util: drop alias for collections.deque Martin von Zweigbergk <martinvonz@google.com> parents: 24585 diff changeset	520 visit = collections.deque(r for r in heads if r not in has)
7233 9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	521 while visit:
16803 107a3270a24a cleanup: use the deque type where appropriate Bryan O'Sullivan <bryano@fb.com> parents: 16790 diff changeset	522 r = visit.popleft()
7233 9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	523 if r in missing:
9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	524 continue
9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	525 else:
8451 d1ca637b0773 revlog.missing(): use sets instead of a dict Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 8391 diff changeset	526 missing.add(r)
7233 9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	527 for p in self.parentrevs(r):
9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	528 if p not in has:
9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	529 visit.append(p)
8451 d1ca637b0773 revlog.missing(): use sets instead of a dict Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 8391 diff changeset	530 missing = list(missing)
7233 9f0e52e1df77 fix pull racing with push/commit (issue1320) Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7109 diff changeset	531 missing.sort()
13741 b51bf961b3cb wireproto: add getbundle() function Peter Arrenbrecht <peter.arrenbrecht@gmail.com> parents: 13400 diff changeset	532 return has, [self.node(r) for r in missing]
b51bf961b3cb wireproto: add getbundle() function Peter Arrenbrecht <peter.arrenbrecht@gmail.com> parents: 13400 diff changeset	533
23337 3a8a763f4197 revlog: add a method to get missing revs incrementally Siddharth Agarwal <sid0@fb.com> parents: 23328 diff changeset	534 def incrementalmissingrevs(self, common=None):
3a8a763f4197 revlog: add a method to get missing revs incrementally Siddharth Agarwal <sid0@fb.com> parents: 23328 diff changeset	535 """Return an object that can be used to incrementally compute the
3a8a763f4197 revlog: add a method to get missing revs incrementally Siddharth Agarwal <sid0@fb.com> parents: 23328 diff changeset	536 revision numbers of the ancestors of arbitrary sets that are not
3a8a763f4197 revlog: add a method to get missing revs incrementally Siddharth Agarwal <sid0@fb.com> parents: 23328 diff changeset	537 ancestors of common. This is an ancestor.incrementalmissingancestors
3a8a763f4197 revlog: add a method to get missing revs incrementally Siddharth Agarwal <sid0@fb.com> parents: 23328 diff changeset	538 object.
3a8a763f4197 revlog: add a method to get missing revs incrementally Siddharth Agarwal <sid0@fb.com> parents: 23328 diff changeset	539
3a8a763f4197 revlog: add a method to get missing revs incrementally Siddharth Agarwal <sid0@fb.com> parents: 23328 diff changeset	540 'common' is a list of revision numbers. If common is not supplied, uses
3a8a763f4197 revlog: add a method to get missing revs incrementally Siddharth Agarwal <sid0@fb.com> parents: 23328 diff changeset	541 nullrev.
3a8a763f4197 revlog: add a method to get missing revs incrementally Siddharth Agarwal <sid0@fb.com> parents: 23328 diff changeset	542 """
3a8a763f4197 revlog: add a method to get missing revs incrementally Siddharth Agarwal <sid0@fb.com> parents: 23328 diff changeset	543 if common is None:
3a8a763f4197 revlog: add a method to get missing revs incrementally Siddharth Agarwal <sid0@fb.com> parents: 23328 diff changeset	544 common = [nullrev]
3a8a763f4197 revlog: add a method to get missing revs incrementally Siddharth Agarwal <sid0@fb.com> parents: 23328 diff changeset	545
3a8a763f4197 revlog: add a method to get missing revs incrementally Siddharth Agarwal <sid0@fb.com> parents: 23328 diff changeset	546 return ancestor.incrementalmissingancestors(self.parentrevs, common)
3a8a763f4197 revlog: add a method to get missing revs incrementally Siddharth Agarwal <sid0@fb.com> parents: 23328 diff changeset	547
17968 7ef00d09ef35 revlog: add rev-specific variant of findmissing Siddharth Agarwal <sid0@fb.com> parents: 17967 diff changeset	548 def findmissingrevs(self, common=None, heads=None):
7ef00d09ef35 revlog: add rev-specific variant of findmissing Siddharth Agarwal <sid0@fb.com> parents: 17967 diff changeset	549 """Return the revision numbers of the ancestors of heads that
7ef00d09ef35 revlog: add rev-specific variant of findmissing Siddharth Agarwal <sid0@fb.com> parents: 17967 diff changeset	550 are not ancestors of common.
7ef00d09ef35 revlog: add rev-specific variant of findmissing Siddharth Agarwal <sid0@fb.com> parents: 17967 diff changeset	551
7ef00d09ef35 revlog: add rev-specific variant of findmissing Siddharth Agarwal <sid0@fb.com> parents: 17967 diff changeset	552 More specifically, return a list of revision numbers corresponding to

Mercurial > hg > mercurial-source

annotate mercurial/revlog.py @ 28078:8f016345e6b0