| /******************************************************************************* |
| * 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: 8 mars 2017 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| |
| #include "ExecutableQuery.h" |
| |
| #include <collection/Collection.h> |
| |
| #include <common/NamedElement.h> |
| |
| #include <fml/symbol/TableOfSymbol.h> |
| |
| |
| namespace sep |
| { |
| |
| |
| /** |
| * GETTER |
| * List of all RUNTIME Executable Element |
| */ |
| void ExecutableQuery::getRuntimeExecutable(InstanceOfMachine * aMachine, |
| Collection< ExecutableForm * > & listOfExecutable) |
| { |
| listOfExecutable.add_union( aMachine->getExecutable() ); |
| |
| TableOfSymbol::const_iterator it; |
| TableOfSymbol::const_iterator itEnd; |
| |
| it = aMachine->getExecutable()->instance_model_begin(); |
| itEnd = aMachine->getExecutable()->instance_model_end(); |
| for( ; it != itEnd ; ++it ) |
| { |
| getRuntimeExecutable((*it).rawMachine(), listOfExecutable); |
| } |
| |
| it = aMachine->getExecutable()->instance_static_begin(); |
| itEnd = aMachine->getExecutable()->instance_static_end(); |
| for( ; it != itEnd ; ++it ) |
| { |
| getRuntimeExecutable((*it).rawMachine(), listOfExecutable); |
| } |
| } |
| |
| |
| |
| /** |
| * SEARCH |
| * AvmTransition |
| */ |
| const BF & ExecutableQuery::getTransitionByAstElement( |
| const ObjectElement * astElement) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const BF & foundTransition = |
| (itExec)->getTransitionByAstElement(astElement); |
| if( foundTransition.valid() ) |
| { |
| return( foundTransition ); |
| } |
| } |
| |
| return( BF::REF_NULL ); |
| } |
| |
| |
| const BF & ExecutableQuery::getTransition( |
| const std::string & aFullyQualifiedNameID) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const BF & foundTransition = |
| (itExec)->getTransition(aFullyQualifiedNameID); |
| |
| if( foundTransition.valid() ) |
| { |
| return( foundTransition ); |
| } |
| } |
| |
| return( BF::REF_NULL ); |
| } |
| |
| |
| const BF & ExecutableQuery::getTransitionByNameID( |
| const std::string & aNameID) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const BF & foundTransition = (itExec)->getTransitionByNameID( aNameID ); |
| if( foundTransition.valid() ) |
| { |
| return( foundTransition ); |
| } |
| } |
| |
| return( BF::REF_NULL ); |
| } |
| |
| const BF & ExecutableQuery::getTransitionByQualifiedNameID( |
| const std::string & aQualifiedNameID) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const BF & foundTransition = |
| (itExec)->getTransitionByQualifiedNameID(aQualifiedNameID); |
| |
| if( foundTransition.valid() ) |
| { |
| return( foundTransition ); |
| } |
| } |
| |
| return( BF::REF_NULL ); |
| } |
| |
| |
| /** |
| * SEARCH |
| * AvmProgram |
| */ |
| const BF & ExecutableQuery::getProgram( |
| const std::string & aFullyQualifiedNameID) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const BF & foundProgram = (itExec)->getProgram(aFullyQualifiedNameID); |
| |
| if( foundProgram.valid() ) |
| { |
| return( foundProgram ); |
| } |
| } |
| |
| return( BF::REF_NULL ); |
| } |
| |
| |
| |
| /** |
| * SEARCH |
| * AvmProgram |
| * ExecutableForm |
| */ |
| const BF & ExecutableQuery::getExecutableOrProgram( |
| const std::string & aFullyQualifiedNameID) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| if( NamedElement::compareLocation( |
| itExec->getFullyQualifiedNameID(), aFullyQualifiedNameID) ) |
| { |
| return( (*itExec) ); |
| } |
| else |
| { |
| { |
| const BF & foundTransition = |
| itExec->getTransition(aFullyQualifiedNameID); |
| |
| if( foundTransition.valid() ) |
| { |
| return( foundTransition ); |
| } |
| } |
| { |
| const BF & foundProgram = |
| itExec->getProgram(aFullyQualifiedNameID); |
| |
| if( foundProgram.valid() ) |
| { |
| return( foundProgram ); |
| } |
| } |
| } |
| } |
| |
| return( BF::REF_NULL ); |
| } |
| |
| |
| // Getter by AST-Element |
| const BF & ExecutableQuery::getExecutableOrProgram( |
| const ObjectElement * astElement) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| if( itExec->isAstElement( astElement ) ) |
| { |
| return( (*itExec) ); |
| } |
| else |
| { |
| { |
| const BF & foundTransition = |
| itExec->getTransitionByAstElement(astElement); |
| |
| if( foundTransition.valid() ) |
| { |
| return( foundTransition ); |
| } |
| } |
| { |
| const BF & foundProgram = |
| itExec->getProgramByAstElement(astElement); |
| if( foundProgram.valid() ) |
| { |
| return( foundProgram ); |
| } |
| } |
| } |
| } |
| |
| return( BF::REF_NULL ); |
| } |
| |
| |
| /** |
| * SEARCH |
| * InstanceOfBuffer |
| */ |
| const Symbol & ExecutableQuery::getBuffer( |
| const std::string & aFullyQualifiedNameID) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const Symbol & foundElement = |
| (itExec)->getBuffer().getByFQNameID( aFullyQualifiedNameID ); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| const Symbol & ExecutableQuery::getBufferByNameID( |
| const std::string & aNameID) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const Symbol & foundElement = |
| (itExec)->getBuffer().getByNameID( aNameID ); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| const Symbol & ExecutableQuery::getBufferByQualifiedNameID( |
| const std::string & aQualifiedNameID) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const Symbol & foundElement = |
| (itExec)->getBuffer().getByQualifiedNameID(aQualifiedNameID); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| const Symbol & ExecutableQuery::getBufferByAstElement( |
| const ObjectElement * astElement) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const Symbol & foundElement = |
| (itExec)->getBuffer().getByAstElement(astElement); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| |
| |
| |
| /** |
| * SEARCH |
| * InstanceOfData |
| */ |
| const BF & ExecutableQuery::getDataByNameID(const std::string & aNameID) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| { |
| const BF & foundElement = |
| (itExec)->getAllData().getByNameID( aNameID ); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| { |
| const BF & foundElement = |
| (itExec)->getConstData().getByNameID( aNameID ); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| } |
| |
| return( BF::REF_NULL ); |
| } |
| |
| const BF & ExecutableQuery::getDataByQualifiedNameID( |
| const std::string & aQualifiedNameID) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| { |
| const BF & foundElement = (itExec)->getAllData(). |
| getByQualifiedNameID(aQualifiedNameID); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| { |
| const BF & foundElement = (itExec)->getConstData(). |
| getByQualifiedNameID(aQualifiedNameID); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| } |
| |
| return( BF::REF_NULL ); |
| } |
| |
| |
| const BF & ExecutableQuery::getData( |
| const std::string & aFullyQualifiedNameID) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| { |
| const BF & foundElement = |
| (itExec)->getAllData().getByFQNameID( aFullyQualifiedNameID ); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| { |
| const BF & foundElement = |
| (itExec)->getConstData().getByFQNameID( aFullyQualifiedNameID ); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| } |
| |
| return( BF::REF_NULL ); |
| } |
| |
| |
| const BF & ExecutableQuery::getDataByAstElement( |
| const ObjectElement * astElement) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| { |
| const BF & foundElement = |
| (itExec)->getAllData().getByAstElement(astElement); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| { |
| const BF & foundElement = |
| (itExec)->getConstData().getByAstElement(astElement); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| } |
| |
| return( BF::REF_NULL ); |
| } |
| |
| |
| /** |
| * SEARCH |
| * Symbol as InstanceOfPort |
| * by ID |
| */ |
| const Symbol & ExecutableQuery::getPortByNameID(const std::string & aNameID, |
| Modifier::DIRECTION_KIND ioDirection) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const Symbol & foundElement = (itExec)->getPort().getByNameID(aNameID); |
| |
| if( foundElement.valid() |
| && foundElement.getModifier().isDirectionKind(ioDirection) ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| |
| const Symbol & ExecutableQuery::getPortByNameID( |
| const std::string & aNameID) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const Symbol & foundElement = (itExec)->getPort().getByNameID(aNameID); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| |
| |
| avm_size_t ExecutableQuery::getPortByNameID( |
| const std::string & aNameID, ListOfSymbol & listofPort, |
| Modifier::DIRECTION_KIND ioDirection, bool isStrongly) const |
| { |
| avm_size_t count = 0; |
| |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| count += (itExec)->getPort().getByNameID(aNameID, listofPort); |
| } |
| |
| ListOfSymbol::iterator itPort = listofPort.begin(); |
| ListOfSymbol::iterator endPort = listofPort.end(); |
| for( ; itPort != endPort ; ) |
| { |
| if( (*itPort).getModifier(). |
| isnotDirectionKind(ioDirection, isStrongly) ) |
| { |
| itPort = listofPort.erase(itPort); |
| } |
| else |
| { |
| ++itPort; |
| } |
| } |
| |
| |
| return( count ); |
| } |
| |
| |
| avm_size_t ExecutableQuery::getPortByNameID( |
| const std::string & aNameID, ListOfSymbol & listofPort) const |
| { |
| avm_size_t count = 0; |
| |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| count += (itExec)->getPort().getByNameID(aNameID, listofPort); |
| } |
| |
| return( count ); |
| } |
| |
| |
| /** |
| * SEARCH |
| * Symbol as InstanceOfPort |
| * by [ [ FULLY ] QUALIFIED ] NAME ID |
| */ |
| const Symbol & ExecutableQuery::getPortByQualifiedNameID( |
| const std::string & aQualifiedNameID, |
| Modifier::DIRECTION_KIND ioDirection, bool isStrongly) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const Symbol & foundElement = |
| (itExec)->getPort().getByQualifiedNameID(aQualifiedNameID); |
| |
| if( foundElement.valid() |
| && foundElement.getModifier(). |
| isDirectionKind(ioDirection, isStrongly) ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| |
| avm_size_t ExecutableQuery::getPortByQualifiedNameID( |
| const std::string & aQualifiedNameID, ListOfSymbol & listofPort, |
| Modifier::DIRECTION_KIND ioDirection, bool isStrongly) const |
| { |
| avm_size_t count = 0; |
| |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| count += (itExec)->getPort(). |
| getByQualifiedNameID(aQualifiedNameID, listofPort); |
| } |
| |
| ListOfSymbol::iterator itPort = listofPort.begin(); |
| ListOfSymbol::iterator endPort = listofPort.end(); |
| for( ; itPort != endPort ; ) |
| { |
| if( (*itPort).getModifier().isnotDirectionKind(ioDirection, isStrongly) ) |
| { |
| itPort = listofPort.erase(itPort); |
| } |
| else |
| { |
| ++itPort; |
| } |
| } |
| |
| |
| return( count ); |
| } |
| |
| |
| avm_size_t ExecutableQuery::getPortByQualifiedNameID( |
| const std::string & aQualifiedNameID, ListOfSymbol & listofPort) const |
| { |
| avm_size_t count = 0; |
| |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| count += (itExec)->getPort(). |
| getByQualifiedNameID(aQualifiedNameID, listofPort); |
| } |
| |
| return( count ); |
| } |
| |
| |
| const Symbol & ExecutableQuery::getPort( |
| const std::string & aFullyQualifiedNameID) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const Symbol & foundElement = |
| (itExec)->getPort().getByFQNameID( aFullyQualifiedNameID ); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| const Symbol & ExecutableQuery::getSemPort(const ExecutableForm * anExecutable, |
| const std::string & aFullyQualifiedNameID) |
| { |
| for( ; anExecutable != NULL ; |
| anExecutable = anExecutable->getExecutableContainer() ) |
| { |
| const Symbol & foundElement = |
| anExecutable->getPort().getByFQNameID( aFullyQualifiedNameID ); |
| if( foundElement.valid() ) |
| { |
| return foundElement; |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| |
| const Symbol & ExecutableQuery::getPortByAstElement( |
| const ObjectElement * astElement) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const Symbol & foundElement = |
| (itExec)->getPort().getByAstElement(astElement); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| |
| const Symbol & ExecutableQuery::getSemPortByAstElement( |
| const ExecutableForm * anExecutable, const ObjectElement * astElement) |
| { |
| for( ; anExecutable != NULL ; |
| anExecutable = anExecutable->getExecutableContainer() ) |
| { |
| const Symbol & foundElement = |
| anExecutable->getPort().getByAstElement( astElement ); |
| if( foundElement.valid() ) |
| { |
| return foundElement; |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| |
| /** |
| * SEARCH |
| * InstanceOfChannel |
| */ |
| const Symbol & ExecutableQuery::getChannel( |
| const ObjectElement * astElement) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const Symbol & foundElement = |
| (itExec)->getChannel().getByAstElement(astElement); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| |
| /** |
| * SEARCH |
| * InstanceOfMachine |
| */ |
| const Symbol & ExecutableQuery::getMachine( |
| Specifier::DESIGN_KIND aDesign, |
| const std::string & aFullyQualifiedNameID) const |
| { |
| // STRICT:> compare LOCATOR & LOCATION [true:- retry only only LOCATION] |
| if( getSystem().fqnEquals( aFullyQualifiedNameID , true ) ) |
| { |
| return( getSystem().getSystemInstance() ); |
| } |
| |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const Symbol & foundElement = (itExec)->getInstanceByDesign( |
| aDesign ).getByFQNameID( aFullyQualifiedNameID ); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| const Symbol & ExecutableQuery::getMachineByNameID( |
| Specifier::DESIGN_KIND aDesign, const std::string & aNamleID) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const Symbol & foundElement = |
| (itExec)->getInstanceByDesign(aDesign).getByNameID(aNamleID); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| const Symbol & ExecutableQuery::getMachineByQualifiedNameID( |
| Specifier::DESIGN_KIND aDesign, |
| const std::string & aQualifiedNameID) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const Symbol & foundElement = (itExec)->getInstanceByDesign(aDesign). |
| getByQualifiedNameID(aQualifiedNameID); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| |
| InstanceOfMachine * ExecutableQuery::rawMachineByNameID( |
| Specifier::DESIGN_KIND aDesign, const std::string & aNameID) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| InstanceOfMachine * foundElement = |
| (itExec)->getInstanceByDesign( |
| aDesign ).getByNameID(aNameID).rawMachine(); |
| |
| if( foundElement != NULL ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( NULL ); |
| } |
| |
| InstanceOfMachine * ExecutableQuery::rawMachineByQualifiedNameID( |
| Specifier::DESIGN_KIND aDesign, |
| const std::string & aQualifiedNameID) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| InstanceOfMachine * foundElement = (itExec)->getInstanceByDesign( |
| aDesign ).getByQualifiedNameID(aQualifiedNameID).rawMachine(); |
| |
| if( foundElement != NULL ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( NULL ); |
| } |
| |
| |
| const Symbol & ExecutableQuery::getMachineByAstElement( |
| Specifier::DESIGN_KIND aDesign, const ObjectElement * astElement) const |
| { |
| if( getSystem().rawSystemInstance()->isAstElement( astElement ) ) |
| { |
| return( getSystem().getSystemInstance() ); |
| } |
| |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const Symbol & foundElement = |
| (itExec)->getInstanceByDesign(aDesign).getByAstElement(astElement); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| |
| /** |
| * SEARCH |
| * Machine |
| */ |
| const BF & ExecutableQuery::searchMachine( |
| Specifier::DESIGN_KIND aDesign, const std::string & aQualifiedNameID ) |
| { |
| std::string::size_type pos = aQualifiedNameID.find("->"); |
| |
| if( pos != std::string::npos ) |
| { |
| std::string mid = aQualifiedNameID.substr(0, pos); |
| std::string obj = aQualifiedNameID.substr(pos + 2); |
| |
| InstanceOfMachine * mainMachine = NULL; |
| |
| if( mid.find('.') == std::string::npos ) |
| { |
| mainMachine = rawMachineByNameID(aDesign, mid); |
| } |
| else |
| { |
| mainMachine = rawMachineByQualifiedNameID(aDesign, mid); |
| } |
| |
| if( mainMachine != NULL ) |
| { |
| if( obj != "[*]" ) |
| { |
| const BF & machine = mainMachine->getExecutable()-> |
| getInstanceByDesign( aDesign ).getByNameID( obj ); |
| if( machine.valid() ) |
| { |
| return( machine ); |
| } |
| |
| } |
| } |
| else |
| { |
| const BF & machine = |
| getMachineByQualifiedNameID(aDesign, mid + "." + obj); |
| if( machine.valid() ) |
| { |
| return( machine ); |
| } |
| } |
| } |
| else |
| { |
| if( aQualifiedNameID.find('.') == std::string::npos ) |
| { |
| const BF & machine = getMachineByNameID(aDesign, aQualifiedNameID); |
| if( machine.valid() ) |
| { |
| return( machine ); |
| } |
| } |
| else |
| { |
| const BF & machine = |
| getMachineByQualifiedNameID(aDesign, aQualifiedNameID); |
| if( machine.valid() ) |
| { |
| return( machine ); |
| } |
| } |
| } |
| |
| return( BF::REF_NULL ); |
| } |
| |
| |
| /** |
| * SEARCH |
| * for Machine Instance Model |
| */ |
| const Symbol & ExecutableQuery::getInstanceModel( |
| const ObjectElement * astElement) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const Symbol & foundElement = |
| (itExec)->getByAstInstanceModel( astElement ); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| const Symbol & ExecutableQuery::getSemInstanceModel( |
| const ExecutableForm * anExecutable, |
| const ObjectElement * astElement) const |
| { |
| for( ; anExecutable != NULL ; |
| anExecutable = anExecutable->getExecutableContainer() ) |
| { |
| const Symbol & foundInstance = |
| anExecutable->getByAstInstanceModel( astElement ); |
| if( foundInstance.valid() && foundInstance.machine().isnotThis() ) |
| { |
| return( foundInstance ); |
| } |
| } |
| |
| return( getInstanceModel( astElement ) ); |
| } |
| |
| |
| /** |
| * SEARCH |
| * for Machine Instance Static |
| */ |
| const Symbol & ExecutableQuery::getInstanceStatic( |
| const ObjectElement * astElement) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const Symbol & foundElement = |
| (itExec)->getByAstInstanceStatic( astElement ); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| const Symbol & ExecutableQuery::getSemInstanceStatic( |
| const ExecutableForm * anExecutable, |
| const ObjectElement * astElement) const |
| { |
| for( ; anExecutable != NULL ; |
| anExecutable = anExecutable->getExecutableContainer() ) |
| { |
| const Symbol & foundInstance = |
| anExecutable->getByAstInstanceStatic( astElement ); |
| if( foundInstance.valid() ) |
| { |
| return( foundInstance ); |
| } |
| } |
| |
| return( getInstanceStatic( astElement ) ); |
| } |
| |
| |
| /** |
| * SEARCH |
| * for Machine Instance Dynamic |
| */ |
| const Symbol & ExecutableQuery::getInstanceDynamic( |
| const ObjectElement * astElement) const |
| { |
| // REVERSE because machines are insert after children |
| const_exec_iterator itExec = getSystem().getExecutables().begin(); |
| const_exec_iterator endExec = getSystem().getExecutables().end(); |
| for( ; itExec != endExec ; ++itExec ) |
| { |
| const Symbol & foundElement = |
| (itExec)->getByAstInstanceDynamic( astElement ); |
| |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( Symbol::REF_NULL ); |
| } |
| |
| const Symbol & ExecutableQuery::getSemInstanceDynamic( |
| const ExecutableForm * anExecutable, |
| const ObjectElement * astElement) const |
| { |
| for( ; anExecutable != NULL ; anExecutable = anExecutable->getExecutableContainer() ) |
| { |
| const Symbol & foundInstance = |
| anExecutable->getByAstInstanceDynamic( astElement ); |
| if( foundInstance.valid() ) |
| { |
| return( foundInstance ); |
| } |
| } |
| |
| return( getInstanceDynamic( astElement ) ); |
| } |
| |
| |
| /** |
| * SEARCH |
| * any Instance |
| */ |
| const BF & ExecutableQuery::getInstanceByAstElement( |
| const ObjectElement * astElement) const |
| { |
| if( getSystem().rawSystemInstance()->isAstElement( astElement ) ) |
| { |
| return( getSystem().getSystemInstance() ); |
| } |
| |
| { |
| const BF & foundElement = getDataByAstElement(astElement); |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| { |
| const Symbol & foundElement = getPortByAstElement(astElement); |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| { |
| const Symbol & foundElement = getMachineByAstElement( |
| Specifier::DESIGN_INSTANCE_KIND, astElement); |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| { |
| const Symbol & foundElement = getBufferByAstElement(astElement); |
| if( foundElement.valid() ) |
| { |
| return( foundElement ); |
| } |
| } |
| |
| return( BF::REF_NULL ); |
| } |
| |
| |
| } /* namespace sep */ |