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       * @return new Buffer
47       */
48      final protected Buffer newHeader()
49      {
50          switch(_headerType)
51          {
52              case BYTE_ARRAY:
53                  return new ByteArrayBuffer(_headerSize);
54              case DIRECT:
55                  return new DirectNIOBuffer(_headerSize);
56              case INDIRECT:
57                  return new IndirectNIOBuffer(_headerSize);
58          }
59          throw new IllegalStateException();
60      }
61      
62      /* ------------------------------------------------------------ */
63      /**
64       * Create a new content Buffer
65       * @return new Buffer
66       */
67      final protected Buffer newBuffer()
68      {
69         switch(_bufferType)
70         {
71             case BYTE_ARRAY:
72                 return new ByteArrayBuffer(_bufferSize);
73             case DIRECT:
74                 return new DirectNIOBuffer(_bufferSize);
75             case INDIRECT:
76                 return new IndirectNIOBuffer(_bufferSize);
77         }
78         throw new IllegalStateException();
79      }
80      
81      /* ------------------------------------------------------------ */
82      /**
83       * Create a new content Buffer
84       * @param size
85       * @return new Buffer
86       */
87      final protected Buffer newBuffer(int size)
88      {
89         switch(_otherType)
90         {
91             case BYTE_ARRAY:
92                 return new ByteArrayBuffer(size);
93             case DIRECT:
94                 return new DirectNIOBuffer(size);
95             case INDIRECT:
96                 return new IndirectNIOBuffer(size);
97         }
98         throw new IllegalStateException();
99      }
100 
101     /* ------------------------------------------------------------ */
102     /**
103      * @param buffer
104      * @return True if the buffer is the correct type to be a Header buffer
105      */
106     public final boolean isHeader(Buffer buffer)
107     {
108         if (buffer.capacity()==_headerSize)
109         {
110             switch(_headerType)
111             {
112                 case BYTE_ARRAY:
113                     return buffer instanceof ByteArrayBuffer && !(buffer instanceof  IndirectNIOBuffer);
114                 case DIRECT:
115                     return buffer instanceof  DirectNIOBuffer;
116                 case INDIRECT:
117                     return buffer instanceof  IndirectNIOBuffer;
118             }
119         }
120         return false;
121     }
122 
123     /* ------------------------------------------------------------ */
124     /**
125      * @param buffer
126      * @return True if the buffer is the correct type to be a Header buffer
127      */
128     public final boolean isBuffer(Buffer buffer)
129     {
130         if (buffer.capacity()==_bufferSize)
131         {
132             switch(_bufferType)
133             {
134                 case BYTE_ARRAY:
135                     return buffer instanceof ByteArrayBuffer && !(buffer instanceof  IndirectNIOBuffer);
136                 case DIRECT:
137                     return buffer instanceof  DirectNIOBuffer;
138                 case INDIRECT:
139                     return buffer instanceof  IndirectNIOBuffer;
140             }
141         }
142         return false;
143     }
144 
145 }