View Javadoc

1   //
2   //  ========================================================================
3   //  Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd.
4   //  ------------------------------------------------------------------------
5   //  All rights reserved. This program and the accompanying materials
6   //  are made available under the terms of the Eclipse Public License v1.0
7   //  and Apache License v2.0 which accompanies this distribution.
8   //
9   //      The Eclipse Public License is available at
10  //      http://www.eclipse.org/legal/epl-v10.html
11  //
12  //      The Apache License v2.0 is available at
13  //      http://www.opensource.org/licenses/apache2.0.php
14  //
15  //  You may elect to redistribute this code under either of these licenses.
16  //  ========================================================================
17  //
18  
19  package org.eclipse.jetty.io.nio;
20  
21  import java.io.File;
22  import java.io.FileNotFoundException;
23  import java.io.IOException;
24  import java.io.RandomAccessFile;
25  import java.nio.channels.FileChannel;
26  import java.nio.channels.WritableByteChannel;
27  
28  import org.eclipse.jetty.io.AbstractBuffer;
29  import org.eclipse.jetty.io.Buffer;
30  
31  public class RandomAccessFileBuffer extends AbstractBuffer implements Buffer
32  {
33      final RandomAccessFile _file;
34      final FileChannel _channel;
35      final int _capacity;
36  
37      public RandomAccessFileBuffer(File file) 
38          throws FileNotFoundException
39      {
40          super(READWRITE,true);
41          assert file.length()<=Integer.MAX_VALUE;
42          _file = new RandomAccessFile(file,"rw");
43          _channel=_file.getChannel();
44          _capacity=Integer.MAX_VALUE;
45          setGetIndex(0);
46          setPutIndex((int)file.length());
47      }
48      
49      public RandomAccessFileBuffer(File file,int capacity) 
50          throws FileNotFoundException
51      {
52          super(READWRITE,true);
53          assert capacity>=file.length();
54          assert file.length()<=Integer.MAX_VALUE;
55          _capacity=capacity;
56          _file = new RandomAccessFile(file,"rw");
57          _channel=_file.getChannel();
58          setGetIndex(0);
59          setPutIndex((int)file.length());
60      }
61      
62      public RandomAccessFileBuffer(File file,int capacity,int access) 
63          throws FileNotFoundException
64      {
65          super(access,true);
66          assert capacity>=file.length();
67          assert file.length()<=Integer.MAX_VALUE;
68          _capacity=capacity;
69          _file = new RandomAccessFile(file,access==READWRITE?"rw":"r");
70          _channel=_file.getChannel();
71          setGetIndex(0);
72          setPutIndex((int)file.length());
73      }
74  
75      public byte[] array()
76      {
77          return null;
78      }
79  
80      public int capacity()
81      {
82          return _capacity;
83      }
84  
85      @Override
86      public void clear()
87      {
88          try
89          {
90              synchronized (_file)
91              {
92                  super.clear();
93                  _file.setLength(0);
94              }
95          }
96          catch(Exception e)
97          {
98              throw new RuntimeException(e);
99          }
100     }
101 
102 
103     @Override
104     public byte peek()
105     {
106         synchronized (_file)
107         {
108             try
109             {
110                 if (_get!=_file.getFilePointer())
111                     _file.seek(_get);
112                 return _file.readByte();
113             }
114             catch(Exception e)
115             {
116                 throw new RuntimeException(e);
117             }
118         }
119     }
120 
121     public byte peek(int index)
122     {
123         synchronized (_file)
124         {
125             try
126             {
127                 _file.seek(index);
128                 return _file.readByte();
129             }
130             catch(Exception e)
131             {
132                 throw new RuntimeException(e);
133             }
134         }
135     }
136 
137     public int peek(int index, byte[] b, int offset, int length)
138     {
139         synchronized (_file)
140         {
141             try
142             {
143                 _file.seek(index);
144                 return _file.read(b,offset,length);
145             }
146             catch(Exception e)
147             {
148                 throw new RuntimeException(e);
149             }
150         }
151     }
152 
153     public void poke(int index, byte b)
154     {
155         synchronized (_file)
156         {
157             try
158             {
159                 _file.seek(index);
160                 _file.writeByte(b);
161             }
162             catch(Exception e)
163             {
164                 throw new RuntimeException(e);
165             }
166         }
167     }
168 
169     @Override
170     public int poke(int index, byte[] b, int offset, int length)
171     {
172         synchronized (_file)
173         {
174             try
175             {
176                 _file.seek(index);
177                 _file.write(b,offset,length);
178                 return length;
179             }
180             catch(Exception e)
181             {
182                 throw new RuntimeException(e);
183             }
184         }
185     }
186     
187     public int writeTo(WritableByteChannel channel,int index, int length)
188         throws IOException
189     {
190         synchronized (_file)
191         {
192             return (int)_channel.transferTo(index,length,channel);
193         }
194     }
195     
196 }