EMMA Coverage Report (generated Wed Jun 28 22:15:27 PDT 2006)
[all classes][org.apache.derby.iapi.util]

COVERAGE SUMMARY FOR SOURCE FILE [StringUtil.java]

nameclass, %method, %block, %line, %
StringUtil.java100% (1/1)85%  (11/13)92%  (410/444)88%  (67/76)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class StringUtil100% (1/1)85%  (11/13)92%  (410/444)88%  (67/76)
<static initializer> 100% (1/1)100% (68/68)100% (1/1)
SQLEqualsIgnoreCase (String, String): boolean 100% (1/1)83%  (10/12)67%  (2/3)
SQLToLowerCase (String): String 100% (1/1)100% (4/4)100% (1/1)
SQLToUpperCase (String): String 100% (1/1)100% (4/4)100% (1/1)
StringUtil (): void 0%   (0/1)0%   (0/3)0%   (0/1)
formatForPrint (String): String 100% (1/1)100% (21/21)100% (5/5)
fromHexString (String, int, int): byte [] 100% (1/1)100% (62/62)100% (12/12)
getAsciiBytes (String): byte [] 100% (1/1)100% (26/26)100% (5/5)
hexDump (byte []): String 100% (1/1)100% (138/138)100% (24/24)
toHexString (byte [], int, int): String 100% (1/1)100% (47/47)100% (8/8)
toStringArray (Object []): String [] 0%   (0/1)0%   (0/22)0%   (0/5)
trimTrailing (String): String 100% (1/1)92%  (22/24)86%  (6/7)
truncate (String, int): String 100% (1/1)62%  (8/13)67%  (2/3)

1/*
2 
3   Derby - Class com.ihost.cs.StringUtil
4 
5   Copyright 1999, 2004 The Apache Software Foundation or its licensors, as applicable.
6 
7   Licensed under the Apache License, Version 2.0 (the "License");
8   you may not use this file except in compliance with the License.
9   You may obtain a copy of the License at
10 
11      http://www.apache.org/licenses/LICENSE-2.0
12 
13   Unless required by applicable law or agreed to in writing, software
14   distributed under the License is distributed on an "AS IS" BASIS,
15   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16   See the License for the specific language governing permissions and
17   limitations under the License.
18 
19 */
20 
21package org.apache.derby.iapi.util;
22import java.util.Locale;
23 
24/**
25        A set of public static methods for dealing with Strings
26*/
27public class StringUtil 
28{
29        /**
30         * Used to print out a string for error messages, 
31         * chops is off at 60 chars for historical reasons.
32         */
33        public final static String formatForPrint(String input)
34        {
35                if (input.length() > 60)
36                {
37                        StringBuffer tmp = new StringBuffer(input.substring(0, 60));
38                        tmp.append("&");
39                        input = tmp.toString();
40                }
41                return input;
42        }
43 
44        /**
45         * A method that receive an array of Objects and return a 
46         * String array representation of that array.
47         */
48        public static String [] toStringArray(Object [] objArray) {
49                int idx;
50                int len=objArray.length;
51                String [] strArray=new String[len];
52 
53                for (idx=0 ; idx<len ; idx++) {
54                        strArray[idx]=objArray[idx].toString();
55                }
56 
57                return strArray;
58        }
59 
60        /**
61                Get 7-bit ASCII character array from input String.
62                The lower 7 bits of each character in the input string is assumed to be
63                the ASCII character value.
64 
65     Hexadecimal - Character
66 
67     | 00 NUL| 01 SOH| 02 STX| 03 ETX| 04 EOT| 05 ENQ| 06 ACK| 07 BEL|
68     | 08 BS | 09 HT | 0A NL | 0B VT | 0C NP | 0D CR | 0E SO | 0F SI |
69     | 10 DLE| 11 DC1| 12 DC2| 13 DC3| 14 DC4| 15 NAK| 16 SYN| 17 ETB|
70     | 18 CAN| 19 EM | 1A SUB| 1B ESC| 1C FS | 1D GS | 1E RS | 1F US |
71     | 20 SP | 21  ! | 22  " | 23  # | 24  $ | 25  % | 26  & | 27  ' |
72     | 28  ( | 29  ) | 2A  * | 2B  + | 2C  , | 2D  - | 2E  . | 2F  / |
73     | 30  0 | 31  1 | 32  2 | 33  3 | 34  4 | 35  5 | 36  6 | 37  7 |
74     | 38  8 | 39  9 | 3A  : | 3B  ; | 3C  < | 3D  = | 3E  > | 3F  ? |
75     | 40  @ | 41  A | 42  B | 43  C | 44  D | 45  E | 46  F | 47  G |
76     | 48  H | 49  I | 4A  J | 4B  K | 4C  L | 4D  M | 4E  N | 4F  O |
77     | 50  P | 51  Q | 52  R | 53  S | 54  T | 55  U | 56  V | 57  W |
78     | 58  X | 59  Y | 5A  Z | 5B  [ | 5C  \ | 5D  ] | 5E  ^ | 5F  _ |
79     | 60  ` | 61  a | 62  b | 63  c | 64  d | 65  e | 66  f | 67  g |
80     | 68  h | 69  i | 6A  j | 6B  k | 6C  l | 6D  m | 6E  n | 6F  o |
81     | 70  p | 71  q | 72  r | 73  s | 74  t | 75  u | 76  v | 77  w |
82     | 78  x | 79  y | 7A  z | 7B  { | 7C  | | 7D  } | 7E  ~ | 7F DEL|
83 
84         */
85        public static byte[] getAsciiBytes(String input)
86        {
87                char[] c = input.toCharArray();
88                byte[] b = new byte[c.length];
89                for (int i = 0; i < c.length; i++)
90                        b[i] = (byte)(c[i] & 0x007F);
91 
92                return b;
93        }
94 
95    /**
96     * Trim off trailing blanks but not leading blanks
97     *
98     * @param str
99     *
100     * @return The input with trailing blanks stipped off
101     */
102    public static String trimTrailing( String str)
103    {
104        if( str == null)
105            return null;
106        int len = str.length();
107        for( ; len > 0; len--)
108        {
109            if( ! Character.isWhitespace( str.charAt( len - 1)))
110                break;
111        }
112        return str.substring( 0, len);
113    } // end of trimTrailing
114 
115 
116        /**
117                Truncate a String to the given length with no warnings
118                or error raised if it is bigger.
119        
120                @param        value String to be truncated
121                @param        length        Maximum length of string
122 
123                @return Returns value if value is null or value.length() is less or equal to than length, otherwise a String representing
124                        value truncated to length.
125        */
126        public static String truncate(String value, int length)
127        {
128                if (value != null && value.length() > length)
129                        value = value.substring(0, length);
130                return value;
131        }
132        
133        /**
134         * Return a slice (substring) of the passed in value, optionally trimmed.
135         * WARNING - endOffset is inclusive for historical reasons, unlike
136         * String.substring() which has an exclusive ending offset.
137         * @param value Value to slice, must be non-null.
138         * @param beginOffset Inclusive start character
139         * @param endOffset Inclusive end character
140         * @param trim To trim or not to trim
141         * @return Sliceed value.
142         */
143        public static String slice(String value,
144                        int beginOffset, int endOffset,
145                        boolean trim)
146        {
147                String retval = value.substring(beginOffset, endOffset + 1);
148                
149                if (trim)
150                        retval = retval.trim();
151                
152                return retval;
153        }
154 
155 
156        private static char[] hex_table = {
157                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
158                'a', 'b', 'c', 'd', 'e', 'f'
159            };
160 
161 
162        /**
163                Convert a byte array to a String with a hexidecimal format.
164                The String may be converted back to a byte array using fromHexString.
165                <BR>
166                For each byte (b) two characaters are generated, the first character
167                represents the high nibble (4 bits) in hexidecimal (<code>b & 0xf0</code>), the second character
168                represents the low nibble (<code>b & 0x0f</code>).
169                <BR>
170                The byte at <code>data[offset]</code> is represented by the first two characters in the returned String.
171 
172                @param        data        byte array
173                @param        offset        starting byte (zero based) to convert.
174                @param        length        number of bytes to convert.
175 
176                @return the String (with hexidecimal format) form of the byte array
177        */
178        public static String toHexString(byte[] data, int offset, int length)
179        {
180                StringBuffer s = new StringBuffer(length*2);
181                int end = offset+length;
182 
183                for (int i = offset; i < end; i++)
184                {
185                        int high_nibble = (data[i] & 0xf0) >>> 4;
186                        int low_nibble = (data[i] & 0x0f);
187                        s.append(hex_table[high_nibble]);
188                        s.append(hex_table[low_nibble]);
189                }
190 
191                return s.toString();
192        }
193                
194        /**
195                Convert a hexidecimal string generated by toHexString() back
196                into a byte array.
197 
198                @param s String to convert
199                @param offset starting character (zero based) to convert.
200                @param length number of characters to convert.
201 
202                @return the converted byte array. Returns null if the length is
203                not a multiple of 2.
204        */
205        public static byte[] fromHexString(String s, int offset, int length)
206        {
207                if ((length%2) != 0)
208                        return null;
209 
210                byte[] byteArray = new byte[length/2];
211 
212                int j = 0;
213                int end = offset+length;
214                for (int i = offset; i < end; i += 2)
215                {
216                        int high_nibble = Character.digit(s.charAt(i), 16);
217                        int low_nibble = Character.digit(s.charAt(i+1), 16);
218 
219                        if (high_nibble == -1 || low_nibble == -1)
220                        {
221                                // illegal format
222                                return null;
223                        }
224 
225                        byteArray[j++] = (byte)(((high_nibble << 4) & 0xf0) | (low_nibble & 0x0f));
226                }
227                return byteArray;
228        }
229        /**
230                Convert a byte array to a human-readable String for debugging purposes.
231        */
232        public static String hexDump(byte[] data)
233        {
234            byte byte_value;
235 
236 
237            StringBuffer str = new StringBuffer(data.length * 3);
238 
239            str.append("Hex dump:\n");
240 
241            for (int i = 0; i < data.length; i += 16)
242            {
243                // dump the header: 00000000: 
244                String offset = Integer.toHexString(i);
245 
246                // "0" left pad offset field so it is always 8 char's long.
247                for (int offlen = offset.length(); offlen < 8; offlen++) 
248                    str.append("0");
249                str.append(offset);
250                str.append(":");
251 
252                // dump hex version of 16 bytes per line.
253                for (int j = 0; (j < 16) && ((i + j) < data.length); j++)
254                {
255                    byte_value = data[i + j];
256 
257                    // add spaces between every 2 bytes.
258                    if ((j % 2) == 0)
259                        str.append(" ");
260 
261                    // dump a single byte.
262                    byte high_nibble = (byte) ((byte_value & 0xf0) >>> 4); 
263                    byte low_nibble  = (byte) (byte_value & 0x0f); 
264 
265                    str.append(hex_table[high_nibble]);
266                    str.append(hex_table[low_nibble]);
267                }
268 
269                // dump ascii version of 16 bytes
270                str.append("  ");
271 
272                for (int j = 0; (j < 16) && ((i + j) < data.length); j++)
273                {
274                    char char_value = (char) data[i + j]; 
275 
276                    // RESOLVE (really want isAscii() or isPrintable())
277                    if (Character.isLetterOrDigit(char_value))
278                        str.append(String.valueOf(char_value));
279                    else
280                        str.append(".");
281                }
282                    
283                // new line
284                str.append("\n");
285            }
286            return(str.toString());
287 
288        }
289 
290        // The functions below are used for uppercasing SQL in a consistent manner.
291        // Cloudscape will uppercase Turkish to the English locale to avoid i
292        // uppercasing to an uppercase dotted i. In future versions, all 
293        // casing will be done in English.   The result will be that we will get
294        // only the 1:1 mappings  in 
295        // http://www.unicode.org/Public/3.0-Update1/UnicodeData-3.0.1.txt
296        // and avoid the 1:n mappings in 
297        //http://www.unicode.org/Public/3.0-Update1/SpecialCasing-3.txt
298        // 
299        // Any SQL casing should use these functions
300 
301 
302        /** Convert string to uppercase
303         * Always use the java.util.ENGLISH locale
304         * @param s   string to uppercase
305         * @return uppercased string
306         */
307        public static String SQLToUpperCase(String s)
308        {
309                        return s.toUpperCase(Locale.ENGLISH);
310        }
311 
312 
313        /** Convert string to lowercase
314         *  Return java.util.Locale.ENGLISH lowercasing
315         * @param s string to lowercase
316         * @return lowercased string
317         */
318        public static String SQLToLowerCase(String s)
319        {
320                return s.toLowerCase(Locale.ENGLISH);
321 
322        }
323 
324 
325        /** Compares two strings 
326         * Strings will be uppercased in english and compared
327         * equivalent to s1.equalsIgnoreCase(s2)
328         * throws NPE if s1 is null
329         *
330         * @param s1  first string to compare
331         * @param s2  second string to compare
332         *
333         * @return   true if the two upppercased ENGLISH values are equal
334         *           return false if s2 is null
335         */
336        public static boolean SQLEqualsIgnoreCase(String s1, String s2)
337        {
338                if (s2 == null)
339                        return  false;
340                else
341                        return s1.toUpperCase(Locale.ENGLISH).equals(s2.toUpperCase(Locale.ENGLISH));
342 
343        }
344 
345}
346 

[all classes][org.apache.derby.iapi.util]
EMMA 2.0.5312 (C) Vladimir Roubtsov