Changeset 175 for trunk/JavaHelperLib


Ignore:
Timestamp:
09/09/11 23:52:51 (13 years ago)
Author:
sherbold
Message:
  • code documentation and formatting
Location:
trunk/JavaHelperLib/src/de/ugoe/cs/util
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaHelperLib/src/de/ugoe/cs/util/ArrayTools.java

    r1 r175  
    11package de.ugoe.cs.util; 
    22 
     3/** 
     4 * <p> 
     5 * Helper class that provides methods to simplify working with arrays. 
     6 * </p> 
     7 *  
     8 * @author Steffen Herbold 
     9 * @version 1.0 
     10 */ 
    311final public class ArrayTools { 
    4          
     12 
    513        /** 
    614         * <p> 
    7          * Finds the first occurence of an object inside an array. 
     15         * Finds the first occurrence of an object inside an array. 
    816         * </p> 
    917         * <p> 
    10          * In case {@code other==null}, the first occurence of a {@code null} value in the array is returned. 
     18         * In case {@code other==null}, the first occurrence of a {@code null} value 
     19         * in the array is returned. 
    1120         * </p> 
    12          *   
    13          * @param array the array 
    14          * @param other the object 
     21         *  
     22         * @param array 
     23         *            the array 
     24         * @param other 
     25         *            the object 
    1526         * @return index of the object if found, -1 otherwise 
    1627         */ 
    1728        public static int findIndex(Object[] array, Object other) { 
    1829                int retVal = -1; 
    19                 for( int i=0 ; i<array.length && retVal==-1 ; i++ ) { 
    20                         if( other!=null ) { 
    21                                 if( array[i]!=null && array[i].equals(other) ) { 
     30                for (int i = 0; i < array.length && retVal == -1; i++) { 
     31                        if (other != null) { 
     32                                if (array[i] != null && array[i].equals(other)) { 
    2233                                        retVal = i; 
    2334                                } 
    2435                        } else { 
    25                                 if( array[i]==null ) { 
     36                                if (array[i] == null) { 
    2637                                        retVal = i; 
    2738                                } 

  • trunk/JavaHelperLib/src/de/ugoe/cs/util/FileTools.java

    r83 r175  
    66import java.io.IOException; 
    77 
     8/** 
     9 * <p> 
     10 * Helper class that provides methods that simplify working with files. 
     11 * </p> 
     12 *  
     13 * @author Steffen Herbold 
     14 * @version 1.0 
     15 */ 
    816public class FileTools { 
    9          
     17 
    1018        /** 
    1119         * <p> 
    12          * Returns an array of the lines contained in a file. The line seperator is "\r\n". 
     20         * Returns an array of the lines contained in a file. The line separator is 
     21         * "\r\n". 
    1322         * </p> 
    14          * @param filename name of the file 
     23         *  
     24         * @param filename 
     25         *            name of the file 
    1526         * @return string array, where each line contains a file 
    16          * @throws IOException see {@link FileReader#read(char[])}, {@link FileReader#close()}  
    17          * @throws FileNotFoundException see {@link FileReader#FileReader(File)} 
     27         * @throws IOException 
     28         *             see {@link FileReader#read(char[])}, 
     29         *             {@link FileReader#close()} 
     30         * @throws FileNotFoundException 
     31         *             see {@link FileReader#FileReader(File)} 
    1832         */ 
    19         public static String[] getLinesFromFile(String filename) throws IOException, FileNotFoundException { 
     33        public static String[] getLinesFromFile(String filename) 
     34                        throws IOException, FileNotFoundException { 
    2035                return getLinesFromFile(filename, true); 
    2136        } 
    22          
     37 
    2338        /** 
    2439         * <p> 
    2540         * Returns an array of the lines contained in a file. 
    2641         * </p> 
    27          * @param filename name of the file 
    28          * @param carriageReturn if true, "\r\n", if false "\n" is used as line seperator 
     42         *  
     43         * @param filename 
     44         *            name of the file 
     45         * @param carriageReturn 
     46         *            if true, "\r\n", if false "\n" is used as line separator 
    2947         * @return string array, where each line contains a file 
    30          * @throws IOException see {@link FileReader#read(char[])}, {@link FileReader#close()}  
    31          * @throws FileNotFoundException see {@link FileReader#FileReader(File)} 
     48         * @throws IOException 
     49         *             see {@link FileReader#read(char[])}, 
     50         *             {@link FileReader#close()} 
     51         * @throws FileNotFoundException 
     52         *             see {@link FileReader#FileReader(File)} 
    3253         */ 
    33         public static String[] getLinesFromFile(String filename, boolean carriageReturn) throws IOException, FileNotFoundException { 
     54        public static String[] getLinesFromFile(String filename, 
     55                        boolean carriageReturn) throws IOException, FileNotFoundException { 
    3456                File f = new File(filename); 
    3557                FileReader reader = new FileReader(f); 
    … …  
    3860                reader.close(); 
    3961                String splitString; 
    40                 if( carriageReturn ) { 
     62                if (carriageReturn) { 
    4163                        splitString = "\r\n"; 
    4264                } else { 

  • trunk/JavaHelperLib/src/de/ugoe/cs/util/StringTools.java

    r1 r175  
    11package de.ugoe.cs.util; 
    22 
     3/** 
     4 * <p> 
     5 * Helper class that provides methods to simplify working with {@link String}s. 
     6 * </p> 
     7 *  
     8 * @author Steffen Herbold 
     9 * @version 1.0 
     10 */ 
    311final public class StringTools { 
    412 
    5         public final static String ENDLINE = System.getProperty("line.separator"); 
    6          
    713        /** 
    814         * <p> 
    9          * Replaces all occurences of {@literal &, <, >, ', and "} with their 
    10          * respective XML entites {@literal &amp;, &lt;, &gt;, &apos;, and &quot;} 
     15         * Simplifies use of operation system specific line separators. 
     16         * </p> 
     17         */ 
     18        public final static String ENDLINE = System.getProperty("line.separator"); 
     19 
     20        /** 
     21         * <p> 
     22         * Replaces all occurrences of {@literal &, <, >, ', and "} with their 
     23         * respective XML entities {@literal &amp;, &lt;, &gt;, &apos;, and &quot;} 
    1124         * without destroying already existing entities. 
    1225         * </p> 
    1326         *  
    1427         * @param str 
    15          *            String where the XML entites are to be replaced 
    16          * @return new String, where the XML entites are used instead of the 
     28         *            String where the XML entities are to be replaced 
     29         * @return new String, where the XML entities are used instead of the 
    1730         *         literals 
    1831         */ 

  • trunk/JavaHelperLib/src/de/ugoe/cs/util/console/Command.java

    r1 r175  
    1111 *  
    1212 * @author Steffen Herbold 
     13 * @version 1.0 
    1314 */ 
    1415public interface Command { 

  • trunk/JavaHelperLib/src/de/ugoe/cs/util/console/CommandExecuter.java

    r1 r175  
    44import java.util.ArrayList; 
    55import java.util.List; 
    6  
    76 
    87/** 
    … …  
    1413 * </p> 
    1514 * <p> 
    16  * This class is implemented as a <i>Singleton</i>.  
     15 * This class is implemented as a <i>Singleton</i>. 
    1716 * </p> 
    1817 *  
    1918 * @author Steffen Herbold 
     19 * @version 1.0 
    2020 */ 
    2121public class CommandExecuter { 
    … …  
    3434         */ 
    3535        private static final String cmdPrefix = "CMD"; 
    36          
     36 
    3737        /** 
    3838         * <p> 
    … …  
    4848         * </p> 
    4949         * <p> 
    50          * The defaultcommands package has always lowest priority, unless it is 
    51          * specificially added. 
     50         * The de.ugoe.cs.util.console.defaultcommands package has always lowest 
     51         * priority, unless it is specifically added. 
    5252         * </p> 
    5353         */ 
    … …  
    7878        /** 
    7979         * <p> 
    80          * Adds a package that will be used by exec to load command from. 
     80         * Adds a package that will be used by {@link #exec(String)} to load command 
     81         * from. 
    8182         * </p> 
    8283         *  
    … …  
    111112                parser.parse(command); 
    112113                for (int i = 0; cmd == null && i < commandPackageList.size(); i++) { 
    113                         cmd = loadCMD(commandPackageList.get(i)+"."+cmdPrefix+parser.getCommandName()); 
     114                        cmd = loadCMD(commandPackageList.get(i) + "." + cmdPrefix 
     115                                        + parser.getCommandName()); 
    114116                } 
    115117                if (cmd == null) { // check if command is available as default command 
    116                         cmd = loadCMD(defaultPackage+"."+cmdPrefix+parser.getCommandName()); 
     118                        cmd = loadCMD(defaultPackage + "." + cmdPrefix 
     119                                        + parser.getCommandName()); 
    117120                } 
    118121                if (cmd == null) { 
    … …  
    128131 
    129132        /** 
     133         * <p> 
    130134         * Helper method that loads a class and tries to cast it to {@link Command}. 
     135         * </p> 
    131136         *  
    132          * @param className qualified name of the class (including package name) 
    133          * @return if class is available and implement {@link Command} and instance of the class, null otherwise 
     137         * @param className 
     138         *            qualified name of the class (including package name) 
     139         * @return if class is available and implement {@link Command} and instance 
     140         *         of the class, null otherwise 
    134141         */ 
    135142        private Command loadCMD(String className) { 
    … …  
    140147                } catch (NoClassDefFoundError e) { 
    141148                        String[] splitResult = e.getMessage().split("CMD"); 
    142                         String correctName = splitResult[splitResult.length-1].replace(")", ""); 
     149                        String correctName = splitResult[splitResult.length - 1].replace( 
     150                                        ")", ""); 
    143151                        Console.traceln("Did you mean " + correctName + "?"); 
    144152                } catch (ClassNotFoundException e) { 

  • trunk/JavaHelperLib/src/de/ugoe/cs/util/console/CommandParser.java

    r1 r175  
    1010 *  
    1111 * @author Steffen Herbold 
     12 * @version 1.0 
    1213 */ 
    1314public class CommandParser { 

  • trunk/JavaHelperLib/src/de/ugoe/cs/util/console/Console.java

    r1 r175  
    55 
    66import de.ugoe.cs.util.StringTools; 
    7  
    87 
    98/** 
    … …  
    2322 *  
    2423 * @author Steffen Herbold 
     24 * @version 1.0 
    2525 */ 
    2626public final class Console { 
    … …  
    120120                } 
    121121                for (ConsoleObserver observer : theInstance.observers) { 
    122                         observer.updateText(msg 
    123                                         + StringTools.ENDLINE); 
     122                        observer.updateText(msg + StringTools.ENDLINE); 
    124123                } 
    125124        } 
    … …  
    157156                } 
    158157                for (ConsoleObserver observer : theInstance.observers) { 
    159                         observer.errStream(errMsg 
    160                                         + StringTools.ENDLINE); 
     158                        observer.errStream(errMsg + StringTools.ENDLINE); 
    161159                } 
    162160        } 
    … …  
    200198         * <p> 
    201199         * Sends a debug message to all observers containing the message that was 
    202          * passed to this function and adds an endline to the message. 
     200         * passed to this function and adds an {@link StringTools#ENDLINE} to the 
     201         * message. 
    203202         * </p> 
    204203         *  
    … …  
    211210                } 
    212211                for (ConsoleObserver observer : theInstance.observers) { 
    213                         observer.trace(traceMsg 
    214                                         + StringTools.ENDLINE); 
     212                        observer.trace(traceMsg + StringTools.ENDLINE); 
    215213                } 
    216214        } 

  • trunk/JavaHelperLib/src/de/ugoe/cs/util/console/ConsoleObserver.java

    r1 r175  
    77 *  
    88 * @author Steffen Herbold 
     9 * @version 1.0 
    910 */ 
    1011public interface ConsoleObserver { 

  • trunk/JavaHelperLib/src/de/ugoe/cs/util/console/TextConsole.java

    r1 r175  
    66 * <p> 
    77 * Implements a simple console observer that prints normal text to 
    8  * <code>stdout</code>, errors to <code>stderr</code> and reads from 
    9  * <code>stdin</code>. 
     8 * {@code stdout}, errors to {@code stderr} and reads from {@code stdin}. 
    109 * </p> 
    1110 *  
    1211 * @author Steffen Herbold 
     12 * @version 1.0 
    1313 */ 
    1414public class TextConsole implements ConsoleObserver { 
    … …  
    3232        /** 
    3333         * <p> 
    34          * Prints messages to <code>stdout</code>. 
     34         * Prints messages to {@code stdout}. 
    3535         * </p> 
    3636         *  
    … …  
    4343        /** 
    4444         * <p> 
    45          * Prints messages to <code>stderr</code>. 
     45         * Prints messages to {@code stderr}. 
    4646         * </p> 
    4747         *  
    … …  
    5555        /** 
    5656         * <p> 
    57          * Prints the stackrace of an exception to <code>stderr</code> 
     57         * Prints the stacktrace of an exception to {@code stderr}. 
    5858         * </p> 
    5959         *  
    … …  
    6767        /** 
    6868         * <p> 
    69          * Prints messages to <code>stdout</code>. These messages are only printed, 
    70          * if the console is run in debug mode. 
     69         * Prints messages to {@code stdout}. These messages are only printed, if 
     70         * the console is run in debug mode. 
    7171         * </p> 
    7272         */ 
    … …  
    8282         * Starts a new TextConsole. If the text console is started, it can be used 
    8383         * not only to print message, but also to execute commands by reading 
    84          * <code>stdin</code>. 
     84         * {@code stdin}. 
    8585         * </p> 
    8686         *  
    … …  
    103103        /** 
    104104         * <p> 
    105          * Reads a new command from <code>stdin</code>. 
     105         * Reads a new command from {@code stdin}. 
    106106         * </p> 
    107107         *  

  • trunk/JavaHelperLib/src/de/ugoe/cs/util/console/defaultcommands/CMDexec.java

    r122 r175  
    1414/** 
    1515 * <p> 
    16  * Implements a command to execute batchs of {@link Command}s, defined by batch 
    17  * file, to allow scripted executions. 
     16 * Command to execute a batch of {@link Command}s. The batch is defined as a 
     17 * text file, where each line defines one command. 
    1818 * </p> 
    1919 *  
    2020 * @author Steffen Herbold 
     21 * @version 1.0 
    2122 */ 
    2223public class CMDexec implements Command { 
    2324 
    24         /** 
    25          * <p> 
    26          * Executes a batch of {@link Command}s that are listed line by line in the 
    27          * given file. 
    28          * </p> 
    29          * <p> 
    30          * Usage: <code>exec filename</code> 
    31          * </p> 
     25        /* 
     26         * (non-Javadoc) 
    3227         *  
    33          * @see de.ugoe.cs.util.console.commands.Command#run(java.util.List) 
     28         * @see de.ugoe.cs.util.console.Command#run(java.util.List) 
    3429         */ 
    3530        public void run(List<Object> parameters) { 

  • trunk/JavaHelperLib/src/de/ugoe/cs/util/console/defaultcommands/CMDexit.java

    r1 r175  
    88/** 
    99 * <p> 
    10  * Implements a command to terminate an application. 
     10 * Command to terminate an application. 
    1111 * </p> 
    1212 *  
    1313 * @author Steffen Herbold 
    14  * 
     14 * @version 1.0 
    1515 */ 
    1616public class CMDexit implements Command { 
    1717 
    18         /* (non-Javadoc) 
     18        /* 
     19         * (non-Javadoc) 
     20         *  
    1921         * @see databasebuilder.console.commands.Command#help() 
    2022         */ 
    … …  
    2325                Console.println("Usage: exit"); 
    2426        } 
    25          
    26         /** 
    27          * <p> 
    28          * Terminates the programm. 
    29          * </p> 
    30          * <p> 
    31          * Usage: <code>exit</code> 
    32          * </p> 
     27 
     28        /* 
     29         * (non-Javadoc) 
     30         *  
     31         * @see de.ugoe.cs.util.console.Command#run(java.util.List) 
    3332         */ 
    3433        @Override 
Note: See TracChangeset for help on using the changeset viewer.