View Javadoc

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;
23  import java.util.concurrent.atomic.AtomicInteger;
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 05:19:00 +0200 (Fri, 13 Jul 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 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 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 buf;
59  
60          private final AtomicInteger refCount = new AtomicInteger();
61  
62          protected SimpleByteBuffer(java.nio.ByteBuffer buf) {
63              this.buf = buf;
64              buf.order(ByteOrder.BIG_ENDIAN);
65              refCount.set(1);
66          }
67  
68          @Override
69          public void acquire() {
70              if (refCount.get() <= 0) {
71                  throw new IllegalStateException("Already released buffer.");
72              }
73  
74              refCount.incrementAndGet();
75          }
76  
77          @Override
78          public void release() {
79              if (refCount.get() <= 0) {
80                  refCount.set(0);
81                  throw new IllegalStateException(
82                          "Already released buffer.  You released the buffer too many times.");
83              }
84  
85              refCount.decrementAndGet();
86          }
87  
88          @Override
89          public java.nio.ByteBuffer buf() {
90              return buf;
91          }
92  
93          @Override
94          public boolean isPooled() {
95              return false;
96          }
97  
98          @Override
99          public void setPooled(boolean pooled) {
100         }
101 
102         @Override
103         protected void capacity0(int requestedCapacity) {
104             int newCapacity = MINIMUM_CAPACITY;
105             while (newCapacity < requestedCapacity) {
106                 newCapacity <<= 1;
107             }
108 
109             java.nio.ByteBuffer oldBuf = this.buf;
110             java.nio.ByteBuffer 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
124         public ByteBuffer duplicate() {
125             return new SimpleByteBuffer(this.buf.duplicate());
126         }
127 
128         @Override
129         public ByteBuffer slice() {
130             return new SimpleByteBuffer(this.buf.slice());
131         }
132 
133         @Override
134         public ByteBuffer asReadOnlyBuffer() {
135             return new SimpleByteBuffer(this.buf.asReadOnlyBuffer());
136         }
137 
138         @Override
139         public byte[] array() {
140             return buf.array();
141         }
142 
143         @Override
144         public int arrayOffset() {
145             return buf.arrayOffset();
146         }
147     }
148 }