39     INDEX_ENTRY_V0,

   139 def getoffset(q):

   140     return int(q >> 16)

   141 

   142 

   143 def gettype(q):

   144     return int(q & 0xFFFF)

   145 

   146 

   215 

   216 

   217 class revlogoldindex(list):

   218     entry_size = INDEX_ENTRY_V0.size

   219 

   220     @property

   221     def nodemap(self):

   222         msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]"

   223         util.nouideprecwarn(msg, b'5.3', stacklevel=2)

   224         return self._nodemap

   225 

   226     @util.propertycache

   227     def _nodemap(self):

   228         nodemap = nodemaputil.NodeMap({sha1nodeconstants.nullid: nullrev})

   229         for r in range(0, len(self)):

   230             n = self[r][7]

   231             nodemap[n] = r

   232         return nodemap

   233 

   234     def has_node(self, node):

   235         """return True if the node exist in the index"""

   236         return node in self._nodemap

   237 

   238     def rev(self, node):

   239         """return a revision for a node

   240 

   241         If the node is unknown, raise a RevlogError"""

   242         return self._nodemap[node]

   243 

   244     def get_rev(self, node):

   245         """return a revision for a node

   246 

   247         If the node is unknown, return None"""

   248         return self._nodemap.get(node)

   249 

   250     def append(self, tup):

   251         self._nodemap[tup[7]] = len(self)

   252         super(revlogoldindex, self).append(tup)

   253 

   254     def __delitem__(self, i):

   255         if not isinstance(i, slice) or not i.stop == -1 or i.step is not None:

   256             raise ValueError(b"deleting slices only supports a:-1 with step 1")

   257         for r in pycompat.xrange(i.start, len(self)):

   258             del self._nodemap[self[r][7]]

   259         super(revlogoldindex, self).__delitem__(i)

   260 

   261     def clearcaches(self):

   262         self.__dict__.pop('_nodemap', None)

   263 

   264     def __getitem__(self, i):

   265         if i == -1:

   266             return (0, 0, 0, -1, -1, -1, -1, sha1nodeconstants.nullid)

   267         return list.__getitem__(self, i)

   268 

   269     def entry_binary(self, rev):

   270         """return the raw binary string representing a revision"""

   271         entry = self[rev]

   272         if gettype(entry[0]):

   273             raise error.RevlogError(

   274                 _(b'index entry flags need revlog version 1')

   275             )

   276         e2 = (

   277             getoffset(entry[0]),

   278             entry[1],

   279             entry[3],

   280             entry[4],

   281             self[entry[5]][7],

   282             self[entry[6]][7],

   283             entry[7],

   284         )

   285         return INDEX_ENTRY_V0.pack(*e2)

   286 

   287     def pack_header(self, header):

   288         """Pack header information in binary"""

   289         return b''

   290 

   291 

   292 def parse_index_v0(data, inline):

   293     s = INDEX_ENTRY_V0.size

   294     index = []

   295     nodemap = nodemaputil.NodeMap({sha1nodeconstants.nullid: nullrev})

   296     n = off = 0

   297     l = len(data)

   298     while off + s <= l:

   299         cur = data[off : off + s]

   300         off += s

   301         e = INDEX_ENTRY_V0.unpack(cur)

   302         # transform to revlogv1 format

   303         e2 = (

   304             offset_type(e[0], 0),

   305             e[1],

   306             -1,

   307             e[2],

   308             e[3],

   309             nodemap.get(e[4], nullrev),

   310             nodemap.get(e[5], nullrev),

   311             e[6],

   312         )

   313         index.append(e2)

   314         nodemap[e[6]] = n

   315         n += 1

   316 

   317     index = revlogoldindex(index)

   318     return index, None