author | avstepan |
Sun, 13 Sep 2015 23:31:47 +0300 | |
changeset 32688 | 936c391804a5 |
parent 25862 | a5e25d68f971 |
permissions | -rw-r--r-- |
4 | 1 |
/* |
5555 | 2 |
* Copyright (c) 2001, 2002, Oracle and/or its affiliates. All rights reserved. |
4 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
5555 | 7 |
* published by the Free Software Foundation. Oracle designates this |
4 | 8 |
* particular file as subject to the "Classpath" exception as provided |
5555 | 9 |
* by Oracle in the LICENSE file that accompanied this code. |
4 | 10 |
* |
11 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
12 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
13 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
14 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
15 |
* accompanied this code). |
|
16 |
* |
|
17 |
* You should have received a copy of the GNU General Public License version |
|
18 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
19 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
20 |
* |
|
5555 | 21 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
22 |
* or visit www.oracle.com if you need additional information or have any |
|
23 |
* questions. |
|
4 | 24 |
*/ |
25 |
||
26 |
package com.sun.corba.se.impl.ior ; |
|
27 |
||
28 |
||
29 |
public class ByteBuffer { |
|
30 |
/** |
|
31 |
* The array buffer into which the components of the ByteBuffer are |
|
32 |
* stored. The capacity of the ByteBuffer is the length of this array buffer, |
|
33 |
* and is at least large enough to contain all the ByteBuffer's elements.<p> |
|
34 |
* |
|
35 |
* Any array elements following the last element in the ByteBuffer are 0. |
|
36 |
*/ |
|
37 |
protected byte elementData[]; |
|
38 |
||
39 |
/** |
|
32688
936c391804a5
8133650: replace some <tt> tags (obsolete in html5) in CORBA docs
avstepan
parents:
25862
diff
changeset
|
40 |
* The number of valid components in this {@code ByteBuffer} object. |
936c391804a5
8133650: replace some <tt> tags (obsolete in html5) in CORBA docs
avstepan
parents:
25862
diff
changeset
|
41 |
* Components {@code elementData[0]} through |
936c391804a5
8133650: replace some <tt> tags (obsolete in html5) in CORBA docs
avstepan
parents:
25862
diff
changeset
|
42 |
* {@code elementData[elementCount-1]} are the actual items. |
4 | 43 |
* |
44 |
* @serial |
|
45 |
*/ |
|
46 |
protected int elementCount; |
|
47 |
||
48 |
/** |
|
49 |
* The amount by which the capacity of the ByteBuffer is automatically |
|
50 |
* incremented when its size becomes greater than its capacity. If |
|
51 |
* the capacity increment is less than or equal to zero, the capacity |
|
52 |
* of the ByteBuffer is doubled each time it needs to grow. |
|
53 |
* |
|
54 |
* @serial |
|
55 |
*/ |
|
56 |
protected int capacityIncrement; |
|
57 |
||
58 |
/** |
|
59 |
* Constructs an empty ByteBuffer with the specified initial capacity and |
|
60 |
* capacity increment. |
|
61 |
* |
|
62 |
* @param initialCapacity the initial capacity of the ByteBuffer. |
|
63 |
* @param capacityIncrement the amount by which the capacity is |
|
64 |
* increased when the ByteBuffer overflows. |
|
65 |
* @exception IllegalArgumentException if the specified initial capacity |
|
66 |
* is negative |
|
67 |
*/ |
|
68 |
public ByteBuffer(int initialCapacity, int capacityIncrement) { |
|
69 |
super(); |
|
70 |
if (initialCapacity < 0) |
|
71 |
throw new IllegalArgumentException("Illegal Capacity: "+ |
|
72 |
initialCapacity); |
|
73 |
this.elementData = new byte[initialCapacity]; |
|
74 |
this.capacityIncrement = capacityIncrement; |
|
75 |
} |
|
76 |
||
77 |
/** |
|
78 |
* Constructs an empty ByteBuffer with the specified initial capacity and |
|
79 |
* with its capacity increment equal to zero. |
|
80 |
* |
|
81 |
* @param initialCapacity the initial capacity of the ByteBuffer. |
|
82 |
* @exception IllegalArgumentException if the specified initial capacity |
|
83 |
* is negative |
|
84 |
*/ |
|
85 |
public ByteBuffer(int initialCapacity) { |
|
86 |
this(initialCapacity, 0); |
|
87 |
} |
|
88 |
||
89 |
/** |
|
90 |
* Constructs an empty ByteBuffer so that its internal data array |
|
32688
936c391804a5
8133650: replace some <tt> tags (obsolete in html5) in CORBA docs
avstepan
parents:
25862
diff
changeset
|
91 |
* has size {@code 10} and its standard capacity increment is |
4 | 92 |
* zero. |
93 |
*/ |
|
94 |
public ByteBuffer() { |
|
95 |
this(200); |
|
96 |
} |
|
97 |
||
98 |
/** |
|
99 |
* Trims the capacity of this ByteBuffer to be the ByteBuffer's current |
|
100 |
* size. If the capacity of this cector is larger than its current |
|
101 |
* size, then the capacity is changed to equal the size by replacing |
|
32688
936c391804a5
8133650: replace some <tt> tags (obsolete in html5) in CORBA docs
avstepan
parents:
25862
diff
changeset
|
102 |
* its internal data array, kept in the field {@code elementData}, |
4 | 103 |
* with a smaller one. An application can use this operation to |
104 |
* minimize the storage of a ByteBuffer. |
|
105 |
*/ |
|
106 |
public void trimToSize() { |
|
107 |
int oldCapacity = elementData.length; |
|
108 |
if (elementCount < oldCapacity) { |
|
109 |
byte oldData[] = elementData; |
|
110 |
elementData = new byte[elementCount]; |
|
111 |
System.arraycopy(oldData, 0, elementData, 0, elementCount); |
|
112 |
} |
|
113 |
} |
|
114 |
||
115 |
/** |
|
116 |
* This implements the unsynchronized semantics of ensureCapacity. |
|
117 |
* Synchronized methods in this class can internally call this |
|
118 |
* method for ensuring capacity without incurring the cost of an |
|
119 |
* extra synchronization. |
|
120 |
* |
|
121 |
* @see java.util.ByteBuffer#ensureCapacity(int) |
|
122 |
*/ |
|
123 |
private void ensureCapacityHelper(int minCapacity) { |
|
124 |
int oldCapacity = elementData.length; |
|
125 |
if (minCapacity > oldCapacity) { |
|
126 |
byte oldData[] = elementData; |
|
127 |
int newCapacity = (capacityIncrement > 0) ? |
|
128 |
(oldCapacity + capacityIncrement) : (oldCapacity * 2); |
|
129 |
if (newCapacity < minCapacity) { |
|
130 |
newCapacity = minCapacity; |
|
131 |
} |
|
132 |
elementData = new byte[newCapacity]; |
|
133 |
System.arraycopy(oldData, 0, elementData, 0, elementCount); |
|
134 |
} |
|
135 |
} |
|
136 |
||
137 |
/** |
|
138 |
* Returns the current capacity of this ByteBuffer. |
|
139 |
* |
|
140 |
* @return the current capacity (the length of its internal |
|
32688
936c391804a5
8133650: replace some <tt> tags (obsolete in html5) in CORBA docs
avstepan
parents:
25862
diff
changeset
|
141 |
* data arary, kept in the field {@code elementData} |
4 | 142 |
* of this ByteBuffer. |
143 |
*/ |
|
144 |
public int capacity() { |
|
145 |
return elementData.length; |
|
146 |
} |
|
147 |
||
148 |
/** |
|
149 |
* Returns the number of components in this ByteBuffer. |
|
150 |
* |
|
151 |
* @return the number of components in this ByteBuffer. |
|
152 |
*/ |
|
153 |
public int size() { |
|
154 |
return elementCount; |
|
155 |
} |
|
156 |
||
157 |
/** |
|
158 |
* Tests if this ByteBuffer has no components. |
|
159 |
* |
|
32688
936c391804a5
8133650: replace some <tt> tags (obsolete in html5) in CORBA docs
avstepan
parents:
25862
diff
changeset
|
160 |
* @return {@code true} if and only if this ByteBuffer has |
4 | 161 |
* no components, that is, its size is zero; |
32688
936c391804a5
8133650: replace some <tt> tags (obsolete in html5) in CORBA docs
avstepan
parents:
25862
diff
changeset
|
162 |
* {@code false} otherwise. |
4 | 163 |
*/ |
164 |
public boolean isEmpty() { |
|
165 |
return elementCount == 0; |
|
166 |
} |
|
167 |
||
168 |
public void append(byte value) |
|
169 |
{ |
|
170 |
ensureCapacityHelper(elementCount + 1); |
|
171 |
elementData[elementCount++] = value; |
|
172 |
} |
|
173 |
||
174 |
public void append( int value ) |
|
175 |
{ |
|
176 |
ensureCapacityHelper(elementCount + 4); |
|
177 |
doAppend( value ) ; |
|
178 |
} |
|
179 |
||
180 |
private void doAppend( int value ) |
|
181 |
{ |
|
182 |
int current = value ; |
|
183 |
for (int ctr=0; ctr<4; ctr++) { |
|
184 |
elementData[elementCount+ctr] = (byte)(current & 255) ; |
|
185 |
current = current >> 8 ; |
|
186 |
} |
|
187 |
elementCount += 4 ; |
|
188 |
} |
|
189 |
||
190 |
public void append( String value ) |
|
191 |
{ |
|
192 |
byte[] data = value.getBytes() ; |
|
193 |
ensureCapacityHelper( elementCount + data.length + 4 ) ; |
|
194 |
doAppend( data.length ) ; |
|
195 |
System.arraycopy( data, 0, elementData, elementCount, data.length ) ; |
|
196 |
elementCount += data.length ; |
|
197 |
} |
|
198 |
||
199 |
/** |
|
200 |
* Returns an array containing all of the elements in this ByteBuffer |
|
201 |
* in the correct order. |
|
202 |
* |
|
203 |
* @since 1.2 |
|
204 |
*/ |
|
205 |
public byte[] toArray() { |
|
206 |
return elementData ; |
|
207 |
} |
|
208 |
} |