| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| package org.apache.tools.ant.taskdefs.optional.starteam; |
| |
| import com.starbase.starteam.Folder; |
| import com.starbase.starteam.Label; |
| import com.starbase.starteam.PropertyNames; |
| import com.starbase.starteam.StarTeamFinder; |
| import com.starbase.starteam.View; |
| import com.starbase.starteam.ViewConfiguration; |
| import com.starbase.util.OLEDate; |
| import java.text.ParseException; |
| import java.text.SimpleDateFormat; |
| import java.util.Date; |
| import java.util.Hashtable; |
| import java.util.StringTokenizer; |
| import org.apache.tools.ant.BuildException; |
| import org.apache.tools.ant.util.DateUtils; |
| import org.apache.tools.ant.DirectoryScanner; |
| import org.apache.tools.ant.Project; |
| |
| /** |
| * TreeBasedTask.java |
| * This abstract class is the base for any tasks that are tree-based, that |
| * is, for tasks which iterate over a tree of folders in StarTeam which |
| * is reflected in a tree of folder the local machine. |
| * |
| * This class provides the tree-iteration functionality. Derived classes |
| * will implement their specific task functionality by the visitor pattern, |
| * specifically by implementing the method |
| * <code>visit(Folder rootStarteamFolder, java.io.File rootLocalFolder)</code> |
| * |
| * Created: Sat Dec 15 16:55:19 2001 |
| * |
| * @see <a href="http://www.borland.com/us/products/starteam/index.html" |
| * >borland StarTeam Web Site</a> |
| */ |
| |
| public abstract class TreeBasedTask extends StarTeamTask { |
| |
| |
| /////////////////////////////////////////////////////////////// |
| // default values for attributes. |
| /////////////////////////////////////////////////////////////// |
| /** |
| * This constant sets the filter to include all files. This default has |
| * the same result as <code>setIncludes("*")</code>. |
| * |
| * @see #getIncludes() |
| * @see #setIncludes(String includes) |
| */ |
| public static final String DEFAULT_INCLUDESETTING = "*"; |
| |
| /** |
| * This disables the exclude filter by default. In other words, no files |
| * are excluded. This setting is equivalent to |
| * <code>setExcludes(null)</code>. |
| * |
| * @see #getExcludes() |
| * @see #setExcludes(String excludes) |
| */ |
| public static final String DEFAULT_EXCLUDESETTING = null; |
| |
| //ATTRIBUTES settable from ant. |
| |
| /** |
| * The root folder of the operation in StarTeam. |
| */ |
| private String rootStarteamFolder = "/"; |
| |
| /** |
| * The local folder corresponding to starteamFolder. If not specified |
| * the Star Team default folder will be used. |
| */ |
| private String rootLocalFolder = null; |
| |
| /** |
| * All files that fit this pattern are checked out. |
| */ |
| private String includes = DEFAULT_INCLUDESETTING; |
| |
| /** |
| * All files fitting this pattern are ignored. |
| */ |
| private String excludes = DEFAULT_EXCLUDESETTING; |
| |
| /** |
| * StarTeam label on which to perform task. |
| */ |
| private String label = null; |
| |
| /** |
| * Set recursion to false to check out files in only the given folder |
| * and not in its subfolders. |
| */ |
| private boolean recursive = true; |
| |
| /** |
| * Set preloadFileInformation to true to load all file information from the server |
| * at once. Increases performance significantly for projects with many files and/or folders. |
| */ |
| private boolean preloadFileInformation = true; |
| |
| /** |
| * If forced set to true, files in the target directory will |
| * be processed regardless of status in the repository. |
| * Usually this should be true if rootlocalfolder is set |
| * because status will be relative to the default folder, not |
| * to the one being processed. |
| */ |
| private boolean forced = false; |
| |
| private Label labelInUse = null; |
| |
| /** |
| * holder for the asofdate attribute |
| */ |
| private String asOfDate = null; |
| |
| /** |
| * holder for the asofdateformat attribute |
| */ |
| private String asOfDateFormat = null; |
| |
| |
| |
| /////////////////////////////////////////////////////////////// |
| // GET/SET methods. |
| // Setters, of course are where ant user passes in values. |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * Set the root of the subtree in the StarTeam repository from which to |
| * work; optional. Defaults to the root folder of the view ('/'). |
| * @param rootStarteamFolder the root folder |
| */ |
| public void setRootStarteamFolder(String rootStarteamFolder) { |
| this.rootStarteamFolder = rootStarteamFolder; |
| } |
| |
| /** |
| * returns the root folder in the Starteam repository |
| * used for this operation |
| * @return the root folder in use |
| */ |
| public String getRootStarteamFolder() { |
| return this.rootStarteamFolder; |
| } |
| |
| /** |
| * Set the local folder that will be the root of the tree |
| * to which files are checked out; optional. |
| * If this is not supplied, then the StarTeam "default folder" |
| * associated with <tt>rootstarteamfolder</tt> is used. |
| * |
| * @param rootLocalFolder |
| * the local folder that will mirror |
| * this.rootStarteamFolder |
| */ |
| public void setRootLocalFolder(String rootLocalFolder) { |
| this.rootLocalFolder = rootLocalFolder; |
| } |
| |
| |
| |
| /** |
| * Returns the local folder specified by the user, |
| * corresponding to the starteam folder for this operation |
| * or null if not specified. |
| * |
| * @return the local folder that mirrors this.rootStarteamFolder |
| */ |
| public String getRootLocalFolder() { |
| return this.rootLocalFolder; |
| } |
| |
| |
| /** |
| * Declare files to include using standard <tt>includes</tt> patterns; optional. |
| * @param includes A string of filter patterns to include. Separate the |
| * patterns by spaces. |
| * @see #getIncludes() |
| * @see #setExcludes(String excludes) |
| * @see #getExcludes() |
| */ |
| public void setIncludes(String includes) { |
| this.includes = includes; |
| } |
| |
| /** |
| * Gets the patterns from the include filter. Rather that duplicate the |
| * details of AntStarTeamCheckOut's filtering here, refer to these |
| * links: |
| * |
| * @return A string of filter patterns separated by spaces. |
| * @see #setIncludes(String includes) |
| * @see #setExcludes(String excludes) |
| * @see #getExcludes() |
| */ |
| public String getIncludes() { |
| return includes; |
| } |
| |
| /** |
| * if excludes have been specified, emit the list to the log |
| */ |
| protected void logIncludes() { |
| if (DEFAULT_INCLUDESETTING != this.includes) { |
| log(" Includes specified: " + this.includes); |
| } |
| } |
| |
| /** |
| * Declare files to exclude using standard <tt>excludes</tt> patterns; optional. |
| * When filtering files, AntStarTeamCheckOut |
| * uses an unmodified version of <code>DirectoryScanner</code>'s |
| * <code>match</code> method, so here are the patterns straight from the |
| * Ant source code: |
| * <br/> |
| * Matches a string against a pattern. The pattern contains two special |
| * characters: |
| * <br/>'*' which means zero or more characters, |
| * <br/>'?' which means one and only one character. |
| * <br/> |
| * For example, if you want to check out all files except .XML and |
| * .HTML files, you would put the following line in your program: |
| * <code>setExcludes("*.XML,*.HTML");</code> |
| * Finally, note that filters have no effect on the <b>directories</b> |
| * that are scanned; you could not skip over all files in directories |
| * whose names begin with "project," for instance. |
| * <br/> |
| * Treatment of overlapping inlcudes and excludes: To give a simplistic |
| * example suppose that you set your include filter to "*.htm *.html" |
| * and your exclude filter to "index.*". What happens to index.html? |
| * AntStarTeamCheckOut will not check out index.html, as it matches an |
| * exclude filter ("index.*"), even though it matches the include |
| * filter, as well. |
| * <br/> |
| * Please also read the following sections before using filters: |
| * |
| * @param excludes A string of filter patterns to exclude. Separate the |
| * patterns by spaces. |
| * @see #setIncludes(String includes) |
| * @see #getIncludes() |
| * @see #getExcludes() |
| */ |
| public void setExcludes(String excludes) { |
| this.excludes = excludes; |
| } |
| |
| /** |
| * Gets the patterns from the exclude filter. Rather that duplicate the |
| * details of AntStarTeanCheckOut's filtering here, refer to these |
| * links: |
| * |
| * @return A string of filter patterns separated by spaces. |
| * @see #setExcludes(String excludes) |
| * @see #setIncludes(String includes) |
| * @see #getIncludes() |
| */ |
| public String getExcludes() { |
| return excludes; |
| } |
| |
| /** |
| * if excludes have been specified, emit the list to the log |
| */ |
| protected void logExcludes() { |
| if (DEFAULT_EXCLUDESETTING != this.excludes) { |
| log(" Excludes specified: " + this.excludes); |
| } |
| } |
| |
| // CheckStyle:MethodNameCheck OFF - bc |
| |
| /** |
| * protected function to allow subclasses to set the label (or not). |
| * sets the StarTeam label |
| * |
| * @param label name of the StarTeam label to be set |
| */ |
| protected void _setLabel(String label) { |
| if (null != label) { |
| label = label.trim(); |
| if (label.length() > 0) { |
| this.label = label; |
| } |
| } |
| } |
| |
| /** |
| * non-public method callable only by derived classes that implement |
| * setAsOfDate (so that derived tasks that do not accept this |
| * parameter will fail if user attempts to use it. |
| * |
| * @param asOfDate asOfDate entered by user. |
| * @since Ant 1.6 |
| */ |
| protected void _setAsOfDate(String asOfDate) { |
| if (asOfDate != null && asOfDate.length() > 0) { |
| this.asOfDate = asOfDate; |
| } |
| } |
| |
| /** |
| * non-public method callable only by derived classes that implement |
| * setAsOfDateFormat (so that derived tasks that do not accept this |
| * parameter will fail if user attempts to use it. |
| * |
| * @param asOfDateFormat asOfDate format entered by user. |
| * @since Ant 1.6 |
| */ |
| protected void _setAsOfDateFormat(String asOfDateFormat) { |
| if (asOfDateFormat != null && asOfDateFormat.length() > 0) { |
| this.asOfDateFormat = asOfDateFormat; |
| } |
| } |
| |
| // CheckStyle:VisibilityModifier ON |
| |
| |
| /** |
| * return the asOfDate entered by the user for internal use by derived |
| * classes. |
| * |
| * @return the asOfDate entered by the user |
| * @since Ant 1.6 |
| */ |
| protected String getAsOfDate() { |
| return this.asOfDate; |
| } |
| |
| /** |
| * If an asofDate parameter has been supplied by the user return a |
| * StarTeam view based on the configuration of the StarTeam view |
| * specified the user as of the date specified in the parameter. |
| * If no asofDate has been specified, return null. |
| * |
| * This method is meant to be called from within implementations of the |
| * <code>createSnapshotView</code> abstract method. |
| * |
| * @param raw the raw view to be configured as of the supplied date |
| * |
| * @return the view as configured. |
| * @exception BuildException |
| * thrown if the date is not parsable by the default or |
| * supplied format patterns. |
| * @since Ant 1.6 |
| */ |
| protected View getViewConfiguredByDate(View raw) throws BuildException { |
| if (this.asOfDate == null) { |
| return null; |
| } |
| Date asOfDate = null; |
| SimpleDateFormat fmt = null; |
| if (this.asOfDateFormat != null) { |
| fmt = new SimpleDateFormat(this.asOfDateFormat); |
| try { |
| asOfDate = fmt.parse(this.asOfDate); |
| } catch (ParseException px) { |
| throw new BuildException("AsOfDate " |
| + this.asOfDate |
| + " not parsable by supplied format " |
| + this.asOfDateFormat); |
| } |
| } else { |
| try { |
| asOfDate = DateUtils.parseIso8601DateTimeOrDate( |
| this.asOfDate); |
| } catch (ParseException px) { |
| throw new BuildException("AsOfDate " |
| + this.asOfDate |
| + " not parsable by default" |
| + " ISO8601 formats"); |
| } |
| } |
| return new View(raw, ViewConfiguration.createFromTime( |
| new OLEDate(asOfDate))); |
| } |
| |
| /** |
| * return the label passed to the task by the user as a string |
| * |
| * @return the label passed to the task by the user as a string |
| */ |
| protected String getLabel() { |
| return this.label; |
| } |
| |
| /** |
| * Get the value of recursive. |
| * @return value of recursive. |
| */ |
| public boolean isRecursive() { |
| return this.recursive; |
| } |
| |
| /** |
| * Flag to set to include files in subfolders in the operation; optional, |
| * default true. |
| * @param v Value to assign to recursive. |
| */ |
| public void setRecursive(boolean v) { |
| this.recursive = v; |
| } |
| |
| /** |
| * Get the value of preloadFileInformation. |
| * @return value of preloadFileInformation. |
| */ |
| public boolean isPreloadFileInformation() { |
| return this.preloadFileInformation; |
| } |
| |
| /** |
| * Flag to set to preload file information from the server; optional, |
| * default true. |
| * Increases performance significantly for projects with many files |
| * and/or folders. |
| * @param v Value to assign to preloadFileInformation. |
| */ |
| public void setPreloadFileInformation(boolean v) { |
| this.preloadFileInformation = v; |
| } |
| |
| /** |
| * Get the value of forced. |
| * @return value of forced. |
| */ |
| public boolean isForced() { |
| return this.forced; |
| } |
| |
| /** |
| * Flag to force actions regardless of the status |
| * that StarTeam is maintaining for the file; optional, default false. |
| * If <tt>rootlocalfolder</tt> is set then |
| * this should be set "true" as otherwise the checkout will be based on statuses |
| * which do not relate to the target folder. |
| * @param v Value to assign to forced. |
| */ |
| public void setForced(boolean v) { |
| this.forced = v; |
| } |
| |
| /** |
| * returns true if a label has been specified and it is a view label. |
| * |
| * @return true if a label has been specified and it is a view label |
| */ |
| protected boolean isUsingViewLabel() { |
| return null != this.labelInUse && this.labelInUse.isViewLabel(); |
| } |
| |
| /** |
| * returns true if a label has been specified and it is a revision label. |
| * |
| * @return true if a label has been specified and it is a revision label |
| */ |
| protected boolean isUsingRevisionLabel() { |
| return null != this.labelInUse && this.labelInUse.isRevisionLabel(); |
| } |
| |
| /** |
| * returns the label being used |
| * |
| * @return the label being used |
| */ |
| protected Label getLabelInUse() { |
| return this.labelInUse; |
| } |
| |
| /** |
| * show the label in the log and its type. |
| */ |
| protected void logLabel() { |
| if (this.isUsingViewLabel()) { |
| log(" Using view label " + getLabel()); |
| } else if (this.isUsingRevisionLabel()) { |
| log(" Using revision label " + getLabel()); |
| } |
| } |
| |
| /** |
| * show the asofDate in the log |
| * @since Ant 1.6 |
| */ |
| protected void logAsOfDate() { |
| if (null != this.asOfDate) { |
| log(" Using view as of date " + getAsOfDate()); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////// |
| // INCLUDE-EXCLUDE processing |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * Look if the file should be processed by the task. |
| * Don't process it if it fits no include filters or if |
| * it fits an exclude filter. |
| * |
| * @param pName the item name to look for being included. |
| * |
| * @return whether the file should be processed or not. |
| */ |
| protected boolean shouldProcess(String pName) { |
| boolean includeIt = matchPatterns(getIncludes(), pName); |
| boolean excludeIt = matchPatterns(getExcludes(), pName); |
| return (includeIt && !excludeIt); |
| } |
| |
| /** |
| * Convenience method to see if a string match a one pattern |
| * in given set of space-separated patterns. |
| * @param patterns the space-separated list of patterns. |
| * @param pName the name to look for matching. |
| * @return whether the name match at least one pattern. |
| */ |
| protected boolean matchPatterns(String patterns, String pName) { |
| if (patterns == null) { |
| return false; |
| } |
| StringTokenizer exStr = new StringTokenizer(patterns, ","); |
| while (exStr.hasMoreTokens()) { |
| if (DirectoryScanner.match(exStr.nextToken(), pName)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Finds and opens the root starteam folder of the operation specified |
| * by this task. This will be one of the following cases: |
| * |
| * @return Starteam's root folder for the operation. |
| * @exception BuildException |
| * if the root folder cannot be found in the repository |
| */ |
| private Folder configureRootStarteamFolder() |
| throws BuildException { |
| Folder starteamrootfolder = null; |
| try { |
| // no root local mapping has been specified. |
| View snapshot = openView(); |
| |
| // find the starteam folder specified to be the root of the |
| // operation. Throw if it can't be found. |
| |
| starteamrootfolder = |
| StarTeamFinder.findFolder(snapshot.getRootFolder(), |
| this.rootStarteamFolder); |
| |
| if (this.isPreloadFileInformation()) { |
| PropertyNames pn = getServer().getPropertyNames(); |
| String[] props = new String[] {pn.FILE_NAME, pn.FILE_PATH, |
| pn.FILE_STATUS, pn.MODIFIED_TIME, |
| pn.FILE_FILE_TIME_AT_CHECKIN, |
| pn.MODIFIED_USER_ID, pn.FILE_SIZE, |
| pn.FILE_ENCODING}; |
| |
| int depth = this.isRecursive() ? -1 : 0; |
| starteamrootfolder.populateNow(getServer().getTypeNames().FILE, |
| props, depth); |
| } |
| |
| |
| } catch (BuildException e) { |
| throw e; |
| } catch (Exception e) { |
| StringBuffer msg = new StringBuffer("Unable to find root folder ") |
| .append(this.rootStarteamFolder) |
| .append(" in repository at ") |
| .append(getURL()); |
| if (this.label != null) { |
| msg.append(" using specified label ").append(this.label); |
| } |
| if (this.asOfDate != null) { |
| msg.append(" as of specified date ") |
| .append(this.asOfDate); |
| } |
| throw new BuildException(msg.toString(), e); |
| |
| } |
| |
| if (null == starteamrootfolder) { |
| throw new BuildException("Unable to find root folder " |
| + this.rootStarteamFolder + " in repository at " + getURL()); |
| } |
| |
| return starteamrootfolder; |
| } |
| |
| /** |
| * Returns the local folder mapped to the given StarTeam root folder |
| * of the operation. There are two cases here, depending on whether |
| * <code>rootLocalFolder</code> is defined. |
| * If <code>rootLocalFolder</code> is defined, it will be used to |
| * establish a root mapping. Otherwise, the repository's default root |
| * folder will be used. |
| * |
| * @param starteamrootfolder |
| * root Starteam folder initialized for the operation |
| * |
| * @return the local folder corresponding to the root Starteam folder. |
| * @see findRootStarteamFolder |
| */ |
| private java.io.File getLocalRootMapping(Folder starteamrootfolder) { |
| // set the local folder. |
| String localrootfolder; |
| if (null != this.rootLocalFolder) { |
| localrootfolder = rootLocalFolder; |
| } else { |
| // either use default path or root local mapping, |
| // which is now embedded in the root folder |
| localrootfolder = starteamrootfolder.getPathFragment(); |
| } |
| |
| return new java.io.File(localrootfolder); |
| |
| } |
| |
| /** |
| * extenders should emit to the log an entry describing the parameters |
| * that will be used by this operation. |
| * |
| * @param starteamrootFolder |
| * root folder in StarTeam for the operation |
| * @param targetrootFolder |
| * root local folder for the operation (whether specified by the user or not. |
| */ |
| protected abstract void logOperationDescription( |
| Folder starteamrootFolder, java.io.File targetrootFolder); |
| |
| /** |
| * This method does the work of opening the supplied Starteam view and |
| * calling the <code>visit()</code> method to perform the task. |
| * Derived classes can customize the called methods |
| * <code>testPreconditions()</code> and <code>visit()</code>. |
| * |
| * @exception BuildException if any error occurs in the processing |
| * @see <code>testPreconditions()</code> |
| * @see <code>visit()</code> |
| */ |
| |
| public final void execute() throws BuildException { |
| try { |
| |
| Folder starteamrootfolder = configureRootStarteamFolder(); |
| |
| // set the local folder. |
| java.io.File localrootfolder = |
| getLocalRootMapping(starteamrootfolder); |
| |
| testPreconditions(); |
| |
| // Tell user what he is doing |
| logOperationDescription(starteamrootfolder, localrootfolder); |
| |
| // Inspect everything in the root folder and then recursively |
| visit(starteamrootfolder, localrootfolder); |
| |
| } catch (Exception e) { |
| throw new BuildException(e); |
| } finally { |
| disconnectFromServer(); |
| } |
| } |
| |
| private void findLabel(View v) throws BuildException { |
| Label[] allLabels = v.getLabels(); |
| for (int i = 0; i < allLabels.length; i++) { |
| Label stLabel = allLabels[i]; |
| log("checking label " + stLabel.getName(), Project.MSG_DEBUG); |
| if (stLabel != null && !stLabel.isDeleted() && stLabel.getName().equals(this.label)) { |
| if (!stLabel.isRevisionLabel() && !stLabel.isViewLabel()) { |
| throw new BuildException("Unexpected label type."); |
| } |
| log("using label " + stLabel.getName(), Project.MSG_VERBOSE); |
| this.labelInUse = stLabel; |
| return; |
| } |
| } |
| throw new BuildException("Error: label " |
| + this.label |
| + " does not exist in view " |
| + v.getFullName()); |
| |
| } |
| |
| /** |
| * Helper method calls on the StarTeam API to retrieve an ID number |
| * for the specified view, corresponding to this.label. |
| * @param v the <code>View</code> in which to search for <code>this.label</code> |
| * @return the ID number corresponding to <code>this.label</code> or -1 if |
| * no label was provided. |
| * @exception BuildException if <code>this.label</code> does not correspond |
| * to any label in the supplied view |
| */ |
| protected int getLabelID(View v) throws BuildException { |
| if (null != this.label) { |
| findLabel(v); |
| return this.labelInUse.getID(); |
| } |
| return -1; |
| } |
| |
| /** |
| * Get the id of the label in use. |
| * @return id of the label in use, if labelinuse is present, |
| * otherwise return null |
| */ |
| protected int getIDofLabelInUse() { |
| if (null != this.labelInUse) { |
| return this.labelInUse.getID(); |
| } |
| return -1; |
| } |
| |
| /** |
| * Derived classes must override this class to define actual processing |
| * to be performed on each folder in the tree defined for the task |
| * |
| * @param rootStarteamFolder |
| * the StarTeam folderto be visited |
| * @param rootLocalFolder |
| * the local mapping of rootStarteamFolder |
| * |
| * @throws BuildException on error |
| */ |
| protected abstract void visit(Folder rootStarteamFolder, |
| java.io.File rootLocalFolder) |
| throws BuildException; |
| |
| /** |
| * Derived classes must override this method to define tests for |
| * any preconditons required by the task. This method is called at |
| * the beginning of the execute() method. |
| * |
| * @exception BuildException throw if any fatal error exists in the |
| * parameters supplied. If there is a non-fatal condition, just writing |
| * to the log may be appropriate. |
| * @see <code>execute()</code> |
| */ |
| protected abstract void testPreconditions() throws BuildException; |
| |
| /** |
| * Return the full repository path name of a file. Surprisingly there's |
| * no method in com.starbase.starteam.File to provide this. |
| * |
| * @param remotefile the Star Team file whose path is to be returned |
| * |
| * @return the full repository path name of a file. |
| */ |
| public static String getFullRepositoryPath( |
| com.starbase.starteam.File remotefile) { |
| StringBuffer sb = new StringBuffer(); |
| sb.append(remotefile.getParentFolderHierarchy()) |
| .append(remotefile.getName()); |
| return sb.toString(); |
| } |
| |
| /** |
| * This class implements a map of existing local files to possibly |
| * existing repository files. The map is created by a TreeBasedTask |
| * upon recursing into a directory. Each local item is mapped to an |
| * unattached StarTeam object of the proper type, File->File and |
| * Directory->Folder. |
| * |
| * As the TreeBased does its work, it deletes from the map all items |
| * it has processed. |
| * |
| * When the TreeBased task processes all the items from the repository, |
| * whatever items left in the UnmatchedFileMap are uncontrolled items |
| * and can be processed as appropriate to the task. In the case of |
| * Checkouts, they can be optionally deleted from the local tree. In the |
| * case of Checkins they can optionally be added to the repository. |
| */ |
| protected abstract class UnmatchedFileMap extends Hashtable { |
| |
| /** |
| * initializes the UnmatchedFileMap with entries from the local folder |
| * These will be mapped to the corresponding StarTeam entry even though |
| * it will not, in fact, exist in the repository. But through it, it |
| * can be added, listed, etc. |
| * |
| * @param localFolder |
| * the local folder from which the mappings will be made. |
| * @param remoteFolder |
| * the corresponding StarTeam folder which will be processed. |
| */ |
| UnmatchedFileMap init(java.io.File localFolder, Folder remoteFolder) { |
| if (!localFolder.exists()) { |
| return this; |
| } |
| |
| String[] localFiles = localFolder.list(); |
| |
| for (int i = 0; i < localFiles.length; i++) { |
| String fn = localFiles[i]; |
| java.io.File localFile = |
| new java.io.File(localFolder, localFiles[i]).getAbsoluteFile(); |
| |
| log("adding " + localFile + " to UnmatchedFileMap", |
| Project.MSG_DEBUG); |
| |
| if (localFile.isDirectory()) { |
| this.put(localFile, new Folder(remoteFolder, fn, fn)); |
| } else { |
| com.starbase.starteam.File remoteFile = |
| new com.starbase.starteam.File(remoteFolder); |
| remoteFile.setName(fn); |
| this.put(localFile, remoteFile); |
| } |
| } |
| return this; |
| } |
| |
| /** |
| * remove an item found to be controlled from the map. |
| * |
| * @param localFile the local item found to be controlled. |
| */ |
| void removeControlledItem(java.io.File localFile) { |
| if (isActive()) { |
| log("removing processed " + localFile.getAbsoluteFile() |
| + " from UnmatchedFileMap", Project.MSG_DEBUG); |
| this.remove(localFile.getAbsoluteFile()); |
| } |
| } |
| /** |
| * override will perform the action appropriate for its task to perform |
| * on items which are on the local tree but not in StarTeam. It is |
| * assumed that this method will not be called until all the items in |
| * the corresponding folder have been processed, and that the internal |
| * map * will contain only uncontrolled items. |
| */ |
| abstract void processUncontrolledItems() throws BuildException; |
| |
| /** |
| * overrides must define this to declare how this method knows if it |
| * is active. This presents extra clock cycles when the functionality |
| * is not called for. |
| * |
| * @return True if this object is to perform its functionality. |
| */ |
| protected abstract boolean isActive(); |
| |
| } |
| |
| } |
