com.ibm.as400.access.AS400FileRecordDescription 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: AS400FileRecordDescription.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.                                                
//                                                                             
///////////////////////////////////////////////////////////////////////////////

package com.ibm.as400.access;

import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.Serializable;
import java.net.UnknownHostException;
import java.util.Vector;
import java.beans.PropertyChangeSupport;
import java.beans.PropertyChangeListener;
import java.beans.VetoableChangeListener;
import java.beans.VetoableChangeSupport; //@C0A
import java.beans.PropertyChangeEvent;
import java.beans.PropertyVetoException;

/**
 *The AS400FileRecordDescription class represents the record descriptions of a physical
 *or logical file on the system.  This class is used to retrieve the file field description
 *of a physical or logical file, and to create Java source code
 *for a class extending from
 *{@link com.ibm.as400.access.RecordFormat RecordFormat} that
 *can then be compiled and used as input to the
 *{@link com.ibm.as400.access.AS400File#setRecordFormat(com.ibm.as400.access.RecordFormat) AS400File.setRecordFormat()}
 *method.
 *This allows the record format to be created statically during
 *development time and then reused when needed.
 *The class also provides a method for returning RecordFormat objects
 *that can be used as input to the AS400File.setRecordFormat() method.
 *This method can be used to create the record format dynamically.
 *The output from the {@link com.ibm.as400.access.AS400FileRecordDescription#createRecordFormatSource(java.lang.String, java.lang.String) createRecordFormatSource()}
 *and
 *{@link com.ibm.as400.access.AS400FileRecordDescription#retrieveRecordFormat retrieveRecordFormat()} methods
 *contains enough information to use to describe the record format of the
 *existing file from which it was generated.  The record formats
 *generated are not meant for creating files with the same format as the
 *file from which they are retrieved.  Use the Copy File (CPYF) command to create
 *a file with the same format as an existing file.
 *

 *AS400FileRecordDescription objects generate the following events:
 *

 *{@link com.ibm.as400.access.AS400FileRecordDescriptionEvent AS400FileRecordDescriptionEvent}
 *
The events fired are:
 *
 *recordFormatRetrieved
 *
recordFormatSourceCreated
 *
 *
PropertyChangeEvent
 *
VetoableChangeEvent
 *
 **/
public class AS400FileRecordDescription implements Serializable
{
  private static final String copyright = "Copyright (C) 1997-2004 International Business Machines Corporation and others.";



    static final long serialVersionUID = 4L;



    // File name
    private String file_ = "";
    // Library name
    //@C0D private String library_ = "";
    // member name
    private String member_ = "";
    // The IFS path name of the file
    private String name_ = "";
    // The system the file is on
    private AS400 system_ = null;

    // The list of AS400FileRecordDescriptionEvent listeners
    transient Vector rdeListeners_;
    // Use default property change support
    transient PropertyChangeSupport changes_;
    // Use default veto change support
    transient VetoableChangeSupport vetos_; //@C0C

    // The impl.
    transient private AS400FileRecordDescriptionImpl impl_; //@C0A

    /**
     *Constructs an AS400FileRecordDescription object.
     *The system on which the file resides and the name of the
     *file must be set prior to invoking any other method in the class.
     *@see AS400FileRecordDescription#setSystem
     *@see AS400FileRecordDescription#setPath
     **/
    public AS400FileRecordDescription()
    {
        initializeTransient();
    }

    /**
     *Constructs an AS400FileRecordDescription object. It uses the specified system on
     *which the file resides and the
     *integrated file system path name of
     *the file.
     *@param system The system on which the file resides.
     *@param name The integrated file system path name
     *of the file.  If a member is not specified in name, the first
     *member of the file is used.
     **/
    public AS400FileRecordDescription(AS400 system, String name)
    {
        if (system == null)
        {
            throw new NullPointerException("system");
        }
        if (name == null)
        {
            throw new NullPointerException("name");
        }
        initializeTransient();
        name_ = name;
        parseName(); //@C0A
        system_ = system;
    }


    /**
     *Adds a listener to be notified when an AS400FileRecordDescriptionEvent is fired.
     *@see #removeAS400FileRecordDescriptionListener
     *@param listener The As400FileRecordDescriptionListener.
     **/
    public void addAS400FileRecordDescriptionListener(AS400FileRecordDescriptionListener listener)
    {
        if (listener == null)
        {
            throw new NullPointerException("listener");
        }
        rdeListeners_.addElement(listener);
    }

    /**
     *Adds a listener to be notified when the value of any bound
     *property is changed.  The propertyChange method will be
     *be called.
     *@see #removePropertyChangeListener
     *@param listener The PropertyChangeListener.
     **/
    public void addPropertyChangeListener(PropertyChangeListener listener)
    {
        if (listener == null)
        {
            throw new NullPointerException("listener");
        }
        changes_.addPropertyChangeListener(listener);
    }

    /**
     *Adds a listener to be notified when the value of any constrained
     *property is changed.
     *The vetoableChange method will be called.
     *@see #removeVetoableChangeListener
     *@param listener The VetoableChangeListener.
     **/
    public void addVetoableChangeListener(VetoableChangeListener listener)
    {
        if (listener == null)
        {
            throw new NullPointerException("listener");
        }
        vetos_.addVetoableChangeListener(listener); //@C0C
    }


    /**
     Chooses the appropriate implementation.
     **/
    private synchronized void chooseImpl() throws AS400SecurityException, IOException
    {
        if (impl_ == null)
        {
            impl_ = (AS400FileRecordDescriptionImpl) system_.loadImpl2("com.ibm.as400.access.AS400FileRecordDescriptionImplRemote",
                                                                       "com.ibm.as400.access.AS400FileRecordDescriptionImplProxy");
            //@E0: We want the connectService() to throw the exception, otherwise
            //     later on down the line, we'll try to use the impl_ we loaded but
            //     its state will not be valid. (This usually exhibits itself as
            //     a NullPointerException when the ImplRemote tries to reconnect.)
            //     We can get away with this because the only methods that
            //     call chooseImpl() already throw AS400SecurityException and IOException.

            //@E0D    try                                           //@B5A
            //@E0D    {
            //      system_.connectService(AS400.RECORDACCESS); //@B5A
            //@E0D    }
            //@E0D    catch(IOException x)                          //@B5A
            //@E0D    {
            //@E0D      if (Trace.isTraceOn() && Trace.isTraceErrorOn()) //@B5A
            //@E0D        Trace.log(Trace.ERROR, "Exception when connecting during chooseImpl().", x);
            //@E0D    }
            //@E0D    catch(AS400SecurityException x)               //@B5A
            //@E0D    {
            //@E0D      if (Trace.isTraceOn() && Trace.isTraceErrorOn()) //@B5A
            //@E0D        Trace.log(Trace.ERROR, "Exception when connecting during chooseImpl().", x);
            //@E0D    }
            impl_.setPath(name_);     //@C0A
            impl_.setSystem(system_.getImpl()); //@C0A @B5C
        }
        system_.signon(false);
    }


    /**
     *Retrieves the file description for the file, and creates a file containing the Java source for
     *a class extending from RecordFormat that represents the record format for the file.  If the
     *file contains more than one record format (for example, is a multiple format logical file), a Java
     *source file for each record format in the file is created; each file will contain the class
     *definition for a single record format.

     *The name of the class is the name of the record format retrieved with the string "Format"
     *appended to it.  The name of the file is the name of the class with the extension .java.

     *The source files generated can be compiled and used as input to the
     *{@link com.ibm.as400.access.AS400File#setRecordFormat(com.ibm.as400.access.RecordFormat) AS400File.setRecordFormat()} method.

     *The system to which to connect and the integrated file system
     *pathname for the file must be set prior to invoking this method.
     *@see AS400FileRecordDescription#AS400FileRecordDescription(com.ibm.as400.access.AS400, java.lang.String)
     *@see AS400FileRecordDescription#setPath
     *@see AS400FileRecordDescription#setSystem
     *@param filePath The path of the directory in which to create the file.  If filePath is null,
     *the file is created in the current working directory.
     *@param packageName The name of the package in which the class belongs. The packageName
     *is used to specify the package statement in the source code for the class.
     * If this value is null, no package statement is specified in the source code for the class.

     *@exception AS400Exception If the system returns an error message.
     *@exception AS400SecurityException If a security or authority error occurs.
     *@exception ConnectionDroppedException If the connection is dropped unexpectedly.
     *@exception IOException If an error occurs while communicating with the
     *system.
     *@exception InterruptedException If this thread is interrupted.
     *@exception ServerStartupException If the host server cannot be started.
     *@exception UnknownHostException If the system cannot be located.
     **/
    public synchronized void createRecordFormatSource(String filePath, String packageName)
      throws AS400Exception,
    AS400SecurityException,
    IOException,
    InterruptedException
    {
        chooseImpl();
        String[] filesToWrite = impl_.createRecordFormatSource(packageName); //@C0A

        // Get the file separator for the system on which we are running
        String fileSeparator = System.getProperty("file.separator");
        // Append file separator if necessary to filePath
        if (filePath != null)
        {
            if (filePath.lastIndexOf(fileSeparator) != filePath.length() - fileSeparator.length())
            {
                filePath += fileSeparator;
            }
        }
        else
        {
            filePath = "";
        }
        FileOutputStream os;
        PrintWriter sourceFile;
        String fileName;
        //@C0A
        for (int i=0; i<(filesToWrite.length/2); ++i)
        {
            fileName = filePath + filesToWrite[i*2]; //@C0C
            os = new FileOutputStream(fileName);
            sourceFile = new PrintWriter(os, true);
            sourceFile.print(filesToWrite[(i*2)+1]); //@C0A
            if (sourceFile.checkError())
            {
                sourceFile.close();
                throw new InternalErrorException("Error writing to sourceFile.", InternalErrorException.UNKNOWN);
            }
            sourceFile.close();
        }

        //@C0C
        // Fire RECORD_FORMAT_SOURCE_CREATED event
        Vector targets = (Vector) rdeListeners_.clone();
        AS400FileRecordDescriptionEvent event = new AS400FileRecordDescriptionEvent(this, AS400FileRecordDescriptionEvent.RECORD_FORMAT_SOURCE_CREATED);
        for (int i=0; iname, the first
     *member of the file is used.
     *@exception PropertyVetoException If a change is vetoed.
     **/
    public void setPath(String name)
      throws PropertyVetoException
    {
        // Verify parameters
        if (name == null)
        {
            throw new NullPointerException("name");
        }

        String oldName = name_;

        //@C0C
        // Notify veto listeners of the change
        vetos_.fireVetoableChange("path", oldName, name);

        name_ = name;
        parseName(); //@C0A

        if (impl_ != null) impl_.setPath(name_); //@C0A
        changes_.firePropertyChange("path", oldName, name); //@C0C
    }

    /**
     *Sets the system to which to connect.
     *@param system The system to which to conenct.
     *@exception PropertyVetoException If a change is vetoed.
     **/
    public void setSystem(AS400 system)
      throws PropertyVetoException
    {
        // Verify parameters
        if (system == null)
        {
            throw new NullPointerException("system");
        }

        //@C0C
        // Notify veto listeners of the change
        AS400 old = system_;
        vetos_.fireVetoableChange("system", old, system);

        system_ = system;
        if (impl_ != null) impl_.setSystem(system_.getImpl()); //@C0A @B5C
        changes_.firePropertyChange("system", old, system_);
    }
}