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

annotate src/org/tmatesoft/hg/internal/RevlogStream.java @ 303:2ffcbf360fd5

Remove debug printout

author	Artem Tikhomirov <tikhomirov.artem@gmail.com>
date	Tue, 20 Sep 2011 04:43:39 +0200
parents	650b45d290b1
children	694ebabb5cb3

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 /*
74 6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	2 * Copyright (c) 2010-2011 TMate Software Ltd
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;
5 fc265ddeab26 File content and non-effective, although working, patch application Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 4 diff changeset	21
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	22 import java.io.File;
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	23 import java.io.IOException;
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	24 import java.util.ArrayList;
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	25 import java.util.List;
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	26 import java.util.zip.Inflater;
0 dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	27
158 b413b16d10a5 Integer offsets and file length explictly, rather than casts throughout code. Inflater may benefit from total length hint, but shall calculate it by its own if needed Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 157 diff changeset	28 import org.tmatesoft.hg.core.HgBadStateException;
74 6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	29 import org.tmatesoft.hg.core.Nodeid;
300 650b45d290b1 Share range check code Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 297 diff changeset	30 import org.tmatesoft.hg.repo.HgInternals;
80 4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	31 import org.tmatesoft.hg.repo.HgRepository;
74 6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	32
10 382cfe9463db Dirstate parsing. DataAccess refactored to allow reuse and control over constants Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 9 diff changeset	33
0 dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	34 /**
dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	35 * ? 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	36 * 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	37 *
0 dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	38 * @see http://mercurial.selenic.com/wiki/Revlog
dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	39 * @see http://mercurial.selenic.com/wiki/RevlogNG
74 6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	40 *
6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	41 * @author Artem Tikhomirov
6f1b88693d48 Complete refactoring to org.tmatesoft Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 52 diff changeset	42 * @author TMate Software Ltd.
0 dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	43 */
dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	44 public class RevlogStream {
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	45
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	46 /*
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	47 * 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	48 *
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	49 * 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	50 * 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	51 * 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	52 * 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	53 */
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	54 private int[] indexRecordOffset;
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	55 private int[] baseRevisions;
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	56 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	57 private final 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	58 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	59
10 382cfe9463db Dirstate parsing. DataAccess refactored to allow reuse and control over constants Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 9 diff changeset	60 // 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	61 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	62 this.dataAccess = dap;
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	63 this.indexFile = indexFile;
24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	64 }
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	65
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	66 /package/ DataAccess getIndexStream() {
280 35125450c804 Erroneous and slow status for working copies based on non-tip revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 264 diff changeset	67 // XXX may supply a hint that I'll need really few bytes of data (perhaps, at some offset)
35125450c804 Erroneous and slow status for working copies based on non-tip revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 264 diff changeset	68 // to avoid mmap files when only few bytes are to be read (i.e. #dataLength())
10 382cfe9463db Dirstate parsing. DataAccess refactored to allow reuse and control over constants Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 9 diff changeset	69 return dataAccess.create(indexFile);
0 dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	70 }
dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	71
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	72 /package/ DataAccess getDataStream() {
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	73 final String indexName = indexFile.getName();
24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	74 File dataFile = new File(indexFile.getParentFile(), indexName.substring(0, indexName.length() - 1) + "d");
10 382cfe9463db Dirstate parsing. DataAccess refactored to allow reuse and control over constants Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 9 diff changeset	75 return dataAccess.create(dataFile);
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	76 }
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	77
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	78 public int revisionCount() {
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	79 initOutline();
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	80 return baseRevisions.length;
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	81 }
22 603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	82
295 981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	83 /**
981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	84 * @throws HgBadStateException if internal read operation failed
981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	85 */
22 603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	86 public int dataLength(int revision) {
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	87 // 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	88 //
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	89 final int indexSize = revisionCount();
280 35125450c804 Erroneous and slow status for working copies based on non-tip revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 264 diff changeset	90 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	91 if (revision == TIP) {
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	92 revision = indexSize - 1;
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	93 }
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	94 try {
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	95 int recordOffset = getIndexOffsetInt(revision);
22 603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	96 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	97 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	98 return actualLen;
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	99 } catch (IOException ex) {
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	100 ex.printStackTrace(); // log error. FIXME better handling
295 981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	101 throw new HgBadStateException(ex);
22 603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	102 } finally {
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	103 daIndex.done();
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	104 }
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	105 }
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	106
295 981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	107 /**
981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	108 * @throws HgBadStateException if internal read operation failed
981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	109 */
80 4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	110 public byte[] nodeid(int revision) {
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	111 final int indexSize = revisionCount();
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	112 if (revision == TIP) {
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	113 revision = indexSize - 1;
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	114 }
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	115 if (revision < 0 \|\| revision >= indexSize) {
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	116 throw new IllegalArgumentException(Integer.toString(revision));
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	117 }
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	118 DataAccess daIndex = getIndexStream();
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	119 try {
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	120 int recordOffset = getIndexOffsetInt(revision);
80 4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	121 daIndex.seek(recordOffset + 32);
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	122 byte[] rv = new byte[20];
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	123 daIndex.readBytes(rv, 0, 20);
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	124 return rv;
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	125 } catch (IOException ex) {
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	126 ex.printStackTrace();
295 981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	127 throw new HgBadStateException();
80 4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	128 } finally {
88 61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	129 daIndex.done();
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	130 }
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	131 }
295 981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	132
981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	133 /**
981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	134 * Get link field from the index record.
981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	135 * @throws HgBadStateException if internal read operation failed
981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	136 */
88 61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	137 public int linkRevision(int revision) {
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	138 final int last = revisionCount() - 1;
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	139 if (revision == TIP) {
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	140 revision = last;
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	141 }
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	142 if (revision < 0 \|\| revision > last) {
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	143 throw new IllegalArgumentException(Integer.toString(revision));
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	144 }
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	145 DataAccess daIndex = getIndexStream();
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	146 try {
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	147 int recordOffset = getIndexOffsetInt(revision);
88 61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	148 daIndex.seek(recordOffset + 20);
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	149 int linkRev = daIndex.readInt();
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	150 return linkRev;
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	151 } catch (IOException ex) {
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	152 ex.printStackTrace();
295 981f9f50bb6c Issue 11: Error log facility. SessionContext to share common facilities Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 288 diff changeset	153 throw new HgBadStateException();
88 61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	154 } finally {
61eedab3eb3e Status between two revisions to recognize copy/rename Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 80 diff changeset	155 daIndex.done();
80 4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	156 }
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	157 }
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	158
49 26e3eeaa3962 branch and user filtering for log operation Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 44 diff changeset	159 // 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	160 // 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	161 // 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	162 // 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	163 /**
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	164 * @return integer in [0..revisionCount()) or {@link HgRepository#BAD_REVISION} if not found
4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	165 */
77 c677e1593919 Moved RevlogStream implementation into .internal Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 74 diff changeset	166 public int findLocalRevisionNumber(Nodeid nodeid) {
22 603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	167 // 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	168 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	169 DataAccess daIndex = getIndexStream();
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	170 try {
24 d4fdd1845b3f Nodeid with array of exactly 20 bytes Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 22 diff changeset	171 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	172 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	173 daIndex.skip(8);
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	174 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	175 daIndex.skip(20);
24 d4fdd1845b3f Nodeid with array of exactly 20 bytes Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 22 diff changeset	176 daIndex.readBytes(nodeidBuf, 0, 20);
d4fdd1845b3f Nodeid with array of exactly 20 bytes Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 22 diff changeset	177 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	178 return i;
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	179 }
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	180 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	181 }
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	182 } catch (IOException ex) {
243 0e01f9182e16 External cache Nodeid<->int added, Revlog.RevisionMap Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 242 diff changeset	183 ex.printStackTrace(); // log error. FIXME better handling. Perhaps, shall return BAD_REVISION here as well?
22 603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	184 throw new IllegalStateException(ex);
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	185 } finally {
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	186 daIndex.done();
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	187 }
80 4222b04f34ee Follow history of a file Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 77 diff changeset	188 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	189 }
603806cd2dc6 Status of local working dir against non-tip base revision Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 10 diff changeset	190
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	191
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	192 private final int REVLOGV1_RECORD_SIZE = 64;
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	193
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	194 // 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	195 // ? boolean needsNodeid
77 c677e1593919 Moved RevlogStream implementation into .internal Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 74 diff changeset	196 public void iterate(int start, int end, boolean needData, Inspector inspector) {
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	197 initOutline();
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	198 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	199 if (indexSize == 0) {
24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	200 return;
24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	201 }
5 fc265ddeab26 File content and non-effective, although working, patch application Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 4 diff changeset	202 if (end == TIP) {
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	203 end = indexSize - 1;
24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	204 }
5 fc265ddeab26 File content and non-effective, although working, patch application Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 4 diff changeset	205 if (start == TIP) {
fc265ddeab26 File content and non-effective, although working, patch application Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 4 diff changeset	206 start = indexSize - 1;
fc265ddeab26 File content and non-effective, although working, patch application Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 4 diff changeset	207 }
300 650b45d290b1 Share range check code Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 297 diff changeset	208 HgInternals.checkRevlogRange(start, end, indexSize-1);
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	209 // 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	210
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	211 ReaderN1 r = new ReaderN1(needData, inspector);
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	212 try {
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	213 r.start(end - start + 1);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	214 r.range(start, end);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	215 } catch (IOException ex) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	216 throw new HgBadStateException(ex); // FIXME need better handling
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	217 } finally {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	218 r.finish();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	219 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	220 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	221
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	222 /**
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	223 * 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	224 * revisions are of interest.
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	225 * @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	226 * @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	227 * @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	228 */
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	229 public void iterate(int[] sortedRevisions, boolean needData, Inspector inspector) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	230 final int indexSize = revisionCount();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	231 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	232 return;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	233 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	234 if (sortedRevisions[0] > indexSize \|\| sortedRevisions[sortedRevisions.length - 1] > indexSize) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	235 throw new IllegalArgumentException(String.format("Can't iterate [%d, %d] in range [0..%d]", sortedRevisions[0], sortedRevisions[sortedRevisions.length - 1], indexSize));
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	236 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	237
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	238 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	239 try {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	240 r.start(sortedRevisions.length);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	241 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	242 int x = i;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	243 i++;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	244 while (i < sortedRevisions.length) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	245 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	246 i++;
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	247 } 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	248 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	249 }
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	250 }
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	251 // 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	252 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	253 return;
51 9429c7bd1920 Try DataAccess to reach revision data instead of plain byte arrays Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 49 diff changeset	254 }
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	255 }
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	256 } catch (IOException ex) {
158 b413b16d10a5 Integer offsets and file length explictly, rather than casts throughout code. Inflater may benefit from total length hint, but shall calculate it by its own if needed Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 157 diff changeset	257 throw new HgBadStateException(ex); // FIXME need better handling
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	258 } finally {
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	259 r.finish();
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	260 }
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	261 }
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	262
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	263 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	264 return baseRevisions[revision];
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	265 }
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	266
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	267 /**
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	268 * @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	269 */
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	270 private int getIndexOffsetInt(int revision) {
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	271 return inline ? indexRecordOffset[revision] : revision * REVLOGV1_RECORD_SIZE;
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	272 }
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	273
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	274 private void initOutline() {
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	275 if (baseRevisions != null && baseRevisions.length > 0) {
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	276 return;
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	277 }
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	278 DataAccess da = getIndexStream();
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	279 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	280 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	281 // 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	282 baseRevisions = new int[0];
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	283 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	284 }
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	285 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	286 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	287 final int INLINEDATA = 1 << 16;
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	288 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	289 IntVector resBases, resOffsets = null;
b11f6a08f748 Avoid boxing int values and list resizes on revlog read Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 280 diff changeset	290 int entryCountGuess = da.length() / REVLOGV1_RECORD_SIZE;
b11f6a08f748 Avoid boxing int values and list resizes on revlog read Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 280 diff changeset	291 if (inline) {
b11f6a08f748 Avoid boxing int values and list resizes on revlog read Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 280 diff changeset	292 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	293 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	294 }
b11f6a08f748 Avoid boxing int values and list resizes on revlog read Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 280 diff changeset	295 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	296
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	297 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	298 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	299 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	300 // 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	301 @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	302 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	303 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	304 // 12 + 8 = 20 bytes read here
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	305 // int linkRevision = di.readInt();
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	306 // int parent1Revision = di.readInt();
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	307 // int parent2Revision = di.readInt();
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	308 // 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	309 resBases.add(baseRevision);
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	310 if (inline) {
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	311 int o = (int) offset;
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	312 if (o != offset) {
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	313 // just in case, can't happen, ever, unless HG (or some other bad tool) produces index file
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	314 // with inlined data of size greater than 2 Gb.
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	315 throw new HgBadStateException("Data too big, offset didn't fit to sizeof(int)");
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	316 }
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	317 resOffsets.add(o + REVLOGV1_RECORD_SIZE * resOffsets.size());
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	318 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	319 } 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	320 da.skip(3*4 + 32);
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	321 }
10 382cfe9463db Dirstate parsing. DataAccess refactored to allow reuse and control over constants Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 9 diff changeset	322 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	323 // 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	324 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	325 if (inline) {
288 b11f6a08f748 Avoid boxing int values and list resizes on revlog read Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 280 diff changeset	326 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	327 }
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	328 break;
10 382cfe9463db Dirstate parsing. DataAccess refactored to allow reuse and control over constants Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 9 diff changeset	329 } else {
382cfe9463db Dirstate parsing. DataAccess refactored to allow reuse and control over constants Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 9 diff changeset	330 // 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	331 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	332 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	333 }
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	334 }
08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	335 } catch (IOException ex) {
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	336 ex.printStackTrace(); // log error
198 33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	337 // too bad, no outline then, but don't fail with NPE
33a7d76f067b Performance optimization: reduce memory to keep revlog cached info Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 170 diff changeset	338 baseRevisions = new int[0];
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	339 } 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	340 da.done();
2 08db726a0fb7 Shaping out low-level Hg structures Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 0 diff changeset	341 }
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	342 }
24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	343
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	344 /**
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	345 * operation with single file open/close and multiple diverse reads.
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	346 * XXX initOutline might need similar extraction to keen N1 format knowledge
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	347 */
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	348 class ReaderN1 {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	349 private final Inspector inspector;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	350 private final boolean needData;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	351 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	352 private Lifecycle.BasicCallback cb = null;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	353 private int lastRevisionRead = BAD_REVISION;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	354 private DataAccess lastUserData;
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	355 // 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	356 // 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	357
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	358
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	359 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	360 assert insp != null;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	361 this.needData = needData;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	362 inspector = insp;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	363 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	364
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	365 public void start(int totalWork) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	366 daIndex = getIndexStream();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	367 if (needData && !inline) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	368 daData = getDataStream();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	369 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	370 if (inspector instanceof Lifecycle) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	371 cb = new Lifecycle.BasicCallback();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	372 ((Lifecycle) inspector).start(totalWork, cb, cb);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	373 }
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	374 // applyTime = inspectorTime = 0; // TIMING
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	375 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	376
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	377 public void finish() {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	378 if (lastUserData != null) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	379 lastUserData.done();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	380 lastUserData = null;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	381 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	382 if (inspector instanceof Lifecycle) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	383 ((Lifecycle) inspector).finish(cb);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	384 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	385 daIndex.done();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	386 if (daData != null) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	387 daData.done();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	388 }
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	389 // 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	390 }
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	391
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	392 public boolean range(int start, int end) throws IOException {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	393 byte[] nodeidBuf = new byte[20];
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	394 int i;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	395 boolean extraReadsToBaseRev = false; // to indicate we read revision prior to start. XXX not sure can't do without
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	396 // 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	397 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	398 // 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	399 // 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	400 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	401 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	402 extraReadsToBaseRev = i < start;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	403 } else {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	404 if (lastUserData != null) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	405 lastUserData.done();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	406 lastUserData = null;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	407 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	408 extraReadsToBaseRev = true;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	409 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	410 } else {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	411 // 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	412 i = start;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	413 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	414
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	415 daIndex.seek(getIndexOffsetInt(i));
258 e5776067b3b8 Reduce number of objects instantiated on revlog read Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 243 diff changeset	416 //
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	417 // reuse some instances
258 e5776067b3b8 Reduce number of objects instantiated on revlog read Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 243 diff changeset	418 final ArrayList<PatchRecord> patches = new ArrayList<PatchRecord>();
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	419 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	420 // 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	421 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	422 //
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	423
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	424 for (; i <= end; i++ ) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	425 if (inline && needData) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	426 // 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	427 daIndex.seek(getIndexOffsetInt(i));
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	428 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	429 long l = daIndex.readLong(); // 0
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	430 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	431 @SuppressWarnings("unused")
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	432 int flags = (int) (l & 0X0FFFF);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	433 int compressedLen = daIndex.readInt(); // +8
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	434 int actualLen = daIndex.readInt(); // +12
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	435 int baseRevision = daIndex.readInt(); // +16
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	436 int linkRevision = daIndex.readInt(); // +20
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	437 int parent1Revision = daIndex.readInt();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	438 int parent2Revision = daIndex.readInt();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	439 // 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	440 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	441 daIndex.skip(12);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	442 DataAccess userDataAccess = null;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	443 if (needData) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	444 int streamOffset;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	445 DataAccess streamDataAccess;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	446 if (inline) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	447 streamDataAccess = daIndex;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	448 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	449 } else {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	450 streamOffset = (int) offset;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	451 streamDataAccess = daData;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	452 daData.seek(streamOffset);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	453 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	454 final boolean patchToPrevious = baseRevision != i; // the only way I found to tell if it's a patch
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	455 if (streamDataAccess.isEmpty()) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	456 userDataAccess = new DataAccess(); // empty
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	457 } else {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	458 final byte firstByte = streamDataAccess.readByte();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	459 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	460 inflater.reset();
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	461 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	462 } else if (firstByte == 0x75 /* 'u' */) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	463 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	464 } else {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	465 // XXX Python impl in fact throws exception when there's not 'x', 'u' or '0'
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	466 // but I don't see reason not to return data as is
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	467 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	468 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	469 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	470 // XXX
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	471 if (patchToPrevious) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	472 // this is a patch
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	473 patches.clear(); // won't hurt to ensure there are no leftovers, even if we already cleaned
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	474 while (!userDataAccess.isEmpty()) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	475 PatchRecord pr = PatchRecord.read(userDataAccess);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	476 // System.out.printf("PatchRecord:%d %d %d\n", pr.start, pr.end, pr.len);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	477 patches.add(pr);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	478 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	479 userDataAccess.done();
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	480 //
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	481 // it shall be reset at the end of prev iteration, when it got assigned from userDataAccess
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	482 // however, actual userDataAccess and lastUserData may share Inflater object, which needs to be reset
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	483 // Alternatively, userDataAccess.done() above may be responsible to reset Inflater (if it's InflaterDataAccess)
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	484 lastUserData.reset();
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	485 // 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	486 byte[] userData = apply(lastUserData, actualLen, patches);
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	487 // applyTime += (System.currentTimeMillis() - startMeasuring); // TIMING
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	488 patches.clear(); // do not keep any reference, allow PatchRecord to be gc'd
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	489 userDataAccess = new ByteArrayDataAccess(userData);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	490 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	491 } else {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	492 if (inline) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	493 daIndex.skip(compressedLen);
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	494 }
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 if (!extraReadsToBaseRev \|\| 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	497 // 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	498 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	499 // 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	500 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	501 if (cb != null) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	502 if (cb.isStopped()) {
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	503 return false;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	504 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	505 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	506 if (userDataAccess != null) {
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	507 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	508 }
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	509 if (lastUserData != null) {
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	510 lastUserData.done();
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	511 }
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	512 lastUserData = userDataAccess;
242 ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	513 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	514 lastRevisionRead = end;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	515 return true;
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	516 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	517 }
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	518
ad6a046943be Improved reading of sparse revisions from a revlog Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 223 diff changeset	519
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	520 // mpatch.c : apply()
24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	521 // FIXME need to implement patch merge (fold, combine, gather and discard from aforementioned mpatch.[c\|py]), also see Revlog and Mercurial PDF
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	522 public/for HgBundle; until moved to better place/static byte[] apply(DataAccess baseRevisionContent, int outcomeLen, List<PatchRecord> patch) throws IOException {
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	523 int last = 0, destIndex = 0;
43 1b26247d7367 Calculate result length of the patch operarion, when unknown Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 37 diff changeset	524 if (outcomeLen == -1) {
158 b413b16d10a5 Integer offsets and file length explictly, rather than casts throughout code. Inflater may benefit from total length hint, but shall calculate it by its own if needed Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 157 diff changeset	525 outcomeLen = baseRevisionContent.length();
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	526 for (int i = 0, x = patch.size(); i < x; i++) {
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	527 PatchRecord pr = patch.get(i);
43 1b26247d7367 Calculate result length of the patch operarion, when unknown Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 37 diff changeset	528 outcomeLen += pr.start - last + pr.len;
1b26247d7367 Calculate result length of the patch operarion, when unknown Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 37 diff changeset	529 last = pr.end;
1b26247d7367 Calculate result length of the patch operarion, when unknown Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 37 diff changeset	530 }
1b26247d7367 Calculate result length of the patch operarion, when unknown Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 37 diff changeset	531 outcomeLen -= last;
1b26247d7367 Calculate result length of the patch operarion, when unknown Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 37 diff changeset	532 last = 0;
1b26247d7367 Calculate result length of the patch operarion, when unknown Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 37 diff changeset	533 }
1b26247d7367 Calculate result length of the patch operarion, when unknown Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 37 diff changeset	534 byte[] rv = new byte[outcomeLen];
263 31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	535 for (int i = 0, x = patch.size(); i < x; i++) {
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 258 diff changeset	536 PatchRecord pr = patch.get(i);
51 9429c7bd1920 Try DataAccess to reach revision data instead of plain byte arrays Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 49 diff changeset	537 baseRevisionContent.seek(last);
9429c7bd1920 Try DataAccess to reach revision data instead of plain byte arrays Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 49 diff changeset	538 baseRevisionContent.readBytes(rv, destIndex, pr.start-last);
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	539 destIndex += pr.start - last;
43 1b26247d7367 Calculate result length of the patch operarion, when unknown Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 37 diff changeset	540 System.arraycopy(pr.data, 0, rv, destIndex, pr.data.length);
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	541 destIndex += pr.data.length;
24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	542 last = pr.end;
24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	543 }
51 9429c7bd1920 Try DataAccess to reach revision data instead of plain byte arrays Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 49 diff changeset	544 baseRevisionContent.seek(last);
9429c7bd1920 Try DataAccess to reach revision data instead of plain byte arrays Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 49 diff changeset	545 baseRevisionContent.readBytes(rv, destIndex, (int) (baseRevisionContent.length() - last));
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	546 return rv;
24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	547 }
24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	548
35 6061aa826a9e Complete parsing of the bundle format Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 33 diff changeset	549 // @see http://mercurial.selenic.com/wiki/BundleFormat, in Changelog group description
77 c677e1593919 Moved RevlogStream implementation into .internal Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 74 diff changeset	550 public static class PatchRecord {
52 30bd38978846 brief explanation of patch record Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 49 diff changeset	551 /*
30bd38978846 brief explanation of patch record Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 49 diff changeset	552 Given there are pr1 and pr2:
30bd38978846 brief explanation of patch record Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 49 diff changeset	553 pr1.start to pr1.end will be replaced with pr's data (of pr1.len)
30bd38978846 brief explanation of patch record Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 49 diff changeset	554 pr1.end to pr2.start gets copied from base
30bd38978846 brief explanation of patch record Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 49 diff changeset	555 */
77 c677e1593919 Moved RevlogStream implementation into .internal Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 74 diff changeset	556 public int start, end, len;
c677e1593919 Moved RevlogStream implementation into .internal Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 74 diff changeset	557 public byte[] data;
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	558
36 205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	559 // TODO consider PatchRecord that only records data position (absolute in data source), and acquires data as needed
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	560 private PatchRecord(int p1, int p2, int length, byte[] src) {
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	561 start = p1;
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	562 end = p2;
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	563 len = length;
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	564 data = src;
3 24bb4f365164 Rudimentary log functionality with basic infrastructure is in place Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 2 diff changeset	565 }
36 205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	566
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	567 /package-local/ static PatchRecord read(byte[] data, int offset) {
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	568 final int x = offset; // shorthand
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	569 int p1 = ((data[x] & 0xFF)<< 24) \| ((data[x+1] & 0xFF) << 16) \| ((data[x+2] & 0xFF) << 8) \| (data[x+3] & 0xFF);
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	570 int p2 = ((data[x+4] & 0xFF) << 24) \| ((data[x+5] & 0xFF) << 16) \| ((data[x+6] & 0xFF) << 8) \| (data[x+7] & 0xFF);
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	571 int len = ((data[x+8] & 0xFF) << 24) \| ((data[x+9] & 0xFF) << 16) \| ((data[x+10] & 0xFF) << 8) \| (data[x+11] & 0xFF);
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	572 byte[] dataCopy = new byte[len];
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	573 System.arraycopy(data, x+12, dataCopy, 0, len);
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	574 return new PatchRecord(p1, p2, len, dataCopy);
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	575 }
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	576
77 c677e1593919 Moved RevlogStream implementation into .internal Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 74 diff changeset	577 public /for HgBundle/ static PatchRecord read(DataAccess da) throws IOException {
36 205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	578 int p1 = da.readInt();
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	579 int p2 = da.readInt();
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	580 int len = da.readInt();
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	581 byte[] src = new byte[len];
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	582 da.readBytes(src, 0, len);
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	583 return new PatchRecord(p1, p2, len, src);
205f9b59b400 Strip parsing logic out from console frontend Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 35 diff changeset	584 }
77 c677e1593919 Moved RevlogStream implementation into .internal Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 74 diff changeset	585 }
c677e1593919 Moved RevlogStream implementation into .internal Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 74 diff changeset	586
c677e1593919 Moved RevlogStream implementation into .internal Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 74 diff changeset	587 // FIXME byte[] data might be too expensive, for few usecases it may be better to have intermediate Access object (when we don't need full data
c677e1593919 Moved RevlogStream implementation into .internal Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 74 diff changeset	588 // instantly - e.g. calculate hash, or comparing two revisions
c677e1593919 Moved RevlogStream implementation into .internal Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 74 diff changeset	589 public interface Inspector {
c677e1593919 Moved RevlogStream implementation into .internal Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: 74 diff changeset	590 // 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	591 // 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	592 // implementers shall not invoke DataAccess.done(), it's accomplished by #iterate at appropraite moment
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	593 void next(int revisionNumber, 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	594 }
0 dbd663faec1f Basic changelog parsing Artem Tikhomirov <tikhomirov.artem@gmail.com> parents: diff changeset	595 }

Mercurial > jhg

annotate src/org/tmatesoft/hg/internal/RevlogStream.java @ 303:2ffcbf360fd5