1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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 }