Java tutorial
/* * ==================================================================== * * The Apache Software License, Version 1.1 * * Copyright (c) 1999-2003 The Apache Software Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. 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. * * 3. The end-user documentation included with the redistribution, if * any, must include the following acknowledgement: * "This product includes software developed by the * Apache Software Foundation (http://www.apache.org/)." * Alternately, this acknowledgement may appear in the software itself, * if and wherever such third-party acknowledgements normally appear. * * 4. The names "The Jakarta Project", "Commons", and "Apache Software * Foundation" must not be used to endorse or promote products derived * from this software without prior written permission. For written * permission, please contact apache@apache.org. * * 5. Products derived from this software may not be called "Apache" * nor may "Apache" appear in their names without prior written * permission of the Apache Software Foundation. * * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 APACHE SOFTWARE FOUNDATION OR * ITS 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. * ==================================================================== * * This software consists of voluntary contributions made by many * individuals on behalf of the Apache Software Foundation. For more * information on the Apache Software Foundation, please see * <http://www.apache.org/>. * */ package org.apache.commons.jrcs.rcs; import java.text.DateFormat; import java.text.Format; import java.text.MessageFormat; import java.text.SimpleDateFormat; import java.util.Arrays; import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.StringTokenizer; import java.util.TreeMap; import org.apache.commons.jrcs.diff.AddDelta; import org.apache.commons.jrcs.diff.Chunk; import org.apache.commons.jrcs.diff.DeleteDelta; import org.apache.commons.jrcs.diff.Diff; import org.apache.commons.jrcs.diff.Revision; import org.apache.commons.jrcs.util.ToString; import org.apache.commons.jrcs.diff.PatchFailedException; /** * Ancestor to all nodes in a version control Archive. * <p>Nodes store the deltas between two revisions of the text.</p> * * This class is NOT thread safe. * * @see TrunkNode * @see BranchNode * @see Archive * * @author <a href="mailto:juanco@suigeneris.org">Juanco Anez</a> * @version $Id$ */ public abstract class Node extends ToString implements Comparable { /** * The version number for this node. */ protected final Version version; protected Date date = new Date(); protected String author = System.getProperty("user.name"); protected String state = "Exp"; protected String log = ""; protected String locker = ""; protected Object[] text; protected Node rcsnext; protected Node parent; protected Node child; protected TreeMap branches = null; protected Phrases phrases = null; protected static final Format dateFormatter = new MessageFormat("\t{0,number,##00}." + "{1,number,00}." + "{2,number,00}." + "{3,number,00}." + "{4,number,00}." + "{5,number,00}"); protected static final DateFormat dateFormat = new SimpleDateFormat("yy.MM.dd.HH.mm.ss"); protected static final DateFormat dateFormat2K = new SimpleDateFormat("yyyy.MM.dd.HH.mm.ss"); /** * Creates a copy of a node. Only used internally. * @param other The node to copy. */ protected Node(Node other) { this(other.version, null); this.date = other.date; this.author = other.author; this.state = other.state; this.log = other.log; this.locker = other.locker; } /** * Creates a node with the given version number. * @param vernum The version number for the node. * @param rcsnext The next node in the RCS logical hierarchy. */ protected Node(Version vernum, Node rcsnext) { if (vernum == null) { throw new IllegalArgumentException(vernum.toString()); } this.version = (Version) vernum.clone(); this.setRCSNext(rcsnext); } /** * Creates a new node of the adequate type for the given version number. * @param vernum The version number for the node. * @param rcsnext The next node in the RCS logical hierarchy. * @return The newly created node. */ static Node newNode(Version vernum, Node rcsnext) throws InvalidVersionNumberException { if (vernum.isTrunk()) { return new TrunkNode(vernum, (TrunkNode) rcsnext); } else { return new BranchNode(vernum, (BranchNode) rcsnext); } } /** * Creates a new node of the adequate type for the given version number. * @param vernum The version number for the node. * @return The newly created node. */ static Node newNode(Version vernum) throws InvalidVersionNumberException { return newNode(vernum, null); } /** * Compares the version number of this node to that of another node. * @param other The node to compare two. * @return 0 if versions are equal, 1 if this version greather than the other, * and -1 otherwise. */ public int compareTo(Object other) { if (other == this) { return 0; } else if (!(other instanceof Node)) { return -1; } else { return version.compareTo(((Node) other).version); } } /** * Returns true if the node is a "ghost" node. * Ghost nodes have no associated text ot deltas. CVS uses * them to mark certain points in the node hierarchy. */ public boolean isGhost() { return version.isGhost() || text == null; } /** * Retrieve the branch node identified with * the given numer. * @param no The branch number. * @return The branch node. * @see BranchNode */ public BranchNode getBranch(int no) { if (branches == null) { return null; } else if (no == 0) { Integer branchNo = (Integer) branches.lastKey(); return (BranchNode) (branchNo == null ? null : branches.get(branchNo)); } else { return (BranchNode) branches.get(Integer.valueOf(no)); } } /** * Return the root node of the node hierarchy. * @return The root node. */ public Node root() { Node result = this; while (result.parent != null) { result = result.parent; } return result; } /** * Set the locker. * @param user A symbol that identifies the locker. */ public void setLocker(String user) { locker = user.intern(); } /** * Set the author of the node's revision. * @param user A symbol that identifies the author. */ public void setAuthor(String user) { author = user.intern(); } /** * Set the date of the node's revision. * @param value an array of 6 integers, corresponding to the * year, month, day, hour, minute, and second of this revision.<br> * If the year has two digits, it is interpreted as belonging to the 20th * century.<br> * The month is a number from 1 to 12. */ public void setDate(int[] value) { this.date = new GregorianCalendar(value[0] + (value[0] <= 99 ? 1900 : 0), value[1] - 1, value[2], value[3], value[4], value[5]).getTime(); } /** * Sets the state of the node's revision. * @param value A symbol that identifies the state. The most commonly * used value is Exp. */ public void setState(String value) { state = value; } /** * Sets the next node in the RCS logical hierarchy. * In the RCS hierarchy, a {@link TrunkNode TrunkNode} points * to the previous revision, while a {@link BranchNode BranchNode} * points to the next revision. * @param node The next node in the RCS logical hierarchy. */ public void setRCSNext(Node node) { rcsnext = node; } /** * Sets the log message for the node's revision. * The log message is usually used to explain why the revision took place. * @param value The message. */ public void setLog(String value) { // the last newline belongs to the file format if (value.endsWith(Archive.RCS_NEWLINE)) log = value.substring(0, value.length() - 1); else log = value; } /** * Sets the text for the node's revision. * <p>For archives containing binary information, the text is an image * of the revision contents.</p> * <p>For ASCII archives, the text contains the delta between the * current revision and the next revision in the RCS logical hierarchy. * The deltas are codified in a format similar to the one used by Unix diff.</p> * <p> The passed string is converted to an array of objects * befored being stored as the revision's text</p> * @param value The revision's text. * @see ArchiveParser */ public void setText(String value) { this.text = org.apache.commons.jrcs.diff.Diff.stringToArray(value); } /** * Sets the text for the node's revision. * <p>For archives containing binary information, the text is an image * of the revision contents.</p> * <p>For ASCII archives, the text contains the delta between the * current revision and the next revision in the RCS logical hierarchy. * The deltas are codified in a format similar to the one used by Unix diff. * @param value The revision's text. * @see ArchiveParser */ public void setText(Object[] value) { this.text = Arrays.asList(value).toArray(); } /** * Adds a branch node to the current node. * @param node The branch node. * @throws InvalidVersionNumberException if the version number * is not a valid branch version number for the current node */ public void addBranch(BranchNode node) throws InvalidVersionNumberException { if (node.version.isLessThan(this.version) || node.version.size() != (this.version.size() + 2)) { throw new InvalidVersionNumberException("version must be grater"); } int branchno = node.version.at(this.version.size()); if (branches == null) { branches = new TreeMap(); } branches.put(Integer.valueOf(branchno), node); node.parent = this; } /** * Returns the version number that should correspond to * the revision folowing this node. * @return The next version number. */ public Version nextVersion() { return this.version.next(); } /** * Returns the version number that should correspond to a newly * created branch of this node. * @return the new branch's version number. */ public Version newBranchVersion() { Version result = new Version(this.version); if (branches == null || branches.size() <= 0) { result.__addBranch(1); } else { result.__addBranch(((Integer) branches.lastKey()).intValue()); } result.__addBranch(1); return result; } /** * Return the next node in the RCS logical hierarchy. * @return the next node */ public Node getRCSNext() { return rcsnext; } /** * Returns the path from the current node to the node * identified by the given version. * @param vernum The version number of the last node in the path. * @return The path * @throws NodeNotFoundException if a node with the given version number * doesn't exist, or is not reachable following the RCS-next chain * from this node. * @see Path */ public Path pathTo(Version vernum) throws NodeNotFoundException { return pathTo(vernum, false); } /** * Returns the path from the current node to the node * identified by the given version. * @param vernum The version number of the last node in the path. * @param soft If true, no error is thrown if a node with the given * version doesn't exist. Use soft=true to find a apth to where a new * node should be added. * @return The path * @throws NodeNotFoundException if a node with the given version number * is not reachable following the RCS-next chain from this node. * If soft=false the exception is also thrown if a node with the given * version number doesn't exist. * @see Path */ public Path pathTo(Version vernum, boolean soft) throws NodeNotFoundException { Path path = new Path(); Node target = this; do { path.add(target); target = target.nextInPathTo(vernum, soft); } while (target != null); return path; } /** * Returns the next node in the path from the current node to the node * identified by the given version. * @param vernum The version number of the last node in the path. * @param soft If true, no error is thrown if a node with the given * version doesn't exist. Use soft=true to find a apth to where a new * node should be added. * @return The path * @throws NodeNotFoundException if a node with the given version number * is not reachable following the RCS-next chain from this node. * If soft=false the exception is also thrown if a node with the given * version number doesn't exist. * @see Path */ public abstract Node nextInPathTo(Version vernum, boolean soft) throws NodeNotFoundException; /** * Returns the Node with the version number that corresponds to * the revision to be obtained after the deltas in the current node * are applied. * <p>For a {@link BranchNode BranchNode} the deltaRevision is the * current revision; that is, after the deltas are applied, the text for * the current revision is obtained.</p> * <p>For a {@link TrunkNode TrunkNode} the deltaRevision is the * next revision; that is, after the deltas are applied, the text obtained * corresponds to the next revision in the chain.</p> * @return The node for the delta revision. */ public abstract Node deltaRevision(); /** * Apply the deltas in the current node to the given text. * @param original the text to be patched * @throws InvalidFileFormatException if the deltas cannot be parsed. * @throws PatchFailedException if the diff engine determines that * the deltas cannot apply to the given text. */ public void patch(List original) throws InvalidFileFormatException, PatchFailedException { patch(original, false); } /** * Apply the deltas in the current node to the given text. * @param original the text to be patched * @param annotate set to true to have each text line be a * {@link Line Line} object that identifies the revision in which * the line was changed or added. * @throws InvalidFileFormatException if the deltas cannot be parsed. * @throws PatchFailedException if the diff engine determines that * the deltas cannot apply to the given text. */ public void patch(List original, boolean annotate) throws InvalidFileFormatException, org.apache.commons.jrcs.diff.PatchFailedException { Revision revision = new Revision(); for (int it = 0; it < text.length; it++) { String cmd = text[it].toString(); java.util.StringTokenizer t = new StringTokenizer(cmd, "ad ", true); char action; int n; int count; try { action = t.nextToken().charAt(0); n = Integer.parseInt(t.nextToken()); t.nextToken(); // skip the space count = Integer.parseInt(t.nextToken()); } catch (Exception e) { throw new InvalidFileFormatException(version + ":line:" + ":" + e.getMessage()); } if (action == 'd') { revision.addDelta(new DeleteDelta(new Chunk(n - 1, count))); } else if (action == 'a') { revision.addDelta( new AddDelta(n, new Chunk(getTextLines(it + 1, it + 1 + count), 0, count, n - 1))); it += count; } else { throw new InvalidFileFormatException(version.toString()); } } revision.applyTo(original); } /** * Conver the current node and all of its branches * to their RCS string representation and * add it to the given StringBuffer. * @param s The string buffer to add the node's image to. */ public void toString(StringBuffer s) { toString(s, Archive.RCS_NEWLINE); } /** * Conver the current node and all of its branches * to their RCS string representation and * add it to the given StringBuffer using the given marker as * line separator. * @param s The string buffer to add the node's image to. * @param EOL The line separator to use. */ public void toString(StringBuffer s, String EOL) { String EOI = ";" + EOL; String NLT = EOL + "\t"; s.append(EOL); s.append(version.toString() + EOL); s.append("date"); if (date != null) { DateFormat formatter = dateFormat; Calendar cal = new GregorianCalendar(); cal.setTime(date); if (cal.get(Calendar.YEAR) > 1999) { formatter = dateFormat2K; } s.append("\t" + formatter.format(date)); } s.append(";\tauthor"); if (author != null) { s.append(" " + author); } s.append(";\tstate"); if (state != null) { s.append(" "); s.append(state); } s.append(EOI); s.append("branches"); if (branches != null) { for (Iterator i = branches.values().iterator(); i.hasNext();) { Node n = (Node) i.next(); if (n != null) { s.append(NLT + n.version); } } } s.append(EOI); s.append("next\t"); if (rcsnext != null) { s.append(rcsnext.version.toString()); } s.append(EOI); } /** * Conver the urrent node to its RCS string representation. * @return The string representation */ public String toText() { final StringBuffer s = new StringBuffer(); toText(s, Archive.RCS_NEWLINE); return s.toString(); } /** * Conver the urrent node to its RCS string representation and * add it to the given StringBuffer using the given marker as * line separator. * @param s The string buffer to add the node's image to. * @param EOL The line separator to use. */ public void toText(StringBuffer s, String EOL) { s.append(EOL + EOL); s.append(version.toString() + EOL); s.append("log" + EOL); if (log.length() == 0) s.append(Archive.quoteString("")); else // add a newline after the comment s.append(Archive.quoteString(log + EOL)); s.append(EOL); if (phrases != null) { s.append(phrases.toString()); } s.append("text" + EOL); s.append(Archive.quoteString(Diff.arrayToString(text, EOL) + EOL)); s.append(EOL); if (branches != null) { for (Iterator i = branches.values().iterator(); i.hasNext();) { Node n = (Node) i.next(); if (n != null) { n.toText(s, EOL); } } } } /** * Return a list with the lines of the node's text. * @return The list */ public List getTextLines() { return getTextLines(new LinkedList()); } /** * Return a list with a subset of the lines of the node's text. * @param from The offset of the first line to retrieve. * @param to The offset of the line after the last one to retrieve. * @return The list */ public List getTextLines(int from, int to) { return getTextLines(new LinkedList(), from, to); } /** * Add a subset of the lines of the node's text to the given list. * @return The given list after the additions have been made. */ public List getTextLines(List lines) { return getTextLines(lines, 0, text.length); } /** * Add a subset of the lines of the node's text to the given list. * @param from The offset of the first line to retrieve. * @param to The offset of the line after the last one to retrieve. * @return The given list after the additions have been made. */ public List getTextLines(List lines, int from, int to) { for (int i = from; i < to; i++) { lines.add(new Line(deltaRevision(), text[i])); } return lines; } public final Date getDate() { return date; } public final String getAuthor() { return author; } public final String getState() { return state; } public final String getLog() { return log; } public final String getLocker() { return locker; } public final Object[] getText() { return text; } public final Node getChild() { return child; } public final TreeMap getBranches() { return branches; } public final Node getParent() { return parent; } public final Version getVersion() { return version; } public Phrases getPhrases() { return phrases; } }