| /******************************************************************************* |
| * 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: 21 avr. 2016 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and Implementation |
| ******************************************************************************/ |
| |
| #ifndef FML_COMMON_SPECIFIERELEMENT_H_ |
| #define FML_COMMON_SPECIFIERELEMENT_H_ |
| |
| #include <util/avm_numeric.h> |
| #include <util/avm_string.h> |
| |
| |
| |
| namespace sep |
| { |
| |
| |
| class Specifier |
| { |
| |
| public: |
| /** |
| * SCOPE_KIND |
| * 3 bits |
| */ |
| enum SCOPE_KIND |
| { |
| SCOPE_MACHINE_KIND, |
| |
| SCOPE_PROGRAM_KIND, |
| |
| SCOPE_TRANSITION_KIND, |
| |
| SCOPE_ROUTINE_KIND, |
| |
| SCOPE_RUNNABLE_KIND, |
| |
| SCOPE_UNDEFINED_KIND |
| }; |
| |
| // Utils |
| static SCOPE_KIND toScope(const std::string & id); |
| |
| static std::string strScope(SCOPE_KIND mMocKind); |
| |
| |
| /** |
| * COMPONENT_KIND |
| * 7 bits |
| */ |
| enum COMPONENT_KIND { |
| |
| COMPONENT_UNDEFINED_KIND = 0x000, |
| |
| COMPONENT_SYSTEM_KIND = 0x001, |
| |
| COMPONENT_EXECUTABLE_KIND = 0x002, |
| |
| |
| COMPONENT_PROCEDURE_KIND = 0x004, |
| |
| COMPONENT_ROUTINE_KIND = 0x008, |
| |
| |
| COMPONENT_STATEMACHINE_KIND = 0x010, |
| |
| COMPONENT_STATE_KIND = 0x020,//| COMPONENT_STATEMACHINE_KIND, |
| |
| COMPONENT_PSEUDOSTATE_KIND = 0x040,//| COMPONENT_STATE_KIND, |
| |
| |
| FAMILY_COMPONENT_STATE_KIND = COMPONENT_STATE_KIND |
| | COMPONENT_PSEUDOSTATE_KIND, |
| |
| FAMILY_COMPONENT_STATEMACHINE_KIND = COMPONENT_STATEMACHINE_KIND |
| | FAMILY_COMPONENT_STATE_KIND, |
| |
| FAMILY_COMPONENT_COMPOSITE_KIND = COMPONENT_SYSTEM_KIND |
| | COMPONENT_STATEMACHINE_KIND |
| | COMPONENT_EXECUTABLE_KIND, |
| |
| |
| }; |
| |
| |
| /** |
| * Model Of Computation |
| * MOC_KIND |
| * 6 bits |
| */ |
| enum MOC_KIND { |
| |
| MOC_UNDEFINED_KIND = 0x000, |
| |
| MOC_COMPOSITE_MASK_KIND = 0x001, |
| |
| MOC_COMPOSITE_STRUCTURE_KIND = 0x002 | MOC_COMPOSITE_MASK_KIND, |
| |
| |
| MOC_STATE_TRANSITION_STRUCTURE_KIND = 0x004 | MOC_COMPOSITE_MASK_KIND, |
| |
| MOC_STATE_TRANSITION_SYSTEM_KIND = 0x008 | MOC_STATE_TRANSITION_STRUCTURE_KIND, |
| |
| MOC_STATE_TRANSITION_FLOW_KIND = 0x010 | MOC_STATE_TRANSITION_STRUCTURE_KIND, |
| |
| |
| MOC_DATA_FLOW_KIND = 0x020 | MOC_COMPOSITE_MASK_KIND, |
| |
| }; |
| |
| |
| /** |
| * GROUP_KIND |
| * 3 bits |
| */ |
| enum GROUP_KIND |
| { |
| |
| GROUP_UNDEFINED_KIND = 0x000, |
| |
| GROUP_MASK_KIND = 0x001, |
| |
| GROUP_SOME_KIND = 0x002 | GROUP_MASK_KIND, |
| |
| GROUP_EXCEPT_KIND = 0x004 | GROUP_MASK_KIND, |
| |
| GROUP_EVERY_KIND = 0x006 | GROUP_MASK_KIND |
| |
| }; |
| |
| |
| /** |
| * STATE_MOC |
| * 4 bits |
| */ |
| enum STATE_MOC |
| { |
| |
| STATE_UNDEFINED_MOC = 0x000, |
| |
| STATE_SIMPLE_MOC = 0x001, |
| |
| STATE_START_MOC = 0x002, |
| |
| STATE_FINAL_MOC = 0x004, |
| |
| STATE_SYNC_MOC = 0x008 |
| |
| }; |
| |
| |
| /** |
| * PSEUDOSTATE_MOC |
| * 11 bits |
| */ |
| enum PSEUDOSTATE_MOC |
| { |
| |
| PSEUDOSTATE_UNDEFINED_MOC = 0x000, |
| |
| PSEUDOSTATE_INITIAL_MOC = 0x001, |
| |
| PSEUDOSTATE_TERMINAL_MOC = 0x002, |
| PSEUDOSTATE_RETURN_MOC = 0x004, |
| |
| FAMILY_PSEUDO_ENDING_MOC = PSEUDOSTATE_TERMINAL_MOC |
| | PSEUDOSTATE_RETURN_MOC, |
| |
| PSEUDOSTATE_JUNCTION_MOC = 0x008, |
| PSEUDOSTATE_CHOICE_MOC = 0x010, |
| |
| PSEUDOSTATE_ENTRY_POINT_MOC = 0x020, |
| PSEUDOSTATE_EXIT_POINT_MOC = 0x040, |
| |
| FAMILY_PSEUDO_CONNECTION_POINT_MOC = PSEUDOSTATE_ENTRY_POINT_MOC |
| | PSEUDOSTATE_EXIT_POINT_MOC, |
| |
| PSEUDOSTATE_FORK_MOC = 0x080, |
| PSEUDOSTATE_JOIN_MOC = 0x100, |
| |
| PSEUDOSTATE_DEEP_HISTORY_MOC = 0x200, |
| PSEUDOSTATE_SHALLOW_HISTORY_MOC = 0x400, |
| |
| FAMILY_PSEUDO_HISTORY_MOC = PSEUDOSTATE_DEEP_HISTORY_MOC |
| | PSEUDOSTATE_SHALLOW_HISTORY_MOC, |
| |
| }; |
| |
| |
| /** |
| * FEATURE_KIND |
| * 3 bits |
| */ |
| enum FEATURE_KIND |
| { |
| FEATURE_UNDEFINED_KIND = 0x000, // DEFAULT |
| |
| FEATURE_TIMED_KIND = 0x001, |
| |
| FEATURE_INPUT_ENABLED_KIND = 0x002, |
| |
| FEATURE_LIFELINE_KIND = 0x004 |
| |
| }; |
| |
| |
| |
| /** |
| * DESIGN_KIND |
| * 5 bits |
| */ |
| enum DESIGN_KIND |
| { |
| DESIGN_UNDEFINED_KIND = 0x000, // UNUSED |
| // DESIGN_META_KIND = 0x000, // UNUSED |
| |
| DESIGN_MODEL_KIND = 0x001, |
| |
| DESIGN_INSTANCE_KIND = 0x002, |
| |
| DESIGN_STATIC_KIND = 0x004, |
| |
| DESIGN_DYNAMIC_KIND = 0x008, |
| |
| DESIGN_RUNTIME_KIND = 0x010, |
| |
| DESIGN_INSTANCE_STATIC_KIND = DESIGN_INSTANCE_KIND |
| | DESIGN_STATIC_KIND, |
| |
| DESIGN_INSTANCE_DYNAMIC_KIND = DESIGN_INSTANCE_KIND |
| | DESIGN_DYNAMIC_KIND, |
| |
| // DEFAULT |
| DESIGN_PROTOTYPE_STATIC_KIND = DESIGN_INSTANCE_STATIC_KIND |
| | DESIGN_MODEL_KIND, |
| |
| DESIGN_PROTOTYPE_DYNAMIC_KIND = DESIGN_INSTANCE_DYNAMIC_KIND |
| | DESIGN_MODEL_KIND, |
| |
| DESIGN_INSTANCE_RUNTIME_KIND = DESIGN_INSTANCE_KIND |
| | DESIGN_RUNTIME_KIND, |
| |
| }; |
| |
| |
| /** |
| * TYPEDEF |
| */ |
| typedef unsigned short bit_field_t; |
| |
| /** |
| * BIT FIELDS |
| */ |
| bit_field_t component : 7; |
| |
| bit_field_t computation : 6; |
| |
| bit_field_t group : 3; |
| |
| bit_field_t state : 4; |
| |
| bit_field_t pseudostate : 11; |
| |
| bit_field_t feature : 3; |
| |
| bit_field_t design : 5; |
| |
| |
| /** |
| * ENABLING POSITION |
| */ |
| enum |
| { |
| FIELD_COMPONENT_POSITION = 0x001, |
| FIELD_COMPUTATION_POSITION = 0x002, |
| FIELD_GROUP_POSITION = 0x004, |
| FIELD_STATE_POSITION = 0x008, |
| FIELD_PSEUDOSTATE_POSITION = 0x010, |
| FIELD_FEATURE_POSITION = 0x020, |
| FIELD_DESIGN_POSITION = 0x040, |
| |
| ENABLE_ALL_FIELDS = 0xFFF, |
| |
| ENABLE_COMPONENT_DESIGN_FIELD = FIELD_COMPONENT_POSITION |
| | FIELD_DESIGN_POSITION, |
| |
| DISABLE_COMPONENT_DESIGN_FIELD = (~ ENABLE_COMPONENT_DESIGN_FIELD), |
| |
| ENABLE_FEATURE_DESIGN_FIELD = FIELD_FEATURE_POSITION |
| | FIELD_DESIGN_POSITION, |
| |
| DISABLE_FEATURE_DESIGN_FIELD = (~ ENABLE_FEATURE_DESIGN_FIELD) |
| |
| }; |
| |
| |
| /** |
| * STATIC EXECUTABLE SPECIFIER |
| */ |
| static Specifier EXECUTABLE_UNDEFINED_SPECIFIER; |
| |
| static Specifier COMPONENT_PACKAGE_SPECIFIER; |
| |
| static Specifier COMPONENT_SYSTEM_SPECIFIER; |
| |
| static Specifier COMPONENT_EXECUTABLE_SPECIFIER; |
| |
| static Specifier COMPONENT_PROCEDURE_SPECIFIER; |
| |
| static Specifier EXECUTABLE_PROCEDURE_COMPOSITE_SPECIFIER; |
| |
| static Specifier EXECUTABLE_PROCEDURE_MODEL_SPECIFIER; |
| |
| static Specifier EXECUTABLE_PROCEDURE_INSTANCE_STATIC_SPECIFIER; |
| |
| /** |
| * EXECUTABLE DESIGN |
| */ |
| static Specifier DESIGN_MODEL_SPECIFIER; |
| |
| static Specifier DESIGN_PROTOTYPE_STATIC_SPECIFIER; |
| |
| static Specifier DESIGN_INSTANCE_STATIC_SPECIFIER; |
| |
| static Specifier DESIGN_INSTANCE_DYNAMIC_SPECIFIER; |
| |
| |
| |
| /** |
| * CONSTRUCTORS |
| */ |
| Specifier() |
| : component( COMPONENT_UNDEFINED_KIND ), |
| computation( MOC_UNDEFINED_KIND ), |
| |
| group( GROUP_UNDEFINED_KIND ), |
| state( STATE_UNDEFINED_MOC ), |
| pseudostate( PSEUDOSTATE_UNDEFINED_MOC ), |
| |
| feature( FEATURE_UNDEFINED_KIND ), |
| design( DESIGN_UNDEFINED_KIND ) |
| { |
| //!! NOTHING |
| } |
| |
| Specifier(bit_field_t componentKind, |
| bit_field_t modelOfComputationKind, bit_field_t groupKind, |
| bit_field_t stateMoc, bit_field_t pseudostateMoc, |
| bit_field_t featureKind, bit_field_t designKind) |
| : component( componentKind ), |
| computation( modelOfComputationKind ), |
| |
| group( groupKind ), |
| state( stateMoc ), |
| pseudostate( pseudostateMoc ), |
| |
| feature( featureKind ), |
| design( designKind ) |
| { |
| //!! NOTHING |
| } |
| |
| Specifier(COMPONENT_KIND componentKind, MOC_KIND modelOfComputationKind) |
| : component( componentKind ), |
| computation( modelOfComputationKind ), |
| |
| group( GROUP_UNDEFINED_KIND ), |
| state( STATE_UNDEFINED_MOC ), |
| pseudostate( PSEUDOSTATE_UNDEFINED_MOC ), |
| |
| feature( FEATURE_UNDEFINED_KIND ), |
| design( DESIGN_UNDEFINED_KIND ) |
| { |
| //!! NOTHING |
| } |
| |
| Specifier(COMPONENT_KIND componentKind, DESIGN_KIND designKind) |
| : component( componentKind ), |
| computation( MOC_UNDEFINED_KIND ), |
| |
| group( GROUP_UNDEFINED_KIND ), |
| state( STATE_UNDEFINED_MOC ), |
| pseudostate( PSEUDOSTATE_UNDEFINED_MOC ), |
| |
| feature( FEATURE_UNDEFINED_KIND ), |
| design( designKind ) |
| { |
| //!! NOTHING |
| } |
| |
| Specifier(COMPONENT_KIND componentKind) |
| : component( componentKind ), |
| computation( MOC_UNDEFINED_KIND ), |
| |
| group( GROUP_UNDEFINED_KIND ), |
| state( STATE_UNDEFINED_MOC ), |
| pseudostate ( PSEUDOSTATE_UNDEFINED_MOC ), |
| |
| feature( FEATURE_UNDEFINED_KIND ), |
| design( DESIGN_UNDEFINED_KIND ) |
| { |
| //!! NOTHING |
| } |
| |
| Specifier(MOC_KIND modelOfComputationKind) |
| : component( COMPONENT_UNDEFINED_KIND ), |
| computation( modelOfComputationKind ), |
| |
| group( GROUP_UNDEFINED_KIND ), |
| state( STATE_UNDEFINED_MOC ), |
| pseudostate ( PSEUDOSTATE_UNDEFINED_MOC ), |
| |
| feature( FEATURE_UNDEFINED_KIND ), |
| design( DESIGN_UNDEFINED_KIND ) |
| { |
| //!! NOTHING |
| } |
| |
| Specifier(GROUP_KIND groupKind) |
| : component( COMPONENT_UNDEFINED_KIND ), |
| computation( MOC_UNDEFINED_KIND ), |
| |
| group( groupKind ), |
| state( STATE_UNDEFINED_MOC ), |
| pseudostate ( PSEUDOSTATE_UNDEFINED_MOC ), |
| |
| feature( FEATURE_UNDEFINED_KIND ), |
| design( DESIGN_UNDEFINED_KIND ) |
| { |
| //!! NOTHING |
| } |
| |
| Specifier(STATE_MOC stateMoc) |
| : component( COMPONENT_UNDEFINED_KIND ), |
| computation( MOC_UNDEFINED_KIND ), |
| |
| group( GROUP_UNDEFINED_KIND ), |
| state( stateMoc ), |
| pseudostate ( PSEUDOSTATE_UNDEFINED_MOC ), |
| |
| feature( FEATURE_UNDEFINED_KIND ), |
| design( DESIGN_UNDEFINED_KIND ) |
| { |
| //!! NOTHING |
| } |
| |
| Specifier(PSEUDOSTATE_MOC pseudostateMoc) |
| : component( COMPONENT_UNDEFINED_KIND ), |
| computation( MOC_UNDEFINED_KIND ), |
| |
| group( GROUP_UNDEFINED_KIND ), |
| state( STATE_UNDEFINED_MOC ), |
| pseudostate ( pseudostateMoc ), |
| |
| feature( FEATURE_UNDEFINED_KIND ), |
| design( DESIGN_UNDEFINED_KIND ) |
| { |
| //!! NOTHING |
| } |
| |
| Specifier(FEATURE_KIND featureKind) |
| : component( COMPONENT_UNDEFINED_KIND ), |
| computation( MOC_UNDEFINED_KIND ), |
| |
| group( GROUP_UNDEFINED_KIND ), |
| state( STATE_UNDEFINED_MOC ), |
| pseudostate ( PSEUDOSTATE_UNDEFINED_MOC ), |
| |
| feature( featureKind ), |
| design( DESIGN_UNDEFINED_KIND ) |
| { |
| //!! NOTHING |
| } |
| |
| Specifier(DESIGN_KIND designKind) |
| : component( COMPONENT_UNDEFINED_KIND ), |
| computation( MOC_UNDEFINED_KIND ), |
| |
| group( GROUP_UNDEFINED_KIND ), |
| state( STATE_UNDEFINED_MOC ), |
| pseudostate ( PSEUDOSTATE_UNDEFINED_MOC ), |
| |
| feature( FEATURE_UNDEFINED_KIND ), |
| design( designKind ) |
| { |
| //!! NOTHING |
| } |
| |
| /** |
| * DESTRUCTOR |
| */ |
| ~Specifier() |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * TESTER |
| */ |
| inline bool isDefined() const |
| { |
| return( (component != COMPONENT_UNDEFINED_KIND ) |
| || (computation != MOC_UNDEFINED_KIND ) |
| || (group != GROUP_UNDEFINED_KIND ) |
| || (state != STATE_UNDEFINED_MOC ) |
| || (pseudostate != PSEUDOSTATE_UNDEFINED_MOC) |
| || (feature != FEATURE_UNDEFINED_KIND ) |
| || (design != DESIGN_UNDEFINED_KIND ) ); |
| } |
| |
| |
| inline bool isDefined(bit_field_t enabledFields) const |
| { |
| return( (((enabledFields & FIELD_COMPONENT_POSITION ) != 0) |
| && (component != COMPONENT_UNDEFINED_KIND )) |
| |
| || (((enabledFields & FIELD_COMPUTATION_POSITION) != 0) |
| && (computation != MOC_UNDEFINED_KIND )) |
| |
| || (((enabledFields & FIELD_GROUP_POSITION ) != 0) |
| && (group != GROUP_UNDEFINED_KIND )) |
| |
| || (((enabledFields & FIELD_STATE_POSITION ) != 0) |
| && (state != STATE_UNDEFINED_MOC )) |
| |
| || (((enabledFields & FIELD_PSEUDOSTATE_POSITION) != 0) |
| && (pseudostate != PSEUDOSTATE_UNDEFINED_MOC )) |
| |
| || (((enabledFields & FIELD_FEATURE_POSITION ) != 0) |
| && (feature != FEATURE_UNDEFINED_KIND )) |
| |
| || (((enabledFields & FIELD_DESIGN_POSITION ) != 0) |
| && (design != DESIGN_UNDEFINED_KIND )) ); |
| } |
| |
| |
| inline bool isDefined_otherThan(const Specifier & other) const |
| { |
| return( ( (*this) & (~ other) ).isDefined() ); |
| } |
| |
| |
| inline bool isUndefined() const |
| { |
| return( (component == COMPONENT_UNDEFINED_KIND ) |
| && (computation == MOC_UNDEFINED_KIND ) |
| && (group == GROUP_UNDEFINED_KIND ) |
| && (state == STATE_UNDEFINED_MOC ) |
| && (pseudostate == PSEUDOSTATE_UNDEFINED_MOC) |
| && (feature == FEATURE_UNDEFINED_KIND ) |
| && (design == DESIGN_UNDEFINED_KIND ) ); |
| } |
| |
| |
| /** |
| * SETTER |
| */ |
| Specifier & set(const std::string strSpecifier); |
| |
| Specifier & setMoc(const std::string strSpecifier); |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // OPERATOR = |
| //////////////////////////////////////////////////////////////////////////// |
| |
| inline Specifier & override_ifdef(const Specifier & other) |
| { |
| if( other.component != COMPONENT_UNDEFINED_KIND ) |
| { |
| component = other.component; |
| } |
| |
| if( other.computation != MOC_UNDEFINED_KIND ) |
| { |
| computation = other.computation; |
| } |
| |
| if( other.group != GROUP_UNDEFINED_KIND ) |
| { |
| group = other.group; |
| } |
| |
| if( other.state != STATE_UNDEFINED_MOC ) |
| { |
| state = other.state; |
| } |
| if( other.pseudostate != PSEUDOSTATE_UNDEFINED_MOC ) |
| { |
| pseudostate = other.pseudostate; |
| } |
| |
| if( other.feature != FEATURE_UNDEFINED_KIND ) |
| { |
| feature = other.feature; |
| } |
| |
| if( other.design != DESIGN_UNDEFINED_KIND ) |
| { |
| design = other.design; |
| } |
| |
| return( *this ); |
| } |
| |
| inline Specifier & ifnot_define(const Specifier & other) |
| { |
| if( component == COMPONENT_UNDEFINED_KIND ) |
| { |
| component = other.component; |
| } |
| |
| if( (computation <= MOC_COMPOSITE_MASK_KIND) |
| && (other.computation != MOC_UNDEFINED_KIND) ) |
| { |
| computation = other.computation; |
| } |
| |
| if( (group <= GROUP_MASK_KIND) |
| && (other.group != GROUP_UNDEFINED_KIND) ) |
| { |
| group = other.group; |
| } |
| |
| if( state == STATE_UNDEFINED_MOC ) |
| { |
| state = other.state; |
| } |
| if( pseudostate == PSEUDOSTATE_UNDEFINED_MOC ) |
| { |
| pseudostate = other.pseudostate; |
| } |
| |
| if( feature == FEATURE_UNDEFINED_KIND ) |
| { |
| feature = other.feature; |
| } |
| |
| if( design == DESIGN_UNDEFINED_KIND ) |
| { |
| design = other.design; |
| } |
| |
| return( *this ); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // OPERATOR &= |
| //////////////////////////////////////////////////////////////////////////// |
| |
| inline Specifier & operator&=(const Specifier & other) |
| { |
| component &= other.component; |
| computation &= other.computation; |
| group &= other.group; |
| state &= other.state; |
| pseudostate &= other.pseudostate; |
| feature &= other.feature; |
| design &= other.design; |
| |
| return( *this ); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // OPERATOR |= |
| //////////////////////////////////////////////////////////////////////////// |
| |
| inline Specifier & operator|=(const Specifier & other) |
| { |
| component |= other.component; |
| computation |= other.computation; |
| group |= other.group; |
| state |= other.state; |
| pseudostate |= other.pseudostate; |
| feature |= other.feature; |
| design |= other.design; |
| |
| return( *this ); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // OPERATOR == != |
| //////////////////////////////////////////////////////////////////////////// |
| |
| inline bool operator==(const Specifier & other) const |
| { |
| return( (component == other.component ) |
| && (computation == other.computation ) |
| && (group == other.group ) |
| && (state == other.state ) |
| && (pseudostate == other.pseudostate) |
| && (feature == other.feature ) |
| && (design == other.design ) ); |
| } |
| |
| inline bool operator!=(const Specifier & other) const |
| { |
| return( (component != other.component ) |
| || (computation != other.computation ) |
| || (group != other.group ) |
| || (state != other.state ) |
| || (pseudostate != other.pseudostate) |
| || (feature != other.feature ) |
| || (design != other.design ) ); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // OPERATOR | |
| //////////////////////////////////////////////////////////////////////////// |
| |
| inline Specifier operator|(const Specifier & other) const |
| { |
| return( Specifier( |
| component | other.component, |
| computation | other.computation, |
| group | other.group, |
| state | other.state, |
| pseudostate | other.pseudostate, |
| feature | other.feature, |
| design | other.design ) ); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // OPERATOR & |
| //////////////////////////////////////////////////////////////////////////// |
| |
| inline Specifier operator&(const Specifier & other) const |
| { |
| return( Specifier( |
| component & other.component, |
| computation & other.computation, |
| group & other.group, |
| state & other.state, |
| pseudostate & other.pseudostate, |
| feature & other.feature, |
| design & other.design ) ); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // OPERATOR & |
| //////////////////////////////////////////////////////////////////////////// |
| |
| inline Specifier operator~() const |
| { |
| return( Specifier( |
| (~ component), |
| (~ computation), |
| (~ group), |
| (~ state), |
| (~ pseudostate), |
| (~ feature), |
| (~ design) ) ); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // COMPONENT KIND |
| //////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * GETTER - SETTER |
| * component |
| */ |
| inline COMPONENT_KIND getComponentKind() const |
| { |
| return( static_cast< COMPONENT_KIND >( component ) ); |
| } |
| |
| inline bool hasComponentKind() const |
| { |
| return( component != COMPONENT_UNDEFINED_KIND ); |
| } |
| |
| inline bool noneComponentKind() const |
| { |
| return( component == COMPONENT_UNDEFINED_KIND ); |
| } |
| |
| inline bool isComponentKind(COMPONENT_KIND componentKind) const |
| { |
| return( component == componentKind ); |
| } |
| |
| inline Specifier & addComponentKind(COMPONENT_KIND componentKind) |
| { |
| component |= componentKind; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & remComponentKind(COMPONENT_KIND componentKind) |
| { |
| component &= (~ componentKind); |
| |
| return( *this ); |
| } |
| |
| inline Specifier & setComponentKind(COMPONENT_KIND componentKind) |
| { |
| component = componentKind; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & unsetComponentKind() |
| { |
| component = COMPONENT_UNDEFINED_KIND; |
| |
| return( *this ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * "system" component |
| */ |
| inline bool isComponentSystem() const |
| { |
| return( component == COMPONENT_SYSTEM_KIND ); |
| } |
| |
| inline Specifier & setComponentSystem() |
| { |
| component = COMPONENT_SYSTEM_KIND; |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "executable" component |
| */ |
| inline bool isComponentExecutable() const |
| { |
| return( component == COMPONENT_EXECUTABLE_KIND ); |
| } |
| |
| inline Specifier & setComponentExecutable() |
| { |
| component = COMPONENT_EXECUTABLE_KIND; |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "procedure" component |
| */ |
| inline bool isComponentProcedure() const |
| { |
| return( component == COMPONENT_PROCEDURE_KIND ); |
| } |
| |
| inline Specifier & setComponentProcedure() |
| { |
| component = COMPONENT_PROCEDURE_KIND; |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "routine" component |
| */ |
| inline bool isComponentRoutine() const |
| { |
| return( component == COMPONENT_ROUTINE_KIND ); |
| } |
| |
| inline Specifier & setComponentRoutine() |
| { |
| component = COMPONENT_ROUTINE_KIND; |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "statemachine" component |
| */ |
| inline bool isComponentStatemachine() const |
| { |
| return( component == COMPONENT_STATEMACHINE_KIND ); |
| } |
| |
| inline Specifier & setComponentStatemachine() |
| { |
| component = COMPONENT_STATEMACHINE_KIND; |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "state" component |
| */ |
| inline bool isComponentState() const |
| { |
| return( component == COMPONENT_STATE_KIND ); |
| } |
| |
| inline Specifier & setComponentState() |
| { |
| component = COMPONENT_STATE_KIND; |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "pseudostate" component |
| */ |
| inline bool isComponentPseudostate() const |
| { |
| return( component == COMPONENT_PSEUDOSTATE_KIND ); |
| } |
| |
| inline Specifier & setComponentPseudostate() |
| { |
| component = COMPONENT_PSEUDOSTATE_KIND; |
| |
| return( *this ); |
| } |
| |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // MODEL OF COMPUTATION |
| //////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * GETTER - SETTER |
| * Model Of Computation |
| */ |
| inline MOC_KIND getModelOfComputation() const |
| { |
| return( static_cast< MOC_KIND >( computation ) ); |
| } |
| |
| inline bool hasModelOfComputation() const |
| { |
| return( computation != MOC_UNDEFINED_KIND ); |
| } |
| |
| inline bool isModelOfComputation(MOC_KIND modelOfComputationKind) const |
| { |
| return( computation == modelOfComputationKind ); |
| } |
| |
| inline Specifier & setModelOfComputation(MOC_KIND modelOfComputationKind) |
| { |
| computation = modelOfComputationKind; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & unsetModelOfComputation() |
| { |
| computation = MOC_UNDEFINED_KIND; |
| |
| return( *this ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * "composite" Model Of Computation |
| */ |
| inline bool hasMocComposite() const |
| { |
| return( (computation & MOC_COMPOSITE_MASK_KIND) != 0 ); |
| } |
| |
| inline bool noneMocComposite() const |
| { |
| return( computation == MOC_UNDEFINED_KIND ); |
| } |
| |
| inline Specifier & setMocComposite() |
| { |
| computation = MOC_COMPOSITE_MASK_KIND; |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "AND" as composite structure MOC |
| */ |
| inline bool isMocCompositeStructure() const |
| { |
| return( computation == MOC_COMPOSITE_STRUCTURE_KIND ); |
| } |
| |
| inline Specifier & setMocCompositeStructure() |
| { |
| computation = MOC_COMPOSITE_STRUCTURE_KIND; |
| |
| return( *this ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * "OR" as State Transition MOC |
| */ |
| inline bool isMocStateTransitionStructure() const |
| { |
| return( (computation & MOC_STATE_TRANSITION_STRUCTURE_KIND) |
| == MOC_STATE_TRANSITION_STRUCTURE_KIND ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "OR" as State Transition System MOC |
| * has at least one state< simple > |
| */ |
| inline bool isMocStateTransitionSystem() const |
| { |
| return( computation == MOC_STATE_TRANSITION_SYSTEM_KIND ); |
| } |
| |
| inline Specifier & setMocStateTransitionSystem() |
| { |
| computation = MOC_STATE_TRANSITION_SYSTEM_KIND; |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "OR" as State Transition Flow MOC |
| * has only pseudostate |
| */ |
| inline bool isMocStateTransitionFlow() const |
| { |
| return( computation == MOC_STATE_TRANSITION_FLOW_KIND ); |
| } |
| |
| inline Specifier & setMocStateTransitionFlow() |
| { |
| computation = MOC_STATE_TRANSITION_FLOW_KIND; |
| |
| return( *this ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * "FLOW" as DataFlow computation |
| */ |
| inline bool isCompositeMocDataFlow() const |
| { |
| return( computation == MOC_DATA_FLOW_KIND ); |
| } |
| |
| inline Specifier & setCompositeMocDataFlow() |
| { |
| computation = MOC_DATA_FLOW_KIND; |
| |
| return( *this ); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // GROUP KIND |
| //////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * GETTER - SETTER |
| * group |
| */ |
| inline GROUP_KIND getGroupKind() const |
| { |
| return( static_cast< GROUP_KIND >( group ) ); |
| } |
| |
| inline bool hasGroupKind() const |
| { |
| return( group != GROUP_UNDEFINED_KIND ); |
| } |
| |
| inline bool isGroupKind(GROUP_KIND groupKind) const |
| { |
| return( group == groupKind ); |
| } |
| |
| inline Specifier & setGroupKind(GROUP_KIND groupKind) |
| { |
| group = groupKind; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & unsetGroupKind() |
| { |
| group = GROUP_UNDEFINED_KIND; |
| |
| return( *this ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * "group" |
| */ |
| inline bool hasGroupMask() const |
| { |
| return( (group & GROUP_MASK_KIND) != 0 ); |
| } |
| |
| inline Specifier & setGroupMasK() |
| { |
| group = GROUP_MASK_KIND; |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "some" group |
| */ |
| inline bool isGroupSome() const |
| { |
| return( group == GROUP_SOME_KIND ); |
| } |
| |
| inline Specifier & setGroupSome() |
| { |
| group = GROUP_SOME_KIND; |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "except" group |
| */ |
| inline bool isGroupExcept() const |
| { |
| return( group == GROUP_EXCEPT_KIND ); |
| } |
| |
| inline Specifier & setGroupExcept() |
| { |
| group = GROUP_EXCEPT_KIND; |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "every" group |
| */ |
| inline bool isGroupEvery() const |
| { |
| return( group == GROUP_EVERY_KIND ); |
| } |
| |
| inline Specifier & setGroupEvery() |
| { |
| group = GROUP_EVERY_KIND; |
| |
| return( *this ); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // STATE MOC |
| //////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * GETTER - SETTER |
| * state |
| */ |
| inline STATE_MOC getStateMoc() const |
| { |
| return( static_cast< STATE_MOC >( state ) ); |
| } |
| |
| inline bool hasStateMoc() const |
| { |
| return( state != STATE_UNDEFINED_MOC ); |
| } |
| |
| inline bool noneStateMoc() const |
| { |
| return( state == STATE_UNDEFINED_MOC ); |
| } |
| |
| inline bool isStateMoc(STATE_MOC stateMoc) const |
| { |
| return( state == stateMoc ); |
| } |
| |
| inline Specifier & addStateMoc(STATE_MOC stateMoc) |
| { |
| state |= stateMoc; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & remStateMoc(STATE_MOC stateMoc) |
| { |
| state &= (~ stateMoc); |
| |
| return( *this ); |
| } |
| |
| inline Specifier & setStateMoc(STATE_MOC stateMoc) |
| { |
| state = stateMoc; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & unsetStateMoc() |
| { |
| state = STATE_UNDEFINED_MOC; |
| |
| return( *this ); |
| } |
| |
| /** |
| * MIX-IN with component "state" |
| */ |
| inline bool isState() const |
| { |
| return( isComponentState() && hasStateMoc() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * "SIMPLE" state |
| */ |
| inline bool isStateMocSIMPLE() const |
| { |
| return( state == STATE_SIMPLE_MOC ); |
| } |
| |
| inline Specifier & setStateMocSIMPLE() |
| { |
| state = STATE_SIMPLE_MOC; |
| |
| return( *this ); |
| } |
| |
| /** |
| * MIX-IN with component "state" |
| */ |
| inline bool isStateSimple() const |
| { |
| return( isComponentState() && isStateMocSIMPLE() ); |
| } |
| |
| inline Specifier & setStateSimple() |
| { |
| setComponentState(); |
| setStateMocSIMPLE(); |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "START" state |
| */ |
| inline bool isStateMocSTART() const |
| { |
| return( state == STATE_START_MOC ); |
| } |
| |
| inline bool hasStateMocSTART() const |
| { |
| return( (state & STATE_START_MOC) != 0 ); |
| } |
| |
| inline Specifier & addStateMocSTART() |
| { |
| state |= STATE_START_MOC; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & setStateMocSTART() |
| { |
| state = STATE_START_MOC; |
| |
| return( *this ); |
| } |
| |
| /** |
| * MIX-IN with component "state" |
| */ |
| inline bool isStateStart() const |
| { |
| return( isComponentState() && isStateMocSTART() ); |
| } |
| |
| inline Specifier & setStateStart() |
| { |
| setComponentState(); |
| setStateMocSTART(); |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "FINAL" state |
| */ |
| inline bool isStateMocFINAL() const |
| { |
| return( state == STATE_FINAL_MOC ); |
| } |
| |
| inline bool hasStateMocFINAL() const |
| { |
| return( (state & STATE_FINAL_MOC) != 0 ); |
| } |
| |
| inline Specifier & addStateMocFINAL() |
| { |
| state |= STATE_FINAL_MOC; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & setStateMocFINAL() |
| { |
| state = STATE_FINAL_MOC; |
| |
| return( *this ); |
| } |
| |
| /** |
| * MIX-IN with component "state" |
| */ |
| inline bool isStateFinal() const |
| { |
| return( isComponentState() && isStateMocFINAL() ); |
| } |
| |
| inline Specifier & setStateFinal() |
| { |
| setComponentState(); |
| setStateMocFINAL(); |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "SYNC" state |
| */ |
| inline bool isStateMocSYNC() const |
| { |
| return( state == STATE_SYNC_MOC ); |
| } |
| |
| inline Specifier & setStateMocSYNC() |
| { |
| state = STATE_SYNC_MOC; |
| |
| return( *this ); |
| } |
| |
| /** |
| * MIX-IN with component "state" |
| */ |
| inline bool isStateSync() const |
| { |
| return( isComponentState() && isStateMocSYNC() ); |
| } |
| |
| inline Specifier & setStateSync() |
| { |
| setComponentState(); |
| setStateMocSYNC(); |
| |
| return( *this ); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // PSEUDOSTATE MOC |
| //////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * GETTER - SETTER |
| * pseudostate |
| */ |
| inline PSEUDOSTATE_MOC getPseudostateMoc() const |
| { |
| return( static_cast< PSEUDOSTATE_MOC >( pseudostate ) ); |
| } |
| |
| inline bool hasPseudostateMoc() const |
| { |
| return( pseudostate != PSEUDOSTATE_UNDEFINED_MOC ); |
| } |
| |
| inline bool nonePseudostateMoc() const |
| { |
| return( pseudostate == PSEUDOSTATE_UNDEFINED_MOC ); |
| } |
| |
| inline bool isPseudostateMoc(PSEUDOSTATE_MOC pseudostateMoc) const |
| { |
| return( pseudostate == pseudostateMoc ); |
| } |
| |
| inline Specifier & addPseudostateMoc(PSEUDOSTATE_MOC pseudostateMoc) |
| { |
| pseudostate |= pseudostateMoc; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & remPseudostateMoc(PSEUDOSTATE_MOC pseudostateMoc) |
| { |
| pseudostate &= (~ pseudostateMoc); |
| |
| return( *this ); |
| } |
| |
| inline Specifier & setPseudostateMoc(PSEUDOSTATE_MOC pseudostateMoc) |
| { |
| pseudostate = pseudostateMoc; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & unsetPseudostateMoc() |
| { |
| pseudostate = PSEUDOSTATE_UNDEFINED_MOC; |
| |
| return( *this ); |
| } |
| |
| /** |
| * MIX-IN with component "pseudostate" |
| */ |
| inline bool isPseudostate() const |
| { |
| return( isComponentPseudostate() && hasPseudostateMoc() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * "INITIAL" pseudostate |
| */ |
| inline bool isPseudostateMocINITIAL() const |
| { |
| return( pseudostate == PSEUDOSTATE_INITIAL_MOC ); |
| } |
| |
| inline bool hasPseudostateMocINITIAL() const |
| { |
| return( (pseudostate & PSEUDOSTATE_INITIAL_MOC) != 0 ); |
| } |
| |
| inline Specifier & addPseudostateMocINITIAL() |
| { |
| pseudostate |= PSEUDOSTATE_INITIAL_MOC; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & setPseudostateMocINITIAL() |
| { |
| pseudostate = PSEUDOSTATE_INITIAL_MOC; |
| |
| return( *this ); |
| } |
| |
| /** |
| * MIX-IN with component "pseudostate" |
| */ |
| inline bool isPseudostateInitial() const |
| { |
| return( isComponentPseudostate() && isPseudostateMocINITIAL() ); |
| } |
| |
| inline Specifier & setPseudostateInitial() |
| { |
| setComponentPseudostate(); |
| setPseudostateMocINITIAL(); |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "TERMINAL" pseudostate |
| */ |
| inline bool isPseudostateMocTERMINAL() const |
| { |
| return( pseudostate == PSEUDOSTATE_TERMINAL_MOC ); |
| } |
| |
| inline bool hasPseudostateMocTERMINAL() const |
| { |
| return( (pseudostate & PSEUDOSTATE_TERMINAL_MOC) != 0 ); |
| } |
| |
| inline Specifier & addPseudostateMocTERMINAL() |
| { |
| pseudostate |= PSEUDOSTATE_TERMINAL_MOC; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & setPseudostateMocTERMINAL() |
| { |
| pseudostate = PSEUDOSTATE_TERMINAL_MOC; |
| |
| return( *this ); |
| } |
| |
| /** |
| * MIX-IN with component "pseudostate" |
| */ |
| inline bool isPseudostateTerminal() const |
| { |
| return( isComponentPseudostate() && isPseudostateMocTERMINAL() ); |
| } |
| |
| inline Specifier & setPseudostateTerminal() |
| { |
| setComponentPseudostate(); |
| setPseudostateMocTERMINAL(); |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "RETURN" pseudostate |
| */ |
| inline bool isPseudostateMocRETURN() const |
| { |
| return( pseudostate == PSEUDOSTATE_RETURN_MOC ); |
| } |
| |
| inline bool hasPseudostateMocRETURN() const |
| { |
| return( (pseudostate & PSEUDOSTATE_RETURN_MOC) != 0 ); |
| } |
| |
| inline Specifier & addPseudostateMocRETURN() |
| { |
| pseudostate |= PSEUDOSTATE_RETURN_MOC; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & setPseudostateMocRETURN() |
| { |
| pseudostate = PSEUDOSTATE_RETURN_MOC; |
| |
| return( *this ); |
| } |
| |
| |
| /** |
| * MIX-IN with component "pseudostate" |
| */ |
| inline bool isPseudostateReturn() const |
| { |
| return( isComponentPseudostate() && isPseudostateMocRETURN() ); |
| } |
| |
| inline Specifier & setPseudostateReturn() |
| { |
| setComponentPseudostate(); |
| setPseudostateMocRETURN(); |
| |
| return( *this ); |
| } |
| |
| /** |
| * MIX-IN with component "pseudostate" |
| */ |
| inline bool hasFamilyPseudostateENDING() const |
| { |
| return( (pseudostate & FAMILY_PSEUDO_ENDING_MOC) != 0 ); |
| } |
| |
| inline bool hasFamilyPseudostateEnding() const |
| { |
| return( isComponentPseudostate() && hasFamilyPseudostateENDING() ); |
| } |
| |
| |
| |
| /** |
| * GETTER - SETTER |
| * "JUNCTION" pseudostate |
| */ |
| inline bool isPseudostateMocJUNCTION() const |
| { |
| return( pseudostate == PSEUDOSTATE_JUNCTION_MOC ); |
| } |
| |
| inline Specifier & setPseudostateMocJUNCTION() |
| { |
| pseudostate = PSEUDOSTATE_JUNCTION_MOC; |
| |
| return( *this ); |
| } |
| |
| /** |
| * MIX-IN with component "pseudostate" |
| */ |
| inline bool isPseudostateJunction() const |
| { |
| return( isComponentPseudostate() && isPseudostateMocJUNCTION() ); |
| } |
| |
| inline Specifier & setPseudostateJunction() |
| { |
| setComponentPseudostate(); |
| setPseudostateMocJUNCTION(); |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "CHOICE" pseudostate |
| */ |
| inline bool isPseudostateMocCHOICE() const |
| { |
| return( pseudostate == PSEUDOSTATE_CHOICE_MOC ); |
| } |
| |
| inline Specifier & setPseudostateMocCHOICE() |
| { |
| pseudostate = PSEUDOSTATE_CHOICE_MOC; |
| |
| return( *this ); |
| } |
| |
| /** |
| * MIX-IN with component "pseudostate" |
| */ |
| inline bool isPseudostateChoice() const |
| { |
| return( isComponentPseudostate() && isPseudostateMocCHOICE() ); |
| } |
| |
| inline Specifier & setPseudostateChoice() |
| { |
| setComponentPseudostate(); |
| setPseudostateMocCHOICE(); |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "ENTRY_POINT" pseudostate |
| */ |
| inline bool isPseudostateMocENTRY_POINT() const |
| { |
| return( pseudostate == PSEUDOSTATE_ENTRY_POINT_MOC ); |
| } |
| |
| inline Specifier & setPseudostateMocENTRY_POINT() |
| { |
| pseudostate = PSEUDOSTATE_ENTRY_POINT_MOC; |
| |
| return( *this ); |
| } |
| |
| /** |
| * MIX-IN with component "pseudostate" |
| */ |
| inline bool isPseudostateEntryPoint() const |
| { |
| return( isComponentPseudostate() && isPseudostateMocENTRY_POINT() ); |
| } |
| |
| inline Specifier & setPseudostateEntryPoint() |
| { |
| setComponentPseudostate(); |
| setPseudostateMocENTRY_POINT(); |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "EXIT_POINT" pseudostate |
| */ |
| inline bool isPseudostateMocEXIT_POINT() const |
| { |
| return( pseudostate == PSEUDOSTATE_EXIT_POINT_MOC ); |
| } |
| |
| inline Specifier & setPseudostateMocEXIT_POINT() |
| { |
| pseudostate = PSEUDOSTATE_EXIT_POINT_MOC; |
| |
| return( *this ); |
| } |
| |
| /** |
| * MIX-IN with component "pseudostate" |
| */ |
| inline bool isPseudostateExitPoint() const |
| { |
| return( isComponentPseudostate() && isPseudostateMocEXIT_POINT() ); |
| } |
| |
| inline Specifier & setPseudostateExitPoint() |
| { |
| setComponentPseudostate(); |
| setPseudostateMocEXIT_POINT(); |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "CONECTION POINT" pseudostate |
| */ |
| inline bool hasPseudostateMocConnectionPoint() const |
| { |
| return( (pseudostate & FAMILY_PSEUDO_CONNECTION_POINT_MOC) != 0 ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "FORK" pseudostate |
| */ |
| inline bool isPseudostateMocFORK() const |
| { |
| return( pseudostate == PSEUDOSTATE_FORK_MOC ); |
| } |
| |
| inline Specifier & setPseudostateMocFORK() |
| { |
| pseudostate = PSEUDOSTATE_FORK_MOC; |
| |
| return( *this ); |
| } |
| |
| /** |
| * MIX-IN with component "pseudostate" |
| */ |
| inline bool isPseudostateFork() const |
| { |
| return( isComponentPseudostate() && isPseudostateMocFORK() ); |
| } |
| |
| inline Specifier & setPseudostateFork() |
| { |
| setComponentPseudostate(); |
| setPseudostateMocFORK(); |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "JOIN" pseudostate |
| */ |
| inline bool isPseudostateMocJOIN() const |
| { |
| return( pseudostate == PSEUDOSTATE_JOIN_MOC ); |
| } |
| |
| inline Specifier & setPseudostateMocJOIN() |
| { |
| pseudostate = PSEUDOSTATE_JOIN_MOC; |
| |
| return( *this ); |
| } |
| |
| /** |
| * MIX-IN with component "pseudostate" |
| */ |
| inline bool isPseudostateJoin() const |
| { |
| return( isComponentPseudostate() && isPseudostateMocJOIN() ); |
| } |
| |
| inline Specifier & setPseudostateJoin() |
| { |
| setComponentPseudostate(); |
| setPseudostateMocJOIN(); |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "DHISTORY" pseudostate |
| */ |
| inline bool isPseudostateMocDEEP_HISTORY() const |
| { |
| return( pseudostate == PSEUDOSTATE_DEEP_HISTORY_MOC ); |
| } |
| |
| inline bool hasPseudostateMocDEEP_HISTORY() const |
| { |
| return( (pseudostate & PSEUDOSTATE_DEEP_HISTORY_MOC) != 0 ); |
| } |
| |
| inline Specifier & addPseudostateMocDEEP_HISTORY() |
| { |
| pseudostate |= PSEUDOSTATE_DEEP_HISTORY_MOC; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & setPseudostateMocDEEP_HISTORY() |
| { |
| pseudostate = PSEUDOSTATE_DEEP_HISTORY_MOC; |
| |
| return( *this ); |
| } |
| |
| /** |
| * MIX-IN with component "pseudostate" |
| */ |
| inline bool isPseudostateDeepHistory() const |
| { |
| return( isComponentPseudostate() && isPseudostateMocDEEP_HISTORY() ); |
| } |
| |
| inline Specifier & setPseudostateDeepHistory() |
| { |
| setComponentPseudostate(); |
| setPseudostateMocDEEP_HISTORY(); |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "SHISTORY" pseudostate |
| */ |
| inline bool isPseudostateMocSHALLOW_HISTORY() const |
| { |
| return( pseudostate == PSEUDOSTATE_SHALLOW_HISTORY_MOC ); |
| } |
| |
| inline bool hasPseudostateMocSHALLOW_HISTORY() const |
| { |
| return( (pseudostate & PSEUDOSTATE_SHALLOW_HISTORY_MOC) != 0 ); |
| } |
| |
| inline Specifier & addPseudostateMocSHALLOW_HISTORY() |
| { |
| pseudostate |= PSEUDOSTATE_SHALLOW_HISTORY_MOC; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & setPseudostateMocSHALLOW_HISTORY() |
| { |
| pseudostate = PSEUDOSTATE_SHALLOW_HISTORY_MOC; |
| |
| return( *this ); |
| } |
| |
| /** |
| * MIX-IN with component "pseudostate" |
| */ |
| inline bool isPseudostateShallowHistory() const |
| { |
| return( isComponentPseudostate() && isPseudostateMocSHALLOW_HISTORY() ); |
| } |
| |
| inline Specifier & setPseudostateShallowHistory() |
| { |
| setComponentPseudostate(); |
| setPseudostateMocSHALLOW_HISTORY(); |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "HISTORY" pseudostate |
| */ |
| inline bool hasPseudostateMocHISTORY() const |
| { |
| return( (pseudostate & FAMILY_PSEUDO_HISTORY_MOC) != 0 ); |
| } |
| |
| /** |
| * MIX-IN with component "pseudostate" |
| */ |
| inline bool hasPseudostateHistory() const |
| { |
| return( isComponentPseudostate() && hasPseudostateMocHISTORY() ); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // FEATURE KIND |
| //////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * GETTER - SETTER |
| * feature |
| */ |
| inline FEATURE_KIND getFeatureKind() const |
| { |
| return( static_cast< FEATURE_KIND >( feature ) ); |
| } |
| |
| inline bool hasFeatureKind() const |
| { |
| return( feature != FEATURE_UNDEFINED_KIND ); |
| } |
| |
| inline bool hasFeatureKind(FEATURE_KIND designKind) const |
| { |
| return( (feature & designKind) != 0 ); |
| } |
| |
| inline bool isFeatureKind(FEATURE_KIND designKind) const |
| { |
| return( feature == designKind ); |
| } |
| |
| inline Specifier & setFeatureKind(FEATURE_KIND designKind) |
| { |
| feature = designKind; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & addFeatureKind(FEATURE_KIND designKind) |
| { |
| feature |= designKind; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & remFeatureKind(FEATURE_KIND designKind) |
| { |
| feature &= (~ designKind); |
| |
| return( *this ); |
| } |
| |
| inline Specifier & unsetFeatureKind() |
| { |
| feature = FEATURE_UNDEFINED_KIND; |
| |
| return( *this ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * "timed" feature |
| */ |
| inline bool hasFeatureTimed() const |
| { |
| return( (feature & FEATURE_TIMED_KIND) != 0 ); |
| } |
| |
| inline bool noFeatureTimed() const |
| { |
| return( (feature & FEATURE_TIMED_KIND) == 0 ); |
| } |
| |
| inline Specifier & remFeatureTimed() |
| { |
| feature &= (~ FEATURE_TIMED_KIND); |
| |
| return( *this ); |
| } |
| |
| inline Specifier & setFeatureTimed() |
| { |
| feature |= FEATURE_TIMED_KIND; |
| |
| return( *this ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * "input_enabled" feature |
| */ |
| inline bool hasFeatureInputEnabled() const |
| { |
| return( (feature & FEATURE_INPUT_ENABLED_KIND) != 0 ); |
| } |
| |
| inline bool noFeatureInputEnabled() const |
| { |
| return( (feature & FEATURE_INPUT_ENABLED_KIND) == 0 ); |
| } |
| |
| inline Specifier & remFeatureInputEnabled() |
| { |
| feature &= (~ FEATURE_INPUT_ENABLED_KIND); |
| |
| return( *this ); |
| } |
| |
| inline Specifier & setFeatureInputEnabled() |
| { |
| feature |= FEATURE_INPUT_ENABLED_KIND; |
| |
| return( *this ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * "input_enabled" feature |
| */ |
| inline bool hasFeatureLifeline() const |
| { |
| return( (feature & FEATURE_LIFELINE_KIND) != 0 ); |
| } |
| |
| inline bool noFeatureLifeline() const |
| { |
| return( (feature & FEATURE_LIFELINE_KIND) == 0 ); |
| } |
| |
| inline Specifier & remFeatureLifeline() |
| { |
| feature &= (~ FEATURE_LIFELINE_KIND); |
| |
| return( *this ); |
| } |
| |
| inline Specifier & setFeatureLifeline() |
| { |
| feature |= FEATURE_LIFELINE_KIND; |
| |
| return( *this ); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // DESIGN KIND |
| //////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * GETTER - SETTER |
| * design |
| */ |
| inline DESIGN_KIND getDesignKind() const |
| { |
| return( static_cast< DESIGN_KIND >( design ) ); |
| } |
| |
| inline bool hasDesignKind() const |
| { |
| return( design != DESIGN_UNDEFINED_KIND ); |
| } |
| |
| inline bool noneDesignKind() const |
| { |
| return( design == DESIGN_UNDEFINED_KIND ); |
| } |
| |
| inline bool hasDesignKind(DESIGN_KIND designKind) const |
| { |
| return( (design & designKind) != 0 ); |
| } |
| |
| inline bool isDesignKind(DESIGN_KIND designKind) const |
| { |
| return( design == designKind ); |
| } |
| |
| inline Specifier & setDesignKind(DESIGN_KIND designKind) |
| { |
| design = designKind; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & addDesignKind(DESIGN_KIND designKind) |
| { |
| design |= designKind; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & remDesignKind(DESIGN_KIND designKind) |
| { |
| design &= (~ designKind); |
| |
| return( *this ); |
| } |
| |
| inline Specifier & unsetDesignKind() |
| { |
| design = DESIGN_UNDEFINED_KIND; |
| |
| return( *this ); |
| } |
| |
| static DESIGN_KIND toDesignKind(const std::string & strDesign); |
| |
| |
| /** |
| * GETTER - SETTER |
| * "#model" design |
| */ |
| inline bool isDesignModel() const |
| { |
| return(design == DESIGN_MODEL_KIND ); |
| } |
| |
| inline bool hasDesignModel() const |
| { |
| return( (design & DESIGN_MODEL_KIND) != 0 ); |
| } |
| |
| inline Specifier & setDesignModel() |
| { |
| design = DESIGN_MODEL_KIND; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & addDesignModel() |
| { |
| design |= DESIGN_MODEL_KIND; |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "#instance" design |
| */ |
| inline bool isDesignInstance() const |
| { |
| return(design == DESIGN_INSTANCE_KIND ); |
| } |
| |
| inline bool hasDesignInstance() const |
| { |
| return( (design & DESIGN_INSTANCE_KIND) != 0 ); |
| } |
| |
| inline Specifier & setDesignInstance() |
| { |
| design = DESIGN_INSTANCE_KIND; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & addDesignInstance() |
| { |
| design |= DESIGN_INSTANCE_KIND; |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "#static" design |
| */ |
| inline bool isDesignStatic() const |
| { |
| return(design == DESIGN_STATIC_KIND ); |
| } |
| |
| inline bool hasDesignStatic() const |
| { |
| return( (design & DESIGN_STATIC_KIND) != 0 ); |
| } |
| |
| inline Specifier & setDesignStatic() |
| { |
| design = DESIGN_STATIC_KIND; |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "#static instance" design |
| */ |
| inline bool isDesignInstanceStatic() const |
| { |
| return(design == DESIGN_INSTANCE_STATIC_KIND ); |
| } |
| |
| inline bool hasDesignInstanceStatic() const |
| { |
| return( (design & DESIGN_INSTANCE_STATIC_KIND) == |
| DESIGN_INSTANCE_STATIC_KIND ); |
| } |
| |
| inline Specifier & setDesignInstanceStatic() |
| { |
| design = DESIGN_INSTANCE_STATIC_KIND; |
| |
| return( *this ); |
| } |
| |
| inline Specifier & addDesignInstanceStatic() |
| { |
| design |= DESIGN_INSTANCE_STATIC_KIND; |
| |
| return( *this ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * "#static prototype" design |
| */ |
| inline bool isDesignPrototypeStatic() const |
| { |
| return(design == DESIGN_PROTOTYPE_STATIC_KIND ); |
| } |
| |
| inline Specifier & setDesignPrototypeStatic() |
| { |
| design = DESIGN_PROTOTYPE_STATIC_KIND; |
| |
| return( *this ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * "dynamic" design |
| */ |
| inline bool isDesignDynamic() const |
| { |
| return(design == DESIGN_DYNAMIC_KIND ); |
| } |
| |
| inline bool hasDesignDynamic() const |
| { |
| return( (design & DESIGN_DYNAMIC_KIND) != 0 ); |
| } |
| |
| inline Specifier & setDesignDynamic() |
| { |
| design = DESIGN_DYNAMIC_KIND; |
| |
| return( *this ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * "#dynamic instance" design |
| */ |
| inline bool isDesignInstanceDynamic() const |
| { |
| return(design == DESIGN_INSTANCE_DYNAMIC_KIND ); |
| } |
| |
| inline bool hasDesignInstanceDynamic() const |
| { |
| return( (design & DESIGN_INSTANCE_DYNAMIC_KIND) == |
| DESIGN_INSTANCE_DYNAMIC_KIND ); |
| } |
| |
| inline Specifier & setDesignInstanceDynamic() |
| { |
| design = DESIGN_INSTANCE_DYNAMIC_KIND; |
| |
| return( *this ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * "instance [ dynamic ]" design |
| */ |
| inline bool hasDesignInstanceNotModel() const |
| { |
| return( ((design & DESIGN_INSTANCE_KIND) != 0) |
| && ((design & DESIGN_MODEL_KIND) == 0) ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * "runtime" design |
| */ |
| inline bool isDesignRuntime() const |
| { |
| return(design == DESIGN_RUNTIME_KIND ); |
| } |
| |
| inline Specifier & setDesignRuntime() |
| { |
| design = DESIGN_RUNTIME_KIND; |
| |
| return( *this ); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // MIX-IN MODIFIER |
| //////////////////////////////////////////////////////////////////////////// |
| |
| inline bool isFamilyComponentComposite() const |
| { |
| return( hasMocComposite() |
| || ( (component & FAMILY_COMPONENT_COMPOSITE_KIND) != 0) ); |
| } |
| |
| inline bool isFamilyComponentState() const |
| { |
| return( (component & FAMILY_COMPONENT_STATE_KIND) != 0 ); |
| } |
| |
| inline bool isFamilyComponentStatemachine() const |
| { |
| return( ( (component & FAMILY_COMPONENT_STATEMACHINE_KIND) != 0) |
| || isMocStateTransitionStructure() ); |
| } |
| |
| |
| inline bool isStateBasic() const |
| { |
| return( noneMocComposite() && (isState() || isPseudostate()) ); |
| } |
| |
| inline bool isStateComposite() const |
| { |
| return( hasMocComposite() && isState() ); |
| } |
| |
| inline bool isPseudostateInitialOrStateStart() const |
| { |
| return( isPseudostateInitial() || isStateStart() ); |
| } |
| |
| inline bool hasMocINITIAL_START() const |
| { |
| return( hasPseudostateMocINITIAL() || hasStateMocSTART() ); |
| } |
| |
| inline bool couldBeStateMocSIMPLE() const |
| { |
| return( noneStateMoc() && nonePseudostateMoc() && noneMocComposite() ); |
| } |
| |
| |
| |
| /** |
| * COMPONENT KIND to STRING |
| */ |
| inline std::string keywordComponent() const |
| { |
| return( Specifier::keywordComponent( component ) ); |
| } |
| |
| static std::string keywordComponent(bit_field_t componentKind); |
| |
| |
| inline std::string strComponent(const std::string & separator = " ") const |
| { |
| return( Specifier::strComponent( component , separator ) ); |
| } |
| |
| static std::string strComponent(bit_field_t componentKind, |
| const std::string & separator = " "); |
| |
| static std::string xstrComponent(bit_field_t direction, |
| const std::string & separator = " "); |
| |
| /** |
| * COMPOSITE MOC to STRING |
| */ |
| inline std::string strModelOfComputation( |
| const std::string & separator = " ") const |
| { |
| return( Specifier::strModelOfComputation( computation , separator ) ); |
| } |
| |
| static std::string strModelOfComputation( |
| bit_field_t modelOfComputationKind, |
| const std::string & separator = " "); |
| |
| /** |
| * GROUP KIND to STRING |
| */ |
| inline std::string strGroup(const std::string & separator = " ") const |
| { |
| return( Specifier::strGroup( group , separator ) ); |
| } |
| |
| static std::string strGroup(bit_field_t groupKind, |
| const std::string & separator = " "); |
| |
| /** |
| * STATE MOC to STRING |
| */ |
| inline std::string strStateMoc(const std::string & separator = " ") const |
| { |
| return( Specifier::strStateMoc( state , separator ) ); |
| } |
| |
| static std::string strStateMoc(bit_field_t stateMoc, |
| const std::string & separator = " "); |
| |
| static std::string xstrStateMoc(bit_field_t stateMoc, |
| const std::string & separator = " "); |
| |
| /** |
| * PSEUDOSTATE MOC to STRING |
| */ |
| inline std::string strPseudostateMoc( |
| const std::string & separator = " ") const |
| { |
| return( Specifier::strPseudostateMoc( pseudostate , separator ) ); |
| } |
| |
| static std::string strPseudostateMoc(bit_field_t pseudostateMoc, |
| const std::string & separator = " "); |
| |
| static std::string xstrPseudostateMoc(bit_field_t pseudostateMoc, |
| const std::string & separator = " "); |
| |
| /** |
| * ANY-STATE MOC to STRING |
| */ |
| inline std::string strAnyStateMoc( |
| const std::string & separator = " ") const |
| { |
| if( pseudostate != PSEUDOSTATE_UNDEFINED_MOC ) |
| { |
| return( Specifier::strPseudostateMoc( pseudostate , separator ) ); |
| } |
| else if( state != STATE_UNDEFINED_MOC ) |
| { |
| return( Specifier::strStateMoc( pseudostate , separator ) ); |
| } |
| else if( computation != MOC_UNDEFINED_KIND ) |
| { |
| return( Specifier::strModelOfComputation( computation , separator ) ); |
| } |
| else |
| { |
| return( "<any:state:undef>" ); |
| } |
| } |
| |
| |
| /** |
| * FEATURE KIND to STRING |
| */ |
| inline std::string strFeature(const std::string & separator = " ") const |
| { |
| return( Specifier::strFeature( feature , separator ) ); |
| } |
| |
| static std::string strFeature(bit_field_t featureKind, |
| const std::string & separator = " "); |
| |
| /** |
| * DESIGN KIND to STRING |
| */ |
| inline std::string strDesign(const std::string & separator = " ") const |
| { |
| return( Specifier::strDesign( design , separator ) ); |
| } |
| |
| std::string strDesign_not(DESIGN_KIND designKind, |
| const std::string & separator = " ") const; |
| |
| static std::string strDesign(bit_field_t designKind, |
| const std::string & separator = " "); |
| |
| static std::string xstrDesign(bit_field_t designKind, |
| const std::string & separator = " "); |
| |
| |
| /** |
| * Serialization |
| */ |
| static std::string SEPARATOR; |
| |
| |
| inline std::string str(bit_field_t enabledFields, |
| const std::string & separator = SEPARATOR) const |
| { |
| return( StringTools::removeLastIfEndsWith( |
| toString(enabledFields, separator ), separator) ); |
| } |
| |
| inline std::string str(const std::string & separator = SEPARATOR) const |
| { |
| return( StringTools::removeLastIfEndsWith( |
| toString(ENABLE_ALL_FIELDS, separator ), separator) ); |
| } |
| |
| inline std::string str_otherThan( |
| Specifier::COMPONENT_KIND componentKing, |
| const std::string & separator = SEPARATOR) const |
| { |
| Specifier xSpecifier( *this ); |
| |
| xSpecifier.remComponentKind( componentKing ); |
| |
| return( StringTools::removeLastIfEndsWith( |
| xSpecifier.toString( separator ), separator) ); |
| |
| } |
| |
| inline std::string str_otherThan( |
| Specifier::COMPONENT_KIND componentKing, |
| Specifier::STATE_MOC stateMoc, |
| const std::string & separator = SEPARATOR) const |
| { |
| Specifier xSpecifier( *this ); |
| |
| xSpecifier.remComponentKind( componentKing ); |
| |
| xSpecifier.remStateMoc( stateMoc ); |
| |
| return( StringTools::removeLastIfEndsWith( |
| xSpecifier.toString( separator ), separator) ); |
| |
| } |
| |
| std::string toString(bit_field_t enabledFields = ENABLE_ALL_FIELDS, |
| const std::string & separator = " ") const; |
| |
| inline std::string toString(const std::string & separator) const |
| { |
| return( toString( ENABLE_ALL_FIELDS , separator) ); |
| } |
| |
| |
| std::string toString_not(DESIGN_KIND designKind, |
| const std::string & separator = " ") const |
| { |
| return( Specifier::strComponent( component , separator ) + |
| Specifier::strModelOfComputation( computation , separator ) + |
| Specifier::strGroup ( group , separator ) + |
| Specifier::strStateMoc( state , separator ) + |
| Specifier::strPseudostateMoc( pseudostate , separator ) + |
| Specifier::strFeature( feature , separator ) + |
| Specifier::strDesign_not( designKind , separator) ); |
| } |
| |
| }; |
| |
| |
| |
| class SpecifierImpl |
| { |
| |
| protected: |
| /** |
| * ATTRIBUTES |
| */ |
| Specifier mSpecifier; |
| |
| |
| public: |
| /** |
| * CONSTRUCTOR |
| */ |
| SpecifierImpl() |
| : mSpecifier( ) |
| { |
| //!! NOTHING |
| } |
| |
| SpecifierImpl(const Specifier & aSpecifier) |
| : mSpecifier( aSpecifier ) |
| { |
| //!! NOTHING |
| } |
| |
| SpecifierImpl(const SpecifierImpl & aCopy) |
| : mSpecifier( aCopy.mSpecifier ) |
| { |
| //!! NOTHING |
| } |
| |
| SpecifierImpl(const SpecifierImpl * aCopy) |
| : mSpecifier( (aCopy != NULL) ? |
| aCopy->getSpecifier() : Specifier::EXECUTABLE_UNDEFINED_SPECIFIER ) |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * DESTRUCTOR |
| */ |
| ~SpecifierImpl() |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * GETTER |
| * mSpecifier |
| */ |
| inline const Specifier & getSpecifier() const |
| { |
| return( mSpecifier ); |
| } |
| |
| inline Specifier & getwSpecifier() |
| { |
| return( mSpecifier ); |
| } |
| |
| inline bool hasSpecifier() const |
| { |
| return( mSpecifier.isDefined() ); |
| } |
| |
| inline bool hasSpecifier_otherThan(const Specifier & aSpecifier) const |
| { |
| return( mSpecifier.isDefined_otherThan( aSpecifier ) ); |
| } |
| |
| inline void setSpecifier(const Specifier & xSpecifier) |
| { |
| mSpecifier = xSpecifier; |
| } |
| |
| }; |
| |
| |
| } /* namespace sep */ |
| |
| #endif /* FML_COMMON_SPECIFIERELEMENT_H_ */ |
