jhg: src/org/tmatesoft/hg/internal/RevlogStream.java annotate

annotate src/org/tmatesoft/hg/internal/RevlogStream.java @ 570:36853bb80a35

Tests for HgAnnotateCommand with follow/no-follow option

author	Artem Tikhomirov <tikhomirov.artem@gmail.com>
date	Thu, 11 Apr 2013 16:07:17 +0200
parents	6ca3d0c5b4bc
children	5d7399ade999

rev	line source
10 382cfe9463db Dirstate parsing. DataAccess refactored to allow reuse and control over constants Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 9 diff changeset	1 /*
530 0f6fa88e2162 Towards commit command: refactor clone, extract pieces to reuse. Describe a defect discovered when bundle has few patches with 0,0 parents Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 520 diff changeset	2 * Copyright (c) 2010-2013 TMate Software Ltd
74 6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	3 *
6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	4 * This program is free software; you can redistribute it and/or modify
6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	5 * it under the terms of the GNU General Public License as published by
6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	6 * the Free Software Foundation; version 2 of the License.
6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	7 *
6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	8 * This program is distributed in the hope that it will be useful,
6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	11 * GNU General Public License for more details.
6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	12 *
6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	13 * For information on how to redistribute this software under
6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	14 * the terms of a license other than GNU General Public License
102 a3a2e5deb320 Updated contact address to support@hg4j.com Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 88 diff changeset	15 * contact TMate Software at support@hg4j.com
0 dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	16 */
77 c677e1593919 Moved RevlogStream implementation into .internal Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 74 diff changeset	17 package org.tmatesoft.hg.internal;
0 dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	18
80 4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	19 import static org.tmatesoft.hg.repo.HgRepository.BAD_REVISION;
74 6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	20 import static org.tmatesoft.hg.repo.HgRepository.TIP;
530 0f6fa88e2162 Towards commit command: refactor clone, extract pieces to reuse. Describe a defect discovered when bundle has few patches with 0,0 parents Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 520 diff changeset	21 import static org.tmatesoft.hg.internal.Internals.REVLOGV1_RECORD_SIZE;
5 fc265ddeab26 File content and non-effective, although working, patch application Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 4 diff changeset	22
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	23 import java.io.File;
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	24 import java.io.IOException;
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	25 import java.util.zip.Inflater;
0 dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	26
74 6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	27 import org.tmatesoft.hg.core.Nodeid;
300 650b45d290b1 Share range check code Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 297 diff changeset	28 import org.tmatesoft.hg.repo.HgInternals;
423 9c9c442b5f2e Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 420 diff changeset	29 import org.tmatesoft.hg.repo.HgInvalidControlFileException;
9c9c442b5f2e Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 420 diff changeset	30 import org.tmatesoft.hg.repo.HgInvalidRevisionException;
9c9c442b5f2e Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 420 diff changeset	31 import org.tmatesoft.hg.repo.HgInvalidStateException;
80 4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	32 import org.tmatesoft.hg.repo.HgRepository;
520 1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 440 diff changeset	33 import org.tmatesoft.hg.util.Adaptable;
74 6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	34
10 382cfe9463db Dirstate parsing. DataAccess refactored to allow reuse and control over constants Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 9 diff changeset	35
0 dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	36 /**
dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	37 * ? Single RevlogStream per file per repository with accessor to record access session (e.g. with back/forward operations),
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	38 * or numerous RevlogStream with separate representation of the underlying data (cached, lazy ChunkStream)?
74 6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	39 *
0 dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	40 * @see http://mercurial.selenic.com/wiki/Revlog
dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	41 * @see http://mercurial.selenic.com/wiki/RevlogNG
74 6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	42 *
6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	43 * @author Artem Tikhomirov
6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	44 * @author TMate Software Ltd.
0 dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	45 */
dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	46 public class RevlogStream {
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	47
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	48 /*
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	49 * makes sense for index with inline data only - actual offset of the record in the .i file (record entry + revision * record size))
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	50 *
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	51 * long[] in fact (there are 8-bytes field in the revlog)
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	52 * However, (a) DataAccess currently doesn't operate with long seek/length
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	53 * and, of greater significance, (b) files with inlined data are designated for smaller files,
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	54 * guess, about 130 Kb, and offset there won't ever break int capacity
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	55 */
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	56 private int[] indexRecordOffset;
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	57 private int[] baseRevisions;
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	58 private boolean inline = false;
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	59 private final File indexFile;
396 0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	60 private File dataFile;
10 382cfe9463db Dirstate parsing. DataAccess refactored to allow reuse and control over constants Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 9 diff changeset	61 private final DataAccessProvider dataAccess;
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	62
10 382cfe9463db Dirstate parsing. DataAccess refactored to allow reuse and control over constants Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 9 diff changeset	63 // if we need anything else from HgRepo, might replace DAP parameter with HgRepo and query it for DAP.
77 c677e1593919 Moved RevlogStream implementation into .internal Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 74 diff changeset	64 public RevlogStream(DataAccessProvider dap, File indexFile) {
10 382cfe9463db Dirstate parsing. DataAccess refactored to allow reuse and control over constants Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 9 diff changeset	65 this.dataAccess = dap;
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	66 this.indexFile = indexFile;
24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	67 }
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	68
9 d6d2a630f4a6 Access to underlaying file data wrapped into own Access object, implemented with FileChannel and ByteBuffer Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 6 diff changeset	69 /package/ DataAccess getIndexStream() {
534 243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	70 // FIXME post 1.0 must supply a hint that I'll need really few bytes of data (perhaps, at some offset)
280 35125450c804 Erroneous and slow status for working copies based on non-tip revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 264 diff changeset	71 // to avoid mmap files when only few bytes are to be read (i.e. #dataLength())
534 243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	72 return dataAccess.createReader(indexFile);
0 dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	73 }
dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	74
9 d6d2a630f4a6 Access to underlaying file data wrapped into own Access object, implemented with FileChannel and ByteBuffer Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 6 diff changeset	75 /package/ DataAccess getDataStream() {
534 243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	76 return dataAccess.createReader(getDataFile());
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	77 }
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	78
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	79 /package/ DataSerializer getIndexStreamWriter() {
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	80 return dataAccess.createWriter(indexFile, true);
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	81 }
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	82
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	83 /package/ DataSerializer getDataStreamWriter() {
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	84 return dataAccess.createWriter(getDataFile(), true);
9 d6d2a630f4a6 Access to underlaying file data wrapped into own Access object, implemented with FileChannel and ByteBuffer Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 6 diff changeset	85 }
d6d2a630f4a6 Access to underlaying file data wrapped into own Access object, implemented with FileChannel and ByteBuffer Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 6 diff changeset	86
396 0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	87 /**
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	88 * Constructs file object that corresponds to .d revlog counterpart.
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	89 * Note, it's caller responsibility to ensure this file makes any sense (i.e. check {@link #inline} attribute)
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	90 */
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	91 private File getDataFile() {
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	92 if (dataFile == null) {
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	93 final String indexName = indexFile.getName();
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	94 dataFile = new File(indexFile.getParentFile(), indexName.substring(0, indexName.length() - 1) + "d");
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	95 }
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	96 return dataFile;
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	97 }
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	98
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	99 // initialize exception with the file where revlog structure information comes from
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	100 public HgInvalidControlFileException initWithIndexFile(HgInvalidControlFileException ex) {
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	101 return ex.setFile(indexFile);
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	102 }
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	103
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	104 // initialize exception with the file where revlog data comes from
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	105 public HgInvalidControlFileException initWithDataFile(HgInvalidControlFileException ex) {
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	106 // exceptions are usually raised after read attepmt, hence inline shall be initialized
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	107 // although honest approach is to call #initOutline() first
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	108 return ex.setFile(inline ? indexFile : getDataFile());
0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	109 }
534 243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	110
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	111 /package-private/String getDataFileName() {
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	112 // XXX a temporary solution to provide more info to fill in exceptions other than
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	113 // HgInvalidControlFileException (those benefit from initWith* methods above)
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	114 //
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	115 // Besides, since RevlogStream represents both revlogs with user data (those with WC representative and
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	116 // system data under store/data) and system-only revlogs (like changelog and manifest), there's no
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	117 // easy way to supply human-friendly name of the active file (independent from whether it's index of data)
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	118 return inline ? indexFile.getPath() : getDataFile().getPath();
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	119 }
396 0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	120
534 243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	121 public boolean isInlineData() {
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	122 initOutline();
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	123 return inline;
243202f1bda5 Commit: refactor revision creation code from clone command to work separately, fit into existing library structure Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 530 diff changeset	124 }
396 0ae53c32ecef Straighten out exceptions thrown when file access failed - three is too much Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	125
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	126 public int revisionCount() {
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	127 initOutline();
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	128 return baseRevisions.length;
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	129 }
22 603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	130
295 981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	131 /**
354 5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	132 * @throws HgInvalidControlFileException if attempt to read index file failed
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	133 * @throws HgInvalidRevisionException if revisionIndex argument doesn't represent a valid record in the revlog
295 981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	134 */
354 5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	135 public int dataLength(int revisionIndex) throws HgInvalidControlFileException, HgInvalidRevisionException {
22 603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	136 // XXX in fact, use of iterate() instead of this implementation may be quite reasonable.
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	137 //
354 5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	138 revisionIndex = checkRevisionIndex(revisionIndex);
280 35125450c804 Erroneous and slow status for working copies based on non-tip revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 264 diff changeset	139 DataAccess daIndex = getIndexStream();
22 603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	140 try {
354 5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	141 int recordOffset = getIndexOffsetInt(revisionIndex);
22 603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	142 daIndex.seek(recordOffset + 12); // 6+2+4
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	143 int actualLen = daIndex.readInt();
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	144 return actualLen;
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	145 } catch (IOException ex) {
440 299870249a28 Issue 30: bogus IOException for mmap file on linux Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 425 diff changeset	146 throw new HgInvalidControlFileException(null, ex, indexFile).setRevisionIndex(revisionIndex);
22 603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	147 } finally {
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	148 daIndex.done();
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	149 }
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	150 }
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	151
295 981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	152 /**
354 5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	153 * Read nodeid at given index
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	154 *
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	155 * @throws HgInvalidControlFileException if attempt to read index file failed
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	156 * @throws HgInvalidRevisionException if revisionIndex argument doesn't represent a valid record in the revlog
295 981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	157 */
354 5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	158 public byte[] nodeid(int revisionIndex) throws HgInvalidControlFileException, HgInvalidRevisionException {
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	159 revisionIndex = checkRevisionIndex(revisionIndex);
80 4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	160 DataAccess daIndex = getIndexStream();
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	161 try {
354 5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	162 int recordOffset = getIndexOffsetInt(revisionIndex);
80 4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	163 daIndex.seek(recordOffset + 32);
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	164 byte[] rv = new byte[20];
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	165 daIndex.readBytes(rv, 0, 20);
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	166 return rv;
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	167 } catch (IOException ex) {
440 299870249a28 Issue 30: bogus IOException for mmap file on linux Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 425 diff changeset	168 throw new HgInvalidControlFileException("Revision lookup failed", ex, indexFile).setRevisionIndex(revisionIndex);
80 4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	169 } finally {
88 61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	170 daIndex.done();
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	171 }
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	172 }
295 981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	173
981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	174 /**
981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	175 * Get link field from the index record.
354 5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	176 *
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	177 * @throws HgInvalidControlFileException if attempt to read index file failed
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	178 * @throws HgInvalidRevisionException if revisionIndex argument doesn't represent a valid record in the revlog
295 981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	179 */
354 5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	180 public int linkRevision(int revisionIndex) throws HgInvalidControlFileException, HgInvalidRevisionException {
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	181 revisionIndex = checkRevisionIndex(revisionIndex);
88 61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	182 DataAccess daIndex = getIndexStream();
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	183 try {
354 5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	184 int recordOffset = getIndexOffsetInt(revisionIndex);
88 61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	185 daIndex.seek(recordOffset + 20);
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	186 int linkRev = daIndex.readInt();
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	187 return linkRev;
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	188 } catch (IOException ex) {
440 299870249a28 Issue 30: bogus IOException for mmap file on linux Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 425 diff changeset	189 throw new HgInvalidControlFileException("Linked revision lookup failed", ex, indexFile).setRevisionIndex(revisionIndex);
88 61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	190 } finally {
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	191 daIndex.done();
80 4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	192 }
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	193 }
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	194
49 26e3eeaa3962 branch and user filtering for log operation Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 44 diff changeset	195 // Perhaps, RevlogStream should be limited to use of plain int revisions for access,
26e3eeaa3962 branch and user filtering for log operation Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 44 diff changeset	196 // while Nodeids should be kept on the level up, in Revlog. Guess, Revlog better keep
26e3eeaa3962 branch and user filtering for log operation Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 44 diff changeset	197 // map of nodeids, and once this comes true, we may get rid of this method.
80 4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	198 // Unlike its counterpart, {@link Revlog#getLocalRevisionNumber()}, doesn't fail with exception if node not found,
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	199 /**
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	200 * @return integer in [0..revisionCount()) or {@link HgRepository#BAD_REVISION} if not found
354 5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	201 * @throws HgInvalidControlFileException if attempt to read index file failed
80 4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	202 */
367 2fadf8695f8a Use 'revision index' instead of the vague 'local revision number' concept in the API Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 366 diff changeset	203 public int findRevisionIndex(Nodeid nodeid) throws HgInvalidControlFileException {
22 603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	204 // XXX this one may be implemented with iterate() once there's mechanism to stop iterations
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	205 final int indexSize = revisionCount();
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	206 DataAccess daIndex = getIndexStream();
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	207 try {
24 d4fdd1845b3f Nodeid with array of exactly 20 bytes Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 22 diff changeset	208 byte[] nodeidBuf = new byte[20];
22 603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	209 for (int i = 0; i < indexSize; i++) {
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	210 daIndex.skip(8);
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	211 int compressedLen = daIndex.readInt();
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	212 daIndex.skip(20);
24 d4fdd1845b3f Nodeid with array of exactly 20 bytes Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 22 diff changeset	213 daIndex.readBytes(nodeidBuf, 0, 20);
d4fdd1845b3f Nodeid with array of exactly 20 bytes Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 22 diff changeset	214 if (nodeid.equalsTo(nodeidBuf)) {
22 603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	215 return i;
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	216 }
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	217 daIndex.skip(inline ? 12 + compressedLen : 12);
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	218 }
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	219 } catch (IOException ex) {
440 299870249a28 Issue 30: bogus IOException for mmap file on linux Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 425 diff changeset	220 throw new HgInvalidControlFileException("Revision lookup failed", ex, indexFile).setRevision(nodeid);
22 603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	221 } finally {
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	222 daIndex.done();
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	223 }
80 4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	224 return BAD_REVISION;
22 603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	225 }
538 dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	226
539 9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	227 /**
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	228 * @return value suitable for the corresponding field in the new revision's header, not physical offset in the file
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	229 * (which is different in case of inline revlogs)
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	230 */
538 dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	231 public long newEntryOffset() {
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	232 if (revisionCount() == 0) {
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	233 return 0;
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	234 }
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	235 DataAccess daIndex = getIndexStream();
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	236 int lastRev = revisionCount() - 1;
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	237 try {
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	238 int recordOffset = getIndexOffsetInt(lastRev);
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	239 daIndex.seek(recordOffset);
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	240 long value = daIndex.readLong();
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	241 value = value >>> 16;
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	242 int compressedLen = daIndex.readInt();
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	243 return lastRev == 0 ? compressedLen : value + compressedLen;
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	244 } catch (IOException ex) {
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	245 throw new HgInvalidControlFileException("Linked revision lookup failed", ex, indexFile).setRevisionIndex(lastRev);
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	246 } finally {
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	247 daIndex.done();
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	248 }
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	249 }
dd4f6311af52 Commit: first working version Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 534 diff changeset	250
22 603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	251
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	252
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	253 // should be possible to use TIP, ALL, or -1, -2, -n notation of Hg
24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	254 // ? boolean needsNodeid
423 9c9c442b5f2e Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 420 diff changeset	255 public void iterate(int start, int end, boolean needData, Inspector inspector) throws HgInvalidRevisionException, HgInvalidControlFileException {
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	256 initOutline();
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	257 final int indexSize = revisionCount();
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	258 if (indexSize == 0) {
24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	259 return;
24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	260 }
5 fc265ddeab26 File content and non-effective, although working, patch application Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 4 diff changeset	261 if (end == TIP) {
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	262 end = indexSize - 1;
24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	263 }
5 fc265ddeab26 File content and non-effective, although working, patch application Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 4 diff changeset	264 if (start == TIP) {
fc265ddeab26 File content and non-effective, although working, patch application Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 4 diff changeset	265 start = indexSize - 1;
fc265ddeab26 File content and non-effective, although working, patch application Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 4 diff changeset	266 }
300 650b45d290b1 Share range check code Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 297 diff changeset	267 HgInternals.checkRevlogRange(start, end, indexSize-1);
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	268 // XXX may cache [start .. end] from index with a single read (pre-read)
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	269
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	270 ReaderN1 r = new ReaderN1(needData, inspector);
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	271 try {
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	272 r.start(end - start + 1);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	273 r.range(start, end);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	274 } catch (IOException ex) {
366 189dc6dc1c3e Use exceptions to expose errors reading mercurial data Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 354 diff changeset	275 throw new HgInvalidControlFileException(String.format("Failed reading [%d..%d]", start, end), ex, indexFile);
189dc6dc1c3e Use exceptions to expose errors reading mercurial data Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 354 diff changeset	276 } catch (HgInvalidControlFileException ex) {
189dc6dc1c3e Use exceptions to expose errors reading mercurial data Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 354 diff changeset	277 throw ex;
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	278 } finally {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	279 r.finish();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	280 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	281 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	282
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	283 /**
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	284 * Effective alternative to {@link #iterate(int, int, boolean, Inspector) batch read}, when only few selected
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	285 * revisions are of interest.
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	286 * @param sortedRevisions revisions to walk, in ascending order.
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	287 * @param needData whether inspector needs access to header only
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	288 * @param inspector callback to process entries
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	289 */
366 189dc6dc1c3e Use exceptions to expose errors reading mercurial data Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 354 diff changeset	290 public void iterate(int[] sortedRevisions, boolean needData, Inspector inspector) throws HgInvalidRevisionException, HgInvalidControlFileException /REVISIT - too general exception/ {
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	291 final int indexSize = revisionCount();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	292 if (indexSize == 0 \|\| sortedRevisions.length == 0) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	293 return;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	294 }
347 8da7ade36c57 Add specific IAE subclass to handle wrong (e.g. outdated after rollback) revisions Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 329 diff changeset	295 if (sortedRevisions[0] > indexSize) {
8da7ade36c57 Add specific IAE subclass to handle wrong (e.g. outdated after rollback) revisions Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 329 diff changeset	296 throw new HgInvalidRevisionException(String.format("Can't iterate [%d, %d] in range [0..%d]", sortedRevisions[0], sortedRevisions[sortedRevisions.length - 1], indexSize), null, sortedRevisions[0]);
8da7ade36c57 Add specific IAE subclass to handle wrong (e.g. outdated after rollback) revisions Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 329 diff changeset	297 }
8da7ade36c57 Add specific IAE subclass to handle wrong (e.g. outdated after rollback) revisions Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 329 diff changeset	298 if (sortedRevisions[sortedRevisions.length - 1] > indexSize) {
8da7ade36c57 Add specific IAE subclass to handle wrong (e.g. outdated after rollback) revisions Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 329 diff changeset	299 throw new HgInvalidRevisionException(String.format("Can't iterate [%d, %d] in range [0..%d]", sortedRevisions[0], sortedRevisions[sortedRevisions.length - 1], indexSize), null, sortedRevisions[sortedRevisions.length - 1]);
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	300 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	301
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	302 ReaderN1 r = new ReaderN1(needData, inspector);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	303 try {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	304 r.start(sortedRevisions.length);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	305 for (int i = 0; i < sortedRevisions.length; ) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	306 int x = i;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	307 i++;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	308 while (i < sortedRevisions.length) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	309 if (sortedRevisions[i] == sortedRevisions[i-1] + 1) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	310 i++;
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	311 } else {
217 e39cf474ef94 Experimental support to mix-in start and end events for inspectors. Additionally, Lifecycle may serve as iteration control Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 202 diff changeset	312 break;
e39cf474ef94 Experimental support to mix-in start and end events for inspectors. Additionally, Lifecycle may serve as iteration control Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 202 diff changeset	313 }
e39cf474ef94 Experimental support to mix-in start and end events for inspectors. Additionally, Lifecycle may serve as iteration control Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 202 diff changeset	314 }
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	315 // commitRevisions[x..i-1] are sequential
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	316 if (!r.range(sortedRevisions[x], sortedRevisions[i-1])) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	317 return;
51 9429c7bd1920 Try DataAccess to reach revision data instead of plain byte arrays Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 49 diff changeset	318 }
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	319 }
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	320 } catch (IOException ex) {
366 189dc6dc1c3e Use exceptions to expose errors reading mercurial data Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 354 diff changeset	321 final int c = sortedRevisions.length;
189dc6dc1c3e Use exceptions to expose errors reading mercurial data Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 354 diff changeset	322 throw new HgInvalidControlFileException(String.format("Failed reading %d revisions in [%d; %d]",c, sortedRevisions[0], sortedRevisions[c-1]), ex, indexFile);
189dc6dc1c3e Use exceptions to expose errors reading mercurial data Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 354 diff changeset	323 } catch (HgInvalidControlFileException ex) {
423 9c9c442b5f2e Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 420 diff changeset	324 // TODO post-1.0 fill HgRuntimeException with appropriate file (either index or data, depending on error source)
366 189dc6dc1c3e Use exceptions to expose errors reading mercurial data Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 354 diff changeset	325 throw ex;
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	326 } finally {
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	327 r.finish();
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	328 }
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	329 }
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	330
539 9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	331 void revisionAdded(int revisionIndex, Nodeid revision, int baseRevisionIndex, long revisionOffset) throws HgInvalidControlFileException {
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	332 if (!outlineCached()) {
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	333 return;
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	334 }
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	335 if (baseRevisions.length != revisionIndex) {
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	336 throw new HgInvalidControlFileException(String.format("New entry's index shall be %d, not %d", baseRevisions.length, revisionIndex), null, indexFile);
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	337 }
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	338 if (baseRevisionIndex < 0 \|\| baseRevisionIndex > baseRevisions.length) {
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	339 // baseRevisionIndex MAY be == to baseRevisions.length, it's when new revision is based on itself
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	340 throw new HgInvalidControlFileException(String.format("Base revision index %d doesn't fit [0..%d] range", baseRevisionIndex, baseRevisions.length), null, indexFile);
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	341 }
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	342 assert revision != null;
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	343 assert !revision.isNull();
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	344 int[] baseRevisionsCopy = new int[baseRevisions.length + 1];
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	345 System.arraycopy(baseRevisions, 0, baseRevisionsCopy, 0, baseRevisions.length);
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	346 baseRevisionsCopy[baseRevisions.length] = baseRevisionIndex;
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	347 baseRevisions = baseRevisionsCopy;
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	348 if (inline && indexRecordOffset != null) {
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	349 assert indexRecordOffset.length == revisionIndex;
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	350 int[] indexRecordOffsetCopy = new int[indexRecordOffset.length + 1];
559 6ca3d0c5b4bc Commit: tests and fixes for defects discovered Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 539 diff changeset	351 System.arraycopy(indexRecordOffset, 0, indexRecordOffsetCopy, 0, indexRecordOffset.length);
539 9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	352 indexRecordOffsetCopy[indexRecordOffset.length] = offsetFieldToInlineFileOffset(revisionOffset, revisionIndex);
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	353 indexRecordOffset = indexRecordOffsetCopy;
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	354 }
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	355 }
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	356
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	357 private int getBaseRevision(int revision) {
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	358 return baseRevisions[revision];
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	359 }
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	360
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	361 /**
354 5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	362 * @param revisionIndex shall be valid index, [0..baseRevisions.length-1].
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	363 * It's advised to use {@link #checkRevisionIndex(int)} to ensure argument is correct.
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	364 * @return offset of the revision's record in the index (.i) stream
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	365 */
354 5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	366 private int getIndexOffsetInt(int revisionIndex) {
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	367 return inline ? indexRecordOffset[revisionIndex] : revisionIndex * REVLOGV1_RECORD_SIZE;
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	368 }
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	369
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	370 private int checkRevisionIndex(int revisionIndex) throws HgInvalidRevisionException {
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	371 final int last = revisionCount() - 1;
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	372 if (revisionIndex == TIP) {
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	373 revisionIndex = last;
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	374 }
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	375 if (revisionIndex < 0 \|\| revisionIndex > last) {
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	376 throw new HgInvalidRevisionException(revisionIndex).setRevisionIndex(revisionIndex, 0, last);
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	377 }
5f9073eabf06 Propagate errors with exceptions up to a end client Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 347 diff changeset	378 return revisionIndex;
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	379 }
539 9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	380
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	381 private boolean outlineCached() {
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	382 return baseRevisions != null && baseRevisions.length > 0;
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	383 }
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	384
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	385 // translate 6-byte offset field value to pysical file offset for inline revlogs
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	386 // DOESN'T MAKE SENSE if revlog with data is separate
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	387 private static int offsetFieldToInlineFileOffset(long offset, int recordIndex) throws HgInvalidStateException {
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	388 int o = Internals.ltoi(offset);
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	389 if (o != offset) {
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	390 // just in case, can't happen, ever, unless HG (or some other bad tool) produces index file
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	391 // with inlined data of size greater than 2 Gb.
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	392 throw new HgInvalidStateException("Data too big, offset didn't fit to sizeof(int)");
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	393 }
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	394 return o + REVLOGV1_RECORD_SIZE * recordIndex;
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	395 }
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	396
425 48f993aa2f41 FIXMEs: exceptions, javadoc Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 423 diff changeset	397 private void initOutline() throws HgInvalidControlFileException {
539 9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	398 if (outlineCached()) {
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	399 return;
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	400 }
9 d6d2a630f4a6 Access to underlaying file data wrapped into own Access object, implemented with FileChannel and ByteBuffer Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 6 diff changeset	401 DataAccess da = getIndexStream();
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	402 try {
202 706bcc7cfee4 Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general. Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 198 diff changeset	403 if (da.isEmpty()) {
706bcc7cfee4 Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general. Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 198 diff changeset	404 // do not fail with exception if stream is empty, it's likely intentional
706bcc7cfee4 Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general. Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 198 diff changeset	405 baseRevisions = new int[0];
539 9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	406 // empty revlog, likely to be populated, indicate we start with a single file
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	407 inline = true;
202 706bcc7cfee4 Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general. Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 198 diff changeset	408 return;
706bcc7cfee4 Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general. Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 198 diff changeset	409 }
9 d6d2a630f4a6 Access to underlaying file data wrapped into own Access object, implemented with FileChannel and ByteBuffer Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 6 diff changeset	410 int versionField = da.readInt();
170 71ddbf8603e8 Initial clone: populate given directory from a bundle. Everything but remote server access is there, albeit prototype code style Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 158 diff changeset	411 da.readInt(); // just to skip next 4 bytes of offset + flags
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	412 final int INLINEDATA = 1 << 16;
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	413 inline = (versionField & INLINEDATA) != 0;
288 b11f6a08f748 Avoid boxing int values and list resizes on revlog read Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 280 diff changeset	414 IntVector resBases, resOffsets = null;
420 6c22bdc0bdfd Respect long offsets in revlogs Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 398 diff changeset	415 int entryCountGuess = Internals.ltoi(da.longLength() / REVLOGV1_RECORD_SIZE);
288 b11f6a08f748 Avoid boxing int values and list resizes on revlog read Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 280 diff changeset	416 if (inline) {
b11f6a08f748 Avoid boxing int values and list resizes on revlog read Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 280 diff changeset	417 entryCountGuess >>>= 2; // pure guess, assume useful data takes 3/4 of total space
b11f6a08f748 Avoid boxing int values and list resizes on revlog read Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 280 diff changeset	418 resOffsets = new IntVector(entryCountGuess, 5000);
b11f6a08f748 Avoid boxing int values and list resizes on revlog read Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 280 diff changeset	419 }
b11f6a08f748 Avoid boxing int values and list resizes on revlog read Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 280 diff changeset	420 resBases = new IntVector(entryCountGuess, 5000);
b11f6a08f748 Avoid boxing int values and list resizes on revlog read Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 280 diff changeset	421
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	422 long offset = 0; // first offset is always 0, thus Hg uses it for other purposes
9 d6d2a630f4a6 Access to underlaying file data wrapped into own Access object, implemented with FileChannel and ByteBuffer Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 6 diff changeset	423 while(true) {
d6d2a630f4a6 Access to underlaying file data wrapped into own Access object, implemented with FileChannel and ByteBuffer Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 6 diff changeset	424 int compressedLen = da.readInt();
5 fc265ddeab26 File content and non-effective, although working, patch application Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 4 diff changeset	425 // 8+4 = 12 bytes total read here
49 26e3eeaa3962 branch and user filtering for log operation Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 44 diff changeset	426 @SuppressWarnings("unused")
9 d6d2a630f4a6 Access to underlaying file data wrapped into own Access object, implemented with FileChannel and ByteBuffer Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 6 diff changeset	427 int actualLen = da.readInt();
d6d2a630f4a6 Access to underlaying file data wrapped into own Access object, implemented with FileChannel and ByteBuffer Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 6 diff changeset	428 int baseRevision = da.readInt();
5 fc265ddeab26 File content and non-effective, although working, patch application Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 4 diff changeset	429 // 12 + 8 = 20 bytes read here
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	430 // int linkRevision = di.readInt();
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	431 // int parent1Revision = di.readInt();
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	432 // int parent2Revision = di.readInt();
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	433 // byte[] nodeid = new byte[32];
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	434 resBases.add(baseRevision);
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	435 if (inline) {
539 9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	436 int o = offsetFieldToInlineFileOffset(offset, resOffsets.size());
9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	437 resOffsets.add(o);
9 d6d2a630f4a6 Access to underlaying file data wrapped into own Access object, implemented with FileChannel and ByteBuffer Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 6 diff changeset	438 da.skip(3*4 + 32 + compressedLen); // Check: 44 (skip) + 20 (read) = 64 (total RevlogNG record size)
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	439 } else {
9 d6d2a630f4a6 Access to underlaying file data wrapped into own Access object, implemented with FileChannel and ByteBuffer Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 6 diff changeset	440 da.skip(3*4 + 32);
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	441 }
10 382cfe9463db Dirstate parsing. DataAccess refactored to allow reuse and control over constants Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 9 diff changeset	442 if (da.isEmpty()) {
9 d6d2a630f4a6 Access to underlaying file data wrapped into own Access object, implemented with FileChannel and ByteBuffer Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 6 diff changeset	443 // fine, done then
288 b11f6a08f748 Avoid boxing int values and list resizes on revlog read Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 280 diff changeset	444 baseRevisions = resBases.toArray(true);
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	445 if (inline) {
288 b11f6a08f748 Avoid boxing int values and list resizes on revlog read Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 280 diff changeset	446 indexRecordOffset = resOffsets.toArray(true);
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	447 }
9 d6d2a630f4a6 Access to underlaying file data wrapped into own Access object, implemented with FileChannel and ByteBuffer Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 6 diff changeset	448 break;
10 382cfe9463db Dirstate parsing. DataAccess refactored to allow reuse and control over constants Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 9 diff changeset	449 } else {
382cfe9463db Dirstate parsing. DataAccess refactored to allow reuse and control over constants Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 9 diff changeset	450 // start reading next record
382cfe9463db Dirstate parsing. DataAccess refactored to allow reuse and control over constants Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 9 diff changeset	451 long l = da.readLong();
382cfe9463db Dirstate parsing. DataAccess refactored to allow reuse and control over constants Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 9 diff changeset	452 offset = l >>> 16;
9 d6d2a630f4a6 Access to underlaying file data wrapped into own Access object, implemented with FileChannel and ByteBuffer Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 6 diff changeset	453 }
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	454 }
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	455 } catch (IOException ex) {
423 9c9c442b5f2e Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 420 diff changeset	456 throw new HgInvalidControlFileException("Failed to analyze revlog index", ex, indexFile);
9 d6d2a630f4a6 Access to underlaying file data wrapped into own Access object, implemented with FileChannel and ByteBuffer Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 6 diff changeset	457 } finally {
d6d2a630f4a6 Access to underlaying file data wrapped into own Access object, implemented with FileChannel and ByteBuffer Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 6 diff changeset	458 da.done();
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	459 }
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	460 }
24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	461
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	462 /**
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	463 * operation with single file open/close and multiple diverse reads.
366 189dc6dc1c3e Use exceptions to expose errors reading mercurial data Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 354 diff changeset	464 * XXX initOutline might need similar extraction to keep N1 format knowledge
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	465 */
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	466 class ReaderN1 {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	467 private final Inspector inspector;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	468 private final boolean needData;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	469 private DataAccess daIndex = null, daData = null;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	470 private Lifecycle.BasicCallback cb = null;
520 1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 440 diff changeset	471 private Lifecycle lifecycleListener = null;
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	472 private int lastRevisionRead = BAD_REVISION;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	473 private DataAccess lastUserData;
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	474 // next are to track two major bottlenecks - patch application and actual time spent in inspector
264 6bb5e7ed051a Optimize memory usage (reduce number of objects instantiated) when pooling file names and nodeids during manifest parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 263 diff changeset	475 // private long applyTime, inspectorTime; // TIMING
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	476
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	477
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	478 public ReaderN1(boolean needData, Inspector insp) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	479 assert insp != null;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	480 this.needData = needData;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	481 inspector = insp;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	482 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	483
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	484 public void start(int totalWork) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	485 daIndex = getIndexStream();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	486 if (needData && !inline) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	487 daData = getDataStream();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	488 }
520 1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 440 diff changeset	489 lifecycleListener = Adaptable.Factory.getAdapter(inspector, Lifecycle.class, null);
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 440 diff changeset	490 if (lifecycleListener != null) {
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	491 cb = new Lifecycle.BasicCallback();
520 1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 440 diff changeset	492 lifecycleListener.start(totalWork, cb, cb);
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	493 }
264 6bb5e7ed051a Optimize memory usage (reduce number of objects instantiated) when pooling file names and nodeids during manifest parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 263 diff changeset	494 // applyTime = inspectorTime = 0; // TIMING
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	495 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	496
520 1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 440 diff changeset	497 // invoked only once per instance
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	498 public void finish() {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	499 if (lastUserData != null) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	500 lastUserData.done();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	501 lastUserData = null;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	502 }
520 1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 440 diff changeset	503 if (lifecycleListener != null) {
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 440 diff changeset	504 lifecycleListener.finish(cb);
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 440 diff changeset	505 lifecycleListener = null;
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 440 diff changeset	506 cb = null;
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 440 diff changeset	507
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	508 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	509 daIndex.done();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	510 if (daData != null) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	511 daData.done();
520 1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 440 diff changeset	512 daData = null;
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	513 }
264 6bb5e7ed051a Optimize memory usage (reduce number of objects instantiated) when pooling file names and nodeids during manifest parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 263 diff changeset	514 // System.out.printf("applyTime:%d ms, inspectorTime: %d ms\n", applyTime, inspectorTime); // TIMING
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	515 }
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	516
520 1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 440 diff changeset	517 // may be invoked few times per instance life
423 9c9c442b5f2e Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 420 diff changeset	518 public boolean range(int start, int end) throws IOException {
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	519 byte[] nodeidBuf = new byte[20];
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	520 int i;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	521 // it (i.e. replace with i >= start)
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	522 if (needData && (i = getBaseRevision(start)) < start) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	523 // if lastRevisionRead in [baseRevision(start), start) can reuse lastUserData
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	524 // doesn't make sense to reuse if lastRevisionRead == start (too much to change in the cycle below).
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	525 if (lastRevisionRead != BAD_REVISION && i <= lastRevisionRead && lastRevisionRead < start) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	526 i = lastRevisionRead + 1; // start with first not-yet-read revision
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	527 } else {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	528 if (lastUserData != null) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	529 lastUserData.done();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	530 lastUserData = null;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	531 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	532 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	533 } else {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	534 // don't need to clean lastUserData as it's always null when !needData
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	535 i = start;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	536 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	537
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	538 daIndex.seek(getIndexOffsetInt(i));
258 e5776067b3b8 Reduce number of objects instantiated on revlog read Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 243 diff changeset	539 //
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	540 // reuse some instances
329 694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 300 diff changeset	541 final Patch patch = new Patch();
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	542 final Inflater inflater = new Inflater();
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	543 // can share buffer between instances of InflaterDataAccess as I never read any two of them in parallel
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	544 final byte[] inflaterBuffer = new byte[1024];
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	545 //
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	546
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	547 for (; i <= end; i++ ) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	548 if (inline && needData) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	549 // inspector reading data (though FilterDataAccess) may have affected index position
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	550 daIndex.seek(getIndexOffsetInt(i));
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	551 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	552 long l = daIndex.readLong(); // 0
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	553 long offset = i == 0 ? 0 : (l >>> 16);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	554 @SuppressWarnings("unused")
420 6c22bdc0bdfd Respect long offsets in revlogs Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 398 diff changeset	555 int flags = (int) (l & 0x0FFFF);
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	556 int compressedLen = daIndex.readInt(); // +8
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	557 int actualLen = daIndex.readInt(); // +12
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	558 int baseRevision = daIndex.readInt(); // +16
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	559 int linkRevision = daIndex.readInt(); // +20
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	560 int parent1Revision = daIndex.readInt();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	561 int parent2Revision = daIndex.readInt();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	562 // Hg has 32 bytes here, uses 20 for nodeid, and keeps 12 last bytes empty
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	563 daIndex.readBytes(nodeidBuf, 0, 20); // +32
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	564 daIndex.skip(12);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	565 DataAccess userDataAccess = null;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	566 if (needData) {
420 6c22bdc0bdfd Respect long offsets in revlogs Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 398 diff changeset	567 long streamOffset;
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	568 DataAccess streamDataAccess;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	569 if (inline) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	570 streamDataAccess = daIndex;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	571 streamOffset = getIndexOffsetInt(i) + REVLOGV1_RECORD_SIZE; // don't need to do seek as it's actual position in the index stream
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	572 } else {
420 6c22bdc0bdfd Respect long offsets in revlogs Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 398 diff changeset	573 streamOffset = offset;
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	574 streamDataAccess = daData;
420 6c22bdc0bdfd Respect long offsets in revlogs Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 398 diff changeset	575 daData.longSeek(streamOffset);
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	576 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	577 final boolean patchToPrevious = baseRevision != i; // the only way I found to tell if it's a patch
397 5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	578 if (streamDataAccess.isEmpty() \|\| compressedLen == 0) {
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	579 userDataAccess = new DataAccess(); // empty
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	580 } else {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	581 final byte firstByte = streamDataAccess.readByte();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	582 if (firstByte == 0x78 /* 'x' */) {
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	583 inflater.reset();
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	584 userDataAccess = new InflaterDataAccess(streamDataAccess, streamOffset, compressedLen, patchToPrevious ? -1 : actualLen, inflater, inflaterBuffer);
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	585 } else if (firstByte == 0x75 /* 'u' */) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	586 userDataAccess = new FilterDataAccess(streamDataAccess, streamOffset+1, compressedLen-1);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	587 } else {
397 5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	588 // XXX Python impl in fact throws exception when there's not 'x', 'u' or '0' but I don't see reason not to return data as is
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	589 //
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	590 // although firstByte is already read from the streamDataAccess, FilterDataAccess#readByte would seek to
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	591 // initial offset before first attempt to read a byte
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	592 userDataAccess = new FilterDataAccess(streamDataAccess, streamOffset, compressedLen);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	593 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	594 }
397 5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	595 // userDataAccess is revision content, either complete revision, patch of a previous content, or an empty patch
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	596 if (patchToPrevious) {
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	597 // this is a patch
397 5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	598 if (userDataAccess.isEmpty()) {
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	599 // Issue 22, empty patch to an empty base revision
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	600 // Issue 24, empty patch to non-empty base revision
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	601 // empty patch modifies nothing, use content of a previous revision (shall present - it's a patch here)
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	602 //
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	603 assert lastUserData.length() == actualLen; // with no patch, data size shall be the same
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	604 userDataAccess = lastUserData;
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	605 } else {
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	606 patch.read(userDataAccess);
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	607 userDataAccess.done();
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	608 //
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	609 // it shall be reset at the end of prev iteration, when it got assigned from userDataAccess
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	610 // however, actual userDataAccess and lastUserData may share Inflater object, which needs to be reset
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	611 // Alternatively, userDataAccess.done() above may be responsible to reset Inflater (if it's InflaterDataAccess)
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	612 lastUserData.reset();
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	613 // final long startMeasuring = System.currentTimeMillis(); // TIMING
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	614 byte[] userData = patch.apply(lastUserData, actualLen);
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	615 // applyTime += (System.currentTimeMillis() - startMeasuring); // TIMING
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	616 patch.clear(); // do not keep any reference, allow byte[] data to be gc'd
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	617 userDataAccess = new ByteArrayDataAccess(userData);
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	618 }
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	619 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	620 } else {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	621 if (inline) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	622 daIndex.skip(compressedLen);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	623 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	624 }
329 694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 300 diff changeset	625 if (i >= start) {
264 6bb5e7ed051a Optimize memory usage (reduce number of objects instantiated) when pooling file names and nodeids during manifest parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 263 diff changeset	626 // final long startMeasuring = System.currentTimeMillis(); // TIMING
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	627 inspector.next(i, actualLen, baseRevision, linkRevision, parent1Revision, parent2Revision, nodeidBuf, userDataAccess);
264 6bb5e7ed051a Optimize memory usage (reduce number of objects instantiated) when pooling file names and nodeids during manifest parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 263 diff changeset	628 // inspectorTime += (System.currentTimeMillis() - startMeasuring); // TIMING
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	629 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	630 if (cb != null) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	631 if (cb.isStopped()) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	632 return false;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	633 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	634 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	635 if (userDataAccess != null) {
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	636 userDataAccess.reset(); // not sure this is necessary here, as lastUserData would get reset anyway before next use.
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	637 }
397 5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	638 if (lastUserData != null && lastUserData != userDataAccess /* empty patch case, reuse of recent data in actual revision */) {
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	639 // release lastUserData only if we didn't reuse it in actual revision due to empty patch:
5e95b0da26f2 Issue 24: IAE, Underflow in FilterDataAccess. Issue 26:UnsupportedOperationException when patching empty base revision. Tests Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 377 diff changeset	640 // empty patch means we have previous revision and didn't alter it with a patch, hence use lastUserData for userDataAccess above
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	641 lastUserData.done();
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	642 }
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	643 lastUserData = userDataAccess;
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	644 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	645 lastRevisionRead = end;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	646 return true;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	647 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	648 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	649
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	650
77 c677e1593919 Moved RevlogStream implementation into .internal Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 74 diff changeset	651 public interface Inspector {
c677e1593919 Moved RevlogStream implementation into .internal Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 74 diff changeset	652 // XXX boolean retVal to indicate whether to continue?
157 d5268ca7715b Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 53 102 diff changeset	653 // TODO specify nodeid and data length, and reuse policy (i.e. if revlog stream doesn't reuse nodeid[] for each call)
d5268ca7715b Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 53 102 diff changeset	654 // implementers shall not invoke DataAccess.done(), it's accomplished by #iterate at appropraite moment
423 9c9c442b5f2e Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 420 diff changeset	655 void next(int revisionIndex, int actualLen, int baseRevision, int linkRevision, int parent1Revision, int parent2Revision, byte[/20/] nodeid, DataAccess data);
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	656 }
539 9edfd5a223b8 Commit: handle empty repository case Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 538 diff changeset	657
0 dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	658 }

Mercurial > jhg

annotate src/org/tmatesoft/hg/internal/RevlogStream.java @ 570:36853bb80a35