com.ibm.as400.access.RecordFormat Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400 Show documentation
Show all versions of jt400 Show documentation
The Open Source version of the IBM Toolbox for Java
///////////////////////////////////////////////////////////////////////////////
//
// JTOpen (IBM Toolbox for Java - OSS version)
//
// Filename: RecordFormat.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 - 09/10/2007 - Change to ignore *NONE keys in addKeyFieldDescription()
//
///////////////////////////////////////////////////////////////////////////////
package com.ibm.as400.access;
import java.util.Hashtable;
import java.util.Vector;
import java.util.Enumeration;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.io.Serializable;
import java.beans.PropertyChangeSupport;
import java.beans.PropertyChangeListener;
import java.beans.VetoableChangeSupport; //@B0A
import java.beans.VetoableChangeListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyVetoException;
/**
*The RecordFormat class represents the format of data returned from an IBM i system.
*It contains FieldDescription objects that describe the
*data returned from a system. The RecordFormat class is used to generate a Record
*object that can be used to access the data returned from the system as Java objects or
*as byte arrays of IBM i data.
*For instance, the entries on a data queue
*may have a specific format. This format could be represented by a
*RecordFormat object. The RecordFormat object could be used to generate a Record
*object containing the data read from the data queue. Based on the description of the
*data contained in the RecordFormat object, the Record object could be used by the Java
*program to handle the data as Java objects. As another example, a parameter for a program
*may be
*an array of bytes representing several different types of data. Such a parameter
*could be described by a RecordFormat object.
*
*The RecordFormat class is also used to describe the record format of a file when using
*the record-level database access classes. The record format of the file must be set prior
*to invoking the open() method on an AS400File object.
*
*The RecordFormat class is also used to describe the record format of a record when using
*the LineDataRecordWriter class. The following record format attributes are required to be
*set.
*
*- Record format ID
*
- Record format type
*
- Field descriptions that make up the record format
*
- The delimiter, when the record format type is VARIABLE_LAYOUT_LENGTH
*
- Field description layout attributes,length and alignment, when the record format
*is FIXED_LAYOUT_LENGTH
*
*
*The RecordFormat class allows the user to do the following:
*
*- Describe the data returned from a system.
*
- Retrieve a Record object containing data that is described by the RecordFormat.
*
*RecordFormat objects generate the following events:
*
*- {@link com.ibm.as400.access.RecordDescriptionEvent RecordDescriptionEvent}
*
The events fired are:
*
*- fieldDescriptionAdded()
*
- keyFieldDescriptionAdded()
*
* - PropertyChangeEvent
*
- VetoableChangeEvent
*
*Examples
*
*- Using the RecordFormat class with the Data queue classes
*
- Using the RecordFormat class with the record-level database access classes
*
- Using the RecordFormat class with the LineDataRecordWriter class
*
*@see AS400FileRecordDescription
**/
public class RecordFormat implements Serializable
{
static final long serialVersionUID = 4L;
/** Constant indicating the layout length of all fields is fixed. **/ // @C1A
/** This constant is only used for record level writing. **/ // @C1A
public static final int FIXED_LAYOUT_LENGTH = 1; // @C1A
/** Constant indicating the layout length of all fields is variable. **/ //@C1A
/** This constant is only used for record level writing. **/ // @C1A
public static final int VARIABLE_LAYOUT_LENGTH = 2; // @C1A
// The delimiter used for printing variable length field records @C1A
private char delimiter_; // @C1A
// The fieldDescriptions that make up this record format.
private Vector fieldDescriptions_ = new Vector();
// Hashtable mapping the field names to their index in fieldDescriptions_
private Hashtable fieldNameToIndexMap_ = new Hashtable();
// Indicates if this format contains dependent fields
private boolean hasDependentFields_;
// The keyFieldDescriptions that make up this record format.
private Vector keyFieldDescriptions_ = new Vector();
// Hashtable mapping the key field names to their index in keyFieldDescriptions_
private Hashtable keyFieldNameToIndexMap_ = new Hashtable();
// Contains the index of the field depended on for length by the field description specified by the
// the index into this Vector.
private Vector lengthDependentFields_ = new Vector();
// Name of this record format
private String name_ = "";
// Constant used to indicate that a field is not a dependent field
private static final Integer NOT_DEPENDENT_ = Integer.valueOf(-1);
// Contains the index of the field depended on for offset by the field description specified by the
// the index into this Vector.
private Vector offsetDependentFields_ = new Vector();
// The record format type @C1A
private int recordFormatType_; // @C1A
// The record format ID @C1A
private String recordFormatID_ = ""; // @C1A
// Transient data.
transient private PropertyChangeSupport changes_; //@B0C
//@B0D transient private Vector currentVetoListeners_ = new Vector(); //@B0C
//@B0D transient private Vector currentRecordDescriptionListeners_ = new Vector(); //@B0C
transient private Vector rdListeners_; //@B0C
transient private VetoableChangeSupport vetos_; //@B0C
/**
*Constructs a RecordFormat object.
*Note: When using this object with the record level access classes,
*the version of the constructor that takes name must be used.
*@see RecordFormat#RecordFormat(java.lang.String)
**/
public RecordFormat()
{
initializeTransient(); //@B0A
}
/**
*Constructs a RecordFormat object. It uses the name specified.
*Note: Use this version of the constructor when the object is
*being used with the record level access classes.
*@param name The name of the record format. The name is converted
*to uppercase by this method. When using this object with the record level
*access classes, the name must be the name of the record format for
*the file that is being described.
**/
public RecordFormat(String name)
{
if (name == null)
{
throw new NullPointerException("name");
}
name_ = name.toUpperCase();
initializeTransient(); //@B0A
}
/**
*Adds a field description to this record format. The field description
*is added to the end of the field descriptions in this object.
*@param field The field description to be added.
**/
public void addFieldDescription(FieldDescription field)
{
if (field == null)
{
throw new NullPointerException("field");
}
// Map the name to the appropriate index
fieldNameToIndexMap_.put(field.getFieldName(), Integer.valueOf(fieldDescriptions_.size()));
// Add the field to the field descriptions
fieldDescriptions_.addElement(field);
// Indicate that this field is not a dependent field
lengthDependentFields_.addElement(NOT_DEPENDENT_);
// Indicate that this field is not a dependent field
offsetDependentFields_.addElement(NOT_DEPENDENT_);
// Fire FIELD_DESCRIPTION_ADDED event
//@B0D - removed event firing code block
fireEvent(RecordDescriptionEvent.FIELD_DESCRIPTION_ADDED); //@B0A
}
/**
*Adds a key field description to this record format.
*The key field description is determined by the index of a field description
*that was already added to this object. The key field description
*is added to the end of the key field descriptions in this object.
*The order in which the key field descriptions are added must match
*the order of the key fields in the files for which this record format
*is meant.
*@param index The index of a field description that was already
*added to this object via addFieldDescription(). The index must
*be in the range zero to getNumberOfFields() - 1.
**/
public void addKeyFieldDescription(int index)
{
if (index < 0 || index > fieldDescriptions_.size() - 1)
{
throw new ExtendedIllegalArgumentException("index", ExtendedIllegalArgumentException.RANGE_NOT_VALID);
}
FieldDescription f = (FieldDescription)fieldDescriptions_.elementAt(index);
// Map the name to the appropriate index
keyFieldNameToIndexMap_.put(f.getFieldName(), Integer.valueOf(keyFieldDescriptions_.size()));
// Add the field to the key field descriptions
keyFieldDescriptions_.addElement(f);
// Fire KEY_FIELD_DESCRIPTION_ADDED event
//@B0D - removed event firing code block
fireEvent(RecordDescriptionEvent.KEY_FIELD_DESCRIPTION_ADDED); //@B0A
}
/**
*Adds a key field description to this record format.
*The key field description is determined by the name of a field description
*that was already added to this object. The key field description
*is added to the end of the key field descriptions in this object.
*The order in which the key field descriptions are added must match
*the order of the key fields in the files for which this record format
*is meant.
*@param name The name of a field description that was already
*added to this object via addFieldDescription(). The name is
*case sensitive.
**/
public void addKeyFieldDescription(String name)
{
if (name == null)
{
throw new NullPointerException("name");
}
// Do not add this key if the key is *NONE
if (!(name.equals("*NONE"))) //@A1A
{
// Key(s) of *NONE are just place holders for DB code for multi-format
// logical files. Key(s) of *NONE allows DB to build a search index
// for a multi-format logical file. The toolbox code does not use the
// *NONE key(s) in any way.
addKeyFieldDescription(getIndexOfFieldName(name));
}
}
/**
*Adds a listener to be notified when the value of any bound
*property is changed. The propertyChange method will be
*called.
*@see #removePropertyChangeListener
*@param listener The PropertyChangeListener.
**/
public /*@B0D synchronized*/ void addPropertyChangeListener(PropertyChangeListener listener)
{
if (listener == null)
{
throw new NullPointerException("listener");
}
if (changes_ == null) changes_ = new PropertyChangeSupport(this);
changes_.addPropertyChangeListener(listener);
}
/**
*Adds a listener to be notified when a RecordDescriptionEvent is fired.
*@see #removeRecordDescriptionListener
*@param listener The RecordDescriptionListener.
**/
public /*@B0D synchronized*/ void addRecordDescriptionListener(RecordDescriptionListener listener)
{
if (listener == null)
{
throw new NullPointerException("listener");
}
if (rdListeners_ == null) rdListeners_ = new Vector();
rdListeners_.addElement(listener); //@B0C
//@B0D currentRecordDescriptionListeners_ = (Vector)recordDescriptionListeners_.clone();
}
/**
*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 /*@B0D synchronized*/ void addVetoableChangeListener(VetoableChangeListener listener)
{
if (listener == null)
{
throw new NullPointerException("listener");
}
if (vetos_ == null) vetos_ = new VetoableChangeSupport(this);
vetos_.addVetoableChangeListener(listener); //@B0C
//@B0D currentVetoListeners_ = (Vector)vetoListeners_.clone();
}
//@B0A
/**
* Fire the appropriate event.
**/
private void fireEvent(int index)
{
if (rdListeners_ == null) return;
Vector targets = (Vector)rdListeners_.clone();
RecordDescriptionEvent event = new RecordDescriptionEvent(this, index);
for (int i=0; iindex must
*be in the range zero to getNumberOfFields() - 1.
*@return The field description.
**/
public FieldDescription getFieldDescription(int index)
{
if (index < 0 || index > fieldDescriptions_.size() - 1)
{
throw new ExtendedIllegalArgumentException("index", ExtendedIllegalArgumentException.RANGE_NOT_VALID);
}
return (FieldDescription)fieldDescriptions_.elementAt(index);
}
/**
*Returns the field description with the specified name.
*@param name The name of the field description. The name is
*case sensitive.
*@return The field description.
**/
public FieldDescription getFieldDescription(String name)
{
return (FieldDescription)fieldDescriptions_.elementAt(getIndexOfFieldName(name));
}
/**
*Returns the field descriptions that make up this object.
*@return The field descriptions. An array of size zero is returned if no
*fields have been added to this object.
**/
public FieldDescription[] getFieldDescriptions()
{
FieldDescription[] fds = new FieldDescription[fieldDescriptions_.size()];
fieldDescriptions_.copyInto(fds);
return fds;
}
/**
*Returns the names of the field descriptions that make up this record format.
*@return The names of the field descriptions. An array of size zero is
*returned if no fields have been added to this object.
**/
public String[] getFieldNames()
{
int size = fieldDescriptions_.size();
String[] names = new String[size];
for (int i = 0; i < size; ++i)
{
names[i] = ((FieldDescription)fieldDescriptions_.elementAt(i)).getFieldName();
}
return names;
}
/**
*Indicates if this record format contains dependent fields.
*@return true if this record format contains dependent fields; false otherwise
**/
boolean getHasDependentFields()
{
return hasDependentFields_;
}
/**
*Returns the index of the field description named name.
*@param name The name of the field description. The name
*is case sensitive.
*@return The index of the field description.
**/
public int getIndexOfFieldName(String name)
{
if (name == null)
{
throw new NullPointerException("name");
}
Integer i = (Integer)fieldNameToIndexMap_.get(name);
if (i == null)
{
throw new ExtendedIllegalArgumentException("name (" + name + ")", ExtendedIllegalArgumentException.FIELD_NOT_FOUND);
}
return i.intValue();
}
/**
*Returns the index of the field description of the key field named name.
*@param name The name of the key field description. The name is
*case sensitive.
*@return The index of the key field description. This is the index of the key field description
*in the key field descriptions for this object. It is not the index of the field description in the
*field descriptions for this object.
**/
public int getIndexOfKeyFieldName(String name)
{
if (name == null)
{
throw new NullPointerException("name");
}
Integer i = (Integer)keyFieldNameToIndexMap_.get(name);
if (i == null)
{
throw new ExtendedIllegalArgumentException("name (" + name + ")", ExtendedIllegalArgumentException.FIELD_NOT_FOUND);
}
return i.intValue();
}
/**
*Returns the field description of the key field at the specified index.
*@param index The index of the key field description in the key field descriptions for this object.
*@return The key field description.
**/
public FieldDescription getKeyFieldDescription(int index)
{
if (index < 0 || index > fieldDescriptions_.size() - 1)
{
throw new ExtendedIllegalArgumentException("index", ExtendedIllegalArgumentException.RANGE_NOT_VALID);
}
return (FieldDescription)keyFieldDescriptions_.elementAt(index);
}
/**
*Returns the field description of the key field with the specified name.
*@param name The name of the key field description. The name is
*case sensitive.
*@return The key field description.
**/
public FieldDescription getKeyFieldDescription(String name)
{
if (name == null)
{
throw new NullPointerException("name");
}
return (FieldDescription)keyFieldDescriptions_.elementAt(getIndexOfKeyFieldName(name));
}
/**
*Returns the key field descriptions that make up this object.
*@return The key field descriptions.
**/
public FieldDescription[] getKeyFieldDescriptions()
{
FieldDescription[] fds = new FieldDescription[keyFieldDescriptions_.size()];
keyFieldDescriptions_.copyInto(fds);
return fds;
}
/**
*Returns the names of the field descriptions of the keys that make up this record format.
*@return The names of the key field descriptions. If no key field descriptions exist,
*an array of size 0 is returned.
**/
public String[] getKeyFieldNames()
{
int size = keyFieldDescriptions_.size();
String[] names = new String[size];
for (int i = 0; i < size; ++i)
{
names[i] = ((FieldDescription)keyFieldDescriptions_.elementAt(i)).getFieldName();
}
return names;
}
/**
*Returns the index of the field description on which the field description at the specified
*index depends.
*@param index The index of the field description. The index must be in the range 0 to
*getNumberOfFields() - 1.
*@return The index of the field description on which the field description at the specified
*index depends.
*If index is not the index of a dependent field, -1 is returned.
**/
public int getLengthDependency(int index)
{
if (index < 0 || index > fieldDescriptions_.size() - 1)
{
throw new ExtendedIllegalArgumentException("index", ExtendedIllegalArgumentException.RANGE_NOT_VALID);
}
return ((Integer)lengthDependentFields_.elementAt(index)).intValue();
}
/**
*Returns the index of the field description on which the field description with the specified
*name depends.
*@param name The name of the field description. The name is
*case sensitive.
*@return The index of the field description on which the field description with the specified
*name depends.
*If name is not the name of a dependent field, -1 is returned.
**/
public int getLengthDependency(String name)
{
if (name == null)
{
throw new NullPointerException("name");
}
return ((Integer)lengthDependentFields_.elementAt(getIndexOfFieldName(name))).intValue();
}
/**
*Returns the name of this record format.
*@return The name of this record format. If the name has not been
*set, an empty string is returned.
**/
public String getName()
{
return name_;
}
/**
*Returns a new record based on this record format, which contains default values for the
*contents of the fields. The default values are determined as follows:
*
*- Use the value specified for the DFT keyword on the field description object for
*a particular field.
*
- If no value was specified for the DFT keyword, use the default value from the
*AS400DataType object specified when constructing the field description object for
*a particular field.
*
*@return A record based on this record format. If no field descriptions have been
*added to this object, null is returned.
**/
public Record getNewRecord()
{
if (fieldDescriptions_.size() == 0)
{
return null;
}
return new Record(this);
}
/**
*Returns a new record based on this record format, which contains default values for the
*contents of the fields. The default values are determined as follows:
*
*- Use the value specified for the DFT keyword on the field description object for
*a particular field.
*
- If no value was specified for the DFT keyword, use the default value from the
*AS400DataType object specified when constructing the field description object for
*a particular field.
*
*@param recordName The name to assign to the Record object being returned.
*@return A record based on this record format.
*If no field descriptions have been added to this object, null is returned.
**/
public Record getNewRecord(String recordName)
{
if (recordName == null)
{
throw new NullPointerException("recordName");
}
if (fieldDescriptions_.size() == 0)
{
return null;
}
return new Record(this, recordName);
}
/**
*Returns a new record based on this record format, which contains data from
*the specified byte array.
*@param contents The data with which to initialize the contents of the record.
*The length of contents must be greater than zero.
*@return A record based on this record format.
*If no field descriptions have been added to this object, null is returned.
*@exception UnsupportedEncodingException If an error occurs during conversion.
**/
public Record getNewRecord(byte[] contents)
throws UnsupportedEncodingException
{
return getNewRecord(contents, 0);
}
/**
*Returns a new record based on this record format, which contains data from
*the specified byte array.
*@param contents The data with which to initialize the contents of the record.
*The length of contents must be greater than zero.
*@param recordName The name to assign to the Record object being returned.
*@return A record based on this record format.
*If no field descriptions have been added to this object, null is returned.
*@exception UnsupportedEncodingException If an error occurs during conversion.
**/
public Record getNewRecord(byte[] contents, String recordName)
throws UnsupportedEncodingException
{
return getNewRecord(contents, 0, recordName);
}
/**
*Returns a new record based on this record format, which contains data from
*the specified byte array.
*@param contents The data with which to initialize the contents of the record.
*The length of contents must be greater than zero.
*@param offset The offset in contents at which to start. The offset
*cannot be less than zero.
*@return A record based on this record format.
*If no field descriptions have been added to this object, null is returned.
*@exception UnsupportedEncodingException If an error occurs during conversion.
**/
public Record getNewRecord(byte[] contents, int offset)
throws UnsupportedEncodingException
{
if (contents == null)
{
throw new NullPointerException("contents");
}
if (contents.length == 0)
{
throw new ExtendedIllegalArgumentException("contents", ExtendedIllegalArgumentException.LENGTH_NOT_VALID);
}
if (offset < 0)
{
throw new ExtendedIllegalArgumentException("offset", ExtendedIllegalArgumentException.PARAMETER_VALUE_NOT_VALID);
}
if (fieldDescriptions_.size() == 0)
{
return null;
}
return new Record(this, contents, offset);
}
/**
*Returns a new record based on this record format, which contains data from
*the specified byte array.
*@param contents The data with which to initialize the contents of the record.
*The length of contents must be greater than zero.
*@param offset The offset in contents at which to start. The offset
*cannot be less than zero.
*@param recordName The name to assign to the Record object being returned.
*@return A record based on this record format.
*If no field descriptions have been added to this object, null is returned.
*@exception UnsupportedEncodingException If an error occurs during conversion.
**/
public Record getNewRecord(byte[] contents, int offset, String recordName)
throws UnsupportedEncodingException
{
if (contents == null)
{
throw new NullPointerException("contents");
}
if (contents.length == 0)
{
throw new ExtendedIllegalArgumentException("contents", ExtendedIllegalArgumentException.LENGTH_NOT_VALID);
}
if (offset < 0)
{
throw new ExtendedIllegalArgumentException("offset", ExtendedIllegalArgumentException.PARAMETER_VALUE_NOT_VALID);
}
if (recordName == null)
{
throw new NullPointerException("recordName");
}
if (fieldDescriptions_.size() == 0)
{
return null;
}
return new Record(this, contents, offset, recordName);
}
/**
*Returns the number of field descriptions in this record format.
*@return The number of field descriptions in this record format.
**/
public int getNumberOfFields()
{
return fieldDescriptions_.size();
}
/**
*Returns the number of key field descriptions in this record format.
*@return The number of key field descriptions in this record format.
**/
public int getNumberOfKeyFields()
{
return keyFieldDescriptions_.size();
}
/**
*Returns the index of the field description on which the field description at the specified
*index depends.
*@param index The index of the field description. The index must be in the range 0 to
*getNumberOfFields() - 1.
*@return The index of the field description on which the field description at the specified
*index depends.
*If index is not the index of a dependent field, -1 is returned.
**/
public int getOffsetDependency(int index)
{
if (index < 0 || index > fieldDescriptions_.size() - 1)
{
throw new ExtendedIllegalArgumentException("index", ExtendedIllegalArgumentException.RANGE_NOT_VALID);
}
return ((Integer)offsetDependentFields_.elementAt(index)).intValue();
}
/**
*Returns the index of the field description on which the field description with the specified
*name depends.
*@param name The name of the field description. The name is
*case sensitive.
*@return The index of the field description on which the field description with the specified
*name depends.
*If name is not the name of a dependent field, -1 is returned.
**/
public int getOffsetDependency(String name)
{
if (name == null)
{
throw new NullPointerException("name");
}
return ((Integer)offsetDependentFields_.elementAt(getIndexOfFieldName(name))).intValue();
}
// @C1A - added method
/**
* Returns the record format ID.
* The record format ID corresponds to a record format ID within a page definition
* defined on the system.
*
* @return The record format ID.
**/
public String getRecordFormatID()
{
return recordFormatID_;
}
// @C1A - added method
/**
* Returns the record format type.
*
* @return The record format type.
**/
public int getRecordFormatType()
{
return recordFormatType_;
}
//@D0A
/**
* This should be called by any class that is running proxified and retrieves
* a RecordFormat from the System i side.
**/
void initializeTextObjects(AS400 system)
{
//@D0A - need to finish filling in the AS400Text objects
// now that we're back on the client
for (int i=0; ifieldDependedOn must have been added prior to adding the
*dependentField.
*@param dependentField The index of the dependent field. The
*dependentField must be in the range 1 to getNumberOfFields() - 1.
*@param fieldDependedOn The index of a field on which this field depends. The fieldDependedOn must
*be in the range 0 to dependentField.
**/
public void setLengthDependency(int dependentField, int fieldDependedOn)
{
if (dependentField < 0)
{
throw new ExtendedIllegalArgumentException("dependentField", ExtendedIllegalArgumentException.RANGE_NOT_VALID);
}
if (dependentField > fieldDescriptions_.size() - 1)
{
throw new ExtendedIllegalArgumentException("dependentField", ExtendedIllegalArgumentException.RANGE_NOT_VALID);
}
if (fieldDependedOn < 0)
{
throw new ExtendedIllegalArgumentException("fieldDependedOn", ExtendedIllegalArgumentException.RANGE_NOT_VALID);
}
if (dependentField > fieldDescriptions_.size() - 1)
{
throw new ExtendedIllegalArgumentException("dependentField", ExtendedIllegalArgumentException.RANGE_NOT_VALID);
}
if (fieldDependedOn >= dependentField)
{
throw new ExtendedIllegalArgumentException("fieldDependedOn", ExtendedIllegalArgumentException.PARAMETER_VALUE_NOT_VALID);
}
lengthDependentFields_.setElementAt(Integer.valueOf(fieldDependedOn), dependentField);
hasDependentFields_ = true;
}
/**
*Sets the field on which a dependent field depends. Both fields must have been added already
*to this RecordFormat. The fieldDependedOn must have been added prior to adding the
*dependentField. The names of the fields are
*case sensitive.
*@param dependentField The name of the dependent field.
*@param fieldDependedOn The name of a field on which this field depends. The index of
*fieldDependedOn in this RecordFormat must be less than the index of dependentField.
**/
public void setLengthDependency(String dependentField, String fieldDependedOn)
{
if (dependentField == null)
{
throw new NullPointerException("dependentField");
}
if (fieldDependedOn == null)
{
throw new NullPointerException("fieldDependedOn");
}
int depOnIndex = getIndexOfFieldName(fieldDependedOn);
int depIndex = getIndexOfFieldName(dependentField);
setLengthDependency(depIndex, depOnIndex);
}
/**
*Sets the name of this record format.
*@param name The name of this record format.
*The name is converted to uppercase by this method.
*@exception PropertyVetoException If a change is vetoed.
**/
public void setName(String name)
throws PropertyVetoException
{
if (name == null)
{
throw new NullPointerException("name");
}
//@B0D: removed old veto-listener code block
String old = name_;
if (vetos_ != null) vetos_.fireVetoableChange("name", old, name.toUpperCase()); //@B0A
name_ = name.toUpperCase();
if (changes_ != null) changes_.firePropertyChange("name", old, name_);
}
/**
*Sets the field on which a dependent field depends. Both fields must have been added already
*to this RecordFormat. The fieldDependedOn must have been added prior to adding the
*dependentField.
*@param dependentField The index of the dependent field. The
*dependentField must be in the range 1 to getNumberOfFields() - 1.
*@param fieldDependedOn The index of a field on which this field depends. The fieldDependedOn must
*be in the range 0 to dependentField.
**/
public void setOffsetDependency(int dependentField, int fieldDependedOn)
{
if (dependentField < 0)
{
throw new ExtendedIllegalArgumentException("dependentField", ExtendedIllegalArgumentException.RANGE_NOT_VALID);
}
if (fieldDependedOn < 0)
{
throw new ExtendedIllegalArgumentException("fieldDependedOn", ExtendedIllegalArgumentException.RANGE_NOT_VALID);
}
if (dependentField > fieldDescriptions_.size() - 1)
{
throw new ExtendedIllegalArgumentException("dependentField", ExtendedIllegalArgumentException.RANGE_NOT_VALID);
}
if (fieldDependedOn >= dependentField)
{
throw new ExtendedIllegalArgumentException("fieldDependedOn", ExtendedIllegalArgumentException.PARAMETER_VALUE_NOT_VALID);
}
offsetDependentFields_.setElementAt(Integer.valueOf(fieldDependedOn), dependentField);
hasDependentFields_ = true;
}
/**
*Sets the field on which a dependent field depends. Both fields must have been added already
*to this RecordFormat. The fieldDependedOn must have been added prior to adding the
*dependentField. The names of the fields are
*case sensitive.
*@param dependentField The name of the dependent field.
*@param fieldDependedOn The name of a field on which this field depends. The index of
*fieldDependedOn in this RecordFormat must be less than the index of dependentField.
**/
public void setOffsetDependency(String dependentField, String fieldDependedOn)
{
if (dependentField == null)
{
throw new NullPointerException("dependentField");
}
if (fieldDependedOn == null)
{
throw new NullPointerException("fieldDependedOn");
}
int depOnIndex = getIndexOfFieldName(fieldDependedOn);
int depIndex = getIndexOfFieldName(dependentField);
setOffsetDependency(depIndex, depOnIndex);
}
// @C1A - added method
/**
* Sets the record format ID. The length of the record format ID must be 10 characters
* or less. The record format ID corresponds to a record format ID within a page
* definition on the system. If the record format ID is less than 10 characters,
* it is padded to 10 characters in length with spaces.
*
* @param id The record format ID.
**/
public void setRecordFormatID(String id)
{
String pad = " " ;
if (id.length() > 10) {
throw new ExtendedIllegalArgumentException("id",
ExtendedIllegalArgumentException.LENGTH_NOT_VALID);
}
if (id.length() < 10) {
int padl = 10 - id.length();
recordFormatID_ = id + pad.substring(0,padl);
}
else
recordFormatID_ = id;
}
// @C1A - added method
/**
* Sets the record format type. Valid values are FIXED_LAYOUT_LENGTH and
* VARIABLE_LAYOUT_LENGTH. This attribute is only valid when using the
* line record writer class.
*
* @param type The record format type.
**/
public void setRecordFormatType(int type)
{
if ((type != VARIABLE_LAYOUT_LENGTH) && (type != FIXED_LAYOUT_LENGTH)) {
throw new ExtendedIllegalArgumentException("type",
ExtendedIllegalArgumentException.PARAMETER_VALUE_NOT_VALID);
}
recordFormatType_ = type;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy