1  /*
  2   * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//httpclient/src/java/org/apache/commons/httpclient/HttpConstants.java,v 1.15 2004/04/18 23:51:35 jsdever Exp $
  3   * $Revision: 480424 $
  4   * $Date: 2006-11-29 06:56:49 +0100 (Wed, 29 Nov 2006) $
  5   *
  6   * ====================================================================
  7   *
  8   *  Licensed to the Apache Software Foundation (ASF) under one or more
  9   *  contributor license agreements.  See the NOTICE file distributed with
 10   *  this work for additional information regarding copyright ownership.
 11   *  The ASF licenses this file to You under the Apache License, Version 2.0
 12   *  (the "License"); you may not use this file except in compliance with
 13   *  the License.  You may obtain a copy of the License at
 14   *
 15   *      http://www.apache.org/licenses/LICENSE-2.0
 16   *
 17   *  Unless required by applicable law or agreed to in writing, software
 18   *  distributed under the License is distributed on an "AS IS" BASIS,
 19   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 20   *  See the License for the specific language governing permissions and
 21   *  limitations under the License.
 22   * ====================================================================
 23   *
 24   * This software consists of voluntary contributions made by many
 25   * individuals on behalf of the Apache Software Foundation.  For more
 26   * information on the Apache Software Foundation, please see
 27   * <http://www.apache.org/>.
 28   *
 29   */
 30  
 31  package org.apache.commons.httpclient;
 32  
 33  import java.io.UnsupportedEncodingException;
 34  
 35  import org.apache.commons.logging.Log;
 36  import org.apache.commons.logging.LogFactory;
 37  
 38  
 39  /**
 40   * HTTP content conversion routines.
 41   *
 42   * @author Oleg Kalnichevski
 43   * @author <a href="mailto:mbowler@GargoyleSoftware.com">Mike Bowler</a>
 44   * 
 45   * @deprecated use EncodingUtil class
 46   */
 47  public class HttpConstants {
 48  
 49      /** Character set used to encode HTTP protocol elements */
 50      public static final String HTTP_ELEMENT_CHARSET = "US-ASCII";
 51  
 52      /** Default content encoding chatset */
 53      public static final String DEFAULT_CONTENT_CHARSET = "ISO-8859-1";
 54  
 55      /** Log object for this class. */
 56      private static final Log LOG = LogFactory.getLog(HttpConstants.class);
 57  
 58      /**
 59       * Converts the specified string to a byte array of HTTP element characters.
 60       * This method is to be used when encoding content of HTTP elements (such as
 61       * request headers)
 62       *
 63       * @param data the string to be encoded
 64       * @return The resulting byte array.
 65       */
 66      public static byte[] getBytes(final String data) {
 67          if (data == null) {
 68              throw new IllegalArgumentException("Parameter may not be null");
 69          }
 70  
 71          try {
 72              return data.getBytes(HTTP_ELEMENT_CHARSET);
 73          } catch (UnsupportedEncodingException e) {
 74  
 75              if (LOG.isWarnEnabled()) {
 76                  LOG.warn("Unsupported encoding: " 
 77                      + HTTP_ELEMENT_CHARSET 
 78                      + ". System default encoding used");
 79              }
 80  
 81              return data.getBytes();
 82          }
 83      }
 84  
 85      /**
 86       * Converts the byte array of HTTP element characters to a string This
 87       * method is to be used when decoding content of HTTP elements (such as
 88       * response headers)
 89       *
 90       * @param data the byte array to be encoded
 91       * @param offset the index of the first byte to encode
 92       * @param length the number of bytes to encode 
 93       * @return The resulting string.
 94       */
 95      public static String getString(final byte[] data, int offset, int length) {
 96  
 97          if (data == null) {
 98              throw new IllegalArgumentException("Parameter may not be null");
 99          }
100  
101          try {
102              return new String(data, offset, length, HTTP_ELEMENT_CHARSET);
103          } catch (UnsupportedEncodingException e) {
104  
105              if (LOG.isWarnEnabled()) {
106                  LOG.warn("Unsupported encoding: " 
107                      + HTTP_ELEMENT_CHARSET 
108                      + ". System default encoding used");
109              }
110  
111              return new String(data, offset, length);
112          }
113      }
114  
115      /**
116       * Converts the byte array of HTTP element characters to a string This
117       * method is to be used when decoding content of HTTP elements (such as
118       * response headers)
119       *
120       * @param data the byte array to be encoded
121       * @return The resulting string.
122       */
123      public static String getString(final byte[] data) {
124          return getString(data, 0, data.length);
125      }
126  
127      /**
128       * Converts the specified string to a byte array of HTTP content charachetrs
129       * This method is to be used when encoding content of HTTP request/response
130       * If the specified charset is not supported, default HTTP content encoding
131       * (ISO-8859-1) is applied
132       *
133       * @param data the string to be encoded
134       * @param charset the desired character encoding
135       * @return The resulting byte array.
136       */
137      public static byte[] getContentBytes(final String data, String charset) {
138  
139          if (data == null) {
140              throw new IllegalArgumentException("Parameter may not be null");
141          }
142  
143          if ((charset == null) || (charset.equals(""))) {
144              charset = DEFAULT_CONTENT_CHARSET;
145          }
146  
147          try {
148              return data.getBytes(charset);
149          } catch (UnsupportedEncodingException e) {
150  
151              if (LOG.isWarnEnabled()) {
152                  LOG.warn("Unsupported encoding: " 
153                      + charset 
154                      + ". HTTP default encoding used");
155              }
156  
157              try {
158                  return data.getBytes(DEFAULT_CONTENT_CHARSET);
159              } catch (UnsupportedEncodingException e2) {
160  
161                  if (LOG.isWarnEnabled()) {
162                      LOG.warn("Unsupported encoding: " 
163                          + DEFAULT_CONTENT_CHARSET 
164                          + ". System encoding used");
165                  }
166  
167                  return data.getBytes();
168              }
169          }
170      }
171  
172      /**
173       * Converts the byte array of HTTP content characters to a string This
174       * method is to be used when decoding content of HTTP request/response If
175       * the specified charset is not supported, default HTTP content encoding
176       * (ISO-8859-1) is applied
177       *
178       * @param data the byte array to be encoded
179       * @param offset the index of the first byte to encode
180       * @param length the number of bytes to encode 
181       * @param charset the desired character encoding
182       * @return The result of the conversion.
183       */
184      public static String getContentString(
185          final byte[] data, 
186          int offset, 
187          int length, 
188          String charset
189      ) {
190  
191          if (data == null) {
192              throw new IllegalArgumentException("Parameter may not be null");
193          }
194  
195          if ((charset == null) || (charset.equals(""))) {
196              charset = DEFAULT_CONTENT_CHARSET;
197          }
198  
199          try {
200              return new String(data, offset, length, charset);
201          } catch (UnsupportedEncodingException e) {
202  
203              if (LOG.isWarnEnabled()) {
204                  LOG.warn("Unsupported encoding: " + charset + ". Default HTTP encoding used");
205              }
206  
207              try {
208                  return new String(data, offset, length, DEFAULT_CONTENT_CHARSET);
209              } catch (UnsupportedEncodingException e2) {
210  
211                  if (LOG.isWarnEnabled()) {
212                      LOG.warn("Unsupported encoding: " 
213                          + DEFAULT_CONTENT_CHARSET 
214                          + ". System encoding used");
215                  }
216  
217                  return new String(data, offset, length);
218              }
219          }
220      }
221  
222  
223      /**
224       * Converts the byte array of HTTP content characters to a string This
225       * method is to be used when decoding content of HTTP request/response If
226       * the specified charset is not supported, default HTTP content encoding
227       * (ISO-8859-1) is applied
228       *
229       * @param data the byte array to be encoded
230       * @param charset the desired character encoding
231       * @return The result of the conversion.
232       */
233      public static String getContentString(final byte[] data, String charset) {
234          return getContentString(data, 0, data.length, charset);
235      }
236  
237      /**
238       * Converts the specified string to a byte array of HTTP content characters
239       * using default HTTP content encoding (ISO-8859-1) This method is to be
240       * used when encoding content of HTTP request/response
241       *
242       * @param data the string to be encoded
243       * @return The byte array as above.
244       */
245      public static byte[] getContentBytes(final String data) {
246          return getContentBytes(data, null);
247      }
248  
249      /**
250       * Converts the byte array of HTTP content characters to a string using
251       * default HTTP content encoding (ISO-8859-1) This method is to be used when
252       * decoding content of HTTP request/response
253       *
254       * @param data the byte array to be encoded
255       * @param offset the index of the first byte to encode
256       * @param length the number of bytes to encode 
257       * @return The string representation of the byte array.
258       */
259      public static String getContentString(final byte[] data, int offset, int length) {
260          return getContentString(data, offset, length, null);
261      }
262  
263      /**
264       * Converts the byte array of HTTP content characters to a string using
265       * default HTTP content encoding (ISO-8859-1) This method is to be used when
266       * decoding content of HTTP request/response
267       *
268       * @param data the byte array to be encoded
269       * @return The string representation of the byte array.
270       */
271      public static String getContentString(final byte[] data) {
272          return getContentString(data, null);
273      }
274  
275      /**
276       * Converts the specified string to byte array of ASCII characters.
277       *
278       * @param data the string to be encoded
279       * @return The string as a byte array.
280       */
281      public static byte[] getAsciiBytes(final String data) {
282  
283          if (data == null) {
284              throw new IllegalArgumentException("Parameter may not be null");
285          }
286  
287          try {
288              return data.getBytes("US-ASCII");
289          } catch (UnsupportedEncodingException e) {
290              throw new RuntimeException("HttpClient requires ASCII support");
291          }
292      }
293  
294      /**
295       * Converts the byte array of ASCII characters to a string. This method is
296       * to be used when decoding content of HTTP elements (such as response
297       * headers)
298       *
299       * @param data the byte array to be encoded
300       * @param offset the index of the first byte to encode
301       * @param length the number of bytes to encode 
302       * @return The string representation of the byte array
303       */
304      public static String getAsciiString(final byte[] data, int offset, int length) {
305  
306          if (data == null) {
307              throw new IllegalArgumentException("Parameter may not be null");
308          }
309  
310          try {
311              return new String(data, offset, length, "US-ASCII");
312          } catch (UnsupportedEncodingException e) {
313              throw new RuntimeException("HttpClient requires ASCII support");
314          }
315      }
316  
317      /**
318       * Converts the byte array of ASCII characters to a string. This method is
319       * to be used when decoding content of HTTP elements (such as response
320       * headers)
321       *
322       * @param data the byte array to be encoded
323       * @return The string representation of the byte array
324       */
325      public static String getAsciiString(final byte[] data) {
326          return getAsciiString(data, 0, data.length);
327      }
328  }