| /******************************************************************************* |
| * Copyright (c) 2016 CEA LIST. |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Created on: 5 août 2008 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| |
| #ifndef INSTANCEOFDATA_H_ |
| #define INSTANCEOFDATA_H_ |
| |
| #include <fml/executable/BaseInstanceForm.h> |
| |
| #include <common/AvmPointer.h> |
| |
| #include <collection/BFContainer.h> |
| |
| #include <fml/lib/AvmLang.h> |
| |
| #include <fml/symbol/TableOfSymbol.h> |
| |
| #include <fml/infrastructure/Variable.h> |
| |
| |
| namespace sep |
| { |
| |
| |
| class ArrayBF; |
| class AvmProgram; |
| |
| class BuiltinArray; |
| class BaseAvmProgram; |
| |
| class Element; |
| |
| class ObjectElement; |
| |
| class Symbol; |
| |
| |
| class InstanceOfData : |
| public BaseInstanceForm, |
| public IPointerDataNature, |
| AVM_INJECT_INSTANCE_COUNTER_CLASS( InstanceOfData ) |
| { |
| |
| AVM_DECLARE_CLONABLE_CLASS( InstanceOfData ) |
| |
| |
| protected: |
| /* |
| * ATTRIBUTES |
| */ |
| POINTER_DATA_NATURE mPointerNature; |
| |
| // Used to the container of store record/class or array data field instance |
| InstanceOfData * mParent; |
| |
| // The Monitor Routine for Assignation |
| AvmProgram * mOnWriteRoutine; |
| |
| // The initial value |
| BF mValue; |
| |
| // The initial buffer value |
| BF mBufferValue; |
| |
| // The variable Field table |
| // Used to store record/class or array data field instance |
| TableOfSymbol * mAttributeTable; |
| |
| // The Relative Data Path for an Instance from this Data Container |
| TableOfSymbol * mRelativeDataPath; |
| avm_size_t * mRelativeOffsetPath; |
| |
| // Mark use by some tools like Solver |
| avm_offset_t mMark; |
| |
| |
| public: |
| /** |
| * DEFAULT |
| * Empty TableOfSymbol |
| */ |
| static TableOfSymbol NULL_TABLE_OF_SYMBOL; |
| |
| |
| public: |
| /** |
| * CONSTRUCTOR |
| * copy |
| */ |
| InstanceOfData(const InstanceOfData & aData) |
| : BaseInstanceForm( aData ), |
| mPointerNature( aData.mPointerNature ), |
| mParent( aData.mParent ), |
| |
| mOnWriteRoutine( aData.mOnWriteRoutine ), |
| |
| mValue( aData.mValue ), |
| mBufferValue( aData.mBufferValue ), |
| |
| mAttributeTable( & NULL_TABLE_OF_SYMBOL ), |
| |
| mRelativeDataPath( & NULL_TABLE_OF_SYMBOL ), |
| mRelativeOffsetPath( NULL ), |
| |
| mMark( aData.mMark ) |
| { |
| copyAttribute( aData.mAttributeTable ); |
| |
| copyDataPath( aData.mRelativeDataPath ); |
| } |
| |
| |
| |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| InstanceOfData(POINTER_DATA_NATURE aPointerNature, |
| BaseAvmProgram * aContainer, const ObjectElement * astElement, |
| BaseTypeSpecifier * aTypeSpecifier, avm_offset_t anOffset) |
| : BaseInstanceForm(CLASS_KIND_T( InstanceOfData ), aContainer, |
| astElement, aTypeSpecifier, anOffset), |
| mPointerNature( aPointerNature ), |
| mParent( NULL ), |
| |
| mOnWriteRoutine( NULL ), |
| |
| mValue( ), |
| mBufferValue( ), |
| |
| mAttributeTable( & NULL_TABLE_OF_SYMBOL ), |
| |
| mRelativeDataPath( & NULL_TABLE_OF_SYMBOL ), |
| mRelativeOffsetPath( NULL ), |
| |
| mMark( 0 ) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( aTypeSpecifier ) |
| << "InstanceOfData:> Unexpected an instance << " |
| << this->getFullyQualifiedNameID() |
| << " >> without typeSpecifier !!!" |
| << SEND_EXIT; |
| } |
| |
| InstanceOfData(POINTER_DATA_NATURE aPointerNature, |
| BaseAvmProgram * aContainer, const ObjectElement * astElement, |
| BaseTypeSpecifier * aTypeSpecifier, |
| avm_offset_t anOffset, const Modifier & aModifier) |
| : BaseInstanceForm(CLASS_KIND_T( InstanceOfData ), aContainer, |
| astElement, aTypeSpecifier, anOffset, aModifier), |
| mPointerNature( aPointerNature ), |
| mParent( NULL ), |
| |
| mOnWriteRoutine( NULL ), |
| |
| mValue( ), |
| mBufferValue( ), |
| |
| mAttributeTable( & NULL_TABLE_OF_SYMBOL ), |
| |
| mRelativeDataPath( & NULL_TABLE_OF_SYMBOL ), |
| mRelativeOffsetPath( NULL ), |
| |
| mMark( 0 ) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( aTypeSpecifier ) |
| << "InstanceOfData:> Unexpected an instance << " |
| << this->getFullyQualifiedNameID() |
| << " >> without typeSpecifier !!!" |
| << SEND_EXIT; |
| } |
| |
| /** |
| * CONSTRUCTOR |
| * Other |
| */ |
| InstanceOfData(POINTER_DATA_NATURE aPointerNature, |
| BaseAvmProgram * aContainer, const ObjectElement * astElement, |
| BaseTypeSpecifier * aTypeSpecifier, |
| const std::string & aFullyQualifiedNameID, avm_offset_t anOffset, |
| const Modifier & aModifier = Modifier::PROPERTY_UNDEFINED_MODIFIER) |
| : BaseInstanceForm(CLASS_KIND_T( InstanceOfData ), aContainer, astElement, |
| aTypeSpecifier, aFullyQualifiedNameID, anOffset, aModifier), |
| mPointerNature( aPointerNature ), |
| mParent( NULL ), |
| |
| mOnWriteRoutine( NULL ), |
| |
| mValue( ), |
| mBufferValue( ), |
| |
| mAttributeTable( & NULL_TABLE_OF_SYMBOL ), |
| |
| mRelativeDataPath( & NULL_TABLE_OF_SYMBOL ), |
| mRelativeOffsetPath( NULL ), |
| |
| mMark( 0 ) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( aTypeSpecifier ) |
| << "InstanceOfData:> Unexpected an instance << " |
| << this->getFullyQualifiedNameID() |
| << " >> without typeSpecifier !!!" |
| << SEND_EXIT; |
| } |
| |
| |
| InstanceOfData(POINTER_DATA_NATURE aPointerNature, |
| BaseAvmProgram * aContainer, const ObjectElement * astElement, |
| BaseTypeSpecifier * aTypeSpecifier, |
| const std::string & aFullyQualifiedNameID, |
| avm_offset_t anOffset, InstanceOfData * aParent) |
| : BaseInstanceForm(CLASS_KIND_T( InstanceOfData ), aContainer, astElement, |
| aTypeSpecifier, aFullyQualifiedNameID, anOffset, aParent), |
| mPointerNature( aPointerNature ), |
| mParent( NULL ), |
| |
| mOnWriteRoutine( NULL ), |
| |
| mValue( ), |
| mBufferValue( ), |
| |
| mAttributeTable( & NULL_TABLE_OF_SYMBOL ), |
| |
| mRelativeDataPath( & NULL_TABLE_OF_SYMBOL ), |
| mRelativeOffsetPath( NULL ), |
| |
| mMark( 0 ) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( aTypeSpecifier ) |
| << "InstanceOfData:> Unexpected an instance << " |
| << this->getFullyQualifiedNameID() << " >> without typeSpecifier !!!" |
| << SEND_EXIT; |
| } |
| |
| |
| InstanceOfData(POINTER_DATA_NATURE aPointerNature, |
| BaseTypeSpecifier * aTypeSpecifier, |
| const std::string & aFullyQualifiedNameID, avm_offset_t anOffset, |
| const Modifier & aModifier = Modifier::PROPERTY_UNDEFINED_MODIFIER) |
| : BaseInstanceForm(CLASS_KIND_T( InstanceOfData ), |
| aTypeSpecifier, aFullyQualifiedNameID, anOffset, aModifier), |
| mPointerNature( aPointerNature ), |
| mParent( NULL ), |
| |
| mOnWriteRoutine( NULL ), |
| |
| mValue( ), |
| mBufferValue( ), |
| |
| mAttributeTable( & NULL_TABLE_OF_SYMBOL ), |
| |
| mRelativeDataPath( & NULL_TABLE_OF_SYMBOL ), |
| mRelativeOffsetPath( NULL ), |
| |
| mMark( 0 ) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( aTypeSpecifier ) |
| << "InstanceOfData:> Unexpected an instance << " |
| << this->getFullyQualifiedNameID() << " >> without typeSpecifier !!!" |
| << SEND_EXIT; |
| } |
| |
| /** |
| * CONSTRUCTOR |
| * for UFI |
| */ |
| InstanceOfData(POINTER_DATA_NATURE aPointerNature, |
| BaseAvmProgram * aContainer, InstanceOfData * aParent, |
| const TableOfSymbol & aRelativeDataPath = NULL_TABLE_OF_SYMBOL) |
| : BaseInstanceForm(CLASS_KIND_T( InstanceOfData ), aContainer, aParent), |
| mPointerNature( aPointerNature ), |
| mParent( aParent->mParent ), |
| |
| mOnWriteRoutine( aParent->mOnWriteRoutine ), |
| |
| mValue( aParent->mValue ), |
| mBufferValue( aParent->mBufferValue ), |
| |
| mAttributeTable( NULL ), |
| mRelativeDataPath( new TableOfSymbol(aRelativeDataPath) ), |
| mRelativeOffsetPath( NULL ), |
| |
| mMark( 0 ) |
| { |
| updateOffsetPath(); |
| |
| if( aRelativeDataPath.nonempty() ) |
| { |
| setTypeSpecifier( aRelativeDataPath.back().getTypeSpecifier() ); |
| setAstElement( aRelativeDataPath.back().getAstElement() ); |
| |
| setOnWriteRoutine( |
| aRelativeDataPath.back().data().getOnWriteRoutine() ); |
| |
| setValue( aRelativeDataPath.back().getValue() ); |
| |
| setBValue( aRelativeDataPath.back().data().getBValue() ); |
| } |
| |
| setAliasTarget( aParent ); |
| } |
| |
| InstanceOfData(POINTER_DATA_NATURE aPointerNature, |
| BaseAvmProgram * aContainer, InstanceOfData * aParent, |
| const TableOfSymbol & aRelativeDataPath, const Symbol & pathLeaf) |
| : BaseInstanceForm(CLASS_KIND_T( InstanceOfData ), aContainer, aParent), |
| mPointerNature( aPointerNature ), |
| mParent( aParent->mParent ), |
| |
| mOnWriteRoutine( pathLeaf.data().mOnWriteRoutine ), |
| |
| mValue( pathLeaf.data().mValue ), |
| mBufferValue( pathLeaf.data().mBufferValue ), |
| |
| mAttributeTable( NULL ), |
| mRelativeDataPath( new TableOfSymbol(aRelativeDataPath, pathLeaf) ), |
| mRelativeOffsetPath( NULL ), |
| |
| mMark( 0 ) |
| { |
| updateOffsetPath(); |
| |
| setTypeSpecifier( pathLeaf.getTypeSpecifier() ); |
| setAstElement( pathLeaf.getAstElement() ); |
| |
| setAliasTarget( aParent ); |
| } |
| |
| |
| |
| /** |
| * CONSTRUCTOR |
| * for RUNTIME UFI OFFSET |
| */ |
| InstanceOfData(InstanceOfData * aModel, |
| InstanceOfData * aRoot, avm_size_t * aRelativeOffsetPath) |
| : BaseInstanceForm(CLASS_KIND_T( InstanceOfData ), |
| aModel->getContainer(), aRoot), |
| mPointerNature( POINTER_UFI_RUNTIME_NATURE ), |
| mParent( aModel ), |
| |
| mOnWriteRoutine( aModel->mOnWriteRoutine ), |
| |
| mValue( aModel->mValue ), |
| mBufferValue( aModel->mBufferValue ), |
| |
| mAttributeTable( aModel->getAttribute() ), |
| mRelativeDataPath( aModel->getDataPath() ), |
| mRelativeOffsetPath( aRelativeOffsetPath ), |
| |
| mMark( 0 ) |
| { |
| setAllNameID(aModel->getFullyQualifiedNameID(), aModel->getNameID()); |
| |
| setRuntimeContainerRID( aRoot->getRuntimeContainerRID() ); |
| } |
| |
| |
| /** |
| * CONSTRUCTOR |
| * for Alias |
| */ |
| InstanceOfData(BaseAvmProgram * aContainer, InstanceOfData * aTarget, |
| VectorOfInstanceOfMachine & aRelativeMachinePath) |
| : BaseInstanceForm(CLASS_KIND_T( InstanceOfData ), aContainer, aTarget, |
| aRelativeMachinePath), |
| mPointerNature( aTarget->mPointerNature ), |
| mParent( aTarget->mParent ), |
| |
| mOnWriteRoutine( aTarget->mOnWriteRoutine ), |
| |
| mValue( aTarget->mValue ), |
| mBufferValue( aTarget->mBufferValue ), |
| |
| mAttributeTable( & NULL_TABLE_OF_SYMBOL ), |
| mRelativeDataPath( & NULL_TABLE_OF_SYMBOL ), |
| mRelativeOffsetPath( NULL ), |
| |
| mMark( 0 ) |
| { |
| copyDataPath( aTarget->mRelativeDataPath ); |
| } |
| |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~InstanceOfData() |
| { |
| updateOffsetPath(); |
| |
| if( (mAttributeTable != (& NULL_TABLE_OF_SYMBOL)) && |
| (mPointerNature != POINTER_UFI_RUNTIME_NATURE) ) |
| { |
| delete( mAttributeTable ); |
| mAttributeTable = NULL; |
| } |
| |
| if( (mRelativeDataPath != (& NULL_TABLE_OF_SYMBOL)) && |
| (mPointerNature != POINTER_UFI_RUNTIME_NATURE) ) |
| { |
| delete( mRelativeDataPath ); |
| mRelativeDataPath = NULL; |
| } |
| |
| delete( mRelativeOffsetPath ); |
| mRelativeOffsetPath = NULL; |
| |
| // AVM_OS_TRACE << "InstanceOfData::del :> " |
| //// << "offset#" << getOffset() << FQN_ID_ROOT_SEPARATOR |
| // << mFullyQualifiedNameID << std::endl; |
| } |
| |
| |
| /** |
| * GETTER |
| * Compiled ObjectElement as Compiled Variable |
| */ |
| inline const Variable * getAstVariable() const |
| { |
| return( getAstElement()->as< Variable >() ); |
| } |
| |
| inline bool hasAstVariable() const |
| { |
| return( hasAstElement() && getAstElement()->is< Variable >() ); |
| } |
| |
| |
| /** |
| * GETTER |
| * Qualified Name IDentifier |
| * QualifiedNameID using mFullyQualifiedNameID & mNameID |
| */ |
| inline virtual std::string getQualifiedNameID() const |
| { |
| AVM_IF_DEBUG_LEVEL_FLAG( MEDIUM, DATA ) |
| |
| return( getFullyQualifiedNameID() ); |
| |
| AVM_ELSE |
| |
| return( (isStandardPointer() || isEnumSymbolPointer()) |
| ? makeQualifiedNameID( getFullyQualifiedNameID(), getNameID() ) |
| : makeQualifiedNameID( getFullyQualifiedNameID() ) ); |
| |
| AVM_ENDIF_DEBUG_LEVEL_FLAG( MEDIUM, DATA ) |
| } |
| |
| /** |
| * GETTER |
| * mFullyQualifiedNameID |
| * mNameID |
| */ |
| virtual void updateFullyQualifiedNameID(); |
| |
| inline void updateFullyQualifiedNameID( |
| const std::string & aFullyQualifiedNameID, const std::string & id) |
| { |
| setAllNameID( aFullyQualifiedNameID , id ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * mId |
| */ |
| void updateNameID(); |
| |
| |
| /** |
| * SETTER |
| * the SharedData |
| */ |
| inline void setSharedData(InstanceOfData * sData) |
| { |
| setOffset( sData->getOffset() ); |
| |
| // setModifier( sData->getModifier() ); |
| |
| mOnWriteRoutine = sData->mOnWriteRoutine; |
| |
| mValue = sData->mValue; |
| |
| mBufferValue = sData->mBufferValue; |
| } |
| |
| /** |
| * GETTER - SETTER |
| * mParent |
| */ |
| inline InstanceOfData * getParent() const |
| { |
| return( mParent ); |
| } |
| |
| inline bool hasParent() const |
| { |
| return( mParent != NULL ); |
| } |
| |
| inline void setParent(InstanceOfData * aParent) |
| { |
| mParent = aParent; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mAttributeTable |
| */ |
| inline TableOfSymbol * getAttribute() const |
| { |
| return( mAttributeTable ); |
| } |
| |
| inline bool hasAttribute() const |
| { |
| return( (mAttributeTable != (& NULL_TABLE_OF_SYMBOL)) && |
| (mAttributeTable != NULL) && mAttributeTable->nonempty() ); |
| } |
| |
| inline void setAttribute(TableOfSymbol * anAttributeTable) |
| { |
| mAttributeTable = ( anAttributeTable != NULL ) ? |
| anAttributeTable : (& NULL_TABLE_OF_SYMBOL); |
| } |
| |
| inline void copyAttribute(TableOfSymbol * anAttributeTable) |
| { |
| mAttributeTable = ( anAttributeTable != NULL ) ? |
| new TableOfSymbol(*anAttributeTable) : (& NULL_TABLE_OF_SYMBOL); |
| } |
| |
| |
| inline void setAttribute(avm_offset_t offset, const Symbol & aWProperty) |
| { |
| AVM_OS_ASSERT_FATAL_ERROR_EXIT( hasAttribute() ) |
| << "setAttribute:> Unexpected a <null> AttributeTable !!!" |
| << SEND_EXIT; |
| |
| mAttributeTable->set(offset, aWProperty); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * mOnWriteRoutine |
| */ |
| inline AvmProgram * getOnWriteRoutine() const |
| { |
| return( mOnWriteRoutine ); |
| } |
| |
| const BFCode & getOnWriteCode() const; |
| |
| |
| inline bool hasOnWriteRoutine() const |
| { |
| return( mOnWriteRoutine != NULL ); |
| } |
| |
| inline void setOnWriteRoutine(AvmProgram * onWriteRoutine) |
| { |
| mOnWriteRoutine = onWriteRoutine; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mValue |
| */ |
| |
| inline BF & getValue() |
| { |
| return( mValue ); |
| } |
| |
| |
| inline const BF & getValue() const |
| { |
| return( mValue ); |
| } |
| |
| inline bool hasValue() const |
| { |
| return( mValue.valid() ); |
| } |
| |
| |
| inline void setValue(const BF & aValue) |
| { |
| mValue = aValue; |
| } |
| |
| |
| // ArrayValue |
| ArrayBF * getArrayValue() const; |
| |
| bool hasArrayValue() const; |
| |
| // BuiltinArrayValue |
| BuiltinArray * getBuiltinArrayValue() const; |
| |
| bool hasBuiltinArrayValue() const; |
| |
| /** |
| * GETTER - SETTER |
| * mBufferValue |
| */ |
| |
| inline BF & getBValue() |
| { |
| return( mBufferValue ); |
| } |
| |
| inline const BF & getBValue() const |
| { |
| return( mBufferValue ); |
| } |
| |
| inline bool hasBValue() const |
| { |
| return( mBufferValue.valid() ); |
| } |
| |
| |
| inline void setBValue(const BF & aBufferValue) |
| { |
| mBufferValue = aBufferValue; |
| } |
| |
| inline void resetBValue(Element * aBufferValue) |
| { |
| mBufferValue.replacePointer( aBufferValue ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mRelativeDataPath |
| */ |
| inline TableOfSymbol * getDataPath() const |
| { |
| return( mRelativeDataPath ); |
| } |
| |
| inline bool hasDataPath() const |
| { |
| return( (mRelativeDataPath != (& NULL_TABLE_OF_SYMBOL)) && |
| (mRelativeDataPath != NULL) && mRelativeDataPath->nonempty() ); |
| } |
| |
| inline void setDataPath(TableOfSymbol * aRelativeDataPath) |
| { |
| mRelativeDataPath = (aRelativeDataPath != NULL) ? |
| aRelativeDataPath : (& NULL_TABLE_OF_SYMBOL); |
| |
| updateOffsetPath(); |
| } |
| |
| inline void copyDataPath(TableOfSymbol * aRelativeDataPath) |
| { |
| mRelativeDataPath = (aRelativeDataPath != NULL) ? |
| new TableOfSymbol(*aRelativeDataPath) : (& NULL_TABLE_OF_SYMBOL); |
| |
| updateOffsetPath(); |
| } |
| |
| inline void setDataPath(const TableOfSymbol & aRelativeDataPath) |
| { |
| mRelativeDataPath = new TableOfSymbol( aRelativeDataPath ); |
| |
| updateOffsetPath(); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mRelativeOffsetPath |
| */ |
| inline avm_size_t * getOffsetPath() const |
| { |
| return( mRelativeOffsetPath ); |
| } |
| |
| inline avm_size_t getOffsetPath(avm_size_t idx) const |
| { |
| return( mRelativeOffsetPath[idx] ); |
| } |
| |
| bool hasOffsetPath() const |
| { |
| return( mRelativeOffsetPath != NULL ); |
| } |
| |
| inline void setOffsetPath(avm_size_t * anOffsetPath) |
| { |
| mRelativeOffsetPath = anOffsetPath; |
| } |
| |
| std::string strOffsetPath(const std::string & tab = "") const; |
| |
| void updateOffsetPath(); |
| |
| |
| |
| /** |
| * GETTER - SETTER |
| * mPointerNature |
| */ |
| inline virtual POINTER_DATA_NATURE getPointerNature() const |
| { |
| return( mPointerNature ); |
| } |
| |
| bool isConcreteArrayIndex(); |
| |
| bool isConcreteStructAttribute(); |
| |
| |
| /** |
| * GETTER - SETTER |
| * mMark |
| */ |
| inline avm_offset_t getMark() |
| { |
| return( mMark ); |
| } |
| |
| inline void eraseMark() |
| { |
| mMark = 0; |
| } |
| |
| inline void setMark(avm_offset_t aMark) |
| { |
| mMark = aMark; |
| } |
| |
| |
| |
| /** |
| * Format a value w.r.t. its type |
| */ |
| virtual void formatStream(OutStream & os, const BF & bfValue) const; |
| |
| virtual void formatStream(OutStream & os, const ArrayBF & arrayValue) const; |
| |
| |
| /** |
| * Serialization |
| */ |
| void strHeader(OutStream & os) const; |
| |
| std::string strHeaderId() const; |
| |
| void toStream(OutStream & os) const; |
| |
| |
| inline void strValue(OutStream & os, const BF & aValue) const |
| { |
| os << AVM_STR_INDENT; //<< IGNORE_FIRST_TAB; |
| |
| if( aValue.valid() ) |
| { |
| formatStream( os << TAB , aValue ); |
| } |
| else |
| { |
| aValue.toStream( os ); |
| } |
| |
| os << END_INDENT; |
| } |
| |
| inline void strValue(OutStream & os) const |
| { |
| strValue( os, mValue ); |
| } |
| |
| inline void strBValue(OutStream & os) const |
| { |
| strValue( os, mBufferValue ); |
| } |
| |
| |
| inline std::string strValue(const BF & aValue) const |
| { |
| StringOutStream oss; |
| |
| formatStream( oss , aValue ); |
| |
| return( oss.str() ); |
| } |
| |
| |
| inline std::string strValue() const |
| { |
| return( mValue.valid() ? strValue(mValue) : mValue.str() ); |
| } |
| |
| inline std::string strBValue() const |
| { |
| return( mBufferValue.valid() ? |
| strValue(mBufferValue) : mBufferValue.str() ); |
| } |
| |
| }; |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////// |
| // InstanceOfData |
| // TYPE DEFINITION for TABLE , SMART POINTER and CONTAINER |
| //////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| typedef TableOfBF_T< InstanceOfData > TableOfInstanceOfData; |
| |
| |
| } |
| |
| #endif /* INSTANCEOFDATA_H_ */ |