KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > tomcat > util > buf > Ascii


1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements. See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License. You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 package org.apache.tomcat.util.buf;
19
20 /**
21  * This class implements some basic ASCII character handling functions.
22  *
23  * @author dac@eng.sun.com
24  * @author James Todd [gonzo@eng.sun.com]
25  */
26 public final class Ascii {
27     /*
28      * Character translation tables.
29      */
30
31     private static final byte[] toUpper = new byte[256];
32     private static final byte[] toLower = new byte[256];
33
34     /*
35      * Character type tables.
36      */
37
38     private static final boolean[] isAlpha = new boolean[256];
39     private static final boolean[] isUpper = new boolean[256];
40     private static final boolean[] isLower = new boolean[256];
41     private static final boolean[] isWhite = new boolean[256];
42     private static final boolean[] isDigit = new boolean[256];
43
44     /*
45      * Initialize character translation and type tables.
46      */
47
48     static {
49         for (int i = 0; i < 256; i++) {
50             toUpper[i] = (byte)i;
51             toLower[i] = (byte)i;
52         }
53
54         for (int lc = 'a'; lc <= 'z'; lc++) {
55             int uc = lc + 'A' - 'a';
56
57             toUpper[lc] = (byte)uc;
58             toLower[uc] = (byte)lc;
59             isAlpha[lc] = true;
60             isAlpha[uc] = true;
61             isLower[lc] = true;
62             isUpper[uc] = true;
63         }
64
65         isWhite[ ' '] = true;
66         isWhite['\t'] = true;
67         isWhite['\r'] = true;
68         isWhite['\n'] = true;
69         isWhite['\f'] = true;
70         isWhite['\b'] = true;
71
72         for (int d = '0'; d <= '9'; d++) {
73             isDigit[d] = true;
74         }
75     }
76
77     /**
78      * Returns the upper case equivalent of the specified ASCII character.
79      */
80
81     public static int toUpper(int c) {
82         return toUpper[c & 0xff] & 0xff;
83     }
84
85     /**
86      * Returns the lower case equivalent of the specified ASCII character.
87      */
88
89     public static int toLower(int c) {
90         return toLower[c & 0xff] & 0xff;
91     }
92
93     /**
94      * Returns true if the specified ASCII character is upper or lower case.
95      */
96
97     public static boolean isAlpha(int c) {
98         return isAlpha[c & 0xff];
99     }
100
101     /**
102      * Returns true if the specified ASCII character is upper case.
103      */
104
105     public static boolean isUpper(int c) {
106         return isUpper[c & 0xff];
107     }
108
109     /**
110      * Returns true if the specified ASCII character is lower case.
111      */
112
113     public static boolean isLower(int c) {
114         return isLower[c & 0xff];
115     }
116
117     /**
118      * Returns true if the specified ASCII character is white space.
119      */
120
121     public static boolean isWhite(int c) {
122         return isWhite[c & 0xff];
123     }
124
125     /**
126      * Returns true if the specified ASCII character is a digit.
127      */
128
129     public static boolean isDigit(int c) {
130         return isDigit[c & 0xff];
131     }
132
133     /**
134      * Parses an unsigned integer from the specified subarray of bytes.
135      * @param b the bytes to parse
136      * @param off the start offset of the bytes
137      * @param len the length of the bytes
138      * @exception NumberFormatException if the integer format was invalid
139      */
140     public static int parseInt(byte[] b, int off, int len)
141         throws NumberFormatException JavaDoc
142     {
143         int c;
144
145         if (b == null || len <= 0 || !isDigit(c = b[off++])) {
146             throw new NumberFormatException JavaDoc();
147         }
148
149         int n = c - '0';
150
151         while (--len > 0) {
152             if (!isDigit(c = b[off++])) {
153                 throw new NumberFormatException JavaDoc();
154             }
155             n = n * 10 + c - '0';
156         }
157
158         return n;
159     }
160
161     public static int parseInt(char[] b, int off, int len)
162         throws NumberFormatException JavaDoc
163     {
164         int c;
165
166         if (b == null || len <= 0 || !isDigit(c = b[off++])) {
167             throw new NumberFormatException JavaDoc();
168         }
169
170         int n = c - '0';
171
172         while (--len > 0) {
173             if (!isDigit(c = b[off++])) {
174                 throw new NumberFormatException JavaDoc();
175             }
176             n = n * 10 + c - '0';
177         }
178
179         return n;
180     }
181
182     /**
183      * Parses an unsigned long from the specified subarray of bytes.
184      * @param b the bytes to parse
185      * @param off the start offset of the bytes
186      * @param len the length of the bytes
187      * @exception NumberFormatException if the long format was invalid
188      */
189     public static long parseLong(byte[] b, int off, int len)
190         throws NumberFormatException JavaDoc
191     {
192         int c;
193
194         if (b == null || len <= 0 || !isDigit(c = b[off++])) {
195             throw new NumberFormatException JavaDoc();
196         }
197
198         long n = c - '0';
199         long m;
200         
201         while (--len > 0) {
202             if (!isDigit(c = b[off++])) {
203                 throw new NumberFormatException JavaDoc();
204             }
205             m = n * 10 + c - '0';
206
207             if (m < n) {
208                 // Overflow
209 throw new NumberFormatException JavaDoc();
210             } else {
211                 n = m;
212             }
213         }
214
215         return n;
216     }
217
218     public static long parseLong(char[] b, int off, int len)
219         throws NumberFormatException JavaDoc
220     {
221         int c;
222
223         if (b == null || len <= 0 || !isDigit(c = b[off++])) {
224             throw new NumberFormatException JavaDoc();
225         }
226
227         long n = c - '0';
228         long m;
229
230         while (--len > 0) {
231             if (!isDigit(c = b[off++])) {
232                 throw new NumberFormatException JavaDoc();
233             }
234             m = n * 10 + c - '0';
235
236             if (m < n) {
237                 // Overflow
238 throw new NumberFormatException JavaDoc();
239             } else {
240                 n = m;
241             }
242         }
243
244         return n;
245     }
246
247 }
248
Popular Tags