| /******************************************************************************* |
| * 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 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| #ifndef UFI_H_ |
| #define UFI_H_ |
| |
| #include <common/NamedElement.h> |
| |
| #include <fml/common/TraceableElement.h> |
| |
| #include <common/AvmPointer.h> |
| #include <base/ClassKindInfo.h> |
| #include <common/BF.h> |
| |
| #include <fml/builtin/Identifier.h> |
| #include <collection/List.h> |
| |
| |
| namespace sep |
| { |
| |
| class Element; |
| |
| |
| typedef avm_uint8_t avm_ufi_scheme_t; |
| |
| enum { |
| UFI_SCHEME_UNDEFINED = 0x00, |
| |
| UFI_SCHEME_MACHINE = 0x01, |
| UFI_SCHEME_INSTANCE = 0x02, |
| UFI_SCHEME_PORT = 0x04, |
| UFI_SCHEME_BUFFER = 0x08, |
| UFI_SCHEME_VARIABLE = 0x10, |
| // UFI_SCHEME_CONNECTOR = 0x20, |
| |
| UFI_SCHEME_INVOKABLE = 0x20, |
| |
| UFI_SCHEME_FIELD = UFI_SCHEME_MACHINE |
| | UFI_SCHEME_INSTANCE |
| | UFI_SCHEME_PORT |
| | UFI_SCHEME_BUFFER |
| | UFI_SCHEME_VARIABLE, |
| // | UFI_SCHEME_CONNECTOR, |
| // | UFI_SCHEME_INVOKABLE, |
| |
| |
| UFI_SCHEME_INDEX = 0x40, |
| |
| UFI_SCHEME_ARRAY = UFI_SCHEME_INDEX, |
| |
| |
| UFI_SCHEME_PARAMETER = 0x80, |
| |
| |
| UFI_SCHEME_ARGUMENT = UFI_SCHEME_ARRAY |
| | UFI_SCHEME_PARAMETER, |
| |
| |
| UFI_SCHEME_HYBRID = UFI_SCHEME_FIELD |
| | UFI_SCHEME_INDEX |
| | UFI_SCHEME_ARRAY, |
| |
| UFI_SCHEME_MASK_ALL = 0xFF |
| }; |
| |
| |
| |
| class UfiField : public BF |
| { |
| |
| public: |
| /** |
| * ATTRIBUTE |
| */ |
| avm_ufi_scheme_t scheme; |
| |
| |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| UfiField(const BF & bf, avm_ufi_scheme_t aScheme) |
| : BF( bf ), |
| scheme( aScheme ) |
| { |
| // NOTHING |
| } |
| |
| UfiField(Element * bf, avm_ufi_scheme_t aScheme) |
| : BF( bf ), |
| scheme( aScheme ) |
| { |
| // NOTHING |
| } |
| |
| /** |
| * CONSTRUCTOR |
| * Copy |
| */ |
| UfiField(const UfiField & atom) |
| : BF( atom ), |
| scheme( atom.scheme ) |
| { |
| // NOTHING |
| } |
| |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~UfiField() |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * COMPARISON |
| * OPERATOR |
| */ |
| inline bool operator==(const UfiField & other) const |
| { |
| return( (scheme == other.scheme) && (*this == other) ); |
| } |
| |
| inline bool operator!=(const UfiField & other) const |
| { |
| return( (scheme != other.scheme) || (*this != other) ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * for mScheme |
| */ |
| inline void addScheme(avm_ufi_scheme_t aScheme) |
| { |
| scheme |= aScheme; |
| } |
| |
| inline avm_ufi_scheme_t getScheme() const |
| { |
| return( scheme ); |
| } |
| |
| inline bool isFieldIndex() const |
| { |
| return( scheme & UFI_SCHEME_INDEX ); |
| } |
| |
| inline bool isFieldMachine() const |
| { |
| return( scheme & UFI_SCHEME_MACHINE ); |
| } |
| |
| inline bool isFieldBuffer() const |
| { |
| return( scheme & UFI_SCHEME_BUFFER ); |
| } |
| |
| inline bool isFieldPort() const |
| { |
| return( scheme & UFI_SCHEME_PORT ); |
| } |
| |
| inline bool isFieldVariable() const |
| { |
| return( scheme & UFI_SCHEME_VARIABLE ); |
| } |
| |
| inline bool isFieldInvokable() const |
| { |
| return( scheme & UFI_SCHEME_INVOKABLE ); |
| } |
| |
| inline bool isFieldParameter() const |
| { |
| return( scheme & UFI_SCHEME_PARAMETER ); |
| } |
| |
| |
| inline void setScheme(avm_ufi_scheme_t aScheme) |
| { |
| scheme = aScheme; |
| } |
| |
| }; |
| |
| |
| class UniFormIdentifier : |
| public NamedElement, |
| public TraceableElement, |
| public List< UfiField >, |
| AVM_INJECT_INSTANCE_COUNTER_CLASS( UniFormIdentifier ) |
| { |
| |
| AVM_DECLARE_CLONABLE_CLASS( UniFormIdentifier ) |
| |
| |
| public: |
| typedef List< UfiField > ListOfField; |
| |
| |
| static BF ANONYM_LOCATION; |
| |
| static std::string SEPARATOR_ID; |
| static std::string SEPARATOR_LOCATION; |
| static std::string SEPARATOR_LOCATOR; |
| |
| |
| protected: |
| /** |
| * ATTRIBUTES |
| */ |
| avm_ufi_scheme_t mScheme; |
| |
| BF mLocator; |
| |
| |
| public: |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| UniFormIdentifier(bool anonymLocation) |
| : NamedElement( CLASS_KIND_T( UniFormIdentifier ) ), |
| TraceableElement( ), |
| ListOfField( ), |
| mScheme( UFI_SCHEME_UNDEFINED ), |
| mLocator( ( anonymLocation )? ANONYM_LOCATION : BF::REF_NULL ) |
| { |
| //!! NOTHING |
| } |
| |
| UniFormIdentifier(const BF & aLocator) |
| : NamedElement( CLASS_KIND_T( UniFormIdentifier ) ), |
| TraceableElement( ), |
| ListOfField( ), |
| mScheme( UFI_SCHEME_UNDEFINED ), |
| mLocator( aLocator ) |
| { |
| //!! NOTHING |
| } |
| |
| /** |
| * CONSTRUCTOR |
| * Other |
| */ |
| UniFormIdentifier(const std::string & aQualifiedNameID) |
| : NamedElement( CLASS_KIND_T( UniFormIdentifier ), aQualifiedNameID ), |
| TraceableElement( ), |
| ListOfField( ), |
| mScheme( UFI_SCHEME_UNDEFINED ), |
| mLocator( ) |
| { |
| build( aQualifiedNameID ); |
| } |
| |
| /** |
| * CONSTRUCTOR |
| * Copy |
| */ |
| UniFormIdentifier(const UniFormIdentifier & anUFI) |
| : NamedElement( anUFI ), |
| TraceableElement( anUFI ), |
| ListOfField( anUFI ), |
| mScheme( anUFI.mScheme ), |
| mLocator( anUFI.mLocator ) |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~UniFormIdentifier() |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * BUILD FROM QUALIFIED NAME ID |
| */ |
| void build(const std::string & aQualifiedNameID); |
| |
| /** |
| * LOADER - DISPOSER |
| */ |
| static void load(); |
| static void dispose(); |
| |
| |
| /** |
| * ListOfField |
| */ |
| inline avm_size_t size() const |
| { |
| return( ListOfField::size() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * for mScheme |
| */ |
| inline void addScheme(avm_ufi_scheme_t aScheme) |
| { |
| mScheme |= aScheme; |
| } |
| |
| |
| inline avm_ufi_scheme_t getScheme() const |
| { |
| return( mScheme ); |
| } |
| |
| inline bool hasScheme() const |
| { |
| return( mScheme != UFI_SCHEME_UNDEFINED ); |
| } |
| |
| inline bool isScheme(avm_ufi_scheme_t aScheme) const |
| { |
| return( (mScheme & aScheme) == aScheme ); |
| } |
| |
| |
| inline bool isFields() const |
| { |
| return( (mScheme & (UFI_SCHEME_ARGUMENT)) == 0 ); |
| } |
| |
| inline bool isAbsoluteFullFields() const |
| { |
| return( (mLocator.valid() |
| || (nonempty() && first().is< ObjectElement >())) |
| && ((mScheme & UFI_SCHEME_ARGUMENT) == 0) ); |
| } |
| |
| inline bool isFullOffset() const |
| { |
| return( (mScheme & UFI_SCHEME_PARAMETER) == 0 ); |
| } |
| |
| inline bool hasArray() const |
| { |
| return( mScheme & UFI_SCHEME_ARRAY ); |
| } |
| |
| inline bool hasInvokable() const |
| { |
| return( mScheme & UFI_SCHEME_INVOKABLE ); |
| } |
| |
| inline bool hasParameter() const |
| { |
| return( mScheme & UFI_SCHEME_PARAMETER ); |
| } |
| |
| |
| inline void setScheme(avm_ufi_scheme_t aScheme) |
| { |
| mScheme = aScheme; |
| } |
| |
| |
| |
| /** |
| * GETTER - SETTER |
| * for mLocator |
| */ |
| inline BF & getLocator() |
| { |
| return( mLocator ); |
| } |
| |
| inline const BF & getLocator() const |
| { |
| return( mLocator ); |
| } |
| |
| inline bool hasLocator() const |
| { |
| return( mLocator.valid() ); |
| } |
| |
| |
| void setLocator(const std::string & aLocationId); |
| |
| // inline void setLocator(const BF & aLocation) |
| // { |
| // mLocator = aLocation; |
| // } |
| |
| |
| inline bool isAnonymLocation() const |
| { |
| return( mLocator.isTEQ( ANONYM_LOCATION ) ); |
| } |
| |
| inline void setAnonymLocation() |
| { |
| mLocator = ANONYM_LOCATION; |
| } |
| |
| inline void setAbsolute() |
| { |
| if( not hasLocator() ) |
| { |
| setAnonymLocation(); |
| } |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * FIELD UNDEFINED |
| */ |
| inline void appendUndef(const BF & field) |
| { |
| ListOfField::append( UfiField(field, UFI_SCHEME_UNDEFINED) ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * FIELD INDEX |
| */ |
| inline void appendIndex(const BF & idx) |
| { |
| ListOfField::append( UfiField(idx, UFI_SCHEME_INDEX) ); |
| mScheme |= UFI_SCHEME_ARRAY; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * FIELD |
| */ |
| inline void updateAllNameID() |
| { |
| const std::string strID = str(); |
| |
| setAllNameID( strID , strID , strID ); |
| } |
| |
| |
| |
| inline void appendField(Element * field, avm_ufi_scheme_t scheme) |
| { |
| ListOfField::append( UfiField(field, scheme) ); |
| mScheme |= scheme; |
| |
| updateAllNameID(); |
| } |
| |
| inline void appendField(const BF & field, avm_ufi_scheme_t scheme) |
| { |
| ListOfField::append( UfiField(field, scheme) ); |
| mScheme |= scheme; |
| |
| updateAllNameID(); |
| } |
| |
| void appendField(const std::string & aQualifiedNameID, |
| avm_ufi_scheme_t scheme); |
| |
| void appendField(const BF & field); |
| |
| inline void appendField(const std::string & aQualifiedNameID) |
| { |
| appendField( aQualifiedNameID , UFI_SCHEME_FIELD ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * FIELD MACHINE |
| */ |
| inline void appendFieldMachine(const BF & field) |
| { |
| appendField( field , UFI_SCHEME_MACHINE ); |
| } |
| |
| inline void appendFieldMachine(const std::string & aQualifiedNameID) |
| { |
| appendField( aQualifiedNameID , UFI_SCHEME_MACHINE ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * FIELD VARIABLE |
| */ |
| inline void appendFieldVariable(const BF & field) |
| { |
| appendField( field , UFI_SCHEME_VARIABLE ); |
| } |
| |
| inline void appendFieldVariable(const std::string & aQualifiedNameID) |
| { |
| appendField( aQualifiedNameID , UFI_SCHEME_VARIABLE ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * FIELD FUNCTION |
| */ |
| inline void appendFieldInvokable(const BF & field) |
| { |
| appendField( field , UFI_SCHEME_INVOKABLE ); |
| } |
| |
| inline void appendFieldInvokable(const std::string & aQualifiedNameID) |
| { |
| appendField( aQualifiedNameID , UFI_SCHEME_INVOKABLE ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * FIELD PARAMETER |
| */ |
| inline void appendFieldParameter(const BF & field) |
| { |
| appendField( field , UFI_SCHEME_PARAMETER ); |
| } |
| |
| inline void appendFieldParameter(const std::string & aQualifiedNameID) |
| { |
| appendField( aQualifiedNameID , UFI_SCHEME_PARAMETER ); |
| } |
| |
| |
| /** |
| * TEST |
| */ |
| inline bool isPureIdentifier() const |
| { |
| return( ListOfField::singleton() && mLocator.invalid() && |
| isScheme(UFI_SCHEME_FIELD) && |
| ListOfField::back().is< Identifier >() ); |
| } |
| |
| inline BF popIdentifier() |
| { |
| return( ListOfField::pop_first() ); |
| } |
| |
| inline const BF & toIdentifier() const |
| { |
| return( ListOfField::back() ); |
| } |
| |
| |
| /** |
| * COMPARISON |
| * OPERATOR |
| */ |
| int compare(const UniFormIdentifier & other) const; |
| |
| inline bool operator==(const UniFormIdentifier & other) const |
| { |
| return( UniFormIdentifier::isEQ( other ) ); |
| } |
| |
| bool isEQ(const UniFormIdentifier & other) const; |
| |
| |
| /** |
| * Serialization |
| */ |
| void toStream(OutStream & out) const; |
| |
| std::string str() const; |
| |
| |
| void toStreamLocator(OutStream & out) const; |
| |
| inline std::string toStringLocator() const |
| { |
| StringOutStream oss(AVM_NO_INDENT); |
| |
| toStreamLocator(oss); |
| |
| return( oss.str() ); |
| } |
| |
| |
| void toStreamLocation(OutStream & out) const; |
| |
| inline std::string toStringLocation() const |
| { |
| StringOutStream oss(AVM_NO_INDENT); |
| |
| toStreamLocation(oss); |
| |
| return( oss.str() ); |
| } |
| |
| |
| void toStreamLocation(OutStream & out, ListOfField::const_iterator it, |
| ListOfField::const_iterator itEnd) const; |
| |
| std::string toStringContainer() const; |
| |
| std::string toStringId() const; |
| |
| |
| void toStreamAvm(OutStream & out) const; |
| |
| }; |
| |
| |
| } |
| |
| #endif /*UFI_H_*/ |
