001/* ***** BEGIN LICENSE BLOCK *****
002 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
003 *
004 * The contents of this file are subject to the Mozilla Public License Version
005 * 1.1 (the "License"); you may not use this file except in compliance with
006 * the License. You may obtain a copy of the License at
007 * http://www.mozilla.org/MPL/
008 *
009 * Software distributed under the License is distributed on an "AS IS" basis,
010 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
011 * for the specific language governing rights and limitations under the
012 * License.
013 *
014 * The Original Code is the reusable ccl java library
015 * (http://www.kclee.com/clemens/java/ccl/).
016 *
017 * The Initial Developer of the Original Code is
018 * Chr. Clemens Lee.
019 * Portions created by Chr. Clemens Lee are Copyright (C) 2002
020 * Chr. Clemens Lee. All Rights Reserved.
021 *
022 * Contributor(s): Chr. Clemens Lee <clemens@kclee.com>
023 *
024 * Alternatively, the contents of this file may be used under the terms of
025 * either the GNU General Public License Version 2 or later (the "GPL"), or
026 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
027 * in which case the provisions of the GPL or the LGPL are applicable instead
028 * of those above. If you wish to allow use of your version of this file only
029 * under the terms of either the GPL or the LGPL, and not to allow others to
030 * use your version of this file under the terms of the MPL, indicate your
031 * decision by deleting the provisions above and replace them with the notice
032 * and other provisions required by the GPL or the LGPL. If you do not delete
033 * the provisions above, a recipient may use your version of this file under
034 * the terms of any one of the MPL, the GPL or the LGPL.
035 *
036 * ***** END LICENSE BLOCK ***** */
037
038package net.sourceforge.cobertura.javancss.ccl;
039
040import java.util.Vector;
041
042/**
043 * A general purpose class with a variety of support and convenience methods.
044 *
045 * <p> There are different groups of methods in this class:
046 * <br>
047 * <br><a href="#print(char)">print methods</a> - convenience methods for System.out.print etc. that additionally make sure output is gets flushed immediately.
048 * <br><a href="#isEmpty(java.lang.String)">string methods</a>
049 * <br><a href="#concat(java.util.Vector)">string/vector converter methods</a>
050 * <br><a href="#getConstantObject()">miscellaneous methods</a>
051 * <p>
052 *
053 * Some basic but none the less the most used methods by myself are:<br>
054 * - {@link #isEmpty(java.lang.String) isEmpty}<br>
055 * - {@link #stringToLines(java.lang.String) stringToLines}<br>
056 * - {@link #sleep(int) sleep}<br>
057 * <p>
058 *
059 * @author <a href="http://www.kclee.com/clemens/">
060 *         Chr. Clemens Lee</a>
061 *         &lt;<a href="mailto:clemens@kclee.com">
062 *         clemens@kclee.com
063 *         </a>>
064 */
065
066
067
068/*
069 * cobertura - this file was moved from net.sourceforge.cobertura.javancss package.
070 * 
071 * Mark Doliner apparently got the source from somewhere, but it is not available now.
072 */
073
074public class Util
075{
076
077        public static final Object CONSTANT_OBJECT = new Object();
078
079        /**
080         * This is an utility class, there is (should be) no need
081         * for an instance of this class.
082         */
083        private Util()
084        {
085                super();
086        }
087        
088        // -----------------------------------------------------
089        // debug methods and assertion stuff
090        // -----------------------------------------------------
091/**
092         * panicIf <=> not assert. Throws ApplicationException if true.
093         * It's not necessary to catch this exception.
094         */
095        public static void panicIf(boolean bPanic_)
096        {
097                if (bPanic_)
098                {
099                        throw (new RuntimeException());
100                }
101        }
102
103        /**
104         * panicIf <=> not assert. Throws ApplicationException if true.
105         * It's not necessary to catch this exception.
106         *
107         * @param sMessage_ The error message for the Exception.
108         */
109        public static void panicIf(boolean bPanic_, String sMessage_)
110        {
111                if (bPanic_)
112                {
113                        throw (new RuntimeException(sMessage_));
114                }
115        }
116
117        /**
118         * Tests, if a given String equals null or "".
119         */
120        public static boolean isEmpty(String sTest_)
121        {
122                if (sTest_ == null || sTest_.equals(""))
123                {
124                        return true;
125                }
126
127                return false;
128        }
129
130        /**
131         * This function takes a String and separates it into different
132         * lines. The last line does not need to have a separator character.
133         *
134         * @param lines_   The number of lines that should be extracted.
135         *                 Zero if maximum number of lines is requested.
136         * @param cCutter_ The character that separates pString_ into
137         *                 different lines
138         *
139         * @return         The single lines do not contain the cCutter_
140         *                 character at the end.
141         */
142        private static Vector stringToLines(int lines_, String pString_, char cCutter_)
143        {
144                int maxLines = Integer.MAX_VALUE;
145                if (lines_ > 0)
146                {
147                        maxLines = lines_;
148                }
149
150                Vector vRetVal = new Vector();
151                if (pString_ == null)
152                {
153                        return vRetVal;
154                }
155
156                int startIndex = 0;
157                for (; maxLines > 0; maxLines--)
158                {
159                        int endIndex = pString_.indexOf(cCutter_, startIndex);
160                        if (endIndex == -1)
161                        {
162                                if (startIndex < pString_.length())
163                                {
164                                        endIndex = pString_.length();
165                                }
166                                else
167                                {
168                                        break;
169                                }
170                        }
171                        String sLine = pString_.substring(startIndex, endIndex);
172                        vRetVal.addElement(sLine);
173                        startIndex = endIndex + 1;
174                }
175
176                return vRetVal;
177        }
178
179        /**
180         * This function takes a String and separates it into different
181         * lines. The last line does not need to have a separator character.
182         *
183         * @param cCutter_ The character that separates pString_ into
184         *                 different lines
185         *
186         * @return The single lines do not contain the cCutter_ character
187         *         at the end.
188         */
189        public static Vector stringToLines(String pString_, char cCutter_)
190        {
191                return stringToLines(0, pString_, cCutter_);
192        }
193
194        /**
195         * This function takes a String and separates it into different
196         * lines. The last line does not need to have a '\n'. The function
197         * can't handle dos carriage returns.
198         *
199         * @return The single lines do not contain the '\n' character
200         *         at the end.
201         */
202        public static Vector stringToLines(String pString_)
203        {
204                return stringToLines(pString_, '\n');
205        }
206
207        /**
208         * Current thread sleeps in seconds.
209         */
210        private static void sleep(int seconds_)
211        {
212                try
213                {
214                        Thread.sleep(seconds_ * 1000);
215                }
216                catch (Exception pException)
217                {
218                }
219        }
220        
221        public static Vector concat(Vector vFirst_, Vector vSecond_)
222        {
223                //cobertura Mark Doliner appears to have simplified this.
224                vFirst_.addAll(vSecond_);
225                return vFirst_;
226        }
227
228
229        public static Vector<Object> sort(Vector<Object> input)
230        {
231                //cobertura - apparently Mark Doliner didn't think we need to sort.
232                return input;
233        }
234        
235        // cobertura - gotten from decompile of ccl.jar.
236    public static void debug(Object oMessage_)
237    {
238        if(_bDebug)
239            printlnErr(oMessage_.toString());
240    }
241
242        
243        public static Object getConstantObject()
244        {
245                return CONSTANT_OBJECT;
246        }
247        
248        // cobertura - gotten from decompile of ccl.jar.
249    public static void setDebug(boolean bDebug_)
250    {
251        _bDebug = bDebug_;
252    }
253
254    // cobertura = gotten from decompile of ccl.jar.
255    public static boolean isDebug()
256    {
257        return _bDebug;
258    }
259    
260    // cobertura = gotten from decompile of ccl.jar.
261    public static void println(String pString_)
262    {
263        System.out.println(pString_);
264        System.out.flush();
265    }
266
267    // cobertura = gotten from decompile of ccl.jar.
268    public static void printErr(char c_)
269    {
270        System.err.print(c_);
271        System.err.flush();
272    }
273
274    // cobertura = gotten from decompile of ccl.jar.
275    public static void printErr(String pString_)
276    {
277        System.err.print(pString_);
278        System.err.flush();
279    }
280
281    // cobertura = gotten from decompile of ccl.jar.
282    public static void printlnErr()
283    {
284        printErr('\n');
285    }
286
287    // cobertura = gotten from decompile of ccl.jar.
288    public static void printlnErr(String sMessage_)
289    {
290        printErr(sMessage_);
291        printlnErr();
292    }
293
294    // cobertura = gotten from decompile of ccl.jar.
295    private static boolean _bDebug = false;
296
297}