View Javadoc

1   package org.eclipse.jetty.io;
2   
3   import org.eclipse.jetty.io.nio.DirectNIOBuffer;
4   import org.eclipse.jetty.io.nio.IndirectNIOBuffer;
5   
6   public abstract class AbstractBuffers implements Buffers
7   {
8       protected final Buffers.Type _headerType;
9       protected final int _headerSize;
10      protected final Buffers.Type _bufferType;
11      protected final int _bufferSize;
12      protected final Buffers.Type _otherType;
13  
14      /* ------------------------------------------------------------ */
15      public AbstractBuffers(Buffers.Type headerType, int headerSize, Buffers.Type bufferType, int bufferSize, Buffers.Type otherType)
16      {
17          _headerType=headerType;
18          _headerSize=headerSize;
19          _bufferType=bufferType;
20          _bufferSize=bufferSize;
21          _otherType=otherType;
22      }
23  
24      /* ------------------------------------------------------------ */
25      /**
26       * @return Returns the buffer size in bytes.
27       */
28      public int getBufferSize()
29      {
30          return _bufferSize;
31      }
32  
33      /* ------------------------------------------------------------ */
34      /**
35       * @return Returns the header size in bytes.
36       */
37      public int getHeaderSize()
38      {
39          return _headerSize;
40      }
41  
42  
43      /* ------------------------------------------------------------ */
44      /**
45       * Create a new header Buffer
46       * @param size
47       * @return new Buffer
48       */
49      final protected Buffer newHeader()
50      {
51          switch(_headerType)
52          {
53              case BYTE_ARRAY:
54                  return new ByteArrayBuffer(_headerSize);
55              case DIRECT:
56                  return new DirectNIOBuffer(_headerSize);
57              case INDIRECT:
58                  return new IndirectNIOBuffer(_headerSize);
59          }
60          throw new IllegalStateException();
61      }
62      
63      /* ------------------------------------------------------------ */
64      /**
65       * Create a new content Buffer
66       * @param size
67       * @return new Buffer
68       */
69      final protected Buffer newBuffer()
70      {
71         switch(_bufferType)
72         {
73             case BYTE_ARRAY:
74                 return new ByteArrayBuffer(_bufferSize);
75             case DIRECT:
76                 return new DirectNIOBuffer(_bufferSize);
77             case INDIRECT:
78                 return new IndirectNIOBuffer(_bufferSize);
79         }
80         throw new IllegalStateException();
81      }
82      
83      /* ------------------------------------------------------------ */
84      /**
85       * Create a new content Buffer
86       * @param size
87       * @return new Buffer
88       */
89      final protected Buffer newBuffer(int size)
90      {
91         switch(_otherType)
92         {
93             case BYTE_ARRAY:
94                 return new ByteArrayBuffer(size);
95             case DIRECT:
96                 return new DirectNIOBuffer(size);
97             case INDIRECT:
98                 return new IndirectNIOBuffer(size);
99         }
100        throw new IllegalStateException();
101     }
102 
103     /* ------------------------------------------------------------ */
104     /**
105      * @param buffer
106      * @return True if the buffer is the correct type to be a Header buffer
107      */
108     public final boolean isHeader(Buffer buffer)
109     {
110         if (buffer.capacity()==_headerSize)
111         {
112             switch(_headerType)
113             {
114                 case BYTE_ARRAY:
115                     return buffer instanceof ByteArrayBuffer && !(buffer instanceof  IndirectNIOBuffer);
116                 case DIRECT:
117                     return buffer instanceof  DirectNIOBuffer;
118                 case INDIRECT:
119                     return buffer instanceof  IndirectNIOBuffer;
120             }
121         }
122         return false;
123     }
124 
125     /* ------------------------------------------------------------ */
126     /**
127      * @param buffer
128      * @return True if the buffer is the correct type to be a Header buffer
129      */
130     public final boolean isBuffer(Buffer buffer)
131     {
132         if (buffer.capacity()==_bufferSize)
133         {
134             switch(_bufferType)
135             {
136                 case BYTE_ARRAY:
137                     return buffer instanceof ByteArrayBuffer && !(buffer instanceof  IndirectNIOBuffer);
138                 case DIRECT:
139                     return buffer instanceof  DirectNIOBuffer;
140                 case INDIRECT:
141                     return buffer instanceof  IndirectNIOBuffer;
142             }
143         }
144         return false;
145     }
146 
147 }