public AbstractCvsTask() 
{
       
        super();
}

empty no-arg constructor

 public  void addCommandArgument(String arg) 
{
        this.addCommandArgument(cmd, arg);
}

This needs to be public to allow configuration of commands externally.

 public  void addCommandArgument(Commandline c,
    String arg) 
{
        c.createArgument().setValue(arg);
}

This method adds a command line argument to an external command. I do not understand what this method does in this class ??? particularly not why it is public ???? AntoineLL July 23d 2003

 public  void addConfiguredCommandline(Commandline c) 
{
        this.addConfiguredCommandline(c, false);
}

Adds direct command-line to execute.

 public  void addConfiguredCommandline(Commandline c,
    boolean insertAtStart) 
{
        if (c == null) {
            return;
        }
        this.configureCommandline(c);
        if (insertAtStart) {
            vecCommandlines.insertElementAt(c, 0);
        } else {
            vecCommandlines.addElement(c);
        }
}

Configures and adds the given Commandline.

 protected  void configureCommandline(Commandline c) 
{
        if (c == null) {
            return;
        }
        c.setExecutable("cvs");
        if (cvsPackage != null) {
            c.createArgument().setLine(cvsPackage);
        }
        if (this.compression  > 0
            && this.compression < = MAXIMUM_COMRESSION_LEVEL) {
            c.createArgument(true).setValue("-z" + this.compression);
        }
        if (quiet && !reallyquiet) {
            c.createArgument(true).setValue("-q");
        }
        if (reallyquiet) {
            c.createArgument(true).setValue("-Q");
        }
        if (noexec) {
            c.createArgument(true).setValue("-n");
        }
        if (cvsRoot != null) {
            c.createArgument(true).setLine("-d" + cvsRoot);
        }
}

Configure a commandline element for things like cvsRoot, quiet, etc.

 public  void execute() throws BuildException 
{
        String savedCommand = getCommand();
        if (this.getCommand() == null && vecCommandlines.size() == 0) {
            // re-implement legacy behaviour:
            this.setCommand(AbstractCvsTask.DEFAULT_COMMAND);
        }
        String c = this.getCommand();
        Commandline cloned = null;
        if (c != null) {
            cloned = (Commandline) cmd.clone();
            cloned.createArgument(true).setLine(c);
            this.addConfiguredCommandline(cloned, true);
        }
        try {
            for (int i = 0; i <  vecCommandlines.size(); i++) {
                this.runCommand((Commandline) vecCommandlines.elementAt(i));
            }
        } finally {
            if (cloned != null) {
                removeCommandline(cloned);
            }
            setCommand(savedCommand);
            FileUtils.close(outputStream);
            FileUtils.close(errorStream);
        }
}

do the work

 public String getCommand() 
{
        return this.command;
}

accessor to a command line as string This should be deprecated AntoineLL July 23d 2003

 public String getCvsRoot() 
{
        return this.cvsRoot;
}

access the CVSROOT variable

 public String getCvsRsh() 
{
        return this.cvsRsh;
}

access the CVS_RSH variable

 public File getDest() 
{
        return this.dest;
}

get the file where the checked out files should be placed

 protected OutputStream getErrorStream() 
{
        if (this.errorStream == null) {
            if (error != null) {
                try {
                    setErrorStream(new PrintStream(
                                       new BufferedOutputStream(
                                           new FileOutputStream(error.getPath(),
                                                                append))));
                } catch (IOException e) {
                    throw new BuildException(e, getLocation());
                }
            } else {
                setErrorStream(new LogOutputStream(this, Project.MSG_WARN));
            }
        }
        return this.errorStream;
}

access the stream to which the stderr from cvs should go if this stream has already been set, it will be returned if the stream has not yet been set, if the attribute error has been set, the output stream will go to the file denoted by the error attribute otherwise the stderr output will go to ant's logging system

 protected ExecuteStreamHandler getExecuteStreamHandler() 
{
        if (this.executeStreamHandler == null) {
            setExecuteStreamHandler(new PumpStreamHandler(getOutputStream(),
                                                          getErrorStream()));
        }
        return this.executeStreamHandler;
}

find the handler and instantiate it if it does not exist yet

 protected OutputStream getOutputStream() 
{
        if (this.outputStream == null) {
            if (output != null) {
                try {
                    setOutputStream(new PrintStream(
                                        new BufferedOutputStream(
                                            new FileOutputStream(output
                                                                 .getPath(),
                                                                 append))));
                } catch (IOException e) {
                    throw new BuildException(e, getLocation());
                }
            } else {
                setOutputStream(new LogOutputStream(this, Project.MSG_INFO));
            }
        }
        return this.outputStream;
}

access the stream to which the stdout from cvs should go if this stream has already been set, it will be returned if the stream has not yet been set, if the attribute output has been set, the output stream will go to the output file otherwise the output will go to ant's logging system

 public String getPackage() 
{
        return this.cvsPackage;
}

access the package or module to operate upon

 public File getPassFile() 
{
        return this.passFile;
}

find the password file

 public int getPort() 
{
        return this.port;
}

access the port of CVS

 public String getTag() 
{
        return tag;
}

tag or branch

 protected  void removeCommandline(Commandline c) 
{
        vecCommandlines.removeElement(c);
}

remove a particular command from a vector of command lines

 protected  void runCommand(Commandline toExecute) throws BuildException 
{
        // XXX: we should use JCVS (www.ice.com/JCVS) instead of
        // command line execution so that we don't rely on having
        // native CVS stuff around (SM)
        // We can't do it ourselves as jCVS is GPLed, a third party task
        // outside of jakarta repositories would be possible though (SB).
        Environment env = new Environment();
        if (port  > 0) {
            Environment.Variable var = new Environment.Variable();
            var.setKey("CVS_CLIENT_PORT");
            var.setValue(String.valueOf(port));
            env.addVariable(var);
        }
        /**
         * Need a better cross platform integration with < cvspass >, so
         * use the same filename.
         */
        if (passFile == null) {
            File defaultPassFile = new File(
                System.getProperty("cygwin.user.home",
                    System.getProperty("user.home"))
                + File.separatorChar + ".cvspass");
            if (defaultPassFile.exists()) {
                this.setPassfile(defaultPassFile);
            }
        }
        if (passFile != null) {
            if (passFile.isFile() && passFile.canRead()) {
                Environment.Variable var = new Environment.Variable();
                var.setKey("CVS_PASSFILE");
                var.setValue(String.valueOf(passFile));
                env.addVariable(var);
                log("Using cvs passfile: " + String.valueOf(passFile),
                    Project.MSG_VERBOSE);
            } else if (!passFile.canRead()) {
                log("cvs passfile: " + String.valueOf(passFile)
                    + " ignored as it is not readable",
                    Project.MSG_WARN);
            } else {
                log("cvs passfile: " + String.valueOf(passFile)
                    + " ignored as it is not a file",
                    Project.MSG_WARN);
            }
        }
        if (cvsRsh != null) {
            Environment.Variable var = new Environment.Variable();
            var.setKey("CVS_RSH");
            var.setValue(String.valueOf(cvsRsh));
            env.addVariable(var);
        }
        //
        // Just call the getExecuteStreamHandler() and let it handle
        //     the semantics of instantiation or retrieval.
        //
        Execute exe = new Execute(getExecuteStreamHandler(), null);
        exe.setAntRun(getProject());
        if (dest == null) {
            dest = getProject().getBaseDir();
        }
        if (!dest.exists()) {
            dest.mkdirs();
        }
        exe.setWorkingDirectory(dest);
        exe.setCommandline(toExecute.getCommandline());
        exe.setEnvironment(env.getVariables());
        try {
            String actualCommandLine = executeToString(exe);
            log(actualCommandLine, Project.MSG_VERBOSE);
            int retCode = exe.execute();
            log("retCode=" + retCode, Project.MSG_DEBUG);
            if (failOnError && Execute.isFailure(retCode)) {
                throw new BuildException("cvs exited with error code "
                                         + retCode
                                         + StringUtils.LINE_SEP
                                         + "Command line was ["
                                         + actualCommandLine + "]",
                                         getLocation());
            }
        } catch (IOException e) {
            if (failOnError) {
                throw new BuildException(e, getLocation());
            }
            log("Caught exception: " + e.getMessage(), Project.MSG_WARN);
        } catch (BuildException e) {
            if (failOnError) {
                throw(e);
            }
            Throwable t = e.getException();
            if (t == null) {
                t = e;
            }
            log("Caught exception: " + t.getMessage(), Project.MSG_WARN);
        } catch (Exception e) {
            if (failOnError) {
                throw new BuildException(e, getLocation());
            }
            log("Caught exception: " + e.getMessage(), Project.MSG_WARN);
        }
}

Sets up the environment for toExecute and then runs it.

 public  void setAppend(boolean value) 
{
        this.append = value;
}

Whether to append output/error when redirecting to a file.

 public  void setCommand(String c) 
{
        this.command = c;
}

The CVS command to execute. This should be deprecated, it is better to use the Commandline class ? AntoineLL July 23d 2003

 public  void setCompression(boolean usecomp) 
{
        setCompressionLevel(usecomp
            ? AbstractCvsTask.DEFAULT_COMPRESSION_LEVEL : 0);
}

If true, this is the same as compressionlevel="3".

 public  void setCompressionLevel(int level) 
{
        this.compression = level;
}

If set to a value 1-9 it adds -zN to the cvs command line, else it disables compression.

 public  void setCvsRoot(String root) 
{
        // Check if not real cvsroot = > set it to null
        if (root != null) {
            if (root.trim().equals("")) {
                root = null;
            }
        }
        this.cvsRoot = root;
}

The CVSROOT variable.

 public  void setCvsRsh(String rsh) 
{
        // Check if not real cvsrsh = > set it to null
        if (rsh != null) {
            if (rsh.trim().equals("")) {
                rsh = null;
            }
        }
        this.cvsRsh = rsh;
}

The CVS_RSH variable.

 public  void setDate(String p) 
{
        if (p != null && p.trim().length()  > 0) {
            addCommandArgument("-D");
            addCommandArgument(p);
        }
}

Use the most recent revision no later than the given date.

 public  void setDest(File dest) 
{
        this.dest = dest;
}

The directory where the checked out files should be placed.

Note that this is different from CVS's -d command line switch as Ant will never shorten pathnames to avoid empty directories.

 public  void setError(File error) 
{
        this.error = error;
}

The file to direct standard error from the command.

 protected  void setErrorStream(OutputStream errorStream) 
{
        this.errorStream = errorStream;
}

sets a stream to which the stderr from the cvs exe should go

 public  void setExecuteStreamHandler(ExecuteStreamHandler handler) 
{
        this.executeStreamHandler = handler;
}

sets the handler

 public  void setFailOnError(boolean failOnError) 
{
        this.failOnError = failOnError;
}

Stop the build process if the command exits with a return code other than 0. Defaults to false.

 public  void setNoexec(boolean ne) 
{
        noexec = ne;
}

If true, report only and don't change any files.

 public  void setOutput(File output) 
{
        this.output = output;
}

The file to direct standard output from the command.

 protected  void setOutputStream(OutputStream outputStream) 
{
        this.outputStream = outputStream;
}

sets a stream to which the output from the cvs executable should be sent

 public  void setPackage(String p) 
{
        this.cvsPackage = p;
}

The package/module to operate upon.

 public  void setPassfile(File passFile) 
{
        this.passFile = passFile;
}

Password file to read passwords from.

 public  void setPort(int port) 
{
        this.port = port;
}

Port used by CVS to communicate with the server.

 public  void setQuiet(boolean q) 
{
        quiet = q;
}

If true, suppress informational messages.

 public  void setReallyquiet(boolean q) 
{
        reallyquiet = q;
}

If true, suppress all messages.

 public  void setTag(String p) 
{
        // Check if not real tag = > set it to null
        if (p != null && p.trim().length()  > 0) {
            tag = p;
            addCommandArgument("-r" + p);
        }
}

The tag of the package/module to operate upon.