TrianaType

java.lang.Object
- triana.types.TrianaType

All Implemented Interfaces:

java.io.Serializable, SequenceInterface

Direct Known Subclasses:

DefaultType, Document, EmptyingType, FileName, GraphType, Parameter, TrianaImage, TrianaPixelMap
```
public abstract class TrianaType
extends java.lang.Object
implements java.io.Serializable, SequenceInterface
```
TrianaType is the root class for data types in Triana. It is an abstract class that provides the basic data structures but does not fill them. All working Triana data types must be derived from TrianaType.
The main data objects in TrianaType are:
- A Hashtable dataContainer which should be used in derived classes to hold the main data, which could consist of numerical arrays representing function values, geometrical objects, images, and so on, or which could consist of a text string (as in the Document data type).
- A Vector of Strings (in a StringVector object) called description that can carry information about the data object, for example the time the object was created and the OldUnit that created it, including the values of the OldUnit's parameters when it processed the data.
- A Journal (called journal) that records the description of the current data object and the journals of all the data objects that were used to create it. Thus, journal is a tree of the descriptions of all the data objects whose data went into the present one. In this way data objects can include their entire history of generation, which can be useful when exchanging data between collaborators or in verifying important results.
- A String called legend, which can be used to identify the data object in displays, such as in titles on graphs.
TrianaType implements a number of methods for setting and examining these data. In addition, the class defines two groups of methods that must be implemented for each Triana data type. These include
- Methods copyMe, copyData, and copyParameters, which are vital for passing data from one OldUnit to another, and
- methods inputFromStream and outputToStream, which perform ascii i/o that permits units to display their contents and pass data to non-Java programs and between computing platforms that have different binary representations.
TrianaType also implements a mechanism for allowing Units to attach data to TrianaType data objects. These attachments are called ClipIns, and the attachment holder is called theClip. See the ClipIn interface for details of how these optional attachments work. TrianaType includes a number of methods for attaching, inspecting, and deleting ClipIns.
Type programmers note: Please take note of this class and implement the functions within it when creating new Triana types. For example, the copyMe group of methods is essential to the running of the units, for the reason given in the next paragraph.
OldUnit programmers note: To avoid memory problems, units should normally modify an input data object and output it, rather than copy it. If an output data object is to be of the same type as an input object, then programmers can usually use the copyMe method of the input data to create the new object and then modify its data appropriately. This is easier than instantiating a new object with its Constructors.
See Also:
GraphType, TrianaImage, Document, Journal, Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static TrianaType`	`NOT_CONNECTED` If the input node is set to essential (the default) and there is no cable connected to this input node this constant is returned
`static TrianaType`	`NOT_READY` A TrianaType which represents that the data is not ready.
`static TrianaType`	`OUT_OF_RANGE`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`TrianaType()` Creates an empty TrianaType, adds a message to the description saying when it was created, and constructs the Journal from this description.

Method Summary

Methods
Modifier and Type	Method and Description
`int`	`containerSize()` Returns the actual number of elements stored in the dataContainer Hashtable.
`protected void`	`copyData(TrianaType source)` Copies data held in dataContainer from the argument object to the current object.
`abstract TrianaType`	`copyMe()` This is one of the most important methods of Triana data.
`protected void`	`copyParameters(TrianaType source)` Copies modifiable parameters from the argument object to the current object.
`boolean`	`dataExists(java.lang.Object k)` Returns true if the dataContainer Hashtable contains an object with the given argument k as a key.
`boolean`	`deleteFromContainer(java.lang.Object k)` Deletes the element from the dataContainer Hashtable that is associated with the given key k.
`java.util.Hashtable`	`getDataContainer()` Returns the dataContainer Hashtable.
`java.lang.Object`	`getFromContainer(java.lang.Object k)` Returns the Object from the dataContainer associated with the given argument key k.
`int`	`getSequenceNumber()`
`void`	`insertIntoContainer(java.lang.Object k, java.lang.Object d)` Inserts the given Object d (second argument) into the dataContainer Hashtable with the argument Object k (first argument) as a key.
`java.util.Enumeration`	`inspectDataContainer()` Returns an Enumeration containing the keys identifying the contents of the dataContainer Hashtable.
`void`	`setDataContainer(java.util.Hashtable h)` Initializes the dataContainer Hashtable.
`void`	`setSequenceNumber(int sequenceNumber)`
`protected void`	`updateObsoletePointers()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - NOT_READY
```
public static final TrianaType NOT_READY
```
    A TrianaType which represents that the data is not ready.
  - NOT_CONNECTED
```
public static final TrianaType NOT_CONNECTED
```
    If the input node is set to essential (the default) and there is no cable connected to this input node this constant is returned
  - OUT_OF_RANGE
```
public static final TrianaType OUT_OF_RANGE
```
- Constructor Detail
  - TrianaType
```
protected TrianaType()
```
    Creates an empty TrianaType, adds a message to the description saying when it was created, and constructs the Journal from this description. Most Units automatically add the journals of input data sets to the journal of an object they create, provided the user elects this option.
- Method Detail
  - setDataContainer
```
public void setDataContainer(java.util.Hashtable h)
```
    Initializes the dataContainer Hashtable.
    
    Parameters:
    h - Any Hashtable that may contain suitable data.
  - getDataContainer
```
public java.util.Hashtable getDataContainer()
```
    Returns the dataContainer Hashtable.
    
    Returns:
    Hashtable containing the data.
  - inspectDataContainer
```
public java.util.Enumeration inspectDataContainer()
```
    Returns an Enumeration containing the keys identifying the contents of the dataContainer Hashtable.
    
    Returns:
    Enumeration containing the keys
  - insertIntoContainer
```
public void insertIntoContainer(java.lang.Object k,
                       java.lang.Object d)
```
    Inserts the given Object d (second argument) into the dataContainer Hashtable with the argument Object k (first argument) as a key. Normally this key will be a String identifier, but it can in principle be any Object.
    
    Parameters:
    k - The key to the item being stored in the Hashtable
    d - The data item being stored
  - deleteFromContainer
```
public boolean deleteFromContainer(java.lang.Object k)
```
    Deletes the element from the dataContainer Hashtable that is associated with the given key k.
    
    Parameters:
    k - The key of the object being deleted
    
    Returns:
    boolean True if delete successful, false if container or key does not exit
  - containerSize
```
public int containerSize()
```
    Returns the actual number of elements stored in the dataContainer Hashtable.
    
    Returns:
    int The number of objects stored or 0 if dataContainer does not exist
  - dataExists
```
public boolean dataExists(java.lang.Object k)
```
    Returns true if the dataContainer Hashtable contains an object with the given argument k as a key.
    
    Parameters:
    k - The key
    
    Returns:
    True if the key exists, false if not
  - getFromContainer
```
public java.lang.Object getFromContainer(java.lang.Object k)
```
    Returns the Object from the dataContainer associated with the given argument key k.
    
    Parameters:
    k - The key to the element being sought
    
    Returns:
    The data Object stored under that key, or null if none
  - copyMe
```
public abstract TrianaType copyMe()
```
    This is one of the most important methods of Triana data. types. It returns a copy of the type invoking it. This must be overridden for every derived data type derived. If not, the data cannot be copied to be given to other units. Copying must be done by value, not by reference.
    To override, the programmer should not invoke the super.copyMe method. Instead, create an object of the current type and call methods copyData and copyParameters. If these have been written correctly, then they will do the copying. The code should createTool, for type YourType:
```
 YourType y = null; try { y =
 (YourType)getClass().newInstance(); y.copyData( this ); y.copyParameters( this ); y.setLegend( this.getLegend()
 ); } catch (IllegalAccessException ee) { System.out.println("Illegal Access: " + ee.getMessage()); } catch
 (InstantiationException ee) { System.out.println("Couldn't be instantiated: " + ee.getMessage()); } return y;
 
```
    The copied object's data should be identical to the original. The method here modifies only one item: a String indicating that the object was created as a copy is added to the description StringVector.
    Returns:
    TrianaType Copy by value of the current Object except for an updated description
  - copyData
```
protected void copyData(TrianaType source)
```
    Copies data held in dataContainer from the argument object to the current object. The copy must be by value, not by reference.
    This method must be overridden if subclasses add more data to dataContainer, and the overriding method should invoke its super method. This method is called by copyMe().
    
    Parameters:
    source - Object that contains the data to be copied.
  - copyParameters
```
protected void copyParameters(TrianaType source)
```
    Copies modifiable parameters from the argument object to the current object. The copying is by value, not by reference. Parameters are defined as data not held in dataContainer. They are modifiable if they have set... methods. Parameters that cannot be modified, but which are set by constructors, should be placed correctly into the copied object when it is constructed.
    In this method, the old description is not copied, since it will turn up in the journal list (if history tracking is turned on). A new description line is added to note that this is a copy. Then the legend is copied.
    This must be overridden by any subclass that defines new parameters. The overriding method should invoke its super method. It should use the set... and get... methods for the parameters in question. This method is protected so that it cannot be called except by objects that inherit from this one. It is called by copyMe().
    
    Parameters:
    source - Object that contains the data to be copied.
  - updateObsoletePointers
```
protected void updateObsoletePointers()
```
  - getSequenceNumber
```
public int getSequenceNumber()
```
    Specified by:
    
    getSequenceNumber in interface SequenceInterface
    
    Returns:
    the sequence number of this data type in the set. The default value of -1 infers that this data set is not part of a sequence.
  - setSequenceNumber
```
public void setSequenceNumber(int sequenceNumber)
```
    Specified by:
    
    setSequenceNumber in interface SequenceInterface
    
    Parameters:
    sequenceNumber - the identifying number of this data type in the sequence.

Class TrianaType

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NOT_READY

NOT_CONNECTED

OUT_OF_RANGE

Constructor Detail

TrianaType

Method Detail

setDataContainer

getDataContainer

inspectDataContainer

insertIntoContainer

deleteFromContainer

containerSize

dataExists

getFromContainer

copyMe

copyData

copyParameters

updateObsoletePointers

getSequenceNumber

setSequenceNumber