| /******************************************************************************* |
| * 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 INSTANCEOFMACHINE_H_ |
| #define INSTANCEOFMACHINE_H_ |
| |
| #include <fml/executable/BaseInstanceForm.h> |
| #include <fml/common/SpecifierElement.h> |
| |
| #include <common/AvmPointer.h> |
| |
| #include <collection/Typedef.h> |
| |
| #include <fml/common/ModifierElement.h> |
| |
| #include <fml/executable/AvmProgram.h> |
| #include <fml/executable/InstanceOfBuffer.h> |
| #include <fml/executable/InstanceOfData.h> |
| #include <fml/executable/InstanceOfPort.h> |
| |
| #include <fml/lib/IComPoint.h> |
| |
| #include <fml/runtime/RuntimeID.h> |
| #include <fml/runtime/TableOfData.h> |
| |
| #include <fml/infrastructure/Machine.h> |
| |
| |
| namespace sep |
| { |
| |
| class BaseAvmProgram; |
| |
| class ExecutableForm; |
| |
| class Specifier; |
| |
| |
| class InstanceOfMachine : |
| public BaseInstanceForm, |
| public SpecifierImpl, |
| AVM_INJECT_INSTANCE_COUNTER_CLASS( InstanceOfMachine ) |
| { |
| |
| AVM_DECLARE_CLONABLE_CLASS( InstanceOfMachine ) |
| |
| |
| protected: |
| /* |
| * ATTRIBUTES |
| */ |
| // the Executable Code for Machine |
| ExecutableForm * mExecutable; |
| |
| bool mThisFlag; |
| |
| AvmProgram onCreateRoutine; |
| AvmProgram onStartRoutine; |
| |
| avm_size_t mPossibleDynamicInstanciationCount; |
| avm_size_t mMaximalInstanceCount; |
| |
| APTableOfData mParamReturnTable; |
| |
| avm_size_t mReturnOffset; |
| |
| InstanceOfMachine * mInstanceModel; |
| |
| // The runtime machine RID for RID access optimization |
| RuntimeID mRuntimeRID; |
| |
| bool mModifierAutoStart; |
| |
| // static class of Port/Message/Signal in communicated statement |
| ListOfInstanceOfBuffer mInputEnabledBuffer; |
| ListOfInstanceOfPort mInputEnabledCom; |
| ListOfInstanceOfPort mInputEnabledSave; |
| |
| |
| public: |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| InstanceOfMachine(ExecutableForm * aContainer, |
| const Machine * astMachine, ExecutableForm * anExecutable, |
| InstanceOfMachine * anInstanceModel, avm_offset_t anOffset); |
| |
| InstanceOfMachine(ExecutableForm * aContainer, const Machine * astMachine, |
| ExecutableForm * anExecutable, InstanceOfMachine * anInstanceModel, |
| avm_offset_t anOffset, const Specifier & aSpecifier); |
| |
| |
| /** |
| * CONSTRUCTOR |
| * copy |
| */ |
| InstanceOfMachine(const InstanceOfMachine & aMachine) |
| : BaseInstanceForm( aMachine ), |
| SpecifierImpl( aMachine ), |
| |
| mExecutable( aMachine.mExecutable ), |
| |
| mThisFlag( aMachine.mThisFlag ), |
| |
| onCreateRoutine ( aMachine.onCreateRoutine ), |
| onStartRoutine( aMachine.onStartRoutine ), |
| |
| mPossibleDynamicInstanciationCount( |
| aMachine.mPossibleDynamicInstanciationCount ), |
| mMaximalInstanceCount( aMachine.mMaximalInstanceCount ), |
| mParamReturnTable( aMachine.mParamReturnTable ), |
| mReturnOffset( aMachine.mReturnOffset ), |
| mInstanceModel( aMachine.mInstanceModel ), |
| mRuntimeRID( aMachine.mRuntimeRID ), |
| mModifierAutoStart( aMachine.mModifierAutoStart ), |
| |
| mInputEnabledBuffer( aMachine.mInputEnabledBuffer ), |
| mInputEnabledCom( aMachine.mInputEnabledCom ), |
| mInputEnabledSave( aMachine.mInputEnabledSave ) |
| { |
| //!! NOTHING |
| } |
| |
| /** |
| * CONSTRUCTOR |
| * for Alias |
| */ |
| InstanceOfMachine(BaseAvmProgram * aContainer, InstanceOfMachine * aTarget, |
| VectorOfInstanceOfMachine & aRelativeMachinePath) |
| : BaseInstanceForm(CLASS_KIND_T( InstanceOfMachine ), |
| aContainer, aTarget, aRelativeMachinePath), |
| SpecifierImpl( aTarget->getSpecifier() ), |
| |
| mExecutable( aTarget->mExecutable ), |
| |
| mThisFlag( aTarget->mThisFlag ), |
| |
| onCreateRoutine ( aTarget->onCreateRoutine ), |
| onStartRoutine( aTarget->onStartRoutine ), |
| |
| mPossibleDynamicInstanciationCount( |
| aTarget->mPossibleDynamicInstanciationCount ), |
| mMaximalInstanceCount( aTarget->mMaximalInstanceCount ), |
| mParamReturnTable( aTarget->mParamReturnTable ), |
| mReturnOffset( aTarget->mReturnOffset ), |
| mInstanceModel( aTarget->mInstanceModel ), |
| mRuntimeRID( aTarget->mRuntimeRID ), |
| mModifierAutoStart( aTarget->mModifierAutoStart ), |
| |
| mInputEnabledBuffer( aTarget->mInputEnabledBuffer ), |
| mInputEnabledCom( aTarget->mInputEnabledCom ), |
| mInputEnabledSave( aTarget->mInputEnabledSave ) |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~InstanceOfMachine() |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * GETTER |
| * Compiled ObjectElement as Compiled Machine |
| */ |
| inline const Machine * getAstMachine() const |
| { |
| return( getAstElement()->as< Machine >() ); |
| } |
| |
| |
| /** |
| * SETTER |
| * mFullyQualifiedNameID |
| */ |
| virtual void updateFullyQualifiedNameID(); |
| |
| |
| /** |
| * GETTER - SETTER |
| * mExecutable |
| */ |
| inline ExecutableForm * getExecutable() const |
| { |
| return( mExecutable ); |
| } |
| |
| inline bool hasExecutable() const |
| { |
| return( mExecutable != NULL ); |
| } |
| |
| inline void setExecutable(ExecutableForm * anExecutable) |
| { |
| mExecutable = anExecutable; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mExecutable |
| */ |
| inline bool isThis() const |
| { |
| return( mThisFlag ); |
| } |
| |
| inline bool isnotThis() const |
| { |
| return( not mThisFlag ); |
| } |
| |
| inline bool isThis(const ExecutableForm * anExecutable) const |
| { |
| return( mThisFlag && (mExecutable == anExecutable) ); |
| } |
| |
| inline bool isnotThis(const ExecutableForm * anExecutable) const |
| { |
| return( (mExecutable != anExecutable) || (not mThisFlag) ); |
| } |
| |
| inline void setThis(bool isThisFlag = true) |
| { |
| mThisFlag = isThisFlag; |
| } |
| |
| /** |
| * CONSTRUCTION |
| * the instance << this >> |
| */ |
| static std::string THIS_FQN_SUFFIX; |
| static std::string THIS_ID; |
| |
| static InstanceOfMachine * newThis(ExecutableForm * anExecutable, |
| InstanceOfMachine * anInstanceModel, avm_offset_t anOffset); |
| |
| static InstanceOfMachine * newInstanceModelThis( |
| ExecutableForm * aContainer, Machine * aCompiled, |
| ExecutableForm * anExecutable, InstanceOfMachine * anInstanceModel, |
| avm_offset_t anOffset, const Specifier & aSpecifier); |
| |
| /** |
| * GETTER - SETTER |
| * onCreateRoutine |
| */ |
| inline AvmProgram & getOnCreateRoutine() |
| { |
| return( onCreateRoutine ); |
| } |
| |
| inline BFCode & getOnCreate() |
| { |
| return( onCreateRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnCreate() const |
| { |
| return( onCreateRoutine.getCode() ); |
| } |
| |
| inline bool hasOnCreate() const |
| { |
| return( onCreateRoutine.hasCode() ); |
| } |
| |
| inline void setOnCreate(const BFCode & aProgram) |
| { |
| onCreateRoutine.setCode( aProgram ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onStartRoutine |
| */ |
| inline AvmProgram & getOnStartRoutine() |
| { |
| return( onStartRoutine ); |
| } |
| |
| inline BFCode & getOnStart() |
| { |
| return( onStartRoutine.getCode() ); |
| } |
| |
| inline const BFCode & getOnStart() const |
| { |
| return( onStartRoutine.getCode() ); |
| } |
| |
| inline bool hasOnStart() const |
| { |
| return( onStartRoutine.hasCode() ); |
| } |
| |
| inline void setOnStart(const BFCode & aProgram) |
| { |
| onStartRoutine.setCode( aProgram ); |
| } |
| |
| |
| /** |
| * UTIL |
| */ |
| inline bool hasBehavior() const |
| { |
| return( hasOnCreate() || hasOnStart() ); |
| } |
| |
| /* |
| * GETTER - SETTER |
| * mPossibleDynamicInstanciationCount |
| * Single or Multiple |
| * Instanciation Information |
| * for Data Access optimisation |
| */ |
| inline avm_size_t getStaticInstanciationCount() const |
| { |
| return( mInstanciationCount ); |
| } |
| |
| inline bool hasStaticInstanciation() const |
| { |
| return( mInstanciationCount > 0 ); |
| } |
| |
| |
| inline avm_size_t getPossibleDynamicInstanciationCount() const |
| { |
| return( mPossibleDynamicInstanciationCount ); |
| } |
| |
| inline bool hasPossibleDynamicInstanciation() const |
| { |
| return( mPossibleDynamicInstanciationCount > 0 ); |
| } |
| |
| void incrPossibleDynamicInstanciationCount(avm_size_t offset = 1); |
| |
| |
| inline bool hasSingleRuntimeInstance() |
| { |
| return( (mInstanciationCount > 1) || |
| (mPossibleDynamicInstanciationCount > 0) ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mMaximalInstanceCount |
| */ |
| inline avm_size_t getMaximalInstanceCount() const |
| { |
| return( mMaximalInstanceCount ); |
| } |
| |
| inline bool hasMaximalInstance() const |
| { |
| return( mMaximalInstanceCount != AVM_NUMERIC_MAX_SIZE_T ); |
| } |
| |
| inline bool hasMaximalNewInstance() const |
| { |
| return( (mMaximalInstanceCount > 1) |
| && (mMaximalInstanceCount != AVM_NUMERIC_MAX_SIZE_T) ); |
| } |
| |
| inline void setMaximalInstanceCount(avm_size_t aMaximalInstanceCount) |
| { |
| mMaximalInstanceCount = aMaximalInstanceCount; |
| } |
| |
| |
| inline void setInstanceCount( |
| avm_uint32_t anInitialCount, avm_size_t aMaximalInstanceCount) |
| { |
| BaseInstanceForm::setInstanciationCount( anInitialCount ); |
| |
| mMaximalInstanceCount = aMaximalInstanceCount; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mParamReturnTable |
| */ |
| inline APTableOfData & getParamReturnTable() |
| { |
| return( mParamReturnTable ); |
| } |
| |
| inline const APTableOfData & getParamReturnTable() const |
| { |
| return( mParamReturnTable ); |
| } |
| |
| |
| inline bool hasParamReturnTable() const |
| { |
| return( mParamReturnTable.valid() ); |
| } |
| |
| |
| inline void setParamReturnTable(const APTableOfData & aParamTable) |
| { |
| mParamReturnTable = aParamTable; |
| } |
| |
| |
| inline BF & getParamReturn(avm_size_t offset) |
| { |
| return( mParamReturnTable->at(offset) ); |
| } |
| |
| inline const BF & getParamReturn(avm_size_t offset) const |
| { |
| return( mParamReturnTable->at(offset) ); |
| } |
| |
| |
| inline bool hasParamReturn() const |
| { |
| return( mParamReturnTable.valid() && mParamReturnTable->nonempty() ); |
| } |
| |
| inline void setParamReturn(avm_size_t offset, const BF & aParam) |
| { |
| mParamReturnTable->set(offset, aParam); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mParamReturnTable |
| * mReturnOffset |
| */ |
| |
| inline avm_size_t getParamOffset() const |
| { |
| return( 0 ); |
| } |
| |
| inline avm_size_t getParamCount() const |
| { |
| return( mReturnOffset ); |
| } |
| |
| inline BF & getParam(avm_size_t offset) |
| { |
| return( mParamReturnTable->at(offset) ); |
| } |
| |
| inline const BF & getParam(avm_size_t offset) const |
| { |
| return( mParamReturnTable->at(offset) ); |
| } |
| |
| |
| BaseTypeSpecifier * getParamType(avm_size_t offset) const; |
| |
| |
| inline bool hasParam() const |
| { |
| return( mParamReturnTable.valid() |
| && mParamReturnTable->nonempty() |
| && (mReturnOffset > 0) ); |
| } |
| |
| |
| inline void setParam(avm_size_t offset, const BF & aParam) |
| { |
| mParamReturnTable->set(offset, aParam); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mParamReturnTable |
| * mReturnOffset |
| */ |
| inline void setReturnOffset(avm_size_t aReturnOffset) |
| { |
| mReturnOffset = aReturnOffset; |
| } |
| |
| inline avm_size_t getReturnCount() const |
| { |
| return( mParamReturnTable->size() - mReturnOffset ); |
| } |
| |
| |
| inline bool hasReturn() const |
| { |
| return( mParamReturnTable.valid() |
| && (mReturnOffset < mParamReturnTable->size()) ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mInstanceModel |
| */ |
| inline InstanceOfMachine * getInstanceModel() const |
| { |
| return( mInstanceModel ); |
| } |
| |
| inline bool hasInstanceModel() const |
| { |
| return( mInstanceModel != NULL ); |
| } |
| |
| inline bool isInstanceModel(InstanceOfMachine * anOtherModel) const |
| { |
| return( (mInstanceModel != NULL) |
| && ( (mInstanceModel == anOtherModel) |
| || (anOtherModel->getSpecifier().isDesignPrototypeStatic() |
| && (mInstanceModel |
| == anOtherModel->getInstanceModel()) ))); |
| } |
| |
| inline void setInstanceModel(InstanceOfMachine * anInstanceModel) |
| { |
| mInstanceModel = anInstanceModel; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mRuntimeRID |
| */ |
| inline const RuntimeID & getRuntimeRID() const |
| { |
| return( mRuntimeRID ); |
| } |
| |
| inline bool hasRuntimeRID() const |
| { |
| return( mRuntimeRID.valid() ); |
| } |
| |
| inline void setRuntimeRID(const RuntimeID & aRID) |
| { |
| mRuntimeRID = aRID; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * "autostart" modifier of Instance |
| */ |
| inline bool isAutoStart() const |
| { |
| return( mModifierAutoStart ); |
| } |
| |
| inline void setAutoStart(bool bAutoStart = true) |
| { |
| mModifierAutoStart = bAutoStart; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mInputEnabledBuffer |
| */ |
| inline void addInputEnabledBuffer(InstanceOfBuffer * aBuffer) |
| { |
| mInputEnabledBuffer.add_union( aBuffer ); |
| } |
| |
| inline void addInputEnabledBuffer(ListOfInstanceOfBuffer & inputEnabledBuffer) |
| { |
| mInputEnabledBuffer.add_union( inputEnabledBuffer ); |
| } |
| |
| |
| inline ListOfInstanceOfBuffer & getInputEnabledBuffer() |
| { |
| return( mInputEnabledBuffer ); |
| } |
| |
| inline const ListOfInstanceOfBuffer & getInputEnabledBuffer() const |
| { |
| return( mInputEnabledBuffer ); |
| } |
| |
| |
| bool containsInputEnabledBuffer(InstanceOfBuffer * aBuffer) const |
| { |
| return( mInputEnabledBuffer.contains(aBuffer) ); |
| } |
| |
| inline bool hasInputEnabledBuffer() const |
| { |
| return( mInputEnabledBuffer.nonempty() ); |
| } |
| |
| |
| inline void setInputEnabledBuffer(ListOfInstanceOfBuffer & inputEnabledBuffer) |
| { |
| mInputEnabledBuffer.clear(); |
| |
| mInputEnabledBuffer.add_union( inputEnabledBuffer ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mInputEnabledCom |
| */ |
| inline void addInputEnabledCom(InstanceOfPort * aPort) |
| { |
| mInputEnabledCom.add_union( aPort ); |
| } |
| |
| inline void addInputEnabledCom(ListOfInstanceOfPort & inputEnabledPort) |
| { |
| mInputEnabledCom.add_union( inputEnabledPort ); |
| } |
| |
| |
| inline ListOfInstanceOfPort & getInputEnabledCom() |
| { |
| return( mInputEnabledCom ); |
| } |
| |
| inline const ListOfInstanceOfPort & getInputEnabledCom() const |
| { |
| return( mInputEnabledCom ); |
| } |
| |
| |
| bool containsInputEnabledCom(InstanceOfPort * aPort) const |
| { |
| return( mInputEnabledCom.contains(aPort) ); |
| } |
| |
| inline bool hasInputEnabledCom() const |
| { |
| return( mInputEnabledCom.nonempty() ); |
| } |
| |
| |
| inline void setInputEnabledCom(ListOfInstanceOfPort & inputEnabledPort) |
| { |
| mInputEnabledCom.clear(); |
| |
| mInputEnabledCom.add_union( inputEnabledPort ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mInputEnabledSave |
| */ |
| inline void addInputEnabledSave(InstanceOfPort * aPort) |
| { |
| mInputEnabledSave.add_union( aPort ); |
| } |
| |
| inline void addInputEnabledSave(ListOfInstanceOfPort & inputEnabledSavePort) |
| { |
| mInputEnabledSave.add_union( inputEnabledSavePort ); |
| } |
| |
| |
| inline ListOfInstanceOfPort & getInputEnabledSave() |
| { |
| return( mInputEnabledSave ); |
| } |
| |
| inline const ListOfInstanceOfPort & getInputEnabledSave() const |
| { |
| return( mInputEnabledSave ); |
| } |
| |
| |
| bool containsInputEnabledSave(InstanceOfPort * aPort) const |
| { |
| return( mInputEnabledSave.contains(aPort) ); |
| } |
| |
| inline bool hasInputEnabledSave() const |
| { |
| return( mInputEnabledSave.nonempty() ); |
| } |
| |
| |
| inline void setInputEnabledSave(ListOfInstanceOfPort & inputEnabledSavePort) |
| { |
| mInputEnabledSave.clear(); |
| |
| mInputEnabledSave.add_union( inputEnabledSavePort ); |
| } |
| |
| |
| /** |
| * Serialization |
| */ |
| void header(OutStream & out) const; |
| |
| void strHeader(OutStream & out) const; |
| |
| void toStream(OutStream & out) const; |
| |
| }; |
| |
| |
| } |
| |
| #endif /* INSTANCEOFMACHINE_H_ */ |
