1   package org.mortbay.jetty;
2   
3   import java.util.ArrayList;
4   
5   import org.mortbay.component.AbstractLifeCycle;
6   import org.mortbay.io.Buffer;
7   import org.mortbay.io.Buffers;
8   
9   /* ------------------------------------------------------------ */
10  /** Abstract Buffer pool.
11   * simple unbounded pool of buffers.
12   * @author gregw
13   *
14   */
15  public abstract class AbstractBuffers extends AbstractLifeCycle implements Buffers
16  {
17      private int _headerBufferSize=6*1024;
18      private int _requestBufferSize=8*1024;
19      private int _responseBufferSize=32*1024;
20      
21      // Use and array of buffers to avoid contention
22      private transient ArrayList<Buffer> _headerBuffers=new ArrayList<Buffer>();
23      protected transient int _loss;
24      private transient ArrayList<Buffer> _requestBuffers;
25      private transient ArrayList<Buffer> _responseBuffers;
26  
27      /* ------------------------------------------------------------ */
28      /**
29       * @return Returns the headerBufferSize.
30       */
31      public int getHeaderBufferSize()
32      {
33          return _headerBufferSize;
34      }
35      
36      /* ------------------------------------------------------------ */
37      /**
38       * @param headerBufferSize The headerBufferSize to set.
39       */
40      public void setHeaderBufferSize(int headerBufferSize)
41      {
42          _headerBufferSize = headerBufferSize;
43      }
44      
45      /* ------------------------------------------------------------ */
46      /**
47       * @return Returns the requestBufferSize.
48       */
49      public int getRequestBufferSize()
50      {
51          return _requestBufferSize;
52      }
53      
54      /* ------------------------------------------------------------ */
55      /**
56       * @param requestBufferSize The requestBufferSize to set.
57       */
58      public void setRequestBufferSize(int requestBufferSize)
59      {
60          _requestBufferSize = requestBufferSize;
61      }
62      
63      /* ------------------------------------------------------------ */
64      /**
65       * @return Returns the responseBufferSize.
66       */
67      public int getResponseBufferSize()
68      {
69          return _responseBufferSize;
70      }
71      
72      /* ------------------------------------------------------------ */
73      /**
74       * @param responseBufferSize The responseBufferSize to set.
75       */
76      public void setResponseBufferSize(int responseBufferSize)
77      {
78          _responseBufferSize = responseBufferSize;
79      }
80  
81      
82      /* ------------------------------------------------------------ */
83      protected abstract Buffer newBuffer(int size);
84  
85      
86      /* ------------------------------------------------------------ */
87      public Buffer getBuffer(int size)
88      {
89          if (size==_headerBufferSize)
90          {   
91              synchronized(_headerBuffers)
92              {
93                  if (_headerBuffers.size()>0)
94                      return _headerBuffers.remove(_headerBuffers.size()-1);
95              }
96              return newBuffer(size);
97          }
98          else if (size==_responseBufferSize)
99          {
100             synchronized(_responseBuffers)
101             {
102                 if (_responseBuffers.size()==0)
103                     return newBuffer(size);
104                 return _responseBuffers.remove(_responseBuffers.size()-1);
105             }
106         }
107         else if (size==_requestBufferSize)
108         {
109             synchronized(_requestBuffers)
110             {
111                 if (_requestBuffers.size()==0)
112                     return newBuffer(size);
113                 return _requestBuffers.remove(_requestBuffers.size()-1);
114             }   
115         }
116         
117         return newBuffer(size);    
118     }
119 
120 
121     /* ------------------------------------------------------------ */
122     public void returnBuffer(Buffer buffer)
123     {
124         buffer.clear();
125         if (!buffer.isVolatile() && !buffer.isImmutable())
126         {
127             int c=buffer.capacity();
128             if (c==_headerBufferSize)
129             {
130                 synchronized(_headerBuffers)
131                 {
132                     _headerBuffers.add(buffer);
133                 }
134             }
135             else if (c==_responseBufferSize)
136             {
137                 synchronized(_responseBuffers)
138                 {
139                     _responseBuffers.add(buffer);
140                 }
141             }
142             else if (c==_requestBufferSize)
143             {
144                 synchronized(_requestBuffers)
145                 {
146                     _requestBuffers.add(buffer);
147                 }
148             }
149         }
150     }
151 
152     /* ------------------------------------------------------------ */
153     protected void doStart() throws Exception
154     {
155         super.doStart();
156 
157         if (_headerBuffers!=null)
158             _headerBuffers.clear();
159         else
160             _headerBuffers=new ArrayList<Buffer>();
161 
162         if (_requestBuffers!=null)
163             _requestBuffers.clear();
164         else
165             _requestBuffers=new ArrayList<Buffer>();
166         
167         if (_responseBuffers!=null)
168             _responseBuffers.clear();
169         else
170             _responseBuffers=new ArrayList<Buffer>(); 
171     }
172     
173     
174 }