| /******************************************************************************* |
| * 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: 22 févr. 2011 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| |
| #ifndef FML_INFRASTRUCTURE_PROPERTYPART_H_ |
| #define FML_INFRASTRUCTURE_PROPERTYPART_H_ |
| |
| #include <fml/common/ObjectClassifier.h> |
| #include <fml/common/ObjectElement.h> |
| |
| #include <collection/BFContainer.h> |
| |
| #include <fml/infrastructure/Buffer.h> |
| #include <fml/infrastructure/Channel.h> |
| #include <fml/infrastructure/DataType.h> |
| #include <fml/infrastructure/Port.h> |
| #include <fml/infrastructure/Variable.h> |
| |
| |
| namespace sep |
| { |
| |
| |
| class PropertyPart : public ObjectClassifier , |
| AVM_INJECT_INSTANCE_COUNTER_CLASS( PropertyPart ) |
| { |
| |
| AVM_DECLARE_CLONABLE_CLASS( PropertyPart ) |
| |
| |
| public: |
| /** |
| * TYPEDEF |
| */ |
| typedef TableOfBF_T< Buffer > TableOfBuffer; |
| |
| typedef TableOfBF_T< Port > TableOfPort; |
| |
| typedef TableOfBF_T< Signal > TableOfSignal; |
| |
| typedef TableOfBF_T< Channel > TableOfChannel; |
| |
| typedef TableOfBF_T< DataType > TableOfDataType; |
| |
| typedef TableOfBF_T< Variable > TableOfVariable; |
| |
| typedef TableOfBF_T< ObjectElement > TableOfOwnedElement; |
| |
| /** |
| * ITERATORS |
| */ |
| |
| typedef TableOfOwnedElement::const_raw_iterator const_owned_iterator; |
| |
| typedef TableOfDataType::const_raw_iterator const_type_iterator; |
| |
| typedef TableOfVariable::const_raw_iterator const_variable_iterator; |
| |
| |
| protected: |
| /** |
| * ATTRIBUTES |
| */ |
| TableOfOwnedElement mOwnedElements; |
| |
| TableOfBuffer mBuffers; |
| |
| TableOfPort mPorts; |
| |
| TableOfSignal mSignals; |
| |
| TableOfChannel mChannels; |
| |
| TableOfDataType mDataTypes; |
| |
| TableOfVariable mVariables; |
| |
| TableOfVariable mVariableParameters; |
| |
| TableOfVariable mVariableReturns; |
| |
| |
| public: |
| |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| PropertyPart(ObjectElement * aContainer, const std::string & aNameID) |
| : ObjectClassifier( CLASS_KIND_T( PropertyPart ) , aContainer , aNameID ), |
| mOwnedElements( ), |
| mBuffers( ), |
| mPorts( ), |
| mSignals( ), |
| mChannels( ), |
| mDataTypes( ), |
| mVariables( ), |
| mVariableParameters( ), |
| mVariableReturns( ) |
| { |
| //!! NOTHING |
| } |
| |
| /** |
| * CONSTRUCTOR |
| * Copy |
| */ |
| PropertyPart(const PropertyPart & aPart) |
| : ObjectClassifier( aPart ), |
| mOwnedElements( aPart.mOwnedElements ), |
| mBuffers( aPart.mBuffers ), |
| mPorts( aPart.mPorts ), |
| mSignals( aPart.mSignals ), |
| mChannels( aPart.mChannels ), |
| mDataTypes( aPart.mDataTypes ), |
| mVariables( aPart.mVariables ), |
| mVariableParameters( aPart.mVariableParameters ), |
| mVariableReturns( aPart.mVariableReturns ) |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~PropertyPart() |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * GETTER - DISPATCH - SAVE |
| * mOwnedElements |
| */ |
| inline const TableOfOwnedElement & getOwnedElements() const |
| { |
| return( mOwnedElements ); |
| } |
| |
| |
| /** |
| * [ CONST ] ITERATOR |
| */ |
| inline const_owned_iterator owned_begin() const |
| { |
| return( mOwnedElements.begin() ); |
| } |
| |
| inline const_owned_iterator owned_end() const |
| { |
| return( mOwnedElements.end() ); |
| } |
| |
| |
| /** |
| * DISPATCH - SAVE |
| * mOwnedElements |
| */ |
| void dispatchOwnedElement(const BF & anElement); |
| |
| inline const BF & saveOwnedElement(ObjectElement * ptrElement) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( ptrElement ) |
| << "Property owned element !!!" |
| << SEND_EXIT; |
| |
| // Should be set by the executable machine container ! |
| ptrElement->setOffset( mOwnedElements.size() ); |
| |
| mOwnedElements.append( INCR_BF( ptrElement ) ); |
| |
| dispatchOwnedElement( mOwnedElements.last() ); |
| |
| return( mOwnedElements.last() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mBuffers |
| */ |
| inline void appendBuffer(const BF & aBuffer) |
| { |
| mBuffers.append( aBuffer ); |
| |
| mOwnedElements.append( aBuffer ); |
| } |
| |
| inline const TableOfBuffer & getBuffers() const |
| { |
| return( mBuffers ); |
| } |
| |
| inline const BF & getBuffer(const std::string & aQualifiedNameID) const |
| { |
| return( mBuffers.getByQualifiedNameID(aQualifiedNameID) ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mPorts |
| */ |
| inline void appendPort(const BF & aPort) |
| { |
| mPorts.append( aPort ); |
| |
| mOwnedElements.append( aPort ); |
| } |
| |
| inline const TableOfPort & getPorts() const |
| { |
| return( mPorts ); |
| } |
| |
| inline const BF & getPort(const std::string & aQualifiedNameID) const |
| { |
| return( mPorts.getByQualifiedNameID(aQualifiedNameID) ); |
| } |
| |
| inline bool hasPort() const |
| { |
| return( mPorts.nonempty() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mSignals |
| */ |
| inline void appendSignal(const BF & aSignal) |
| { |
| mSignals.append( aSignal ); |
| |
| mOwnedElements.append( aSignal ); |
| } |
| |
| inline const TableOfSignal & getSignals() const |
| { |
| return( mSignals ); |
| } |
| |
| inline const BF & getSignal(const std::string & aQualifiedNameID) const |
| { |
| return( mSignals.getByQualifiedNameID(aQualifiedNameID) ); |
| } |
| |
| inline bool hasSignal() const |
| { |
| return( mSignals.nonempty() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mPorts / mSignals |
| */ |
| inline const BF & getPortSignal(const std::string & aQualifiedNameID) const |
| { |
| const BF & port = mPorts.getByQualifiedNameID(aQualifiedNameID); |
| if( port.valid() ) |
| { |
| return( port ); |
| } |
| else |
| { |
| return( mSignals.getByQualifiedNameID(aQualifiedNameID) ); |
| } |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mBuffers |
| */ |
| inline void appendChannel(const BF & aChannel) |
| { |
| mChannels.append( aChannel ); |
| |
| mOwnedElements.append( aChannel ); |
| } |
| |
| inline const TableOfChannel & getChannels() const |
| { |
| return( mChannels ); |
| } |
| |
| inline const BF & getChannel(const std::string & aQualifiedNameID) const |
| { |
| return( mChannels.getByQualifiedNameID(aQualifiedNameID) ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mDataTypes |
| */ |
| inline void appendDataType(const BF & aDataType) |
| { |
| mDataTypes.append( aDataType ); |
| |
| mOwnedElements.append( aDataType ); |
| } |
| |
| inline const TableOfDataType & getDataTypes() const |
| { |
| return( mDataTypes ); |
| } |
| |
| inline const BF & getDataType(const std::string & aQualifiedNameID) const |
| { |
| return( mDataTypes.getByQualifiedNameID(aQualifiedNameID) ); |
| } |
| |
| |
| /** |
| * [ CONST ] ITERATOR |
| */ |
| inline const_type_iterator type_begin() const |
| { |
| return( mDataTypes.begin() ); |
| } |
| |
| inline const_type_iterator type_end() const |
| { |
| return( mDataTypes.end() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mVariables |
| */ |
| inline void appendVariable(const BF & aVariable) |
| { |
| mVariables.append( aVariable ); |
| |
| mOwnedElements.append( aVariable ); |
| } |
| |
| inline const TableOfVariable & getVariables() const |
| { |
| return( mVariables ); |
| } |
| |
| inline const BF & getVariable(const std::string & aQualifiedNameID) const |
| { |
| return( mVariables.getByQualifiedNameID(aQualifiedNameID) ); |
| } |
| |
| inline bool hasVariable() const |
| { |
| return( mVariables.nonempty() ); |
| } |
| |
| // inline void saveVariable(Variable * aVariable) |
| // { |
| // appendVariable( BF(aVariable) ); |
| // } |
| |
| |
| /** |
| * [ CONST ] ITERATOR |
| */ |
| inline const_variable_iterator variable_begin() const |
| { |
| return( mVariables.begin() ); |
| } |
| |
| inline const_variable_iterator variable_end() const |
| { |
| return( mVariables.end() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mVariableParameters |
| */ |
| inline void appendVariableParameter(const BF & aVariable) |
| { |
| mVariableParameters.append( aVariable ); |
| |
| mOwnedElements.append( aVariable ); |
| } |
| |
| inline const TableOfVariable & getVariableParameters() const |
| { |
| return( mVariableParameters ); |
| } |
| |
| inline const BF & getVariableParameter( |
| const std::string & aQualifiedNameID) const |
| { |
| return( mVariableParameters.getByQualifiedNameID(aQualifiedNameID) ); |
| } |
| |
| inline bool hasVariableParameter() const |
| { |
| return( mVariableParameters.nonempty() ); |
| } |
| |
| |
| /** |
| * [ CONST ] ITERATOR |
| */ |
| inline const_variable_iterator var_parameter_begin() const |
| { |
| return( mVariableParameters.begin() ); |
| } |
| |
| inline const_variable_iterator var_parameter_end() const |
| { |
| return( mVariableParameters.end() ); |
| } |
| |
| |
| /** |
| * UTIL |
| * mVariables as Parameters |
| */ |
| inline const BF & getVariableParameter(avm_size_t offset) const |
| { |
| return( mVariableParameters.get( offset ) ); |
| } |
| |
| inline avm_offset_t getVariableParametersCount() const |
| { |
| return( mVariableParameters.size() ); |
| } |
| |
| inline avm_offset_t getVariableParameterOffsetByNameID( |
| const std::string & aNameID) const |
| { |
| return( mVariableParameters.getOffsetByNameID( aNameID ) ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mVariableReturns |
| */ |
| inline void appendVariableReturn(const BF & aVariable) |
| { |
| mVariableReturns.append( aVariable ); |
| |
| mOwnedElements.append( aVariable ); |
| } |
| |
| inline const TableOfVariable & getVariableReturns() const |
| { |
| return( mVariableReturns ); |
| } |
| |
| inline const BF & getVariableReturn( |
| const std::string & aQualifiedNameID) const |
| { |
| return( mVariableReturns.getByQualifiedNameID(aQualifiedNameID) ); |
| } |
| |
| inline bool hasVariableReturn() const |
| { |
| return( mVariableReturns.nonempty() ); |
| } |
| |
| |
| /** |
| * [ CONST ] ITERATOR |
| */ |
| inline const_variable_iterator var_return_begin() const |
| { |
| return( mVariableReturns.begin() ); |
| } |
| |
| inline const_variable_iterator var_return_end() const |
| { |
| return( mVariableReturns.end() ); |
| } |
| |
| |
| /** |
| * UTIL |
| * mVariables as Returns |
| */ |
| inline const BF & getVariableReturn(avm_size_t offset) const |
| { |
| return( mVariableReturns.get( offset ) ); |
| } |
| |
| inline avm_offset_t getVariableReturnsCount() const |
| { |
| return( mVariableReturns.size() ); |
| } |
| |
| inline avm_offset_t getVariableReturnOffsetByNameID( |
| const std::string & aNameID) const |
| { |
| return( mVariableReturns.getOffsetByNameID( aNameID ) ); |
| } |
| |
| |
| /** |
| * DISPATCH - SAVE |
| * using Variable::Modifier |
| * mVariables |
| * mVariableParameters |
| * mVariableReturns |
| * mVariableInternals |
| */ |
| void dispatchOwnedVariable(const BF & aVariable); |
| |
| inline const BF & saveOwnedVariable(Variable * aVariable) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( aVariable ) |
| << "Property Variable owned element !!!" |
| << SEND_EXIT; |
| |
| // Should be set by the executable machine container ! |
| aVariable->setOffset( mOwnedElements.size() ); |
| |
| mOwnedElements.append( INCR_BF( aVariable ) ); |
| |
| dispatchOwnedVariable( mOwnedElements.last() ); |
| |
| return( mOwnedElements.last() ); |
| } |
| |
| |
| /** |
| * GETTER |
| * general |
| */ |
| inline bool empty() const |
| { |
| return( mOwnedElements.empty() ); |
| } |
| |
| inline bool nonempty() const |
| { |
| return( mOwnedElements.nonempty() ); |
| } |
| |
| |
| /** |
| * GETTER for |
| * PARSER |
| * COMPILER |
| */ |
| inline const BF & getPropertyByNameID(const std::string & aNameID) const |
| { |
| return( mOwnedElements.getByNameID(aNameID) ); |
| } |
| |
| inline const BF & getPropertyByQualifiedNameID( |
| const std::string & aQualifiedNameID) const |
| { |
| return( mOwnedElements.getByQualifiedNameID(aQualifiedNameID) ); |
| } |
| |
| |
| /** |
| * Serialization |
| */ |
| void strVariableParameters(OutStream & os, |
| const std::string & begin = " [ ", |
| const std::string & end = " ]", |
| const std::string & sep = ", ") const; |
| |
| void strVariableReturns(OutStream & os, |
| const std::string & begin = " returns: [ ", |
| const std::string & end = " ]", |
| const std::string & sep = ", ") const; |
| |
| void toStream(OutStream & os) const; |
| |
| }; |
| |
| |
| } |
| |
| #endif /* FML_INFRASTRUCTURE_PROPERTYPART_H_ */ |
| |
| |
