Java tutorial
/* * Copyright (C) 2008-2009, Google Inc. * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org> * and other copyright owners as documented in the project's IP log. * * This program and the accompanying materials are made available * under the terms of the Eclipse Distribution License v1.0 which * accompanies this distribution, is reproduced below, and is * available at http://www.eclipse.org/org/documents/edl-v10.php * * All rights reserved. * * Redistribution and use in source and binary forms, with or * without modification, are permitted provided that the following * conditions are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * - Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials provided * with the distribution. * * - Neither the name of the Eclipse Foundation, Inc. nor the * names of its contributors may be used to endorse or promote * products derived from this software without specific prior * written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ package org.eclipse.jgit.dircache; import static org.eclipse.jgit.lib.FileMode.TYPE_MASK; import static org.eclipse.jgit.lib.FileMode.TYPE_TREE; import java.io.IOException; import java.text.MessageFormat; import java.util.Arrays; import org.eclipse.jgit.internal.JGitText; import org.eclipse.jgit.lib.AnyObjectId; import org.eclipse.jgit.lib.ObjectReader; import org.eclipse.jgit.treewalk.CanonicalTreeParser; /** * Updates a {@link org.eclipse.jgit.dircache.DirCache} by adding individual * {@link org.eclipse.jgit.dircache.DirCacheEntry}s. * <p> * A builder always starts from a clean slate and appends in every single * <code>DirCacheEntry</code> which the final updated index must have to reflect * its new content. * <p> * For maximum performance applications should add entries in path name order. * Adding entries out of order is permitted, however a final sorting pass will * be implicitly performed during {@link #finish()} to correct any out-of-order * entries. Duplicate detection is also delayed until the sorting is complete. * * @see DirCacheEditor */ public class DirCacheBuilder extends BaseDirCacheEditor { private boolean sorted; /** * Construct a new builder. * * @param dc * the cache this builder will eventually update. * @param ecnt * estimated number of entries the builder will have upon * completion. This sizes the initial entry table. */ protected DirCacheBuilder(DirCache dc, int ecnt) { super(dc, ecnt); } /** * Append one entry into the resulting entry list. * <p> * The entry is placed at the end of the entry list. If the entry causes the * list to now be incorrectly sorted a final sorting phase will be * automatically enabled within {@link #finish()}. * <p> * The internal entry table is automatically expanded if there is * insufficient space for the new addition. * * @param newEntry * the new entry to add. * @throws java.lang.IllegalArgumentException * If the FileMode of the entry was not set by the caller. */ public void add(DirCacheEntry newEntry) { if (newEntry.getRawMode() == 0) throw new IllegalArgumentException( MessageFormat.format(JGitText.get().fileModeNotSetForPath, newEntry.getPathString())); beforeAdd(newEntry); fastAdd(newEntry); } /** * Add a range of existing entries from the destination cache. * <p> * The entries are placed at the end of the entry list. If any of the * entries causes the list to now be incorrectly sorted a final sorting * phase will be automatically enabled within {@link #finish()}. * <p> * This method copies from the destination cache, which has not yet been * updated with this editor's new table. So all offsets into the destination * cache are not affected by any updates that may be currently taking place * in this editor. * <p> * The internal entry table is automatically expanded if there is * insufficient space for the new additions. * * @param pos * first entry to copy from the destination cache. * @param cnt * number of entries to copy. */ public void keep(int pos, int cnt) { beforeAdd(cache.getEntry(pos)); fastKeep(pos, cnt); } /** * Recursively add an entire tree into this builder. * <p> * If pathPrefix is "a/b" and the tree contains file "c" then the resulting * DirCacheEntry will have the path "a/b/c". * <p> * All entries are inserted at stage 0, therefore assuming that the * application will not insert any other paths with the same pathPrefix. * * @param pathPrefix * UTF-8 encoded prefix to mount the tree's entries at. If the * path does not end with '/' one will be automatically inserted * as necessary. * @param stage * stage of the entries when adding them. * @param reader * reader the tree(s) will be read from during recursive * traversal. This must be the same repository that the resulting * DirCache would be written out to (or used in) otherwise the * caller is simply asking for deferred MissingObjectExceptions. * Caller is responsible for releasing this reader when done. * @param tree * the tree to recursively add. This tree's contents will appear * under <code>pathPrefix</code>. The ObjectId must be that of a * tree; the caller is responsible for dereferencing a tag or * commit (if necessary). * @throws java.io.IOException * a tree cannot be read to iterate through its entries. */ public void addTree(byte[] pathPrefix, int stage, ObjectReader reader, AnyObjectId tree) throws IOException { CanonicalTreeParser p = createTreeParser(pathPrefix, reader, tree); while (!p.eof()) { if (isTree(p)) { p = enterTree(p, reader); continue; } DirCacheEntry first = toEntry(stage, p); beforeAdd(first); fastAdd(first); p = p.next(); break; } // Rest of tree entries are correctly sorted; use fastAdd(). while (!p.eof()) { if (isTree(p)) { p = enterTree(p, reader); } else { fastAdd(toEntry(stage, p)); p = p.next(); } } } private static CanonicalTreeParser createTreeParser(byte[] pathPrefix, ObjectReader reader, AnyObjectId tree) throws IOException { return new CanonicalTreeParser(pathPrefix, reader, tree); } private static boolean isTree(CanonicalTreeParser p) { return (p.getEntryRawMode() & TYPE_MASK) == TYPE_TREE; } private static CanonicalTreeParser enterTree(CanonicalTreeParser p, ObjectReader reader) throws IOException { p = p.createSubtreeIterator(reader); return p.eof() ? p.next() : p; } private static DirCacheEntry toEntry(int stage, CanonicalTreeParser i) { byte[] buf = i.getEntryPathBuffer(); int len = i.getEntryPathLength(); byte[] path = new byte[len]; System.arraycopy(buf, 0, path, 0, len); DirCacheEntry e = new DirCacheEntry(path, stage); e.setFileMode(i.getEntryRawMode()); e.setObjectIdFromRaw(i.idBuffer(), i.idOffset()); return e; } /** {@inheritDoc} */ @Override public void finish() { if (!sorted) resort(); replace(); } private void beforeAdd(DirCacheEntry newEntry) { if (sorted && entryCnt > 0) { final DirCacheEntry lastEntry = entries[entryCnt - 1]; final int cr = DirCache.cmp(lastEntry, newEntry); if (cr > 0) { // The new entry sorts before the old entry; we are // no longer sorted correctly. We'll need to redo // the sorting before we can close out the build. // sorted = false; } else if (cr == 0) { // Same file path; we can only insert this if the // stages won't be violated. // final int peStage = lastEntry.getStage(); final int dceStage = newEntry.getStage(); if (peStage == dceStage) throw bad(newEntry, JGitText.get().duplicateStagesNotAllowed); if (peStage == 0 || dceStage == 0) throw bad(newEntry, JGitText.get().mixedStagesNotAllowed); if (peStage > dceStage) sorted = false; } } } private void resort() { Arrays.sort(entries, 0, entryCnt, DirCache.ENT_CMP); for (int entryIdx = 1; entryIdx < entryCnt; entryIdx++) { final DirCacheEntry pe = entries[entryIdx - 1]; final DirCacheEntry ce = entries[entryIdx]; final int cr = DirCache.cmp(pe, ce); if (cr == 0) { // Same file path; we can only allow this if the stages // are 1-3 and no 0 exists. // final int peStage = pe.getStage(); final int ceStage = ce.getStage(); if (peStage == ceStage) throw bad(ce, JGitText.get().duplicateStagesNotAllowed); if (peStage == 0 || ceStage == 0) throw bad(ce, JGitText.get().mixedStagesNotAllowed); } } sorted = true; } private static IllegalStateException bad(DirCacheEntry a, String msg) { return new IllegalStateException(String.format("%s: %d %s", //$NON-NLS-1$ msg, Integer.valueOf(a.getStage()), a.getPathString())); } }