com.ibm.as400.access.IFSFileDescriptor Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400 Show documentation
The Open Source version of the IBM Toolbox for Java
The newest version!
///////////////////////////////////////////////////////////////////////////////
//                                                                             
// JTOpen (IBM Toolbox for Java - OSS version)                              
//                                                                             
// Filename: IFSFileDescriptor.java
//                                                                             
// The source code contained herein is licensed under the IBM Public License   
// Version 1.0, which has been approved by the Open Source Initiative.         
// Copyright (C) 1997-2004 International Business Machines Corporation and     
// others. All rights reserved.                                                
//                                                                             
///////////////////////////////////////////////////////////////////////////////
// @A1 2008-02-22 Change setFileOffset() parameter from int to long 
//     This is a private method and calls the impl.setFileOffset which already
//     takes a long.
//     setFileOffset() is called from IFSRandomAccessFile.seek(long)
///////////////////////////////////////////////////////////////////////////////

package com.ibm.as400.access;

import java.io.IOException;
import java.util.Enumeration;
import java.util.Vector;


/**
 * Represents an integrated file system file descriptor. Instances of the file descriptor class serve as an opaque
 * handle to the underlying structure representing an open file or an open socket. Applications should not create their
 * own file descriptors.

 * Here is an example of two input streams sharing a file descriptor:
 * 
 *  * AS400 as400 = new AS400("mySystem");
 * IFSFileInputStream is1 = new IFSFileInputStream(as400, "/Dir/File");
 * IFSFileInputStream is2 = new IFSFileInputStream(is1.getFD());
 * 
 * 
 * Reading in one object advances the current file position of all objects that share the same descriptor.
 * 
 * @see IFSFileInputStream#getFD
 * @see IFSFileOutputStream#getFD
 * @see IFSRandomAccessFile#getFD
 **/
public final class IFSFileDescriptor implements java.io.Serializable
{
    static final long serialVersionUID = 4L;

    private transient long fileOffset_;
    private transient Object parent_; // The object that instantiated
                                      // this IFSDescriptor.
    private String path_ = "";
    private int shareOption_;
    private AS400 system_;
    private boolean closed_ = false;

    // Semaphore for synchronizing access to fileOffset_.
    private transient Object fileOffsetLock_ = new Object();

    private transient IFSFileDescriptorImpl impl_;

    /**
     * Constructs an IFSFileDescriptor object.
     **/
    public IFSFileDescriptor()
    {
    }

    IFSFileDescriptor(AS400 system, String path, int shareOption, Object parent)
    {
        system_ = system;
        path_ = path;
        shareOption_ = shareOption;
        parent_ = parent;
    }

    IFSFileDescriptor(int shareOption, Object parent)
    {
        shareOption_ = shareOption;
        parent_ = parent;
    }

  /**
   Chooses the appropriate implementation.
   **/
  void chooseImpl ()
  {
      if (impl_ != null)
          return;
    
      impl_ = (IFSFileDescriptorImpl) system_.loadImpl2("com.ibm.as400.access.IFSFileDescriptorImplRemote",
                                                        "com.ibm.as400.access.IFSFileDescriptorImplProxy");

      // Get the "impl" object for the parent, so we can pass it to the impl_.
      Object parentImpl = null;
      if (parent_ != null)
      {
          // Get the impl object for the parent.
          String className = parent_.getClass().getName();
          if (parent_ instanceof IFSFileInputStream)
              parentImpl = ((IFSFileInputStream) parent_).getImpl();
          else if (parent_ instanceof IFSFileOutputStream)
              parentImpl = ((IFSFileOutputStream) parent_).getImpl();
          else if (parent_ instanceof IFSTextFileInputStream)
              parentImpl = ((IFSTextFileInputStream) parent_).getImpl();
          else if (parent_ instanceof IFSTextFileOutputStream)
              parentImpl = ((IFSTextFileOutputStream) parent_).getImpl();
          else if (parent_ instanceof IFSRandomAccessFile)
              parentImpl = ((IFSRandomAccessFile) parent_).getImpl();
          else
          {
              Trace.log(Trace.ERROR, "IFSFileDescriptor has invalid parent: " + className);
              throw new InternalErrorException(InternalErrorException.UNEXPECTED_EXCEPTION);
          }
      }

      impl_.initialize(fileOffset_, parentImpl, path_, shareOption_, system_.getImpl());
  }

  void close()
  {
      if (impl_ != null)
          impl_.close();
      closed_ = true;
  }

  /**
   * Fires events to indicate file has been closed. This static method is provided as a utility for use by other
   * classes.
   **/
  static void fireClosedEvents(Object source, Vector fileListeners)
  {
      FileEvent event = new FileEvent(source, FileEvent.FILE_CLOSED);
      synchronized (fileListeners)
      {
          Enumeration e = fileListeners.elements();
          while (e.hasMoreElements())
          {
              FileListener listener = (FileListener) e.nextElement();
              listener.fileClosed(event);
          }
      }
  }

  /**
   * Fires events to indicate file has been modified. This static method is provided as a utility for use by other
   * classes.
   **/
  static void fireModifiedEvents(Object source, Vector fileListeners)
  {
      FileEvent event = new FileEvent(source, FileEvent.FILE_MODIFIED);
      synchronized (fileListeners)
      {
          Enumeration e = fileListeners.elements();
          while (e.hasMoreElements())
          {
              FileListener listener = (FileListener) e.nextElement();
              listener.fileModified(event);
          }
      }
  }


  /**
   * Fires events to indicate file has been opened. This static method is provided as a utility for use by other
   * classes.
   **/
  static void fireOpenedEvents(Object source, Vector fileListeners)
  {
      FileEvent event = new FileEvent(source, FileEvent.FILE_OPENED);
      synchronized (fileListeners)
      {
          Enumeration e = fileListeners.elements();
          while (e.hasMoreElements())
          {
              FileListener listener = (FileListener) e.nextElement();
              listener.fileOpened(event);
          }
      }
  }


  // Design note: The policy for 'get' and 'is' methods is:
  // If impl_ is null, or the field is never reset by the ImplRemote,
  // simply return the local copy of the data member.
  // If impl_ is non-null, and the field can be reset by the ImplRemote,
  // get the value from impl_ (and disregard the local value).
  // Note that various IFSxxxImplRemote classes are given direct access to impl_.

  IFSFileDescriptorImpl getImpl()
  {
      if (impl_ == null)
          chooseImpl();
      return impl_;
  }

  /**
   * Returns the file's "data CCSID" setting.
   **/
  int getCCSID() throws IOException
  {
      if (impl_ == null)
          chooseImpl();
      return impl_.getCCSID();
  }

  long getFileOffset()
  {
      if (impl_ == null)
          return fileOffset_;

      return impl_.getFileOffset();
  }

  String getPath() {
      return path_; // this field is never reset by the ImplRemote
  }

  int getShareOption() {
      return shareOption_; // this field is never reset by the ImplRemote
  }

  AS400 getSystem() {
      return system_; // this field is never reset by the ImplRemote
  }

  void incrementFileOffset(long fileOffsetIncrement)
  {
      if (impl_ == null)
      {
          synchronized (fileOffsetLock_) {
              fileOffset_ += fileOffsetIncrement;
          }
      } 
      else
          impl_.incrementFileOffset(fileOffsetIncrement);
  }

  boolean isClosed() {
      return closed_;
  }

  boolean isOpen()
  {
      if (impl_ == null)
          return false;

      return impl_.isOpen();
  }

  /**
   * Restores the state of this object from an object input stream.
   * 
   * @param ois The stream of state information.
   * @exception IOException            If an error occurs while communicating with the server.
   * @exception ClassNotFoundException
   **/
  private void readObject(java.io.ObjectInputStream ois) throws IOException, ClassNotFoundException
  {
      // Restore the non-static and non-transient fields.
      ois.defaultReadObject();

      // Initialize the transient fields.
      fileOffset_ = 0;
      parent_ = null;
      fileOffsetLock_ = new Object();
      impl_ = null;
  }

  void setFileOffset(long fileOffset) // @A1C - Change parameter from int to long
  {
      if (impl_ == null)
      {
          synchronized (fileOffsetLock_) {
              fileOffset_ = fileOffset;
          }
      } 
      else
          impl_.setFileOffset(fileOffset);
  }

  void setPath(String path)
  {
      if (impl_ == null)
          path_ = path;
      else
          throw new ExtendedIllegalStateException("path", ExtendedIllegalStateException.PROPERTY_NOT_CHANGED);
  }

  void setShareOption(int shareOption)
  {
      if (impl_ == null)
          shareOption_ = shareOption;
      else
          throw new ExtendedIllegalStateException("shareOption", ExtendedIllegalStateException.PROPERTY_NOT_CHANGED);
  }

  void setSystem(AS400 system)
  {
      if (impl_ == null)
          system_ = system;
      else
          throw new ExtendedIllegalStateException("system", ExtendedIllegalStateException.PROPERTY_NOT_CHANGED);
  }

  /**
   * Force the system buffers to synchronize with the underlying device.
   * 
   * @throws IOException If an error occurs while communicating with the system.
   **/
  public void sync() throws IOException
  {
      if (impl_ == null)
      {
          if (parent_ == null)
              Trace.log(Trace.ERROR, "Parent is null, nothing to synchronize.");
          else if (parent_ instanceof IFSRandomAccessFile)
              ((IFSRandomAccessFile) parent_).flush();
          else if (parent_ instanceof IFSFileOutputStream)
              ((IFSFileOutputStream) parent_).flush();
          else
              Trace.log(Trace.ERROR, "Parent does not have a flush() method: " + parent_.getClass().getName());
      } 
      else
          impl_.sync();
  }

  /**
   * Determines if this file descriptor represents an open file.
   * 
   * @return true if this file descriptor represents a valid, open file; false otherwise.
   **/
  public boolean valid() {
      return isOpen();
  }
}