MeasurementHolder

java.lang.Object
- com.highqsoft.xsd.AbstractImplementation
- - com.highqsoft.xsd.AbstractRule
  - - com.highqsoft.moma.rules.mearules.MeasurementHolder

All Implemented Interfaces:

ExecutableIF, ImplementationIF, RuleIF

Direct Known Subclasses:

MeasurementHolder
```
public class MeasurementHolder
extends AbstractRule
implements ExecutableIF
```
\page MeasurementRules \section MeasurementHolder The MeasurementHolder Class \addindex MeasurementHolder The instances of MeasurementHolder are used to store all Instances belonging to one or more measurements.
The intention of this object is to have a single reference within the modelmapper that can be used to perform complex tasks on measurements, for example \li Merge several measuremens into a single one \li Perform calculations on local columns and store the results in new local columns \li Rename local columns and measurement quantityHolder in with a single rule \li and many more... \subsection MeasurementHolderProperties Properties \addindex MeasurementHolder Properties The MeasurementHolder is initzialized with the following properties: MeasurementId \li \b FatherRef (required if MeasurementId is not used)
Reference to an InstanceElement[] that contains exactly one instance of AoTest or AoSubtest. The level of this instance within the Test / Subtest / Measurement tree must be the one above the measurement! \li \b MeasurementId (required if FatherRef is not used)
The id of the measurement that should be used. MeasuermentId and FatherRef can not be used together. \li \b ResultRef (required)
Reference to the MeasurememtHolder object that contains the result. \li \b MeaNameRegExp (optional, ignored if MeasurementId is used)
A String containing a regular expression. If this argument is set only those measurements with a matching name are loaded. Otherwise all Mesurements are loaded. The java regular expression syntax is used. \li \b LoadCatalogs (optional, default = "true")
If the property is set "true" the referenced catalog elements (Physical Dimensions, Units and Quantities) are loaded. This is usually required even if the catalog elements are not copied to the target but linked to existing catalog elements. \li \b UseQuery (optional, default = "true")
If the property is set "true" the MeasurementHolder uses ValueMatrix and ApplElemAccess methods to load the instances. If the property is set to "false" it uses ODS API calls. This is only recommended if you have to read from an ODS 3 server or from an ODS 4/5 server that does not implement all query options. \li \b QueryCompleteSubmat (optional, default = "true")
If true, the values of all columns in a submatrix are read with a single vm.getValue() call. This is the most efficient way to get the values. However, for huge submatrices it can lead to problems with CORBA communication. If you encounter timeouts, you can set this property to false to get the values column by column. This property is ignored if \e UseQuery is \e false. \li \b DumpFilePath (optional, no default)
The directory where the dumpfiles are created. If this Property is set and is not an empty string the rule creates a dump of all created ElementHolders. The dump files are named "MeasurementHolder_\_*.dmp. If the directory does not exist it will be created. If it cannot be written or cannot be created the rule throws an exception during initialization. \li \b ReadInstanceAttributes (optional, default "false")
The standard behaviour of the MeasurementHolder is to ignore instance attributes when reading the source instances. If the flag is set "true" it also reads the instance attributes and handles them internally as application attributes. All subsequent rules can process them like usual. The target model must provide application attributes to store the values of the instance attributes in the data source. Writing of instance attributes is not supported at the moment. \li \b CheckForDuplicateChannels (optional, default "false")
If this property is \e true, the local column names are checked for duplicates within the same submatrix and the measurement quantities are checked for duplicates within the same measurement. If duplicates are found an Exception is thrown and the duplicates are listed in the messate. \li \b LoadValues (optional, default "true")
If this property is \e false, the local column values are not loaded when the measurement is read. In this case the \e com.highqsoft.moma.rules.mearules.MeasurementToRule uses the AoSession stored in the MeasurementHolder instance to get values and flags from the data source right before the values are written. \b Note: All mearules dealing with values (MakeImplicit, CalculateStatistikAttributes, ...) are not usable in this case! \subsection MeasurementHolderExample Example \addindex MeasurementHolder Example The example below is called from the sequence in a modelmapper control file. It gets all children of the instance referenced by "TestRef" that have a name starting with "$" or "!" \code \endcode \subsection MeasurementHolderMomaMethods Methods used within the Modelmapper \addindex MeasurementHolder Modelmapper Methods \li void execute()
The execute method first loads the instance referenced by \em FatherRef and then loads all its children of type AoMeasurement. If a \em MeaNameRegExp was given the regular expression is used to filter the measurements found. The Measurements, Measurement Quantities, Submatrices and Local Columns are loaded and stored in the Object. If the property "LoadCatalogs" is true, all referenced Physical Dimensions, Units and Quantities are also stored. \subsection MeasurementHolderOtherMethods Methods that can be called from other rules \addindex MeasurementHolder Other Methods The MeasuermentHolder Class has some public methods that can be used to get or set the Elements stored in an object of this class. These rules are only of interest for rule programmers who have to deal with MeasurementHolder Instances and cannot be used from the xml controlfile. \li MeasurementHolder clone ()
Returns a copy of itself. \li boolean hasCatalogs ()
Returns true if the MeasuermentLoader Contains the instances of Unit, Quantitiy and Physical Dimension. \li ElementHolder[][] getLcHolder()
Returns the ElementHolder[][] containing all Instance Elements of type AoLocalColumn. There is one ElementHolder object in the array for every Submatrix of every Measurement. \li NameValueUnit[] getLocalColumnNvu()
Get the two dimensional Array of NameValueUnits describing the Local Columns. All LocalColumns in the MeasurementHolder object are stored in this array. The first index is used to loop over the instances, the second one loops over the attributes of each instance. \li ElementHolder getMeaHolder()
Returns the ElementHolder containing all Instance Elements of type AoMeasurement. \li NameValueUnit[] getMeaNvu()
Get the two dimensional Array of NameValueUnits describing the Measurements. All Measurements in the MeasurementHolder object are stored in this array. The first index is used to loop over the instances, the second one loops over the attributes of each instance. \li ElementHolder[] getMeqHolder()
Returns the ElementHolder[] containing all Instance Elements of type AoMeasurementQuantity. There is one ElementHolder object in the array for every Measurement. \li NameValueUnit[] getMeqNvu()
Get the two dimensional Array of NameValueUnits describing the MeasurementQuantities. All MeasurementQuantities in the MeasurementHolder object are stored in this array. The first index is used to loop over the instances, the second one loops over the attributes of each instance. \li ElementHolder[] getPhyDimHolder()
Returns the ElementHolder containing all Instance Elements of type AoPhysicalDimension that are used by at least one unit. \li NameValueUnit[] getPhyDimNvu()
Get the two dimensional Array of NameValueUnits describing the Physical Dimensions. All Physical Dimensions in the MeasurementHolder object are stored in this array. The first index is used to loop over the instances, the second one loops over the attributes of each instance. \li ElementHolder[] getQtyHolder()
Returns the ElementHolder containing all Instance Elements of type AoQuantity that are used by at least one measurement quantity. \li NameValueUnit[] getQtyNvu()
Get the two dimensional Array of NameValueUnits describing the Quantities. All Quantities in the MeasurementHolder object are stored in this array. The first index is used to loop over the instances, the second one loops over the \li ElementHolder[] getSmHolder()
Returns the ElementHolder[] containing all Instance Elements of type AoSubmatrix. There is one ElementHolder object in the array for every Measurement. attributes of each instance. \li NameValueUnit[] getSmNvu()
Get the two dimensional Array of NameValueUnits describing the Submatrices. All Submatrices in the MeasurementHolder object are stored in this array. The first index is used to loop over the instances, the second one loops over the attributes of each instance. \li ElementHolder getUnitHolder()
Returns the ElementHolder containing all Instance Elements of type AoUnit that are used by at least one measurement quantity. \li NameValueUnit[] getUnitNvu()
Get the two dimensional Array of NameValueUnits describing the Units. All Units in the MeasurementHolder object are stored in this array. The first index is used to loop over the instances, the second one loops over the attributes of each instance. \li void setLcHolder(ElementHolder[][])
Store the ElementHolder[][] containing all the Instances of type AoLocalColumn. \li void setMeaHolder(ElementHolder)
Store the ElementHolder containing all the Instances of type AoMeasurement. \li void setMeqHolder(ElementHolder[])
Store the ElementHolder[] containing all the Instances of type AoMeasurementQuantity. \li void setPhyDimHolder(ElementHolder)
Store the ElementHolder containing all the Instances of type AoPhysicalDimension. \li void setQtyHolder(ElementHolder)
Store the ElementHolder containing all the Instances of type AoQuantity. \li void setSmHolder(ElementHolder[])
Store the ElementHolder[] containing all the Instances of type AoSubmatrix. \li void setUnitHolder(ElementHolder)
Store the ElementHolder containing all the Instances of type AoUnit. \li long getNextMeaId()
Returns the next unused measurement id. \li long getNextSmId()
Returns the next unused submatrix id. \li long getNextMeqId()
Returns the next unused measurement quantity id. \li long getNextLcId()
Returns the next unused local column id.

Field Summary

Fields
Modifier and Type	Field and Description
`protected AoSession`	`aoSession`
`protected java.lang.String`	`dumpFilePath`
`protected ElementHolder[][]`	`extCompHolder`
`protected java.lang.String`	`fatherInstElemRef`
`protected java.util.Map<java.lang.String,ElementHolder>`	`generalHolder`
`protected ElementHolder[][]`	`lcHolder`
`protected boolean`	`loadCatalogs`
`protected int`	`maxRowsPerCall`
`protected ElementHolder`	`meaHolder`
`protected java.lang.String`	`meaNameRegExp`
`protected java.lang.String`	`measurementIdStr`
`protected ElementHolder[]`	`meqHolder`
`protected ElementHolder`	`phyDimHolder`
`protected ElementHolder`	`quantityHolder`
`protected boolean`	`readInstanceAttributes`
`protected java.lang.String`	`resultRef`
`protected ElementHolder[]`	`smHolder`
`protected ElementHolder`	`unitHolder`
`protected boolean`	`useQuery`

Fields inherited from class com.highqsoft.xsd.AbstractRule
loggerName, postMethods, preMethods, sessionRef

Fields inherited from class com.highqsoft.xsd.AbstractImplementation
arguments, ctx, descriptor, NEW_LINE

Constructor Summary

Constructors
Constructor and Description

MeasurementHolder()

Constructors
Constructor and Description
`MeasurementHolder()`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addHolder(java.lang.String baseElementName, ElementHolder holder)` Add a new holder to generic holder map
`MeasurementHolder`	`clone()`
`void`	`destroy()` Destroy all ElementHolders in the MeasurementHolder.
`void`	`execute()` Execute the program.
`AoSession`	`getAoSession()`
`protected ElemId[]`	`getElemIds(ElementHolder elemHolder, java.lang.String baseType)` Get the ElemId[] for all instances in an ElementHolder.
`ElementHolder[][]`	`getExtCompHolder()`
`NameValueUnit[][]`	`getExtCompNvu()`
`long`	`getHighestLcId()` Get the highest id of all local columns in the MeasurementHolder
`long`	`getHighestMeqId()` Get the highest id of all measurement quantities in the MeasurementHolder
`long`	`getHighestSmId()` Get the highest id of all submatrices in the MeasurementHolder
`java.util.Map<java.lang.String,ElementHolder>`	`getHolder()` Add a new holder to generic holder map
`ElementHolder[][]`	`getLcHolder()`
`NameValueUnit[][]`	`getLcNvu()` Convenience method to get the NameValueUnit[][] from the LocalColumnHolder.
`ElementHolder`	`getMeaHolder()`
`NameValueUnit[][]`	`getMeaNvu()` Convenience method to get the NameValueUnit[][] from the MeaHolder.
`ElementHolder[]`	`getMeqHolder()`
`NameValueUnit[][]`	`getMeqNvu()` Convenience method to get the NameValueUnit[][] from the MeqHolder.
`long`	`getNextExtCompId()` Get the next free External component Id
`long`	`getNextLcId()` Get the next free LocalColumn Id
`long`	`getNextMeaId()` Get the next free Measurement Id
`long`	`getNextMeqId()` Get the next free Meq Id
`long`	`getNextSmId()` Get the next free Submatrix Id
`ElementHolder`	`getPhyDimHolder()`
`NameValueUnit[][]`	`getPhyDimNvu()` Convenience method to get the NameValueUnit[][] from the PhyDimHolder.
`ElementHolder`	`getQtyHolder()`
`NameValueUnit[][]`	`getQtyNvu()` Convenience method to get the NameValueUnit[][] from the QuantityHolder.
`ElementHolder[]`	`getSmHolder()`
`NameValueUnit[][]`	`getSmNvu()` Convenience method to get the NameValueUnit[][] from the SubmatrixHolder.
`ElementHolder`	`getUnitHolder()`
`NameValueUnit[][]`	`getUnitNvu()` Convenience method to get the NameValueUnit[][] from the UnitHolder.
`NameValueUnit[][]`	`getValue()` Get the named value from rule.
`boolean`	`hasCatalogs()`
`void`	`init()` Initialize the work.
`void`	`setAoSession(AoSession aoSession)`
`void`	`setExtCompHolder(ElementHolder[][] extCompHolder)`
`void`	`setLcHolder(ElementHolder[][] lcHolder)`
`void`	`setMeaHolder(ElementHolder meaHolder)`
`void`	`setMeqHolder(ElementHolder[] meqHolder)`
`void`	`setPhyDimHolder(ElementHolder phyDimHolder)`
`void`	`setQtyHolder(ElementHolder quantityHolder)`
`void`	`setSmHolder(ElementHolder[] smHolder)`
`void`	`setUnitHolder(ElementHolder unitHolder)`
`void`	`setValue(NameValueUnit[][] nvu)` Set the named values to rule.

Methods inherited from class com.highqsoft.xsd.AbstractRule
execute, executePostMethods, executePreMethods, getAoSessionFromContextWithSessionRef, getId, getOdsCache, getPointTo, getSessionRef, getType, isPedantic, setGathermode, setId, setPointTo, setPostMethods, setPreMethods, setSessionRef, setType, terminate, toString, toString, toString

Methods inherited from class com.highqsoft.xsd.AbstractImplementation
addAttributesToNameValueUnitArray, addAttributeToNameValueUnitArray, addStringValueToNameValueUnitArray, checkDirectoy, checkDirectoy, checkDirectoy, checkFile, checkFile, checkFile, checkIntValue, checkStringValue, compressNvuArray, createMessageFromPropertyFile, createMessageFromPropertyFile, createMessageFromPropertyFile, createTsUnionFromObject, deleteRowWithAttributes, getArguments, getContext, getDescriptor, getListFromProperty, getMandatoryProperty, getMandatoryProperty, getMandatoryPropertyAsInt, getMandatoryPropertyAsList, getMandatoryPropertyWithRuleException, getNvuArrayFromMap, getNvuArrayFromMap, getNvuObjectWithName, getNvuObjectWithName, getNvuObjectWithName, getOdsCacheFromProperty, getOptioanlPropertyAsInt, getOptionalProperty, getOptionalProperty, getOptionalProperty, getOptionalProperty, getOptionalPropertyAsBoolean, getOptionalPropertyAsBoolean, getOptionalPropertyAsBoolean, getOptionalPropertyAsList, makeUpperCaseKeyword, removeAttributeFromNameValueUnitArray, removeAttributeFromNameValueUnitArray, setArguments, setContext, setDescriptor

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

Methods inherited from interface com.highqsoft.xsd.ExecutableIF
terminate

Methods inherited from interface com.highqsoft.xsd.ImplementationIF
getContext, getDescriptor, setArguments, setContext, setDescriptor

- Field Detail
  - meaHolder
```
protected ElementHolder meaHolder
```
  - meqHolder
```
protected ElementHolder[] meqHolder
```
  - smHolder
```
protected ElementHolder[] smHolder
```
  - lcHolder
```
protected ElementHolder[][] lcHolder
```
  - unitHolder
```
protected ElementHolder unitHolder
```
  - quantityHolder
```
protected ElementHolder quantityHolder
```
  - phyDimHolder
```
protected ElementHolder phyDimHolder
```
  - extCompHolder
```
protected ElementHolder[][] extCompHolder
```
  - generalHolder
```
protected java.util.Map<java.lang.String,ElementHolder> generalHolder
```
  - resultRef
```
protected java.lang.String resultRef
```
  - fatherInstElemRef
```
protected java.lang.String fatherInstElemRef
```
  - meaNameRegExp
```
protected java.lang.String meaNameRegExp
```
  - loadCatalogs
```
protected boolean loadCatalogs
```
  - dumpFilePath
```
protected java.lang.String dumpFilePath
```
  - measurementIdStr
```
protected java.lang.String measurementIdStr
```
  - aoSession
```
protected AoSession aoSession
```
  - useQuery
```
protected boolean useQuery
```
  - maxRowsPerCall
```
protected int maxRowsPerCall
```
  - readInstanceAttributes
```
protected boolean readInstanceAttributes
```
- Constructor Detail
  - MeasurementHolder
```
public MeasurementHolder()
```
- Method Detail
  - execute
```
public void execute()
             throws ExecutableException
```
    Description copied from class: AbstractRule
    
    Execute the program. This implementation does nothing by default. Can be overridden.
    
    Specified by:
    
    execute in interface ExecutableIF
    
    Overrides:
    
    execute in class AbstractRule
    
    Throws:
    
    ExecutableException - if execution fails.
  - getElemIds
```
protected ElemId[] getElemIds(ElementHolder elemHolder,
                  java.lang.String baseType)
                       throws ExecutableException
```
    Get the ElemId[] for all instances in an ElementHolder. The method supports datatypes DT_LONGLONG, DT_LONG and DT_STRING for the id data type.
    
    Parameters:
    elemHolder - The ElementHolder
    baseType - The base type of the application element stored in the ElementHolder
    
    Returns:
    The ElemId[][]
    
    Throws:
    
    ExecutableException
  - getUnitNvu
```
public NameValueUnit[][] getUnitNvu()
```
    Convenience method to get the NameValueUnit[][] from the UnitHolder.
    
    Returns:
    The NameValueUnit[][] containing the Units. The first index is for the instances, the second one for the attributes of each instance.
  - getQtyNvu
```
public NameValueUnit[][] getQtyNvu()
```
    Convenience method to get the NameValueUnit[][] from the QuantityHolder.
    
    Returns:
    The NameValueUnit[][] containing the Quantities. The first index is for the instances, the second one for the attributes of each instance.
  - getPhyDimNvu
```
public NameValueUnit[][] getPhyDimNvu()
```
    Convenience method to get the NameValueUnit[][] from the PhyDimHolder.
    
    Returns:
    The NameValueUnit[][] containing the Physical Dimensions. The first index is for the instances, the second one for the attributes of each instance.
  - getMeaNvu
```
public NameValueUnit[][] getMeaNvu()
```
    Convenience method to get the NameValueUnit[][] from the MeaHolder.
    
    Returns:
    The NameValueUnit[][] containing the Measurements. The first index is for the instances, the second one for the attributes of each instance.
  - getMeqNvu
```
public NameValueUnit[][] getMeqNvu()
```
    Convenience method to get the NameValueUnit[][] from the MeqHolder. The method combines the NameValueUnit[][]s of all MeqHolders to a single one that can be passed to the ElementToRule to write all measurement quantities at once.
    
    Returns:
    The NameValueUnit[][] containing the Measurement Quantities. The first index is for the instances, the second one for the attributes of each instance.
  - getSmNvu
```
public NameValueUnit[][] getSmNvu()
```
    Convenience method to get the NameValueUnit[][] from the SubmatrixHolder. The method combines the NameValueUnit[][]s of all SubmatrixHolders to a single one that can be passed to the ElementToRule to write all submatrices at once.
    
    Returns:
    The NameValueUnit[][] containing the Submatrices. The first index is for the instances, the second one for the attributes of each instance.
  - getLcNvu
```
public NameValueUnit[][] getLcNvu()
```
    Convenience method to get the NameValueUnit[][] from the LocalColumnHolder. The method combines the NameValueUnit[][]s of all LocalColumnHolders to a single one that can be passed to the ElementToRule to write all local columns at once.
    
    Returns:
    The NameValueUnit[][] containing the Local Columns. The first index is for the instances, the second one for the attributes of each instance.
  - getHighestLcId
```
public long getHighestLcId()
```
    Get the highest id of all local columns in the MeasurementHolder
    
    Returns:
    The highest existing id
  - getHighestSmId
```
public long getHighestSmId()
```
    Get the highest id of all submatrices in the MeasurementHolder
    
    Returns:
    The highest existing id
  - getHighestMeqId
```
public long getHighestMeqId()
```
    Get the highest id of all measurement quantities in the MeasurementHolder
    
    Returns:
    The highest existing id
  - destroy
```
public void destroy()
```
    Destroy all ElementHolders in the MeasurementHolder.
  - getValue
```
public NameValueUnit[][] getValue()
                           throws RuleException
```
    Description copied from interface: RuleIF
    
    Get the named value from rule.
    
    Specified by:
    
    getValue in interface RuleIF
    
    Returns:
    The name value of the rule.
    
    Throws:
    
    RuleException
    See Also:
    RuleIF.setValue(NameValueUnit[][] nvu)
  - setValue
```
public void setValue(NameValueUnit[][] nvu)
              throws RuleException
```
    Description copied from interface: RuleIF
    
    Set the named values to rule. The rule decides how to organize the array structur. To have a homogenous environment try to hold in mind that the first index should assign something like instances and the second the attributes belong to the instances.
    
    Specified by:
    
    setValue in interface RuleIF
    
    Parameters:
    nvu - The name value of the rule.
    
    Throws:
    
    RuleException
  - init
```
public void init()
          throws InitializationFailedException
```
    Description copied from class: AbstractImplementation
    
    Initialize the work.
    
    Specified by:
    
    init in interface ImplementationIF
    
    Specified by:
    
    init in class AbstractImplementation
    
    Throws:
    
    InitializationFailedException - if the initialization fails.
  - clone
```
public MeasurementHolder clone()
```
    Overrides:
    
    clone in class java.lang.Object
  - getNextLcId
```
public long getNextLcId()
```
    Get the next free LocalColumn Id
    
    Returns:
  - getNextExtCompId
```
public long getNextExtCompId()
```
    Get the next free External component Id
    
    Returns:
  - getNextMeqId
```
public long getNextMeqId()
```
    Get the next free Meq Id
    
    Returns:
  - getNextSmId
```
public long getNextSmId()
```
    Get the next free Submatrix Id
    
    Returns:
  - getNextMeaId
```
public long getNextMeaId()
```
    Get the next free Measurement Id
    
    Returns:
  - getMeaHolder
```
public ElementHolder getMeaHolder()
```
  - setMeaHolder
```
public void setMeaHolder(ElementHolder meaHolder)
```
  - getMeqHolder
```
public ElementHolder[] getMeqHolder()
```
  - setMeqHolder
```
public void setMeqHolder(ElementHolder[] meqHolder)
```
  - getSmHolder
```
public ElementHolder[] getSmHolder()
```
  - setSmHolder
```
public void setSmHolder(ElementHolder[] smHolder)
```
  - getLcHolder
```
public ElementHolder[][] getLcHolder()
```
  - setLcHolder
```
public void setLcHolder(ElementHolder[][] lcHolder)
```
  - setExtCompHolder
```
public void setExtCompHolder(ElementHolder[][] extCompHolder)
```
  - getExtCompHolder
```
public ElementHolder[][] getExtCompHolder()
```
  - getUnitHolder
```
public ElementHolder getUnitHolder()
```
  - setUnitHolder
```
public void setUnitHolder(ElementHolder unitHolder)
```
  - getQtyHolder
```
public ElementHolder getQtyHolder()
```
  - setQtyHolder
```
public void setQtyHolder(ElementHolder quantityHolder)
```
  - getPhyDimHolder
```
public ElementHolder getPhyDimHolder()
```
  - setPhyDimHolder
```
public void setPhyDimHolder(ElementHolder phyDimHolder)
```
  - hasCatalogs
```
public boolean hasCatalogs()
```
  - getExtCompNvu
```
public NameValueUnit[][] getExtCompNvu()
```
  - addHolder
```
public void addHolder(java.lang.String baseElementName,
             ElementHolder holder)
```
    Add a new holder to generic holder map
  - getHolder
```
public java.util.Map<java.lang.String,ElementHolder> getHolder()
```
    Add a new holder to generic holder map
  - getAoSession
```
public AoSession getAoSession()
```
  - setAoSession
```
public void setAoSession(AoSession aoSession)
```

Class MeasurementHolder

Field Summary

Fields inherited from class com.highqsoft.xsd.AbstractRule

Fields inherited from class com.highqsoft.xsd.AbstractImplementation

Constructor Summary

Method Summary

Methods inherited from class com.highqsoft.xsd.AbstractRule

Methods inherited from class com.highqsoft.xsd.AbstractImplementation

Methods inherited from class java.lang.Object

Methods inherited from interface com.highqsoft.xsd.ExecutableIF

Methods inherited from interface com.highqsoft.xsd.ImplementationIF

Field Detail

meaHolder

meqHolder

smHolder

lcHolder

unitHolder

quantityHolder

phyDimHolder

extCompHolder

generalHolder

resultRef

fatherInstElemRef

meaNameRegExp

loadCatalogs

dumpFilePath

measurementIdStr

aoSession

useQuery

maxRowsPerCall

readInstanceAttributes

Constructor Detail

MeasurementHolder

Method Detail

execute

getElemIds

getUnitNvu

getQtyNvu

getPhyDimNvu

getMeaNvu

getMeqNvu

getSmNvu

getLcNvu

getHighestLcId

getHighestSmId

getHighestMeqId

destroy

getValue

setValue

init

clone

getNextLcId

getNextExtCompId

getNextMeqId

getNextSmId

getNextMeaId

getMeaHolder

setMeaHolder

getMeqHolder

setMeqHolder

getSmHolder

setSmHolder

getLcHolder

setLcHolder

setExtCompHolder

getExtCompHolder

getUnitHolder

setUnitHolder

getQtyHolder

setQtyHolder

getPhyDimHolder

setPhyDimHolder

hasCatalogs

getExtCompNvu

addHolder

getHolder

getAoSession

setAoSession