owfileinputstream.java

这是一个以JAVA编写的程序,本人还没有试过,是一个简单的温度控制系统

    */
   public OWFileInputStream(OWFileDescriptor fdObj)
   {
      if (fdObj == null)
         throw new NullPointerException("OWFile provided is null");

      fd = fdObj;
   }

   //--------
   //-------- Read Methods
   //--------

   /**
    * Reads a byte of data from this input stream. This method blocks
    * if no input is yet available.
    *
    * @return     the next byte of data, or <code>-1</code> if the end of the
    *             file is reached.
    * @exception  IOException  if an I/O error occurs.
    */
   public int read()
      throws IOException
   {
      if (fd != null)
         return fd.read();
      else
         throw new IOException("1-Wire FileDescriptor is null");
   }

   /**
    * Reads up to <code>b.length</code> bytes of data from this input
    * stream into an array of bytes. This method blocks until some input
    * is available.
    *
    * @param      b   the buffer into which the data is read.
    * @return     the total number of bytes read into the buffer, or
    *             <code>-1</code> if there is no more data because the end of
    *             the file has been reached.
    * @exception  IOException  if an I/O error occurs.
    */
   public int read(byte b [])
      throws IOException
   {
      if (fd != null)
         return fd.read(b, 0, b.length);
      else
         throw new IOException("1-Wire FileDescriptor is null");
   }

   /**
    * Reads up to <code>len</code> bytes of data from this input stream
    * into an array of bytes. This method blocks until some input is
    * available.
    *
    * @param      b     the buffer into which the data is read.
    * @param      off   the start offset of the data.
    * @param      len   the maximum number of bytes read.
    * @return     the total number of bytes read into the buffer, or
    *             <code>-1</code> if there is no more data because the end of
    *             the file has been reached.
    * @exception  IOException  if an I/O error occurs.
    */
   public int read(byte b [], int off, int len)
      throws IOException
   {
      if (fd != null)
         return fd.read(b, off, len);
      else
         throw new IOException("1-Wire FileDescriptor is null");
   }

   /**
    * Skips over and discards <code>n</code> bytes of data from the
    * input stream. The <code>skip</code> method may, for a variety of
    * reasons, end up skipping over some smaller number of bytes,
    * possibly <code>0</code>. The actual number of bytes skipped is returned.
    *
    * @param      n   the number of bytes to be skipped.
    * @return     the actual number of bytes skipped.
    * @exception  IOException  if an I/O error occurs.
    */
   public long skip(long n)
      throws IOException
   {
      if (fd != null)
         return fd.skip(n);
      else
         throw new IOException("1-Wire FileDescriptor is null");
   }

   /**
    * Returns the number of bytes that can be read from this file input
    * stream without blocking.
    *
    * @return     the number of bytes that can be read from this file input
    *             stream without blocking.
    * @exception  IOException  if an I/O error occurs.
    */
   public int available()
      throws IOException
   {
      if (fd != null)
         return fd.available();
      else
         throw new IOException("1-Wire FileDescriptor is null");
   }

   /**
    * Closes this file input stream and releases any system resources
    * associated with the stream.
    *
    * @exception  IOException  if an I/O error occurs.
    */
   public void close()
      throws IOException
   {
      if (fd != null)
         fd.close();
      else
         throw new IOException("1-Wire FileDescriptor is null");

      fd = null;
   }

   /**
    * Returns the <code>OWFileDescriptor</code>
    * object  that represents the connection to
    * the actual file in the Filesystem being
    * used by this <code>FileInputStream</code>.
    *
    * @return     the file descriptor object associated with this stream.
    * @exception  IOException  if an I/O error occurs.
    * @see        com.dalsemi.onewire.application.file.OWFileDescriptor
    */
   public final OWFileDescriptor getFD()
      throws IOException
   {
      if (fd != null)
         return fd;
      else
         throw new IOException("1-Wire FileDescriptor is null");
   }

   /**
    * Ensures that the <code>close</code> method of this file input stream is
    * called when there are no more references to it.
    *
    * @exception  IOException  if an I/O error occurs.
    * @see        com.dalsemi.onewire.application.file.OWFileInputStream#close()
    */
   public void finalize()
      throws IOException
   {
      if (fd != null)
      {
         fd.close();
      }
   }

   //--------
   //-------- Mark Methods
   //--------

   /**
    * Marks the current position in this input stream. A subsequent call to
    * the <code>reset</code> method repositions this stream at the last marked
    * position so that subsequent reads re-read the same bytes.
    *
    * <p> The <code>readlimit</code> arguments tells this input stream to
    * allow that many bytes to be read before the mark position gets
    * invalidated.
    *
    * <p> The general contract of <code>mark</code> is that, if the method
    * <code>markSupported</code> returns <code>true</code>, the stream somehow
    * remembers all the bytes read after the call to <code>mark</code> and
    * stands ready to supply those same bytes again if and whenever the method
    * <code>reset</code> is called.  However, the stream is not required to
    * remember any data at all if more than <code>readlimit</code> bytes are
    * read from the stream before <code>reset</code> is called.
    *
    * <p> The <code>mark</code> method of <code>InputStream</code> does
    * nothing.
    *
    * @param   readlimit   the maximum limit of bytes that can be read before
    *                      the mark position becomes invalid.
    * @see     java.io.InputStream#reset()
    */
   public void mark(int readlimit)
   {
      if (fd != null)
         fd.mark(readlimit);
   }

   /**
    * Repositions this stream to the position at the time the
    * <code>mark</code> method was last called on this input stream.
    *
    * <p> The general contract of <code>reset</code> is:
    *
    * <p><ul>
    *
    * <li> If the method <code>markSupported</code> returns
    * <code>true</code>, then:
    *
    *     <ul><li> If the method <code>mark</code> has not been called since
    *     the stream was created, or the number of bytes read from the stream
    *     since <code>mark</code> was last called is larger than the argument
    *     to <code>mark</code> at that last call, then an
    *     <code>IOException</code> might be thrown.
    *
    *     <li> If such an <code>IOException</code> is not thrown, then the
    *     stream is reset to a state such that all the bytes read since the
    *     most recent call to <code>mark</code> (or since the start of the
    *     file, if <code>mark</code> has not been called) will be resupplied
    *     to subsequent callers of the <code>read</code> method, followed by
    *     any bytes that otherwise would have been the next input data as of
    *     the time of the call to <code>reset</code>. </ul>
    *
    * <li> If the method <code>markSupported</code> returns
    * <code>false</code>, then:
    *
    *     <ul><li> The call to <code>reset</code> may throw an
    *     <code>IOException</code>.
    *
    *     <li> If an <code>IOException</code> is not thrown, then the stream
    *     is reset to a fixed state that depends on the particular type of the
    *     input stream and how it was created. The bytes that will be supplied
    *     to subsequent callers of the <code>read</code> method depend on the
    *     particular type of the input stream. </ul></ul>
    *
    * <p> The method <code>reset</code> for class <code>InputStream</code>
    * does nothing and always throws an <code>IOException</code>.
    *
    * @exception  IOException  if this stream has not been marked or if the
    *               mark has been invalidated.
    * @see     java.io.InputStream#mark(int)
    * @see     java.io.IOException
    */
   public void reset()
      throws IOException
   {
      if (fd != null)
         fd.reset();
   }

   /**
    * Tests if this input stream supports the <code>mark</code> and
    * <code>reset</code> methods. The <code>markSupported</code> method of
    * <code>InputStream</code> returns <code>false</code>.
    *
    * @return  <code>true</code> if this true type supports the mark and reset
    *          method; <code>false</code> otherwise.
    * @see     java.io.InputStream#mark(int)
    * @see     java.io.InputStream#reset()
    */
   public boolean markSupported()
   {
      return true;
   }
}