1/*
2 * $HeadURL: http://svn.apache.org/repos/asf/httpcomponents/httpcore/trunk/module-main/src/main/java/org/apache/http/util/CharArrayBuffer.java $
3 * $Revision: 496070 $
4 * $Date: 2007-01-14 04:18:34 -0800 (Sun, 14 Jan 2007) $
5 *
6 * ====================================================================
7 * Licensed to the Apache Software Foundation (ASF) under one
8 * or more contributor license agreements.  See the NOTICE file
9 * distributed with this work for additional information
10 * regarding copyright ownership.  The ASF licenses this file
11 * to you under the Apache License, Version 2.0 (the
12 * "License"); you may not use this file except in compliance
13 * with 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,
18 * software distributed under the License is distributed on an
19 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
20 * KIND, either express or implied.  See the License for the
21 * specific language governing permissions and limitations
22 * under the License.
23 * ====================================================================
24 *
25 * This software consists of voluntary contributions made by many
26 * individuals on behalf of the Apache Software Foundation.  For more
27 * information on the Apache Software Foundation, please see
28 * <http://www.apache.org/>.
29 *
30 */
31
32package org.apache.http.util;
33
34import org.apache.http.protocol.HTTP;
35
36/**
37 * A resizable char array.
38 *
39 * @author <a href="mailto:oleg at ural.ru">Oleg Kalnichevski</a>
40 *
41 * @version $Revision: 496070 $
42 *
43 * @since 4.0
44 *
45 * @deprecated Please use {@link java.net.URL#openConnection} instead.
46 *     Please visit <a href="http://android-developers.blogspot.com/2011/09/androids-http-clients.html">this webpage</a>
47 *     for further details.
48 */
49@Deprecated
50public final class CharArrayBuffer  {
51
52    private char[] buffer;
53    private int len;
54
55    public CharArrayBuffer(int capacity) {
56        super();
57        if (capacity < 0) {
58            throw new IllegalArgumentException("Buffer capacity may not be negative");
59        }
60        this.buffer = new char[capacity];
61    }
62
63    private void expand(int newlen) {
64        char newbuffer[] = new char[Math.max(this.buffer.length << 1, newlen)];
65        System.arraycopy(this.buffer, 0, newbuffer, 0, this.len);
66        this.buffer = newbuffer;
67    }
68
69    public void append(final char[] b, int off, int len) {
70        if (b == null) {
71            return;
72        }
73        if ((off < 0) || (off > b.length) || (len < 0) ||
74                ((off + len) < 0) || ((off + len) > b.length)) {
75            throw new IndexOutOfBoundsException();
76        }
77        if (len == 0) {
78            return;
79        }
80        int newlen = this.len + len;
81        if (newlen > this.buffer.length) {
82            expand(newlen);
83        }
84        System.arraycopy(b, off, this.buffer, this.len, len);
85        this.len = newlen;
86    }
87
88    public void append(String str) {
89        if (str == null) {
90            str = "null";
91        }
92        int strlen = str.length();
93        int newlen = this.len + strlen;
94        if (newlen > this.buffer.length) {
95            expand(newlen);
96        }
97        str.getChars(0, strlen, this.buffer, this.len);
98        this.len = newlen;
99    }
100
101    public void append(final CharArrayBuffer b, int off, int len) {
102        if (b == null) {
103            return;
104        }
105        append(b.buffer, off, len);
106    }
107
108    public void append(final CharArrayBuffer b) {
109        if (b == null) {
110            return;
111        }
112        append(b.buffer,0, b.len);
113    }
114
115    public void append(char ch) {
116        int newlen = this.len + 1;
117        if (newlen > this.buffer.length) {
118            expand(newlen);
119        }
120        this.buffer[this.len] = ch;
121        this.len = newlen;
122    }
123
124    public void append(final byte[] b, int off, int len) {
125        if (b == null) {
126            return;
127        }
128        if ((off < 0) || (off > b.length) || (len < 0) ||
129                ((off + len) < 0) || ((off + len) > b.length)) {
130            throw new IndexOutOfBoundsException();
131        }
132        if (len == 0) {
133            return;
134        }
135        int oldlen = this.len;
136        int newlen = oldlen + len;
137        if (newlen > this.buffer.length) {
138            expand(newlen);
139        }
140        for (int i1 = off, i2 = oldlen; i2 < newlen; i1++, i2++) {
141            int ch = b[i1];
142            if (ch < 0) {
143                ch = 256 + ch;
144            }
145            this.buffer[i2] = (char) ch;
146        }
147        this.len = newlen;
148    }
149
150    public void append(final ByteArrayBuffer b, int off, int len) {
151        if (b == null) {
152            return;
153        }
154        append(b.buffer(), off, len);
155    }
156
157    public void append(final Object obj) {
158        append(String.valueOf(obj));
159    }
160
161    public void clear() {
162        this.len = 0;
163    }
164
165    public char[] toCharArray() {
166        char[] b = new char[this.len];
167        if (this.len > 0) {
168            System.arraycopy(this.buffer, 0, b, 0, this.len);
169        }
170        return b;
171    }
172
173    public char charAt(int i) {
174        return this.buffer[i];
175    }
176
177    public char[] buffer() {
178        return this.buffer;
179    }
180
181    public int capacity() {
182        return this.buffer.length;
183    }
184
185    public int length() {
186        return this.len;
187    }
188
189    public void ensureCapacity(int required) {
190        int available = this.buffer.length - this.len;
191        if (required > available) {
192            expand(this.len + required);
193        }
194    }
195
196    public void setLength(int len) {
197        if (len < 0 || len > this.buffer.length) {
198            throw new IndexOutOfBoundsException();
199        }
200        this.len = len;
201    }
202
203    public boolean isEmpty() {
204        return this.len == 0;
205    }
206
207    public boolean isFull() {
208        return this.len == this.buffer.length;
209    }
210
211    public int indexOf(int ch, int beginIndex, int endIndex) {
212        if (beginIndex < 0) {
213            beginIndex = 0;
214        }
215        if (endIndex > this.len) {
216            endIndex = this.len;
217        }
218        if (beginIndex > endIndex) {
219            return -1;
220        }
221        for (int i = beginIndex; i < endIndex; i++) {
222            if (this.buffer[i] == ch) {
223                return i;
224            }
225        }
226        return -1;
227    }
228
229    public int indexOf(int ch) {
230        return indexOf(ch, 0, this.len);
231    }
232
233    public String substring(int beginIndex, int endIndex) {
234        if (beginIndex < 0) {
235            throw new IndexOutOfBoundsException();
236        }
237        if (endIndex > this.len) {
238            throw new IndexOutOfBoundsException();
239        }
240        if (beginIndex > endIndex) {
241            throw new IndexOutOfBoundsException();
242        }
243        return new String(this.buffer, beginIndex, endIndex - beginIndex);
244    }
245
246    public String substringTrimmed(int beginIndex, int endIndex) {
247        if (beginIndex < 0) {
248            throw new IndexOutOfBoundsException();
249        }
250        if (endIndex > this.len) {
251            throw new IndexOutOfBoundsException();
252        }
253        if (beginIndex > endIndex) {
254            throw new IndexOutOfBoundsException();
255        }
256        while (beginIndex < endIndex && HTTP.isWhitespace(this.buffer[beginIndex])) {
257            beginIndex++;
258        }
259        while (endIndex > beginIndex && HTTP.isWhitespace(this.buffer[endIndex - 1])) {
260            endIndex--;
261        }
262        return new String(this.buffer, beginIndex, endIndex - beginIndex);
263    }
264
265    public String toString() {
266        return new String(this.buffer, 0, this.len);
267    }
268
269}
270