001 /****************************************************************
002 * Licensed to the Apache Software Foundation (ASF) under one *
003 * or more contributor license agreements. See the NOTICE file *
004 * distributed with this work for additional information *
005 * regarding copyright ownership. The ASF licenses this file *
006 * to you under the Apache License, Version 2.0 (the *
007 * "License"); you may not use this file except in compliance *
008 * with the License. You may obtain a copy of the License at *
009 * *
010 * http://www.apache.org/licenses/LICENSE-2.0 *
011 * *
012 * Unless required by applicable law or agreed to in writing, *
013 * software distributed under the License is distributed on an *
014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
015 * KIND, either express or implied. See the License for the *
016 * specific language governing permissions and limitations *
017 * under the License. *
018 ****************************************************************/
019
020 package org.apache.james.mime4j.util;
021
022 import java.nio.ByteBuffer;
023 import java.nio.CharBuffer;
024 import java.nio.charset.Charset;
025
026 /**
027 * Utility methods for converting textual content of a message.
028 */
029 public class ContentUtil {
030
031 private ContentUtil() {
032 }
033
034 /**
035 * Encodes the specified string into an immutable sequence of bytes using
036 * the US-ASCII charset.
037 *
038 * @param string
039 * string to encode.
040 * @return encoded string as an immutable sequence of bytes.
041 */
042 public static ByteSequence encode(String string) {
043 if (string == null) {
044 return null;
045 }
046 ByteArrayBuffer buf = new ByteArrayBuffer(string.length());
047 for (int i = 0; i < string.length(); i++) {
048 buf.append((byte) string.charAt(i));
049 }
050 return buf;
051 }
052
053 /**
054 * Encodes the specified string into an immutable sequence of bytes using
055 * the specified charset.
056 *
057 * @param charset
058 * Java charset to be used for the conversion.
059 * @param string
060 * string to encode.
061 * @return encoded string as an immutable sequence of bytes.
062 */
063 public static ByteSequence encode(Charset charset, String string) {
064 if (string == null) {
065 return null;
066 }
067 if (charset == null) {
068 charset = Charset.defaultCharset();
069 }
070 ByteBuffer encoded = charset.encode(CharBuffer.wrap(string));
071 ByteArrayBuffer buf = new ByteArrayBuffer(encoded.remaining());
072 buf.append(encoded.array(), encoded.position(), encoded.remaining());
073 return buf;
074 }
075
076 /**
077 * Decodes the specified sequence of bytes into a string using the US-ASCII
078 * charset.
079 *
080 * @param byteSequence
081 * sequence of bytes to decode.
082 * @return decoded string.
083 */
084 public static String decode(ByteSequence byteSequence) {
085 if (byteSequence == null) {
086 return null;
087 }
088 return decode(byteSequence, 0, byteSequence.length());
089 }
090
091 /**
092 * Decodes the specified sequence of bytes into a string using the specified
093 * charset.
094 *
095 * @param charset
096 * Java charset to be used for the conversion.
097 * @param byteSequence
098 * sequence of bytes to decode.
099 * @return decoded string.
100 */
101 public static String decode(Charset charset, ByteSequence byteSequence) {
102 return decode(charset, byteSequence, 0, byteSequence.length());
103 }
104
105 /**
106 * Decodes a sub-sequence of the specified sequence of bytes into a string
107 * using the US-ASCII charset.
108 *
109 * @param byteSequence
110 * sequence of bytes to decode.
111 * @param offset
112 * offset into the byte sequence.
113 * @param length
114 * number of bytes.
115 * @return decoded string.
116 */
117 public static String decode(ByteSequence byteSequence, int offset, int length) {
118 if (byteSequence == null) {
119 return null;
120 }
121 StringBuilder buf = new StringBuilder(length);
122 for (int i = offset; i < offset + length; i++) {
123 buf.append((char) (byteSequence.byteAt(i) & 0xff));
124 }
125 return buf.toString();
126 }
127
128 /**
129 * Decodes a sub-sequence of the specified sequence of bytes into a string
130 * using the specified charset.
131 *
132 * @param charset
133 * Java charset to be used for the conversion.
134 * @param byteSequence
135 * sequence of bytes to decode.
136 * @param offset
137 * offset into the byte sequence.
138 * @param length
139 * number of bytes.
140 * @return decoded string.
141 */
142 public static String decode(Charset charset, ByteSequence byteSequence,
143 int offset, int length) {
144 if (byteSequence == null) {
145 return null;
146 }
147 if (charset == null) {
148 charset = Charset.defaultCharset();
149 }
150 if (byteSequence instanceof ByteArrayBuffer) {
151 ByteArrayBuffer bab = (ByteArrayBuffer) byteSequence;
152 return decode(charset, bab.buffer(), offset, length);
153 } else {
154 byte[] bytes = byteSequence.toByteArray();
155 return decode(charset, bytes, offset, length);
156 }
157 }
158
159 private static String decode(Charset charset, byte[] buffer, int offset,
160 int length) {
161 return charset.decode(ByteBuffer.wrap(buffer, offset, length))
162 .toString();
163 }
164
165 }