| /******************************************************************************* |
| * 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_BEHAVIORALPART_H_ |
| #define FML_INFRASTRUCTURE_BEHAVIORALPART_H_ |
| |
| #include <fml/common/ObjectClassifier.h> |
| #include <fml/common/ObjectElement.h> |
| |
| #include <collection/BFContainer.h> |
| |
| #include <fml/expression/AvmCode.h> |
| |
| #include <fml/operator/OperatorLib.h> |
| |
| #include <fml/infrastructure/Routine.h> |
| #include <fml/infrastructure/Transition.h> |
| |
| #include <fml/workflow/WObject.h> |
| |
| |
| namespace sep |
| { |
| |
| class Machine; |
| |
| |
| class BehavioralPart : public ObjectClassifier , |
| AVM_INJECT_INSTANCE_COUNTER_CLASS( BehavioralPart ) |
| { |
| |
| AVM_DECLARE_CLONABLE_CLASS( BehavioralPart ) |
| |
| public: |
| /** |
| * TYPEDEF |
| */ |
| typedef TableOfBF_T< Transition > TableOfTransition; |
| |
| typedef TableOfTransition::const_raw_iterator const_transition_iterator; |
| |
| |
| typedef TableOfBF_T< Routine > TableOfRoutine; |
| |
| typedef TableOfRoutine::const_raw_iterator const_routine_iterator; |
| |
| |
| protected: |
| /** |
| * ATTRIBUTES |
| */ |
| TableOfTransition mOutgoingTransitions; |
| |
| TableOfTransition mIncomingTransitions; |
| |
| Routine onCreateRoutine; |
| |
| Routine onInitRoutine; |
| Routine onFinalRoutine; |
| |
| Routine onReturnRoutine; |
| |
| Routine onStartRoutine; |
| Routine onStopRoutine; |
| |
| Routine onIEnableRoutine; |
| Routine onEnableRoutine; |
| |
| Routine onIDisableRoutine; |
| Routine onDisableRoutine; |
| |
| Routine onIAbortRoutine; |
| Routine onAbortRoutine; |
| |
| Routine onIRunRoutine; |
| Routine onRunRoutine; |
| Routine onRtcRoutine; |
| |
| Routine onConcurrencyRoutine; |
| Routine onScheduleRoutine; |
| |
| Routine onSynchronizeRoutine; |
| |
| |
| TableOfRoutine mRoutines; |
| |
| TableOfRoutine mAnonymousInnerRoutines; |
| |
| |
| public: |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| BehavioralPart(ObjectElement * aContainer, |
| const std::string & aNameID = "moe") |
| : ObjectClassifier( CLASS_KIND_T( BehavioralPart ) , aContainer , aNameID ), |
| mOutgoingTransitions( ), |
| mIncomingTransitions( ), |
| |
| onCreateRoutine( *this , "create" ), |
| onInitRoutine( *this , "init" ), |
| onFinalRoutine( *this , "final" ), |
| |
| onReturnRoutine( *this , "return" ), |
| |
| onStartRoutine( *this , "start" ), |
| onStopRoutine( *this , "stop" ), |
| |
| onIEnableRoutine( *this , "ienable" ), |
| onEnableRoutine( *this , "enable" ), |
| |
| onIDisableRoutine( *this , "idisable" ), |
| onDisableRoutine( *this , "disable" ), |
| |
| onIAbortRoutine( *this , "iabort" ), |
| onAbortRoutine( *this , "abort" ), |
| |
| onIRunRoutine( *this , "irun" ), |
| onRunRoutine( *this , "run" ), |
| onRtcRoutine( *this , "rtc" ), |
| |
| onConcurrencyRoutine( *this , "concurrency" ), |
| onScheduleRoutine( *this , "schedule" ), |
| |
| onSynchronizeRoutine( *this , "synchronized" ), |
| |
| mRoutines( ), |
| mAnonymousInnerRoutines( ) |
| { |
| //!! NOTHING |
| } |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~BehavioralPart() |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mOutgoingTransitions |
| */ |
| inline const TableOfTransition & getOutgoingTransitions() const |
| { |
| return( mOutgoingTransitions ); |
| } |
| |
| inline bool hasOutgoingTransition() const |
| { |
| return( mOutgoingTransitions.nonempty() ); |
| } |
| |
| inline void appendOutgoingTransition(const BF & aTransition) |
| { |
| mOutgoingTransitions.append( aTransition ); |
| } |
| |
| inline void saveOutgoingTransition(Transition * aTransition) |
| { |
| mOutgoingTransitions.append( BF(aTransition) ); |
| } |
| |
| /** |
| * [ CONST ] ITERATOR |
| */ |
| inline const_transition_iterator outgoing_transition_begin() const |
| { |
| return( mOutgoingTransitions.begin() ); |
| } |
| |
| inline const_transition_iterator outgoing_transition_end() const |
| { |
| return( mOutgoingTransitions.end() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mTransitions |
| * Attention ! pas de SmartPointer pour cet attribut |
| * Problème de référence circulaire au << delete avec le model ARC >> |
| */ |
| inline const TableOfTransition & getIncomingTransitions() const |
| { |
| return( mIncomingTransitions ); |
| } |
| |
| inline bool hasIncomingTransition() const |
| { |
| return( mIncomingTransitions.nonempty() ); |
| } |
| |
| inline void appendIncomingTransition(const BF & aTransition) |
| { |
| mIncomingTransitions.append( aTransition ); |
| } |
| |
| |
| /** |
| * [ CONST ] ITERATOR |
| */ |
| inline const_transition_iterator incoming_transition_begin() const |
| { |
| return( mIncomingTransitions.begin() ); |
| } |
| |
| inline const_transition_iterator incoming_transition_end() const |
| { |
| return( mIncomingTransitions.end() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onCreateRoutine |
| */ |
| inline Routine & getOnCreateRoutine() |
| { |
| return( onCreateRoutine ); |
| } |
| |
| inline const Routine & getOnCreateRoutine() const |
| { |
| return( onCreateRoutine ); |
| } |
| |
| inline const BFCode & getOnCreate() const |
| { |
| return( onCreateRoutine.getCode() ); |
| } |
| |
| inline bool hasOnCreate() const |
| { |
| return( onCreateRoutine.hasCode() ); |
| } |
| |
| inline void setOnCreate(const BFCode & aCode) |
| { |
| onCreateRoutine.setCode( aCode ); |
| } |
| |
| inline void seqOnCreate(const BFCode & aCode) |
| { |
| onCreateRoutine.seqCode( aCode ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onInitRoutine |
| */ |
| inline Routine & getOnInitRoutine() |
| { |
| return( onInitRoutine ); |
| } |
| |
| inline const Routine & getOnInitRoutine() const |
| { |
| return( onInitRoutine ); |
| } |
| |
| inline const BFCode & getOnInit() const |
| { |
| return( onInitRoutine.getCode() ); |
| } |
| |
| inline bool hasOnInit() const |
| { |
| return( onInitRoutine.hasCode() ); |
| } |
| |
| inline void setOnInit(const BFCode & aCode) |
| { |
| onInitRoutine.setCode( aCode ); |
| } |
| |
| inline void seqOnInit(const BFCode & aCode) |
| { |
| onInitRoutine.seqCode( aCode ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onFinalRoutine |
| */ |
| inline Routine & getOnFinalRoutine() |
| { |
| return( onFinalRoutine ); |
| } |
| |
| inline const Routine & getOnFinalRoutine() const |
| { |
| return( onFinalRoutine ); |
| } |
| |
| inline const BFCode & getOnFinal() const |
| { |
| return( onFinalRoutine.getCode() ); |
| } |
| |
| inline bool hasOnFinal() const |
| { |
| return( onFinalRoutine.hasCode() ); |
| } |
| |
| inline void setOnFinal(const BFCode & aCode) |
| { |
| onFinalRoutine.setCode( aCode ); |
| } |
| |
| inline void seqOnFinal(const BFCode & aCode) |
| { |
| onFinalRoutine.seqCode( aCode ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onReturnRoutine |
| */ |
| inline Routine & getOnReturnRoutine() |
| { |
| return( onReturnRoutine ); |
| } |
| |
| inline const Routine & getOnReturnRoutine() const |
| { |
| return( onReturnRoutine ); |
| } |
| |
| inline const BFCode & getOnReturn() const |
| { |
| return( onReturnRoutine.getCode() ); |
| } |
| |
| inline bool hasOnReturn() const |
| { |
| return( onReturnRoutine.hasCode() ); |
| } |
| |
| inline void setOnReturn(const BFCode & aCode) |
| { |
| onReturnRoutine.setCode( aCode ); |
| } |
| |
| inline void seqOnReturn(const BFCode & aCode) |
| { |
| onReturnRoutine.seqCode( aCode ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onStartRoutine |
| */ |
| inline Routine & getOnStartRoutine() |
| { |
| return( onStartRoutine ); |
| } |
| |
| inline const Routine & getOnStartRoutine() const |
| { |
| return( onStartRoutine ); |
| } |
| |
| inline const BFCode & getOnStart() const |
| { |
| return( onStartRoutine.getCode() ); |
| } |
| |
| inline bool hasOnStart() const |
| { |
| return( onStartRoutine.hasCode() ); |
| } |
| |
| inline void setOnStart(const BFCode & aCode) |
| { |
| onStartRoutine.setCode( aCode ); |
| } |
| |
| inline void seqOnStart(const BFCode & aCode) |
| { |
| onStartRoutine.seqCode( aCode ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onStopRoutine |
| */ |
| inline Routine & getOnStopRoutine() |
| { |
| return( onStopRoutine ); |
| } |
| |
| inline const Routine & getOnStopRoutine() const |
| { |
| return( onStopRoutine ); |
| } |
| |
| inline const BFCode & getOnStop() const |
| { |
| return( onStopRoutine.getCode() ); |
| } |
| |
| inline bool hasOnStop() const |
| { |
| return( onStopRoutine.hasCode() ); |
| } |
| |
| inline void setOnStop(const BFCode & aCode) |
| { |
| onStopRoutine.setCode( aCode ); |
| } |
| |
| inline void seqOnStop(const BFCode & aCode) |
| { |
| onStopRoutine.seqCode( aCode ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onEnableRoutine |
| */ |
| inline Routine & getOnEnableRoutine() |
| { |
| return( onEnableRoutine ); |
| } |
| |
| inline const Routine & getOnEnableRoutine() const |
| { |
| return( onEnableRoutine ); |
| } |
| |
| inline const BFCode & getOnEnable() const |
| { |
| return( onEnableRoutine.getCode() ); |
| } |
| |
| inline bool hasOnEnable() const |
| { |
| return( onEnableRoutine.hasCode() ); |
| } |
| |
| inline void setOnEnable(const BFCode & aCode) |
| { |
| onEnableRoutine.setCode( aCode ); |
| } |
| |
| inline void seqOnEnable(const BFCode & aCode) |
| { |
| onEnableRoutine.seqCode( aCode ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onIEnableRoutine |
| */ |
| inline Routine & getOnIEnableRoutine() |
| { |
| return( onIEnableRoutine ); |
| } |
| |
| inline const Routine & getOnIEnableRoutine() const |
| { |
| return( onIEnableRoutine ); |
| } |
| |
| inline const BFCode & getOnIEnable() const |
| { |
| return( onIEnableRoutine.getCode() ); |
| } |
| |
| inline bool hasOnIEnable() const |
| { |
| return( onIEnableRoutine.hasCode() ); |
| } |
| |
| inline void setOnIEnable(const BFCode & aCode) |
| { |
| onIEnableRoutine.setCode( aCode ); |
| } |
| |
| inline void seqOnIEnable(const BFCode & aCode) |
| { |
| onIEnableRoutine.seqCode( aCode ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onDisableRoutine |
| */ |
| inline Routine & getOnDisableRoutine() |
| { |
| return( onDisableRoutine ); |
| } |
| |
| inline const Routine & getOnDisableRoutine() const |
| { |
| return( onDisableRoutine ); |
| } |
| |
| inline const BFCode & getOnDisable() const |
| { |
| return( onDisableRoutine.getCode() ); |
| } |
| |
| inline bool hasOnDisable() const |
| { |
| return( onDisableRoutine.hasCode() ); |
| } |
| |
| inline void setOnDisable(const BFCode & aCode) |
| { |
| onDisableRoutine.setCode( aCode ); |
| } |
| |
| inline void seqOnDisable(const BFCode & aCode) |
| { |
| onDisableRoutine.seqCode( aCode ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onIDisableRoutine |
| */ |
| inline Routine & getOnIDisableRoutine() |
| { |
| return( onIDisableRoutine ); |
| } |
| |
| inline const Routine & getOnIDisableRoutine() const |
| { |
| return( onIDisableRoutine ); |
| } |
| |
| inline const BFCode & getOnIDisable() const |
| { |
| return( onIDisableRoutine.getCode() ); |
| } |
| |
| inline bool hasOnIDisable() const |
| { |
| return( onIDisableRoutine.hasCode() ); |
| } |
| |
| inline void setOnIDisable(const BFCode & aCode) |
| { |
| onIDisableRoutine.setCode( aCode ); |
| } |
| |
| inline void seqOnIDisable(const BFCode & aCode) |
| { |
| onIDisableRoutine.seqCode( aCode ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onAbortRoutine |
| */ |
| inline Routine & getOnAbortRoutine() |
| { |
| return( onAbortRoutine ); |
| } |
| |
| inline const Routine & getOnAbortRoutine() const |
| { |
| return( onAbortRoutine ); |
| } |
| |
| inline const BFCode & getOnAbort() const |
| { |
| return( onAbortRoutine.getCode() ); |
| } |
| |
| inline bool hasOnAbort() const |
| { |
| return( onAbortRoutine.hasCode() ); |
| } |
| |
| inline void setOnAbort(const BFCode & aCode) |
| { |
| onAbortRoutine.setCode( aCode ); |
| } |
| |
| inline void seqOnAbort(const BFCode & aCode) |
| { |
| onAbortRoutine.seqCode( aCode ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onIAbortRoutine |
| */ |
| inline Routine & getOnIAbortRoutine() |
| { |
| return( onIAbortRoutine ); |
| } |
| |
| inline const Routine & getOnIAbortRoutine() const |
| { |
| return( onIAbortRoutine ); |
| } |
| |
| inline const BFCode & getOnIAbort() const |
| { |
| return( onIAbortRoutine.getCode() ); |
| } |
| |
| inline bool hasOnIAbort() const |
| { |
| return( onIAbortRoutine.hasCode() ); |
| } |
| |
| inline void setOnIAbort(const BFCode & aCode) |
| { |
| onIAbortRoutine.setCode( aCode ); |
| } |
| |
| inline void seqOnIAbort(const BFCode & aCode) |
| { |
| onIAbortRoutine.seqCode( aCode ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onIRunRoutine |
| */ |
| inline Routine & getOnIRunRoutine() |
| { |
| return( onIRunRoutine ); |
| } |
| |
| inline const Routine & getOnIRunRoutine() const |
| { |
| return( onIRunRoutine ); |
| } |
| |
| inline const BFCode & getOnIRun() const |
| { |
| return( onIRunRoutine.getCode() ); |
| } |
| |
| inline bool hasOnIRun() const |
| { |
| return( onIRunRoutine.hasCode() ); |
| } |
| |
| inline void setOnIRun(const BFCode & aCode) |
| { |
| onIRunRoutine.setCode( aCode ); |
| } |
| |
| inline void seqOnIRun(const BFCode & aCode) |
| { |
| onIRunRoutine.seqCode( aCode ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onRunRoutine |
| */ |
| inline Routine & getOnRunRoutine() |
| { |
| return( onRunRoutine ); |
| } |
| |
| inline const Routine & getOnRunRoutine() const |
| { |
| return( onRunRoutine ); |
| } |
| |
| inline const BFCode & getOnRun() const |
| { |
| return( onRunRoutine.getCode() ); |
| } |
| |
| inline bool hasOnRun() const |
| { |
| return( onRunRoutine.hasCode() ); |
| } |
| |
| inline void setOnRun(const BFCode & aCode) |
| { |
| onRunRoutine.setCode( aCode ); |
| } |
| |
| inline void seqOnRun(const BFCode & aCode) |
| { |
| onRunRoutine.seqCode( aCode ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * onRtcRoutine |
| */ |
| inline Routine & getOnRtcRoutine() |
| { |
| return( onRtcRoutine ); |
| } |
| |
| inline const Routine & getOnRtcRoutine() const |
| { |
| return( onRtcRoutine ); |
| } |
| |
| inline const BFCode & getOnRtc() const |
| { |
| return( onRtcRoutine.getCode() ); |
| } |
| |
| inline bool hasOnRtc() const |
| { |
| return( onRtcRoutine.hasCode() ); |
| } |
| |
| inline void setOnRtc(const BFCode & aCode) |
| { |
| onRtcRoutine.setCode( aCode ); |
| } |
| |
| inline void seqOnRtc(const BFCode & aCode) |
| { |
| onRtcRoutine.seqCode( aCode ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * theSchedule |
| */ |
| inline Routine & getOnScheduleRoutine() |
| { |
| return( onScheduleRoutine ); |
| } |
| |
| inline const Routine & getOnScheduleRoutine() const |
| { |
| return( onScheduleRoutine ); |
| } |
| |
| inline const BFCode & getOnSchedule() const |
| { |
| return( onScheduleRoutine.getCode() ); |
| } |
| |
| inline bool hasOnSchedule() const |
| { |
| return( onScheduleRoutine.hasCode() ); |
| } |
| |
| inline void setOnSchedule(const BFCode & aCode) |
| { |
| onScheduleRoutine.setCode( aCode ); |
| } |
| |
| inline void seqOnSchedule(const BFCode & aCode) |
| { |
| onScheduleRoutine.seqCode( aCode ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * theConcurrency |
| */ |
| inline Routine & getOnConcurrencyRoutine() |
| { |
| return( onConcurrencyRoutine ); |
| } |
| |
| inline const Routine & getOnConcurrencyRoutine() const |
| { |
| return( onConcurrencyRoutine ); |
| } |
| |
| inline const BFCode & getOnConcurrency() const |
| { |
| return( onConcurrencyRoutine.getCode() ); |
| } |
| |
| inline bool hasOnConcurrency() const |
| { |
| return( onConcurrencyRoutine.hasCode() ); |
| } |
| |
| inline void setOnConcurrency(const BFCode & aCode) |
| { |
| onConcurrencyRoutine.setCode( aCode ); |
| } |
| |
| inline void seqOnConcurrency(const BFCode & aCode) |
| { |
| onConcurrencyRoutine.seqCode( aCode ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * theSynchronize |
| */ |
| inline Routine & getOnSynchronizeRoutine() |
| { |
| return( onSynchronizeRoutine ); |
| } |
| |
| inline const Routine & getOnSynchronizeRoutine() const |
| { |
| return( onSynchronizeRoutine ); |
| } |
| |
| inline const BFCode & getOnSynchronize() const |
| { |
| return( onSynchronizeRoutine.getCode() ); |
| } |
| |
| inline bool hasOnSynchronize() const |
| { |
| return( onSynchronizeRoutine.hasCode() ); |
| } |
| |
| inline void setOnSynchronize(const BFCode & aCode) |
| { |
| onSynchronizeRoutine.setCode( aCode ); |
| } |
| |
| |
| /** |
| * UTIL |
| */ |
| Routine & getActivity(AVM_OPCODE opcodeActivity); |
| |
| const Routine & getActivity(AVM_OPCODE opcodeActivity) const; |
| |
| |
| |
| /** |
| * GETTER - SETTER |
| * User Routines |
| */ |
| inline void appendRoutine(const BF & routine) |
| { |
| mRoutines.append(routine); |
| } |
| |
| inline void saveRoutine(Routine * routine) |
| { |
| mRoutines.append( BF(routine) ); |
| } |
| |
| Routine * rawRoutineByNameID(const std::string & id) const |
| { |
| return( mRoutines.rawByNameID(id) ); |
| } |
| |
| const TableOfRoutine & getRoutines() const |
| { |
| return( mRoutines ); |
| } |
| |
| |
| inline bool hasRoutine() const |
| { |
| return( mRoutines.nonempty() ); |
| } |
| |
| |
| /** |
| * [ CONST ] ITERATOR |
| */ |
| inline const_routine_iterator routine_begin() const |
| { |
| return( mRoutines.begin() ); |
| } |
| |
| inline const_routine_iterator routine_end() const |
| { |
| return( mRoutines.end() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mAnonymousInnerRoutines |
| * like << variable::on_write >> or << type::constraint >> routines |
| */ |
| inline void saveAnonymousInnerRoutine(Routine * routine) |
| { |
| mAnonymousInnerRoutines.append( BF(routine) ); |
| } |
| |
| inline bool hasAnonymousInnerRoutine() const |
| { |
| return( mAnonymousInnerRoutines.nonempty() ); |
| } |
| |
| /** |
| * TESTER |
| * mRoutines |
| * mAutomaticRoutines |
| */ |
| inline bool hasAnyRoutine() const |
| { |
| return( mRoutines.nonempty() || mAnonymousInnerRoutines.nonempty() ); |
| } |
| |
| |
| /** |
| * Serialization |
| */ |
| virtual void strHeader(OutStream & os) const |
| { |
| os << "moe:"; |
| } |
| |
| |
| void toStreamRoutine(OutStream & os) const; |
| |
| void toStreamAnonymousInnerRoutine(OutStream & os) const; |
| |
| inline void toStreamAnyRoutine(OutStream & os) const |
| { |
| if( mAnonymousInnerRoutines.nonempty() ) |
| { |
| toStreamAnonymousInnerRoutine(os); |
| } |
| |
| if( mRoutines.nonempty() ) |
| { |
| toStreamRoutine( os ); |
| } |
| } |
| |
| void toStreamMoe(OutStream & os) const; |
| |
| inline void toStream(OutStream & os) const |
| { |
| if( mAnonymousInnerRoutines.nonempty() ) |
| { |
| toStreamAnonymousInnerRoutine(os); |
| } |
| |
| if( mRoutines.nonempty() ) |
| { |
| toStreamRoutine( os ); |
| } |
| |
| toStreamMoe(os); |
| } |
| |
| }; |
| |
| |
| } |
| |
| #endif /* FML_INFRASTRUCTURE_BEHAVIORALPART_H_ */ |
