KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > mina > common > SimpleByteBufferAllocator


1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one
3  * or more contributor license agreements. See the NOTICE file
4  * distributed with this work for additional information
5  * regarding copyright ownership. The ASF licenses this file
6  * to you under the Apache License, Version 2.0 (the
7  * "License"); you may not use this file except in compliance
8  * with the License. You may obtain a copy of the License at
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing,
13  * software distributed under the License is distributed on an
14  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15  * KIND, either express or implied. See the License for the
16  * specific language governing permissions and limitations
17  * under the License.
18  *
19  */
20 package org.apache.mina.common;
21
22 import java.nio.ByteOrder JavaDoc;
23 import java.util.concurrent.atomic.AtomicInteger JavaDoc;
24
25 import org.apache.mina.common.support.BaseByteBuffer;
26
27 /**
28  * A simplistic {@link ByteBufferAllocator} which simply allocates a new
29  * buffer every time.
30  *
31  * @author The Apache Directory Project (mina-dev@directory.apache.org)
32  * @version $Rev: 555855 $, $Date: 2007-07-13 12:19:00 +0900 (금, 13 7월 2007) $
33  */
34 public class SimpleByteBufferAllocator implements ByteBufferAllocator {
35     private static final int MINIMUM_CAPACITY = 1;
36
37     public SimpleByteBufferAllocator() {
38     }
39
40     public ByteBuffer allocate(int capacity, boolean direct) {
41         java.nio.ByteBuffer JavaDoc nioBuffer;
42         if (direct) {
43             nioBuffer = java.nio.ByteBuffer.allocateDirect(capacity);
44         } else {
45             nioBuffer = java.nio.ByteBuffer.allocate(capacity);
46         }
47         return new SimpleByteBuffer(nioBuffer);
48     }
49
50     public ByteBuffer wrap(java.nio.ByteBuffer JavaDoc nioBuffer) {
51         return new SimpleByteBuffer(nioBuffer);
52     }
53
54     public void dispose() {
55     }
56
57     private static class SimpleByteBuffer extends BaseByteBuffer {
58         private java.nio.ByteBuffer JavaDoc buf;
59
60         private final AtomicInteger JavaDoc refCount = new AtomicInteger JavaDoc();
61
62         protected SimpleByteBuffer(java.nio.ByteBuffer JavaDoc buf) {
63             this.buf = buf;
64             buf.order(ByteOrder.BIG_ENDIAN);
65             refCount.set(1);
66         }
67
68         @Override JavaDoc
69         public void acquire() {
70             if (refCount.get() <= 0) {
71                 throw new IllegalStateException JavaDoc("Already released buffer.");
72             }
73
74             refCount.incrementAndGet();
75         }
76
77         @Override JavaDoc
78         public void release() {
79             if (refCount.get() <= 0) {
80                 refCount.set(0);
81                 throw new IllegalStateException JavaDoc(
82                         "Already released buffer. You released the buffer too many times.");
83             }
84
85             refCount.decrementAndGet();
86         }
87
88         @Override JavaDoc
89         public java.nio.ByteBuffer JavaDoc buf() {
90             return buf;
91         }
92
93         @Override JavaDoc
94         public boolean isPooled() {
95             return false;
96         }
97
98         @Override JavaDoc
99         public void setPooled(boolean pooled) {
100         }
101
102         @Override JavaDoc
103         protected void capacity0(int requestedCapacity) {
104             int newCapacity = MINIMUM_CAPACITY;
105             while (newCapacity < requestedCapacity) {
106                 newCapacity <<= 1;
107             }
108
109             java.nio.ByteBuffer JavaDoc oldBuf = this.buf;
110             java.nio.ByteBuffer JavaDoc newBuf;
111             if (isDirect()) {
112                 newBuf = java.nio.ByteBuffer.allocateDirect(newCapacity);
113             } else {
114                 newBuf = java.nio.ByteBuffer.allocate(newCapacity);
115             }
116
117             newBuf.clear();
118             oldBuf.clear();
119             newBuf.put(oldBuf);
120             this.buf = newBuf;
121         }
122
123         @Override JavaDoc
124         public ByteBuffer duplicate() {
125             return new SimpleByteBuffer(this.buf.duplicate());
126         }
127
128         @Override JavaDoc
129         public ByteBuffer slice() {
130             return new SimpleByteBuffer(this.buf.slice());
131         }
132
133         @Override JavaDoc
134         public ByteBuffer asReadOnlyBuffer() {
135             return new SimpleByteBuffer(this.buf.asReadOnlyBuffer());
136         }
137
138         @Override JavaDoc
139         public byte[] array() {
140             return buf.array();
141         }
142
143         @Override JavaDoc
144         public int arrayOffset() {
145             return buf.arrayOffset();
146         }
147     }
148 }
149
Popular Tags