| /******************************************************************************* |
| * 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 |
| ******************************************************************************/ |
| |
| #include "SpecifierElement.h" |
| |
| #include <sstream> |
| |
| |
| namespace sep |
| { |
| |
| |
| /** |
| * STATIC EXECUTABLE SPECIFIER |
| */ |
| Specifier Specifier::EXECUTABLE_UNDEFINED_SPECIFIER; |
| |
| Specifier Specifier::COMPONENT_PACKAGE_SPECIFIER( |
| Specifier::COMPONENT_UNDEFINED_KIND);//*COMPONENT_PACKAGE_KIND); |
| |
| Specifier Specifier::COMPONENT_SYSTEM_SPECIFIER( |
| Specifier::COMPONENT_SYSTEM_KIND ); |
| |
| Specifier Specifier::COMPONENT_EXECUTABLE_SPECIFIER( |
| Specifier::COMPONENT_EXECUTABLE_KIND ); |
| |
| Specifier Specifier::COMPONENT_PROCEDURE_SPECIFIER( |
| Specifier::COMPONENT_PROCEDURE_KIND ); |
| |
| Specifier Specifier::EXECUTABLE_PROCEDURE_COMPOSITE_SPECIFIER( |
| Specifier::COMPONENT_PROCEDURE_KIND, |
| Specifier::MOC_COMPOSITE_STRUCTURE_KIND ); |
| |
| Specifier Specifier::EXECUTABLE_PROCEDURE_MODEL_SPECIFIER( |
| Specifier::COMPONENT_PROCEDURE_KIND, |
| Specifier::DESIGN_MODEL_KIND ); |
| |
| Specifier Specifier::EXECUTABLE_PROCEDURE_INSTANCE_STATIC_SPECIFIER( |
| Specifier::COMPONENT_PROCEDURE_KIND, |
| Specifier::DESIGN_INSTANCE_STATIC_KIND ); |
| |
| |
| /** |
| * EXECUTABLE DESIGN |
| */ |
| Specifier Specifier::DESIGN_MODEL_SPECIFIER( |
| Specifier::DESIGN_MODEL_KIND); |
| |
| Specifier Specifier::DESIGN_PROTOTYPE_STATIC_SPECIFIER( |
| Specifier::DESIGN_PROTOTYPE_STATIC_KIND); |
| |
| Specifier Specifier::DESIGN_INSTANCE_STATIC_SPECIFIER( |
| Specifier::DESIGN_INSTANCE_STATIC_KIND); |
| |
| Specifier Specifier::DESIGN_INSTANCE_DYNAMIC_SPECIFIER( |
| Specifier::DESIGN_INSTANCE_DYNAMIC_KIND); |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // SCOPE <KIND |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| Specifier::SCOPE_KIND Specifier::toScope(const std::string & id) |
| { |
| if( id == "machine" ) return SCOPE_MACHINE_KIND; |
| |
| if( id == "program" ) return SCOPE_PROGRAM_KIND; |
| |
| if( id == "transition" ) return SCOPE_TRANSITION_KIND; |
| |
| if( id == "routine" ) return SCOPE_ROUTINE_KIND; |
| |
| if( id == "runnable" ) return SCOPE_RUNNABLE_KIND; |
| |
| return SCOPE_UNDEFINED_KIND; |
| } |
| |
| |
| std::string Specifier::strScope(SCOPE_KIND kind) |
| { |
| switch( kind ) |
| { |
| case SCOPE_MACHINE_KIND : return( "machine" ); |
| |
| case SCOPE_PROGRAM_KIND : return( "program" ); |
| |
| case SCOPE_TRANSITION_KIND : return( "transition" ); |
| |
| case SCOPE_ROUTINE_KIND : return( "routine" ); |
| |
| case SCOPE_RUNNABLE_KIND : return( "runnable" ); |
| |
| case SCOPE_UNDEFINED_KIND : return( "undefined<specifier#scope#kind>"); |
| |
| default : return( "unknown<specifier#scope#kind>" ); |
| } |
| } |
| |
| |
| /** |
| * SETTER |
| */ |
| Specifier & Specifier::set(const std::string strSpecifier) |
| { |
| #define IF_IS( spec ) if( strSpecifier == spec ) |
| #define IF_HAS( spec ) if( strSpecifier.find(spec) != std::string::npos ) |
| |
| IF_HAS( "executable" ) { setComponentExecutable(); } |
| IF_HAS( "machine" ) { setComponentExecutable(); } |
| IF_HAS( "statemachine" ) { setComponentStatemachine(); } |
| IF_HAS( "system" ) { setComponentSystem(); } |
| IF_HAS( "procedure" ) { setComponentProcedure(); } |
| |
| IF_HAS( "package" ) { /*setComponentPackage();*/ } |
| |
| |
| IF_HAS( "group" ) { setGroupMasK(); } |
| IF_HAS( "every" ) { setGroupEvery(); } |
| IF_HAS( "some" ) { setGroupSome(); } |
| IF_HAS( "except" ) { setGroupExcept(); } |
| |
| IF_HAS( "composite" ) { setMocComposite(); } |
| IF_HAS( "and" ) { setMocCompositeStructure(); } |
| |
| IF_HAS( "or" ) { setMocStateTransitionSystem(); } |
| IF_HAS( "STS" ) { setMocStateTransitionSystem(); } |
| IF_HAS( "stf" ) { setMocStateTransitionFlow(); } |
| IF_HAS( "STF" ) { setMocStateTransitionFlow(); } |
| |
| IF_HAS( "flow" ) { setCompositeMocDataFlow(); } |
| IF_HAS( "DF" ) { setCompositeMocDataFlow(); } |
| |
| IF_HAS( "simple" ) { setStateMocSIMPLE(); } |
| IF_HAS( "start" ) { setStateMocSTART(); } |
| IF_HAS( "final" ) { setStateMocFINAL(); } |
| IF_HAS( "sync" ) { setStateMocSYNC(); } |
| |
| IF_HAS( "initial" ) { setPseudostateMocINITIAL(); } |
| IF_HAS( "terminal" ) { setPseudostateMocTERMINAL(); } |
| IF_HAS( "return" ) { setPseudostateMocRETURN(); } |
| |
| IF_HAS( "junction" ) { setPseudostateMocJUNCTION(); } |
| IF_HAS( "choice" ) { setPseudostateMocCHOICE(); } |
| |
| IF_HAS( "fork" ) { setPseudostateMocFORK(); } |
| IF_HAS( "join" ) { setPseudostateMocJOIN(); } |
| |
| IF_HAS( "dhistory" ) { setPseudostateMocDEEP_HISTORY(); } |
| IF_HAS( "deepHistory" ) { setPseudostateMocDEEP_HISTORY(); } |
| |
| IF_HAS( "shistory" ) { setPseudostateMocSHALLOW_HISTORY(); } |
| IF_HAS( "shallowHistory" ) { setPseudostateMocSHALLOW_HISTORY(); } |
| |
| IF_HAS( "history" ) { setPseudostateMocSHALLOW_HISTORY(); } |
| |
| return( *this ); |
| } |
| |
| |
| Specifier & Specifier::setMoc(const std::string strSpecifier) |
| { |
| #define IF_HAS( spec ) if( strSpecifier.find(spec) != std::string::npos ) |
| |
| IF_HAS( "composite" ) { setMocComposite(); } |
| IF_HAS( "and" ) { setMocCompositeStructure(); } |
| |
| IF_HAS( "or" ) { setMocStateTransitionSystem(); } |
| IF_HAS( "sts" ) { setMocStateTransitionSystem(); } |
| IF_HAS( "STS" ) { setMocStateTransitionSystem(); } |
| IF_HAS( "stf" ) { setMocStateTransitionFlow(); } |
| IF_HAS( "STF" ) { setMocStateTransitionFlow(); } |
| |
| IF_HAS( "flow" ) { setCompositeMocDataFlow(); } |
| IF_HAS( "DF" ) { setCompositeMocDataFlow(); } |
| |
| IF_HAS( "simple" ) { setStateMocSIMPLE(); } |
| IF_HAS( "start" ) { setStateMocSTART(); } |
| IF_HAS( "final" ) { setStateMocFINAL(); } |
| IF_HAS( "sync" ) { setStateMocSYNC(); } |
| |
| IF_HAS( "initial" ) { setPseudostateMocINITIAL(); } |
| IF_HAS( "terminal" ) { setPseudostateMocTERMINAL(); } |
| IF_HAS( "return" ) { setPseudostateMocRETURN(); } |
| |
| IF_HAS( "junction" ) { setPseudostateMocJUNCTION(); } |
| IF_HAS( "choice" ) { setPseudostateMocCHOICE(); } |
| |
| IF_HAS( "fork" ) { setPseudostateMocFORK(); } |
| IF_HAS( "join" ) { setPseudostateMocJOIN(); } |
| |
| IF_HAS( "dhistory" ) { setPseudostateMocDEEP_HISTORY(); } |
| IF_HAS( "deepHistory" ) { setPseudostateMocDEEP_HISTORY(); } |
| |
| IF_HAS( "shistory" ) { setPseudostateMocSHALLOW_HISTORY(); } |
| IF_HAS( "shallowHistory" ) { setPseudostateMocSHALLOW_HISTORY(); } |
| |
| IF_HAS( "history" ) { setPseudostateMocSHALLOW_HISTORY(); } |
| |
| return( *this ); |
| } |
| |
| |
| /** |
| * STRING TO DESIGN KIND |
| */ |
| Specifier::DESIGN_KIND Specifier::toDesignKind(const std::string & strDesign) |
| { |
| std::string aDesign = strDesign; |
| StringTools::tolower(aDesign); |
| |
| if( aDesign == "instance" ) |
| { |
| return( Specifier::DESIGN_INSTANCE_KIND ); |
| } |
| else if( (aDesign == "model") || (aDesign == "form") ) |
| { |
| return( Specifier::DESIGN_MODEL_KIND ); |
| |
| } |
| else if( aDesign == "prototype" ) |
| { |
| return( Specifier::DESIGN_PROTOTYPE_STATIC_KIND ); |
| } |
| |
| else if( aDesign == "dynamic" ) |
| { |
| return( Specifier::DESIGN_DYNAMIC_KIND ); |
| } |
| else if( aDesign == "runtime" ) |
| { |
| return( Specifier::DESIGN_RUNTIME_KIND ); |
| } |
| // else if( aDesign == "meta" ) |
| // { |
| // return( Specifier::DESIGN_META_KIND ); |
| // } |
| else |
| { |
| return( Specifier::DESIGN_UNDEFINED_KIND ); |
| } |
| } |
| |
| |
| /** |
| * COMPONENT KIND to STRING |
| */ |
| std::string Specifier::keywordComponent(bit_field_t componentKind) |
| { |
| switch( componentKind ) |
| { |
| case COMPONENT_UNDEFINED_KIND: |
| return( "<keyword:component:undef>" ); |
| |
| case COMPONENT_SYSTEM_KIND: |
| return( "system" ); |
| |
| case COMPONENT_EXECUTABLE_KIND: |
| return( "executable" ); |
| |
| case COMPONENT_PROCEDURE_KIND: |
| return( "procedure" ); |
| |
| case COMPONENT_ROUTINE_KIND: |
| return( "routine" ); |
| |
| case COMPONENT_STATEMACHINE_KIND: |
| return( "statemachine" ); |
| |
| case COMPONENT_STATE_KIND: |
| return( "state" ); |
| |
| case COMPONENT_PSEUDOSTATE_KIND: |
| // return( "pseudostate" ); |
| return( "state" ); |
| |
| default: |
| return( xstrComponent(componentKind, "#") ); |
| } |
| } |
| |
| |
| std::string Specifier::strComponent( |
| bit_field_t componentKind, const std::string & separator) |
| { |
| switch( componentKind ) |
| { |
| case COMPONENT_UNDEFINED_KIND: |
| return( "" ); |
| // return( "<component:undef>" + separator ); |
| |
| case COMPONENT_SYSTEM_KIND: |
| return( "system" + separator ); |
| |
| case COMPONENT_EXECUTABLE_KIND: |
| return( "executable" + separator ); |
| |
| case COMPONENT_PROCEDURE_KIND: |
| return( "procedure" + separator ); |
| |
| case COMPONENT_ROUTINE_KIND: |
| return( "routine" + separator ); |
| |
| case COMPONENT_STATEMACHINE_KIND: |
| return( "statemachine" + separator ); |
| |
| case COMPONENT_STATE_KIND: |
| return( "state" + separator ); |
| |
| case COMPONENT_PSEUDOSTATE_KIND: |
| return( "pseudostate" + separator ); |
| |
| default: |
| return( xstrComponent(componentKind, separator) ); |
| } |
| } |
| |
| |
| std::string Specifier::xstrComponent( |
| bit_field_t componentKind, const std::string & separator) |
| { |
| if( componentKind != COMPONENT_UNDEFINED_KIND) |
| { |
| std::ostringstream oss; |
| |
| if( (componentKind & COMPONENT_SYSTEM_KIND) != 0 ) |
| { |
| oss << "system" << separator; |
| } |
| |
| if( (componentKind & COMPONENT_EXECUTABLE_KIND) != 0 ) |
| { |
| oss << "executable" << separator; |
| } |
| |
| if( (componentKind & COMPONENT_PROCEDURE_KIND) != 0 ) |
| { |
| oss << "procedure" << separator; |
| } |
| if( (componentKind & COMPONENT_ROUTINE_KIND) != 0 ) |
| { |
| oss << "routine" << separator; |
| } |
| |
| if( (componentKind & COMPONENT_STATEMACHINE_KIND) != 0 ) |
| { |
| oss << "statemachine" << separator; |
| } |
| if( (componentKind & COMPONENT_STATE_KIND) != 0 ) |
| { |
| oss << "state" << separator; |
| } |
| if( (componentKind & COMPONENT_PSEUDOSTATE_KIND) != 0 ) |
| { |
| oss << "pseudostate" << separator; |
| } |
| |
| return( oss.str() ); |
| } |
| |
| return "<component:undef>"; |
| } |
| |
| |
| /** |
| * COMPOSITE MOC to STRING |
| */ |
| std::string Specifier::strModelOfComputation( |
| bit_field_t modelOfComputationKind, const std::string & separator) |
| { |
| switch( modelOfComputationKind ) |
| { |
| case MOC_UNDEFINED_KIND: |
| return( "" ); |
| // return( "<composite:undef>" + separator ); |
| |
| case MOC_COMPOSITE_STRUCTURE_KIND: |
| return( "and" + separator ); |
| |
| case MOC_STATE_TRANSITION_STRUCTURE_KIND: |
| return( "or" + separator ); |
| |
| case MOC_STATE_TRANSITION_SYSTEM_KIND: |
| return( "#STS" + separator ); |
| |
| case MOC_STATE_TRANSITION_FLOW_KIND: |
| return( "#STF" + separator ); |
| |
| case MOC_DATA_FLOW_KIND: |
| return( "#DF" + separator ); |
| |
| case MOC_COMPOSITE_MASK_KIND: |
| return( "composite" + separator ); |
| |
| default: |
| return( "<composite:unknown>" + separator ); |
| } |
| } |
| |
| |
| /** |
| * GROUP KIND to STRING |
| */ |
| std::string Specifier::strGroup( |
| bit_field_t groupKind, const std::string & separator) |
| { |
| switch( groupKind ) |
| { |
| case GROUP_UNDEFINED_KIND: |
| return( "" ); |
| // return( "<group:undef>" + separator ); |
| |
| case GROUP_EVERY_KIND: |
| return( "every" + separator ); |
| |
| case GROUP_SOME_KIND: |
| return( "some" + separator ); |
| |
| case GROUP_EXCEPT_KIND: |
| return( "except" + separator ); |
| |
| case GROUP_MASK_KIND: |
| return( "group" + separator ); |
| |
| default: |
| return( "<group:unknown>" + separator ); |
| } |
| } |
| |
| |
| /** |
| * STATE MOC to STRING |
| */ |
| std::string Specifier::strStateMoc( |
| bit_field_t stateMoc, const std::string & separator) |
| { |
| switch( stateMoc ) |
| { |
| case STATE_UNDEFINED_MOC: |
| return( "" ); |
| // return( "<state:undef>" + separator ); |
| |
| case STATE_SIMPLE_MOC: |
| return( "simple" + separator ); |
| |
| case STATE_START_MOC: |
| return( "start" + separator ); |
| |
| case STATE_FINAL_MOC: |
| return( "final" + separator ); |
| |
| case STATE_SYNC_MOC: |
| return( "sync" + separator ); |
| |
| default: |
| return( xstrStateMoc(stateMoc, separator) ); |
| } |
| } |
| |
| |
| std::string Specifier::xstrStateMoc( |
| bit_field_t stateMoc, const std::string & separator) |
| { |
| if( stateMoc != STATE_UNDEFINED_MOC) |
| { |
| std::ostringstream oss; |
| |
| if( (stateMoc & STATE_SIMPLE_MOC) != 0 ) |
| { |
| oss << "simple" << separator; |
| } |
| if( (stateMoc & STATE_START_MOC) != 0 ) |
| { |
| oss << "start" << separator; |
| } |
| if( (stateMoc & STATE_FINAL_MOC) != 0 ) |
| { |
| oss << "final" << separator; |
| } |
| if( (stateMoc & STATE_SYNC_MOC) != 0 ) |
| { |
| oss << "sync" << separator; |
| } |
| |
| return( oss.str() ); |
| } |
| |
| return "<state:undef>"; |
| } |
| |
| |
| /** |
| * PSEUDOSTATE MOC to STRING |
| */ |
| std::string Specifier::strPseudostateMoc( |
| bit_field_t pseudostateMoc, const std::string & separator) |
| { |
| switch( pseudostateMoc ) |
| { |
| case PSEUDOSTATE_UNDEFINED_MOC: |
| return( "" ); |
| // return( "<pseudostate:undef>" + separator ); |
| |
| case PSEUDOSTATE_INITIAL_MOC: |
| return( "initial" + separator ); |
| case PSEUDOSTATE_TERMINAL_MOC: |
| return( "terminal" + separator ); |
| |
| case PSEUDOSTATE_RETURN_MOC: |
| return( "return" + separator ); |
| |
| case PSEUDOSTATE_JUNCTION_MOC: |
| return( "junction" + separator ); |
| case PSEUDOSTATE_CHOICE_MOC: |
| return( "choice" + separator ); |
| |
| case PSEUDOSTATE_ENTRY_POINT_MOC: |
| return( "entryPoint" + separator ); |
| case PSEUDOSTATE_EXIT_POINT_MOC: |
| return( "exitPoint" + separator ); |
| |
| case PSEUDOSTATE_FORK_MOC: |
| return( "fork" + separator ); |
| case PSEUDOSTATE_JOIN_MOC: |
| return( "join" + separator ); |
| |
| case PSEUDOSTATE_DEEP_HISTORY_MOC: |
| return( "dhistory" + separator ); |
| case PSEUDOSTATE_SHALLOW_HISTORY_MOC: |
| return( "shistory" + separator ); |
| |
| default: |
| return( xstrPseudostateMoc(pseudostateMoc, separator) ); |
| } |
| } |
| |
| |
| std::string Specifier::xstrPseudostateMoc( |
| bit_field_t pseudostateMoc, const std::string & separator) |
| { |
| if( pseudostateMoc != PSEUDOSTATE_UNDEFINED_MOC) |
| { |
| std::ostringstream oss; |
| |
| if( (pseudostateMoc & PSEUDOSTATE_INITIAL_MOC) != 0 ) |
| { |
| oss << "initial" << separator; |
| } |
| if( (pseudostateMoc & PSEUDOSTATE_TERMINAL_MOC) != 0 ) |
| { |
| oss << "terminal" << separator; |
| } |
| |
| if( (pseudostateMoc & PSEUDOSTATE_RETURN_MOC) != 0 ) |
| { |
| oss << "return" << separator; |
| } |
| |
| if( (pseudostateMoc & PSEUDOSTATE_JUNCTION_MOC) != 0 ) |
| { |
| oss << "junction" << separator; |
| } |
| if( (pseudostateMoc & PSEUDOSTATE_CHOICE_MOC) != 0 ) |
| { |
| oss << "choice" << separator; |
| } |
| |
| if( (pseudostateMoc & PSEUDOSTATE_ENTRY_POINT_MOC) != 0 ) |
| { |
| oss << "entryPoint" << separator; |
| } |
| if( (pseudostateMoc & PSEUDOSTATE_EXIT_POINT_MOC) != 0 ) |
| { |
| oss << "exitPoint" << separator; |
| } |
| |
| if( (pseudostateMoc & PSEUDOSTATE_FORK_MOC) != 0 ) |
| { |
| oss << "fork" << separator; |
| } |
| if( (pseudostateMoc & PSEUDOSTATE_JOIN_MOC) != 0 ) |
| { |
| oss << "join" << separator; |
| } |
| |
| if( (pseudostateMoc & PSEUDOSTATE_DEEP_HISTORY_MOC) != 0 ) |
| { |
| oss << "dhistory" << separator; |
| } |
| if( (pseudostateMoc & PSEUDOSTATE_SHALLOW_HISTORY_MOC) != 0 ) |
| { |
| oss << "shistory" << separator; |
| } |
| |
| return( oss.str() ); |
| } |
| |
| return "<pseudostate:undef>"; |
| } |
| |
| |
| /** |
| * DESIGN KIND to STRING |
| */ |
| std::string Specifier::strFeature( |
| bit_field_t featureKind, const std::string & separator) |
| { |
| if( (featureKind != FEATURE_UNDEFINED_KIND) ) |
| { |
| std::ostringstream oss; |
| |
| if( (featureKind & FEATURE_TIMED_KIND) != 0 ) |
| { |
| oss << "timed" << separator; |
| } |
| if( (featureKind & FEATURE_INPUT_ENABLED_KIND) != 0 ) |
| { |
| oss << "input_enabled" << separator; |
| } |
| if( (featureKind & FEATURE_LIFELINE_KIND) != 0 ) |
| { |
| oss << "lifeline" << separator; |
| } |
| |
| return( oss.str() ); |
| } |
| |
| return( "" /*"<feature:undef>"*/ ); |
| } |
| |
| |
| /** |
| * DESIGN KIND to STRING |
| */ |
| std::string Specifier::strDesign_not( |
| DESIGN_KIND designKind, const std::string & separator) const |
| { |
| if( isDesignKind(designKind) ) |
| { |
| return( "" ); |
| } |
| else if( isDesignPrototypeStatic() ) |
| { |
| return( strDesign(this->design, separator) ); |
| } |
| else |
| { |
| switch( designKind ) |
| { |
| case DESIGN_MODEL_KIND: |
| case DESIGN_INSTANCE_KIND: |
| case DESIGN_DYNAMIC_KIND: |
| case DESIGN_STATIC_KIND: |
| case DESIGN_RUNTIME_KIND: |
| { |
| return( strDesign(this->design & (~ designKind), separator) ); |
| } |
| default: |
| { |
| return( strDesign(this->design, separator) ); |
| } |
| } |
| } |
| } |
| |
| |
| std::string Specifier::strDesign( |
| bit_field_t designKind, const std::string & separator) |
| { |
| switch( designKind ) |
| { |
| case DESIGN_UNDEFINED_KIND: |
| return( "" ); |
| // return( "<design:undef>" + separator ); |
| // case DESIGN_META_KIND: |
| // return( "#meta" + separator ); |
| |
| case DESIGN_MODEL_KIND: |
| return( "#model" + separator ); |
| case DESIGN_INSTANCE_KIND: |
| return( "#instance" + separator ); |
| case DESIGN_STATIC_KIND: |
| return( "#static" + separator ); |
| case DESIGN_DYNAMIC_KIND: |
| return( "#dynamic" + separator ); |
| case DESIGN_RUNTIME_KIND: |
| return( "#runtime" + separator ); |
| |
| case DESIGN_INSTANCE_STATIC_KIND: |
| return( "#static#instance" + separator ); |
| case DESIGN_INSTANCE_DYNAMIC_KIND: |
| return( "#dynamic#instance" + separator ); |
| |
| case DESIGN_PROTOTYPE_STATIC_KIND: |
| // return( "#static #prototype" + separator ); |
| return( "#prototype" + separator ); |
| case DESIGN_PROTOTYPE_DYNAMIC_KIND: |
| return( "#dynamic #prototype" + separator ); |
| |
| default: |
| return( xstrDesign(designKind, separator) ); |
| } |
| } |
| |
| |
| std::string Specifier::xstrDesign( |
| bit_field_t designKind, const std::string & separator) |
| { |
| if( (designKind != DESIGN_UNDEFINED_KIND) ) |
| // && (designKind != DESIGN_META_KIND) ) |
| { |
| std::ostringstream oss; |
| |
| if( (designKind & DESIGN_MODEL_KIND) != 0 ) |
| { |
| oss << "#model" << separator; |
| } |
| else if( (designKind & DESIGN_INSTANCE_KIND) != 0 ) |
| { |
| oss << "#instance" << separator; |
| } |
| else if( (designKind & DESIGN_STATIC_KIND) != 0 ) |
| { |
| oss << "#static" << separator; |
| } |
| else if( (designKind & DESIGN_DYNAMIC_KIND) != 0 ) |
| { |
| oss << "#dynamic" << separator; |
| } |
| if( (designKind & DESIGN_RUNTIME_KIND) != 0 ) |
| { |
| oss << "#runtime" << separator; |
| } |
| |
| return( oss.str() ); |
| } |
| |
| return( "<design:undef>" ); |
| } |
| |
| |
| /** |
| * Serialization |
| */ |
| std::string Specifier::SEPARATOR = " % "; |
| |
| |
| std::string Specifier::toString(bit_field_t enabledFields, |
| const std::string & separator) const |
| { |
| std::ostringstream oss; |
| |
| if( (enabledFields & FIELD_FEATURE_POSITION) != 0 ) |
| { |
| oss << Specifier::strFeature( feature , separator ); |
| } |
| |
| if( (enabledFields & FIELD_PSEUDOSTATE_POSITION) != 0 ) |
| { |
| oss << Specifier::strPseudostateMoc( pseudostate , separator ); |
| } |
| if( (enabledFields & FIELD_STATE_POSITION) != 0 ) |
| { |
| oss << Specifier::strStateMoc( state , separator ); |
| } |
| |
| if( (enabledFields & FIELD_COMPUTATION_POSITION) != 0 ) |
| { |
| oss << Specifier::strModelOfComputation( computation , separator ); |
| } |
| |
| if( (enabledFields & FIELD_DESIGN_POSITION) != 0 ) |
| { |
| oss << Specifier::strDesign( design , separator); |
| } |
| |
| if( (enabledFields & FIELD_GROUP_POSITION) != 0 ) |
| { |
| oss << Specifier::strGroup ( group , separator ); |
| } |
| |
| if( (enabledFields & FIELD_COMPONENT_POSITION) != 0 ) |
| { |
| oss << Specifier::strComponent( component , separator ); |
| } |
| |
| return( oss.str() ); |
| } |
| |
| |
| } /* namespace sep */ |