| /******************************************************************************* |
| * 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: 18 févr. 2011 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| |
| #include "Transition.h" |
| |
| #include <fml/infrastructure/Machine.h> |
| #include <fml/infrastructure/PropertyPart.h> |
| |
| |
| namespace sep |
| { |
| |
| |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| Transition::Transition(Machine * aContainer) |
| : BehavioralElement( CLASS_KIND_T( Transition ), aContainer), |
| SpecifierImpl( ), |
| |
| mMocKind( MOC_SIMPLE_KIND ), |
| |
| mPriority( 0 ), |
| mProbability( 0.0 ), |
| mTokenCount( 0 ), |
| |
| mSource( aContainer ), |
| mTarget( ), |
| |
| mDeclaration( NULL ), |
| mStatement( ) |
| { |
| //!! NOTHING |
| } |
| |
| Transition::Transition(Machine * aContainer, |
| const std::string & aNameID, MOC_KIND aKind) |
| : BehavioralElement( CLASS_KIND_T( Transition ), aContainer, aNameID), |
| SpecifierImpl( ), |
| |
| mMocKind( aKind ), |
| |
| mPriority( 0 ), |
| mProbability( 0.0 ), |
| mTokenCount( 0 ), |
| |
| mSource( aContainer ), |
| mTarget( ), |
| |
| mDeclaration( NULL ), |
| mStatement( ) |
| { |
| //!! NOTHING |
| } |
| |
| Transition::Transition(Machine * aContainer, const Transition * aTransPattern) |
| : BehavioralElement(CLASS_KIND_T( Transition ), aContainer, (*aTransPattern)), |
| SpecifierImpl( aTransPattern ), |
| |
| mMocKind( aTransPattern->mMocKind ), |
| |
| mPriority( aTransPattern->mPriority ), |
| mProbability( aTransPattern->mProbability ), |
| mTokenCount( aTransPattern->mTokenCount ), |
| |
| mSource( aContainer ), |
| mTarget( aTransPattern->mTarget ), |
| |
| mDeclaration( (aTransPattern->mDeclaration == NULL) ? NULL : |
| new PropertyPart( *(aTransPattern->mDeclaration) ) ), |
| mStatement( aTransPattern->mStatement ) |
| { |
| |
| } |
| |
| |
| /** |
| * DESTRUCTOR |
| */ |
| Transition::~Transition() |
| { |
| delete mDeclaration; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mDeclaration |
| */ |
| |
| bool Transition::hasDeclaration() const |
| { |
| return( (mDeclaration != NULL) && mDeclaration->nonempty() ); |
| } |
| |
| |
| |
| /** |
| * GETTER - SETTER |
| * UFI , ID |
| */ |
| void Transition::updateNameID(const std::string & aNameID) |
| { |
| setFullyQualifiedNameID( |
| ObjectElement::makeFullyQualifiedNameID( |
| getContainer()->as< Machine >(), aNameID) ); |
| |
| setNameID(aNameID); |
| |
| setUnrestrictedName(aNameID); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mSource |
| */ |
| Machine * Transition::getSourceContainer() const |
| { |
| return( mSource->getContainerMachine() ); |
| } |
| |
| |
| /** |
| * Serialization |
| */ |
| Transition::MOC_KIND Transition::toMocKind(const std::string & id) |
| { |
| if( id == "simple" ) return MOC_SIMPLE_KIND; |
| |
| if( id == "abort" ) return MOC_ABORT_KIND; |
| |
| if( id == "final" ) return MOC_FINAL_KIND; |
| |
| if( id == "else" ) return MOC_ELSE_KIND; |
| |
| if( id == "internal" ) return MOC_INTERNAL_KIND; |
| |
| if( id == "auto" ) return MOC_AUTO_KIND; |
| |
| if( id == "flow" ) return MOC_FLOW_KIND; |
| |
| return MOC_UNDEFINED_KIND; |
| } |
| |
| |
| std::string Transition::strMocKind( |
| moc_kind_t mask, const std::string & SEPARATOR) const |
| { |
| moc_kind_t kind = mMocKind & mask; |
| |
| switch( kind ) |
| { |
| case MOC_SIMPLE_KIND : return( "simple" ); |
| case MOC_ABORT_KIND : return( "abort" ); |
| case MOC_FINAL_KIND : return( "final" ); |
| |
| case MOC_ELSE_KIND : return( "else" ); |
| |
| case MOC_INTERNAL_KIND : return( "internal"); |
| |
| case MOC_AUTO_KIND : return( "auto" ); |
| |
| case MOC_FLOW_KIND : return( "flow" ); |
| |
| case MOC_UNDEFINED_KIND : return( "undefined<transition#kind>" ); |
| |
| default : |
| { |
| std::string strKind = ""; |
| std::string sep = ""; |
| |
| if( kind & MOC_SIMPLE_KIND ) |
| { |
| strKind = "simple"; |
| sep = SEPARATOR; |
| } |
| else if( kind & MOC_ABORT_KIND ) |
| { |
| strKind = "abort"; |
| sep = SEPARATOR; |
| } |
| else if( kind & MOC_FINAL_KIND ) |
| { |
| strKind = "final"; |
| sep = SEPARATOR; |
| } |
| |
| if( kind & MOC_ELSE_KIND ) |
| { |
| strKind = strKind + sep + "else"; |
| } |
| |
| if( strKind.empty() ) |
| { |
| return( "unknown<transition#kind>" ); |
| } |
| else |
| { |
| return( strKind ); |
| } |
| |
| } |
| } |
| } |
| |
| |
| void Transition::strHeader(OutStream & os) const |
| { |
| os << getModifier().toString() << "transition"; |
| if( not isMocSimple() ) |
| { |
| os << "< " << strMocKind( ~ MOC_SIMPLE_KIND ); |
| if( mPriority != 0 ) |
| { |
| os << " , " << mPriority; |
| } |
| if( mProbability != 0 ) |
| { |
| os << " , " << mProbability; |
| } |
| os << " >"; |
| } |
| else if( mPriority != 0 ) |
| { |
| os << "< " << mPriority; |
| if( mProbability != 0 ) |
| { |
| os << " , " << mProbability; |
| } |
| os << " >"; |
| } |
| else if( mProbability != 0 ) |
| { |
| os << "< " << mProbability << " >"; |
| } |
| |
| os << " " << getNameID(); |
| |
| if( mTarget.valid() ) |
| { |
| if( mTokenCount != 0 ) |
| { |
| os << "(" << mTokenCount << ")"; |
| } |
| |
| os << " : " << str_header( getContainer()->as< Machine >() ) << " --> " |
| << (mTarget.is< Machine >() ? |
| mTarget.to_ptr< Machine >()->getNameID() : mTarget.str()); |
| } |
| } |
| |
| |
| void Transition::toStreamHeader(OutStream & os) const |
| { |
| os << getModifier().toString() |
| << "transition " << getNameID() << " : " |
| << getSource()->getNameID(); |
| |
| if( mTarget.is< Machine >() || mTarget.is< Variable >() ) |
| { |
| os << " --> " << mTarget.to_ptr< ObjectElement >()->getNameID(); |
| } |
| else if( mTarget.valid() ) |
| { |
| os << " --> " << mTarget.str(); |
| } |
| |
| os << std::flush; |
| } |
| |
| |
| void Transition::toStream(OutStream & os) const |
| { |
| os << TAB << "transition"; |
| if( not isMocSimple() ) |
| { |
| os << "< " << strMocKind( ~ MOC_SIMPLE_KIND ); |
| if( mPriority != 0 ) |
| { |
| os << " , " << mPriority; |
| } |
| if( mProbability != 0 ) |
| { |
| os << " , " << mProbability; |
| } |
| os << " >"; |
| } |
| else if( mPriority != 0 ) |
| { |
| os << "< " << mPriority; |
| if( mProbability != 0 ) |
| { |
| os << " , " << mProbability; |
| } |
| os << " >"; |
| } |
| else if( mProbability != 0 ) |
| { |
| os << "< " << mProbability << " >"; |
| } |
| |
| if( mTokenCount != 0 ) |
| { |
| os << "(" << mTokenCount << ")"; |
| } |
| |
| os << " " << getNameID(); |
| |
| if( mTarget.valid() ) |
| { |
| os << " --> " << mTarget.str(); |
| } |
| |
| if( hasDeclaration() ) |
| { |
| os << " {" << EOL; |
| |
| mDeclaration->toStream(os); |
| os << EOL; |
| |
| if( mStatement.valid() ) |
| { |
| os << TAB << "moe:" << EOL; |
| |
| os << TAB2 << "@run{" << INCR2_INDENT; |
| mStatement->toStreamRoutine( os ); |
| os << DECR2_INDENT_TAB2 << "}" << EOL; |
| } |
| |
| os << TAB << "}" << EOL; |
| } |
| |
| else if( mStatement.valid() ) |
| { |
| mStatement->toStreamRoutine( os << " {" << INCR_INDENT ) |
| << DECR_INDENT_TAB << "}"; |
| } |
| else |
| { |
| os << ";"; |
| } |
| |
| os << EOL << std::flush; |
| } |
| |
| |
| } |