363 self.__index_file = index_file |
364 self.__index_file = index_file |
364 self.data_file = data_file |
365 self.data_file = data_file |
365 self.sidedata_file = sidedata_file |
366 self.sidedata_file = sidedata_file |
366 self.inline = inline |
367 self.inline = inline |
367 self.data_config = data_config |
368 self.data_config = data_config |
|
369 self.delta_config = delta_config |
368 self.feature_config = feature_config |
370 self.feature_config = feature_config |
369 |
371 |
370 self._default_compression_header = default_compression_header |
372 self._default_compression_header = default_compression_header |
371 |
373 |
372 # index |
374 # index |
397 def index_file(self, new_index_file): |
399 def index_file(self, new_index_file): |
398 self.__index_file = new_index_file |
400 self.__index_file = new_index_file |
399 if self.inline: |
401 if self.inline: |
400 self._segmentfile.filename = new_index_file |
402 self._segmentfile.filename = new_index_file |
401 |
403 |
|
404 def __len__(self): |
|
405 return len(self.index) |
|
406 |
402 # Derived from index values. |
407 # Derived from index values. |
403 |
408 |
404 def start(self, rev): |
409 def start(self, rev): |
405 """the offset of the data chunk for this revision""" |
410 """the offset of the data chunk for this revision""" |
406 return int(self.index[rev][0] >> 16) |
411 return int(self.index[rev][0] >> 16) |
410 return self.index[rev][1] |
415 return self.index[rev][1] |
411 |
416 |
412 def end(self, rev): |
417 def end(self, rev): |
413 """the end of the data chunk for this revision""" |
418 """the end of the data chunk for this revision""" |
414 return self.start(rev) + self.length(rev) |
419 return self.start(rev) + self.length(rev) |
|
420 |
|
421 def deltaparent(self, rev): |
|
422 """return deltaparent of the given revision""" |
|
423 base = self.index[rev][3] |
|
424 if base == rev: |
|
425 return nullrev |
|
426 elif self.delta_config.general_delta: |
|
427 return base |
|
428 else: |
|
429 return rev - 1 |
|
430 |
|
431 def issnapshot(self, rev): |
|
432 """tells whether rev is a snapshot""" |
|
433 if not self.delta_config.sparse_revlog: |
|
434 return self.deltaparent(rev) == nullrev |
|
435 elif hasattr(self.index, 'issnapshot'): |
|
436 # directly assign the method to cache the testing and access |
|
437 self.issnapshot = self.index.issnapshot |
|
438 return self.issnapshot(rev) |
|
439 if rev == nullrev: |
|
440 return True |
|
441 entry = self.index[rev] |
|
442 base = entry[3] |
|
443 if base == rev: |
|
444 return True |
|
445 if base == nullrev: |
|
446 return True |
|
447 p1 = entry[5] |
|
448 while self.length(p1) == 0: |
|
449 b = self.deltaparent(p1) |
|
450 if b == p1: |
|
451 break |
|
452 p1 = b |
|
453 p2 = entry[6] |
|
454 while self.length(p2) == 0: |
|
455 b = self.deltaparent(p2) |
|
456 if b == p2: |
|
457 break |
|
458 p2 = b |
|
459 if base == p1 or base == p2: |
|
460 return False |
|
461 return self.issnapshot(base) |
415 |
462 |
416 @util.propertycache |
463 @util.propertycache |
417 def _compressor(self): |
464 def _compressor(self): |
418 engine = util.compengines[self.feature_config.compression_engine] |
465 engine = util.compengines[self.feature_config.compression_engine] |
419 return engine.revlogcompressor( |
466 return engine.revlogcompressor( |
1426 index_file=self._indexfile, |
1473 index_file=self._indexfile, |
1427 data_file=self._datafile, |
1474 data_file=self._datafile, |
1428 sidedata_file=self._sidedatafile, |
1475 sidedata_file=self._sidedatafile, |
1429 inline=self._inline, |
1476 inline=self._inline, |
1430 data_config=self.data_config, |
1477 data_config=self.data_config, |
|
1478 delta_config=self.delta_config, |
1431 feature_config=self.feature_config, |
1479 feature_config=self.feature_config, |
1432 chunk_cache=chunk_cache, |
1480 chunk_cache=chunk_cache, |
1433 default_compression_header=default_compression_header, |
1481 default_compression_header=default_compression_header, |
1434 ) |
1482 ) |
1435 |
1483 |
2439 else: |
2487 else: |
2440 return rev - 1 |
2488 return rev - 1 |
2441 |
2489 |
2442 def issnapshot(self, rev): |
2490 def issnapshot(self, rev): |
2443 """tells whether rev is a snapshot""" |
2491 """tells whether rev is a snapshot""" |
2444 if not self.delta_config.sparse_revlog: |
2492 ret = self._inner.issnapshot(rev) |
2445 return self.deltaparent(rev) == nullrev |
2493 self.issnapshot = self._inner.issnapshot |
2446 elif hasattr(self.index, 'issnapshot'): |
2494 return ret |
2447 # directly assign the method to cache the testing and access |
|
2448 self.issnapshot = self.index.issnapshot |
|
2449 return self.issnapshot(rev) |
|
2450 if rev == nullrev: |
|
2451 return True |
|
2452 entry = self.index[rev] |
|
2453 base = entry[3] |
|
2454 if base == rev: |
|
2455 return True |
|
2456 if base == nullrev: |
|
2457 return True |
|
2458 p1 = entry[5] |
|
2459 while self.length(p1) == 0: |
|
2460 b = self.deltaparent(p1) |
|
2461 if b == p1: |
|
2462 break |
|
2463 p1 = b |
|
2464 p2 = entry[6] |
|
2465 while self.length(p2) == 0: |
|
2466 b = self.deltaparent(p2) |
|
2467 if b == p2: |
|
2468 break |
|
2469 p2 = b |
|
2470 if base == p1 or base == p2: |
|
2471 return False |
|
2472 return self.issnapshot(base) |
|
2473 |
2495 |
2474 def snapshotdepth(self, rev): |
2496 def snapshotdepth(self, rev): |
2475 """number of snapshot in the chain before this one""" |
2497 """number of snapshot in the chain before this one""" |
2476 if not self.issnapshot(rev): |
2498 if not self.issnapshot(rev): |
2477 raise error.ProgrammingError(b'revision %d not a snapshot') |
2499 raise error.ProgrammingError(b'revision %d not a snapshot') |