sventon subversion web client - http://www.sventon.org
[show recent changes]
 
  Help
HEAD
Rev: 9994 - svn://svn.freehep.org/svn / freehep / trunk / hepio / freehep-xdr / src / main / java / hep / io / xdr / XDRInputStream.java
Show File - XDRInputStream.java  [show properties]
Search for Help
spinner
package hep.io.xdr;
import java.io.*;
/**
 * A class for reading XDR files. Not too hard to do in Java since the XDR format is very
 * similar to the Java native DataStream format, except for String and the fact that elements
 * (ro an array of elements) are always padded to a multiple of 4 bytes.
10   *
11   * This class requires the user to call the pad method, to skip to the next
12   * 4-byte boundary after reading an element or array of elements that may not
13   * span a multiple of 4 bytes.
14   * @author Tony Johnson (tonyj@slac.stanford.edu)
15   * @version $Id: XDRInputStream.java 9994 2006-11-28 18:22:13Z tonyj $
16   */
17  public class XDRInputStream extends DataInputStream implements XDRDataInput
18  {
19     private CountedInputStream cin;
20     private final static int SANITY_CHECK = Integer.getInteger("hep.io.xdr.sanityCheck",100000).intValue();
21 
22     public XDRInputStream(InputStream in)
23     {
24        super(new CountedInputStream(in));
25        cin = (CountedInputStream) this.in;
26     }
27 
28     public long getBytesRead()
29     {
30        return cin.getBytesRead();
31     }
32 
33     /**
34      * Sets a limit on the number of bytes that can be read from this file
35      * before an EOF will be generated
36      */
37     public void setReadLimit(int bytes)
38     {
39        cin.setReadLimit(bytes);
40     }
41 
42     public void clearReadLimit()
43     {
44        cin.clearReadLimit();
45     }
46 
47     /**
48      * Skips appropriate amount to bring stream to 4-byte boundary.
49      */
50     public void pad() throws IOException
51     {
52        int offset = (int) (getBytesRead() % 4);
53        if (offset != 0)
54           skipBytes(4 - offset);
55     }
56 
57     public double[] readDoubleArray(double[] buffer) throws IOException
58     {
59        int l = readInt();
60        if (> SANITY_CHECK)
61           throw new IOException("Array length failed sanity check: " + l);
62 
63        double[] result = buffer;
64        if ((buffer == null) || (> buffer.length))
65           result = new double[l];
66        for (int i = 0; i < l; i++)
67           result[i] = readDouble();
68        return result;
69     }
70 
71     public float[] readFloatArray(float[] buffer) throws IOException
72     {
73        int l = readInt();
74        if (> SANITY_CHECK)
75           throw new IOException("Array length failed sanity check: " + l);
76 
77        float[] result = buffer;
78        if ((buffer == null) || (> buffer.length))
79           result = new float[l];
80        for (int i = 0; i < l; i++)
81           result[i] = readFloat();
82        return result;
83     }
84 
85     public int[] readIntArray(int[] buffer) throws IOException
86     {
87        int l = readInt();
88        if (> SANITY_CHECK)
89           throw new IOException("Array length failed sanity check: " + l);
90 
91        int[] result = buffer;
92        if ((buffer == null) || (> buffer.length))
93           result = new int[l];
94        for (int i = 0; i < l; i++)
95           result[i] = readInt();
96        return result;
97     }
98 
99     public String readString(int l) throws IOException
100     {
101        byte[] ascii = new byte[l];
102        readFully(ascii);
103        pad();
104        return new String(ascii,"US-ASCII");
105     }
106 
107     public String readString() throws IOException
108     {
109        int l = readInt();
110        if (> SANITY_CHECK)
111           throw new IOException("String length failed sanity check: " + l);
112        return readString(l);
113     }
114 
115     private static final class CountedInputStream extends BufferedInputStream
116     {
117        private long count = 0;
118        private long limit = -1;
119        private long mark = 0;
120 
121        CountedInputStream(InputStream in)
122        {
123           super(in);
124        }
125 
126        public long getBytesRead()
127        {
128           return count;
129        }
130 
131        public int available() throws IOException
132        {
133           return Math.min((int) (limit - count), super.available());
134        }
135 
136        public synchronized void mark(int readlimit)
137        {
138           mark = count;
139           super.mark(readlimit);
140        }
141 
142        public int read() throws IOException
143        {
144           int available = checkLimit(1);
145           int rc = super.read();
146           if (rc >= 0)
147              count++;
148           return rc;
149        }
150 
151        public int read(byte[] data) throws IOException
152        {
153           return read(data, 0, data.length);
154        }
155 
156        public int read(byte[] data, int off, int len) throws IOException
157        {
158           int available = checkLimit(len);
159           int rc = super.read(data, off, available);
160           if (rc > 0)
161              count += rc;
162           return rc;
163        }
164 
165        public synchronized void reset() throws IOException
166        {
167           count = mark;
168           super.reset();
169        }
170 
171        public long skip(long bytes) throws IOException
172        {
173           long available = checkLimit(bytes);
174           long rc = super.skip(available);
175           if (rc > 0)
176              count += rc;
177           return rc;
178        }
179 
180        /**
181         * Sets a limit on the number of bytes that can be read from this file
182         * before an EOF will be generated
183         */
184        void setReadLimit(int bytes)
185        {
186           limit = count + bytes;
187        }
188 
189        void clearReadLimit()
190        {
191           limit = -1;
192        }
193 
194        private int checkLimit(int request) throws IOException
195        {
196           if (limit < 0)
197              return request;
198           else if (limit <= count)
199              throw new EOFException();
200           return Math.min(request, (int) (limit - count));
201        }
202 
203        private long checkLimit(long request) throws IOException
204        {
205           if (limit < 0)
206              return request;
207           else if (limit <= count)
208              throw new EOFException();
209           return Math.min(request, limit - count);
210        }
211     }
212  }


feed icon

sventon 2.5.1