org.eclipse.efm.symbex/src/computer/primitive/AvmCommunicationFactory.cpp

/*******************************************************************************
 * 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: 27 oct. 2010
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and implementation
 ******************************************************************************/

#include "AvmCommunicationFactory.h"

#include <fml/common/ModifierElement.h>

#include <computer/EvaluationEnvironment.h>
#include <computer/ExecutionDataFactory.h>
#include <computer/ExecutionEnvironment.h>

#include <computer/instruction/InstructionEnvironment.h>

#include <fml/buffer/BaseBufferForm.h>
#include <fml/buffer/BroadcastBuffer.h>

#include <fml/executable/ExecutableLib.h>
#include <fml/executable/InstanceOfBuffer.h>
#include <fml/executable/InstanceOfConnect.h>
#include <fml/executable/InstanceOfData.h>
#include <fml/executable/InstanceOfMachine.h>
#include <fml/executable/InstanceOfPort.h>
#include <fml/executable/Router.h>
#include <fml/executable/RoutingData.h>

#include <fml/expression/AvmCode.h>
#include <fml/expression/StatementConstructor.h>

#include <fml/infrastructure/ComProtocol.h>

#include <fml/operator/OperatorManager.h>

#include <fml/runtime/ExecutionConfiguration.h>
#include <fml/runtime/ExecutionData.h>
#include <fml/runtime/ExecutionSynchronizationPoint.h>
#include <fml/runtime/Message.h>
#include <fml/runtime/RuntimeLib.h>
#include <fml/runtime/RuntimeID.h>

#include <fml/workflow/UniFormIdentifier.h>


namespace sep
{


/**
 * SEARCH ROUTING DATA
 */
const RoutingData & AvmCommunicationFactory::searchInputRoutingData(
		const ExecutionData & anED, InstanceOfPort  * aPort,
		RuntimeID & aRoutingRID)
{
	AVM_OS_ASSERT_FATAL_ERROR_EXIT( aPort->getModifier().hasDirectionInput() )
			<< "AvmCommunicationFactory::searchInputRoutingData :> "
				"Unexpected non-INPUT port "
			<< aPort->getFullyQualifiedNameID() << " !!!"
			<< SEND_EXIT;

	if( aPort->hasInputRoutingData() )
	{
		aRoutingRID = aPort->getInputRoutingData().getRuntimeRID();

		return( aPort->getInputRoutingData() );
	}
	else if( aPort->isPort() )
	{
		if( aPort->hasRuntimeContainerRID() )
		{
			aRoutingRID = aPort->getRuntimeContainerRID();
		}
		else if( aRoutingRID.valid() )
		{
			aRoutingRID = aRoutingRID.getCommunicator(aPort);
		}
	}
	else if( aPort->isSignal() )
	{
		while( aRoutingRID.valid()
			&& (not anED.getRuntime(aRoutingRID).hasRouter()) )
		{
			aRoutingRID = aRoutingRID.getPRID();
		}
	}

	if( aRoutingRID.valid() )
	{
		AVM_OS_ASSERT_FATAL_ERROR_EXIT(
			anED.getRuntime(aRoutingRID).hasRouter() )
				<< "Searching Input RoutingData message error : << "
				<< aRoutingRID.getFullyQualifiedNameID()
				<< " >> doesn't have router !!!"
				<< SEND_EXIT;


		const RoutingData & aRoutingData = anED.getRuntime(aRoutingRID).
				getRouter().getInputRouting( aPort->getRouteOffset() );
		if( aRoutingData != NULL )
		{
//			aRoutingRID = ( aPort->isVisibilityPublic() )?
//					aRoutingRID.getPRID() : aRoutingRID;
			aRoutingRID = aRoutingRID.getCommunicator(
					aRoutingData.getMachine() );
		}

		return( aRoutingData );
	}

	return( RoutingData::_NULL_ );
}


const RoutingData & AvmCommunicationFactory::searchOutputRoutingData(
		const ExecutionData & anED, InstanceOfPort  * aPort,
		RuntimeID & aRoutingRID)
{
	AVM_OS_ASSERT_FATAL_ERROR_EXIT( aPort->getModifier().hasDirectionOutput() )
			<< "AvmCommunicationFactory::searchOutputRoutingData :> "
				"Unexpected non-OUTPUT port "
			<< aPort->getFullyQualifiedNameID() << " !!!"
			<< SEND_EXIT;

	if( aPort->hasOutputRoutingData() )
	{
		aRoutingRID = aPort->getOutputRoutingData().getRuntimeRID();
		return( aPort->getOutputRoutingData() );
	}
	else if( aPort->isPort() )
	{
		if( aPort->hasRuntimeContainerRID() )
		{
			aRoutingRID = aPort->getRuntimeContainerRID();
		}
		else if( aRoutingRID.valid() )
		{
			aRoutingRID = aRoutingRID.getCommunicator(aPort);
		}
	}
	else if( aPort->isSignal() )
	{
		while( aRoutingRID.valid()
			&& (not anED.getRuntime(aRoutingRID).hasRouter()) )
		{
			aRoutingRID = aRoutingRID.getPRID();
		}
	}

	if( aRoutingRID.valid() )
	{
		AVM_OS_ASSERT_FATAL_ERROR_EXIT(
			anED.getRuntime(aRoutingRID).hasRouter() )
				<< "Searching Output RoutingData message error : << "
				<< aRoutingRID.getFullyQualifiedNameID()
				<< " >> doesn't have router !!!"
				<< SEND_EXIT;


		const RoutingData & aRoutingData = anED.getRuntime(aRoutingRID).
				getRouter().getOutputRouting( aPort->getRouteOffset() );
		if( aRoutingData != NULL )
		{
//			aRoutingRID = ( aPort->isVisibilityPublic() )?
//					aRoutingRID.getPRID() : aRoutingRID;
			aRoutingRID = aRoutingRID.getCommunicator(
					aRoutingData.getMachine() );
		}

		return( aRoutingData );
	}

	return( RoutingData::_NULL_ );
}


/*
 * CHECK ROUTING INFORMATION
 */
bool AvmCommunicationFactory::isRoutingProtocolEnv(
		COMPILE_CONTEXT * aCTX, InstanceOfPort * aPort)
{
	return( false );
}

bool AvmCommunicationFactory::isRoutingProtocolRdv(
		COMPILE_CONTEXT * aCTX, InstanceOfPort * aPort)
{
	return( false );
}


/*
 * POP MESSAGE
 */
bool AvmCommunicationFactory::popMessage(
		ExecutionEnvironment & ENV, InstanceOfPort * aPort)
{
	RuntimeID aRoutingRID = ENV.mARG->outED->mRID;

	const RoutingData & aRoutingData =
			searchInputRoutingData(ENV.mARG->outED, aPort, aRoutingRID);

	if( aRoutingData != NULL )
	{
		switch( aRoutingData.getProtocol() )
		{
			case ComProtocol::PROTOCOL_ENVIRONMENT_KIND:
			{
				if( ENV.mARG->outED->getRuntime(aRoutingRID).
						isEnvironmentEnabledCommunication() )
				{
					return( popMessage_environment(ENV, aRoutingRID, aRoutingData) );
				}
				return( false );
			}

			case ComProtocol::PROTOCOL_TRANSFERT_KIND: // inRD->hasAttach() )
			{
				return( popMessage_transfert(ENV, aRoutingRID, aRoutingData) );
			}

			case ComProtocol::PROTOCOL_BUFFER_KIND:
			case ComProtocol::PROTOCOL_BROADCAST_KIND:
			case ComProtocol::PROTOCOL_MULTICAST_KIND:
			case ComProtocol::PROTOCOL_UNICAST_KIND:
			case ComProtocol::PROTOCOL_ANYCAST_KIND:
			{
				return( popMessage_buffer(ENV, aRoutingRID, aRoutingData) );
			}

			case ComProtocol::PROTOCOL_RDV_KIND:
			case ComProtocol::PROTOCOL_MULTIRDV_KIND:
			{
				return( popMessage_rdv(ENV, aRoutingRID, aRoutingData) );
			}

			case ComProtocol::PROTOCOL_UNDEFINED_KIND:
			default:
			{
				AVM_OS_EXIT( FAILED )
						<< "popMessage :> Unknown Protocol for interaction << "
						<< aPort->strComPointNature() << ": "
						<< aPort->getFullyQualifiedNameID() << " >> & << machine: "
						<< aRoutingRID.getInstance()->getFullyQualifiedNameID()
						<< " >> in running context: << "
						<< ENV.mARG->outED->mRID.getInstance()->getFullyQualifiedNameID()
						<< " >> !!!"
						<< SEND_EXIT;

				return( false );
			}
		}
	}
	else
	{
		AVM_OS_EXIT( FAILED )
				<< "popMessage :> Unfound RoutingData for interaction << "
				<< aPort->strComPointNature() << ": "
				<< aPort->getFullyQualifiedNameID() << " >> & << machine: "
				<< aRoutingRID.getInstance()->getFullyQualifiedNameID()
				<< " >> in running context: << "
				<< ENV.mARG->outED->mRID.getInstance()->getFullyQualifiedNameID()
				<< " >> !!!"
				<< SEND_EXIT;
	}

	return( false );
}


bool AvmCommunicationFactory::popMessage_environment(ExecutionEnvironment & ENV,
		const RuntimeID & aRoutingRID, const RoutingData & aRoutingData,
		avm_size_t firstParameterOffset /*= 1*/)
{
	BFCode aTraceInput(OperatorManager::OPERATOR_INPUT_ENV, ENV.mARG->at(0));

	bool allSuccess = true;

	if( ENV.inCODE->populated() )
	{
		ENV.mARG->outED.makeModifiableParamTable();

		InstanceOfPort * aPort = ENV.mARG->at(0).to_ptr< InstanceOfPort >();
		avm_size_t offset = 0;

		InstanceOfData * aVar = NULL;
		BF aNewSymbolicConstant;
		BFList paramList;

		for( ENV.mARG->begin(firstParameterOffset) ; ENV.mARG->hasNext() ;
				ENV.mARG->next() , ++offset )
		{
			paramList.clear();

			aVar = ENV.mARG->current().to_ptr< InstanceOfData >();

			aNewSymbolicConstant = ENV.createNewFreshParam(
					ENV.mARG->outED->mRID,
					aPort->getParameterType(offset),
					aVar, paramList);

			if( not ENV.setRvalue(ENV.mARG->outED, aVar, aNewSymbolicConstant) )
			{
				allSuccess = false;

				break;
			}

			ENV.mARG->outED.appendParameters( paramList );

			aTraceInput->append( aNewSymbolicConstant );
		}
	}

	if( allSuccess )
	{
		ExecutionDataFactory::appendIOElementTrace(ENV.mARG->outED,
				BF( new ExecutionConfiguration(
						ENV.mARG->outED->mRID, aTraceInput) ) );

		ENV.outEDS.append( ENV.mARG->outED );

		return( true );
	}
	else
	{
		return( false );
	}
}


bool AvmCommunicationFactory::popMessage_transfert(ExecutionEnvironment & ENV,
		const RuntimeID & aRoutingRID, const RoutingData & aRoutingData)
{
	return( false );
}


bool AvmCommunicationFactory::popMessage_buffer(ExecutionEnvironment & ENV,
		const RuntimeID & aRoutingRID, const RoutingData & aRoutingData)
{
AVM_IF_DEBUG_FLAG( STATEMENT_COMMUNICATION )
	AVM_OS_TRACE << TAB << "begin "
			"AvmCommunicationFactory::popMessage_buffer" << std::endl;

	ENV.mARG->outED->getRuntime(aRoutingRID).toStreamData(
			ENV.mARG->outED, AVM_OS_TRACE << INCR2_INDENT);
	AVM_OS_TRACE << DECR2_INDENT;
AVM_ENDIF_DEBUG_FLAG( STATEMENT_COMMUNICATION )

	Message popMsg;

	RuntimeID bufferDeclRID = aRoutingRID;

	ListOfInstanceOfBuffer::const_iterator itBuffer =
			aRoutingData.getBufferInstance().begin();
	ListOfInstanceOfBuffer::const_iterator endBuffer =
			aRoutingData.getBufferInstance().end();
	for( ; itBuffer != endBuffer ; ++itBuffer )
	{
		bufferDeclRID = ENV.mARG->outED->getRuntimeContainerRID(
				ENV.mARG->outED->mRID, (*itBuffer) );

		if( bufferDeclRID.valid() )
		{
			if( ENV.mARG->outED->getRuntime(bufferDeclRID).
					getBuffer( *itBuffer ).nonempty() )
			{
				BaseBufferForm & bbf = ENV.mARG->outED.getWritableRuntime(
						bufferDeclRID ).getWritableBuffer( *itBuffer);

				popMsg = bbf.pop(aRoutingData.getMID(), ENV.mARG->outED->mRID);

				if( popMsg.valid() )
				{
					break;
				}
			}
		}
	}

	if( popMsg.valid() )
	{
		BFCode aTraceInput(OperatorManager::OPERATOR_INPUT, ENV.mARG->at(0));

		Message::const_iterator itVal = popMsg.getParameters().begin();
		Message::const_iterator endVal = popMsg.getParameters().end();

		// We have to ignore the << Port >> InstanceOfPort
		for( ENV.mARG->begin(1) ; (itVal != endVal) && ENV.mARG->hasNext() ;
				ENV.mARG->next() , ++itVal )
		{
			if( ENV.setRvalue(ENV.mARG->outED,
					ENV.mARG->current().to_ptr< InstanceOfData >(), *itVal) )
			{
				aTraceInput->append( *itVal );

			}
			else
			{
				return( false );
			}
		}

		ExecutionDataFactory::appendIOElementTrace(ENV.mARG->outED,
				BF( new ExecutionConfiguration(
						ENV.mARG->outED->mRID, aTraceInput, popMsg) ) );

		ENV.outEDS.append( ENV.mARG->outED );

AVM_IF_DEBUG_FLAG( STATEMENT_COMMUNICATION )
	ENV.mARG->outED->getRuntime(aRoutingRID).toStreamData(
			ENV.mARG->outED, AVM_OS_TRACE << INCR2_INDENT);
	AVM_OS_TRACE << DECR2_INDENT_TAB << "end "
			"AvmCommunicationFactory::popMessage_buffer" << std::endl;
AVM_ENDIF_DEBUG_FLAG( STATEMENT_COMMUNICATION )

		return( true );
	}
	else
	{
		return( false );
	}
}


bool AvmCommunicationFactory::popMessage_rdv(ExecutionEnvironment & ENV,
		const RuntimeID & aRoutingRID, const RoutingData & aRoutingData)
{
	Message inMsg( RuntimeID::REF_NULL,
			ENV.mARG->outED->mRID, aRoutingData.getPort() );
	inMsg.setMID( aRoutingData.getMID() );

	// We have to ignore the << Port >> InstanceOfPort
	for( ENV.mARG->begin(1) ; ENV.mARG->hasNext() ; ENV.mARG->next() )
	{
		inMsg.appendParameter( ENV.mARG->current() );
	}

	ENV.mARG->outED.pushExecSyncPoint( new ExecutionSynchronizationPoint(
			AWAITING_POINT_INPUT_NATURE, aRoutingRID, aRoutingData, inMsg) );

	ENV.appendSync_mwsetAEES(ENV.mARG->outED, AEES_WAITING_INCOM_RDV);

	return( true );
}


/*
 * POP MESSAGE FROM
 */

bool AvmCommunicationFactory::popMessageFrom(ExecutionEnvironment & ENV)
{
	RuntimeID aRoutingRID = ENV.mARG->outED->mRID;
	InstanceOfPort * aPort = ENV.mARG->at(0).to_ptr< InstanceOfPort >();

	const RoutingData & aRoutingData =
			searchInputRoutingData(ENV.mARG->outED, aPort, aRoutingRID);

	RuntimeID aSenderRID = ENV.mARG->at(1).bfRID();

	if( aRoutingData != NULL )
	{
		switch( aRoutingData.getProtocol() )
		{
			case ComProtocol::PROTOCOL_ENVIRONMENT_KIND:
			{
				if( ENV.mARG->outED->getRuntime(aRoutingRID).
						isEnvironmentEnabledCommunication() )
				{
					return( popMessage_environment(ENV,
							aRoutingRID, aRoutingData) );
				}
				return( false );
			}

			case ComProtocol::PROTOCOL_TRANSFERT_KIND: // inRD->hasAttach() )
			{
				return( popMessageFrom_transfert(ENV,
						aSenderRID, aRoutingRID, aRoutingData) );
			}

			case ComProtocol::PROTOCOL_BUFFER_KIND:
			case ComProtocol::PROTOCOL_BROADCAST_KIND:
			case ComProtocol::PROTOCOL_MULTICAST_KIND:
			case ComProtocol::PROTOCOL_UNICAST_KIND:
			case ComProtocol::PROTOCOL_ANYCAST_KIND:
			{
				return( popMessageFrom_buffer(ENV,
						aSenderRID, aRoutingRID, aRoutingData) );
			}

			case ComProtocol::PROTOCOL_RDV_KIND:
			case ComProtocol::PROTOCOL_MULTIRDV_KIND:
			{
				return( popMessageFrom_rdv(ENV,
						aSenderRID, aRoutingRID, aRoutingData) );
			}
			case ComProtocol::PROTOCOL_UNDEFINED_KIND:
			default:
			{
				AVM_OS_EXIT( FAILED )
						<< "popMessageFrom :> Unknown Protocol for interaction << "
						<< aPort->strComPointNature() << ": "
						<< aPort->getFullyQualifiedNameID() << " >> & << machine: "
						<< aRoutingRID.getInstance()->getFullyQualifiedNameID()
						<< " >> in running context: << "
						<< ENV.mARG->outED->mRID.getInstance()->getFullyQualifiedNameID()
						<< " >> !!!"
						<< SEND_EXIT;

				return( false );
			}
		}
	}
	else
	{
		AVM_OS_EXIT( FAILED )
				<< "popMessageFrom :> Unfound RoutingData for interaction << "
				<< aPort->strComPointNature() << ": "
				<< aPort->getFullyQualifiedNameID() << " >> & << machine: "
				<< aRoutingRID.getInstance()->getFullyQualifiedNameID()
				<< " >> in running context: << "
				<< ENV.mARG->outED->mRID.getInstance()->getFullyQualifiedNameID()
				<< " >> !!!"
				<< SEND_EXIT;
	}

	return( false );

}


bool AvmCommunicationFactory::popMessageFrom_transfert(
		ExecutionEnvironment & ENV, const RuntimeID & aSenderRID,
		const RuntimeID & aRoutingRID, const RoutingData & aRoutingData)
{
	return( false );
}


bool AvmCommunicationFactory::popMessageFrom_buffer(
		ExecutionEnvironment & ENV, const RuntimeID & aSenderRID,
		const RuntimeID & aRoutingRID, const RoutingData & aRoutingData)
{
AVM_IF_DEBUG_FLAG( STATEMENT_COMMUNICATION )
	AVM_OS_TRACE << TAB << "begin "
			"AvmCommunicationFactory::popMessageFrom_buffer" << std::endl;

	ENV.mARG->outED->getRuntime(aRoutingRID).toStreamData(
			ENV.mARG->outED, AVM_OS_TRACE << INCR2_INDENT);
	AVM_OS_TRACE << DECR2_INDENT;
AVM_ENDIF_DEBUG_FLAG( STATEMENT_COMMUNICATION )

	Message popMsg;

	RuntimeID bufferDeclRID = aRoutingRID;

	ListOfInstanceOfBuffer::const_iterator itBuffer =
			aRoutingData.getBufferInstance().begin();
	ListOfInstanceOfBuffer::const_iterator endBuffer =
			aRoutingData.getBufferInstance().end();
	for( ; itBuffer != endBuffer ; ++itBuffer )
	{
		bufferDeclRID = ENV.mARG->outED->getRuntimeContainerRID(
				ENV.mARG->outED->mRID, (*itBuffer));

		if( bufferDeclRID.valid() )
		{
			BaseBufferForm & bbf = ENV.mARG->outED.getWritableRuntime(
					bufferDeclRID ).getWritableBuffer( *itBuffer );

			popMsg = bbf.top();
			if( popMsg.valid() && popMsg.isSender(aSenderRID) )
			{
				popMsg = bbf.pop(aRoutingData.getMID(), ENV.mARG->outED->mRID);
			}

			if( popMsg.valid() )
			{
				break;
			}
		}
	}

AVM_IF_DEBUG_FLAG( STATEMENT_COMMUNICATION )
	ENV.mARG->outED->getRuntime(aRoutingRID).toStreamData(
			ENV.mARG->outED, AVM_OS_TRACE << INCR2_INDENT);
	AVM_OS_TRACE << DECR2_INDENT_TAB << "end "
			"AvmCommunicationFactory::popMessageFrom_buffer" << std::endl;
AVM_ENDIF_DEBUG_FLAG( STATEMENT_COMMUNICATION )

	if( popMsg.valid() )
	{
		BFCode aTraceInput(OperatorManager::OPERATOR_INPUT, ENV.mARG->at(0));

		Message::const_iterator itVal = popMsg.beginParameters();
		Message::const_iterator endVal = popMsg.endParameters();

		// We have to ignore the << Port >> InstanceOfPort and the << Sender >>
		for( ENV.mARG->begin(2) ; (itVal != endVal) && ENV.mARG->hasNext() ;
				ENV.mARG->next() , ++itVal )
		{
			if( ENV.setRvalue(ENV.mARG->outED,
					ENV.mARG->current().to_ptr< InstanceOfData >(), *itVal) )
			{
				aTraceInput->append( *itVal );

			}
			else
			{
				return( false );
			}
		}

		ExecutionDataFactory::appendIOElementTrace(ENV.mARG->outED,
				BF( new ExecutionConfiguration(
						ENV.mARG->outED->mRID, aTraceInput, popMsg) ) );

		ENV.outEDS.append( ENV.mARG->outED );

AVM_IF_DEBUG_FLAG( STATEMENT_COMMUNICATION )
	ENV.mARG->outED->getRuntime(aRoutingRID).toStreamData(
			ENV.mARG->outED, AVM_OS_TRACE << INCR2_INDENT);
	AVM_OS_TRACE << DECR2_INDENT_TAB << "end "
			"AvmCommunicationFactory::popMessageFrom_buffer"
			<< std::endl;
AVM_ENDIF_DEBUG_FLAG( STATEMENT_COMMUNICATION )

		return( true );
	}
	else
	{
		return( false );
	}
}


bool AvmCommunicationFactory::popMessageFrom_rdv(
		ExecutionEnvironment & ENV, const RuntimeID & aSenderRID,
		const RuntimeID & aRoutingRID, const RoutingData & aRoutingData)
{
	Message inMsg( aSenderRID, ENV.mARG->outED->mRID, aRoutingData.getPort() );
	inMsg.setMID( aRoutingData.getMID() );

	// We have to ignore the << Port >> InstanceOfPort and the << Sender >>
	for( ENV.mARG->begin(2) ; ENV.mARG->hasNext() ; ENV.mARG->next() )
	{
		inMsg.appendParameter( ENV.mARG->current() );
	}

	ENV.mARG->outED.pushExecSyncPoint( new ExecutionSynchronizationPoint(
			AWAITING_POINT_INPUT_NATURE, aRoutingRID, aRoutingData, inMsg) );

	ENV.appendSync_mwsetAEES(ENV.mARG->outED, AEES_WAITING_INCOM_RDV);

	return( true );
}


/*
 * PUSH MESSAGE
 */
bool AvmCommunicationFactory::pushMessage(ExecutionEnvironment & ENV,
		const Message & anOutputMsg, RuntimeID aRoutingRID)
{
	InstanceOfPort * aPort = anOutputMsg.getPort();

	const RoutingData & aRoutingData =
			searchOutputRoutingData(ENV.mARG->outED, aPort, aRoutingRID);

	if( aRoutingData != NULL )
	{
		anOutputMsg.setMID( aRoutingData.getMID() );

		switch( aRoutingData.getProtocol() )
		{
			case ComProtocol::PROTOCOL_ENVIRONMENT_KIND:
			{
				return( pushMessage_environment(ENV,
						aRoutingRID, aRoutingData, anOutputMsg) );
			}

			case ComProtocol::PROTOCOL_TRANSFERT_KIND: // aRoutingData.hasAttach()
			{
				return( pushMessage_transfert(ENV,
						aRoutingRID, aRoutingData, anOutputMsg) );
			}

			case ComProtocol::PROTOCOL_BUFFER_KIND:
			{
				return( pushMessage_buffer(ENV,
						aRoutingRID, aRoutingData, anOutputMsg) );
			}

			case ComProtocol::PROTOCOL_RDV_KIND:
			case ComProtocol::PROTOCOL_MULTIRDV_KIND:
			{
				return( pushMessage_rdv(ENV,
						aRoutingRID, aRoutingData, anOutputMsg) );
			}

			case ComProtocol::PROTOCOL_BROADCAST_KIND:
			{
				return( pushMessage_broadcast(ENV,
						aRoutingRID, aRoutingData, anOutputMsg) );
			}

			case ComProtocol::PROTOCOL_MULTICAST_KIND:
			{
				return( pushMessage_multicast(ENV,
						aRoutingRID, aRoutingData, anOutputMsg) );
			}
			case ComProtocol::PROTOCOL_UNICAST_KIND:
			{
				return( pushMessage_unicast(ENV,
						aRoutingRID, aRoutingData, anOutputMsg) );
			}

			case ComProtocol::PROTOCOL_ANYCAST_KIND:
			{
				return( pushMessage_anycast(ENV,
						aRoutingRID, aRoutingData, anOutputMsg) );
			}

			case ComProtocol::PROTOCOL_UNDEFINED_KIND:
			default:
			{
//				return( pushMessage_environment(anED, ENV.mARG->outED->mRID,
//						aRoutingRF, aRoutingData, anOutputMsg, listOfOutputED) );
				return( false );
			}
		}
	}
	else
	{
		AVM_OS_EXIT( FAILED )
			<< "Push message error : Unfound RoutingData for interaction << "
			<<  aPort->strComPointNature() << ": "
			<< aRoutingRID.getInstance()->getFullyQualifiedNameID()
			<< " >> in running context: << "
			<< aPort->getFullyQualifiedNameID() << " >> & << machine: "
			<< ENV.mARG->outED->mRID.getInstance()->getFullyQualifiedNameID()
			<< " >> !!!"
			<< SEND_EXIT;
	}

	return( false );
}


bool AvmCommunicationFactory::pushMessage_environment(
		ExecutionEnvironment & ENV, const RuntimeID & aRoutingRID,
		const RoutingData & aRoutingData, const Message & anOutputMsg)
{
	BFCode aTraceOutput(OperatorManager::OPERATOR_OUTPUT_ENV,
			anOutputMsg.bfPort());

	aTraceOutput->append( anOutputMsg.getParameters() );

	ExecutionDataFactory::appendIOElementTrace(ENV.mARG->outED,
			BF( new ExecutionConfiguration(
					ENV.mARG->outED->mRID, aTraceOutput, anOutputMsg) ) );

	ENV.outEDS.append( ENV.mARG->outED );

	return( true );
}


bool AvmCommunicationFactory::pushMessage_transfert(
		ExecutionEnvironment & ENV, const RuntimeID & aRoutingRID,
		const RoutingData & aRoutingData, const Message & anOutputMsg)
{
	return( true );
}

bool AvmCommunicationFactory::pushMessage_buffer(
		ExecutionEnvironment & ENV, const RuntimeID & aRoutingRID,
		const RoutingData & aRoutingData, const Message & anOutputMsg)
{
AVM_IF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )
	AVM_OS_TRACE << TAB << "begin "
			"AvmCommunicationFactory::pushMessage_buffer" << std::endl;

	ENV.mARG->outED->getRuntime(aRoutingRID).toStream(
			AVM_OS_TRACE << INCR2_INDENT );
	AVM_OS_TRACE << DECR2_INDENT;
AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )

	bool oneSuccess = false;

	RuntimeID bufferDeclRID = aRoutingRID;

	ListOfInstanceOfBuffer::const_iterator itBuffer =
			aRoutingData.getBufferInstance().begin();
	ListOfInstanceOfBuffer::const_iterator endBuffer =
			aRoutingData.getBufferInstance().end();
	for( ; itBuffer != endBuffer ; ++itBuffer )
	{
		bufferDeclRID = ENV.mARG->outED->getRuntimeContainerRID(
				aRoutingRID, (*itBuffer));

		if( bufferDeclRID.valid() )
		{
			APExecutionData outED = ENV.mARG->outED;

			BaseBufferForm & bbf = outED.getWritableRuntime(
					bufferDeclRID ).getWritableBuffer( *itBuffer );

			if( bbf.push( anOutputMsg ) )
			{
				oneSuccess = true;

				BFCode aTraceOutput(OperatorManager::OPERATOR_OUTPUT,
						anOutputMsg.bfPort());

				aTraceOutput->append( anOutputMsg.getParameters() );

				ExecutionDataFactory::appendIOElementTrace(outED,
						BF( new ExecutionConfiguration(
								outED->mRID, aTraceOutput, anOutputMsg) ) );

				ENV.outEDS.append( outED );


AVM_IF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )
	outED->getRuntime(aRoutingRID).toStream( AVM_OS_TRACE << INCR2_INDENT );
	AVM_OS_TRACE << DECR2_INDENT_TAB
			<< "end AvmCommunicationFactory::pushMessage_buffer" << std::endl;
AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )
			}
		}
	}

	return( oneSuccess );
}


bool AvmCommunicationFactory::pushMessage_rdv(
		ExecutionEnvironment & ENV, const RuntimeID & aRoutingRID,
		const RoutingData & aRoutingData, const Message & anOutputMsg)
{
	ENV.mARG->outED.pushExecSyncPoint(new ExecutionSynchronizationPoint(
		AWAITING_POINT_OUTPUT_NATURE, aRoutingRID, aRoutingData, anOutputMsg) );

	ENV.appendSync_mwsetAEES(ENV.mARG->outED, AEES_WAITING_OUTCOM_RDV);

	return( true );
}


bool AvmCommunicationFactory::pushMessage_broadcast(
		ExecutionEnvironment & ENV, const RuntimeID & aRoutingRID,
		const RoutingData & aRoutingData, const Message & anOutputMsg)
{
	return( true );
}


bool AvmCommunicationFactory::pushMessage_multicast(
		ExecutionEnvironment & ENV, const RuntimeID & aRoutingRID,
		const RoutingData & aRoutingData, const Message & anOutputMsg)
{
AVM_IF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )
	AVM_OS_TRACE << TAB << "begin "
			"AvmCommunicationFactory::pushMessage_multicast" << std::endl;

	ENV.mARG->outED->getRuntime(aRoutingRID).toStream(
			AVM_OS_TRACE << INCR2_INDENT );
	AVM_OS_TRACE << DECR2_INDENT;
AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )

	bool oneSuccess = false;

	RuntimeID bufferDeclRID = aRoutingRID;

	ListOfInstanceOfBuffer::const_iterator itBuffer =
			aRoutingData.getBufferInstance().begin();
	ListOfInstanceOfBuffer::const_iterator endBuffer =
			aRoutingData.getBufferInstance().end();
	for( ; itBuffer != endBuffer ; ++itBuffer )
	{
		bufferDeclRID = ENV.mARG->outED->getRuntimeContainerRID(
				aRoutingRID, (*itBuffer));

		if( bufferDeclRID.valid() )
		{
			BaseBufferForm & bbf = ENV.mARG->outED.getWritableRuntime(
					bufferDeclRID ).getWritableBuffer( *itBuffer );

			if( bbf.push( anOutputMsg ) )
			{
				oneSuccess = true;
			}
		}
	}

	if( oneSuccess )
	{
		BFCode aTraceOutput(OperatorManager::OPERATOR_OUTPUT,
				anOutputMsg.bfPort());

		aTraceOutput->append( anOutputMsg.getParameters() );

		ExecutionDataFactory::appendIOElementTrace(ENV.mARG->outED,
				BF( new ExecutionConfiguration(
						ENV.mARG->outED->mRID, aTraceOutput, anOutputMsg) ) );

		ENV.outEDS.append( ENV.mARG->outED );


AVM_IF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )
	ENV.mARG->outED->getRuntime(aRoutingRID).toStream(
			AVM_OS_TRACE << INCR2_INDENT );
	AVM_OS_TRACE << DECR2_INDENT_TAB
			<< "end AvmCommunicationFactory::pushMessage_buffer"
			<< std::endl;
AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )

		return( true );
	}
	else
	{
		return( false );
	}
}


bool AvmCommunicationFactory::pushMessage_unicast(
		ExecutionEnvironment & ENV, const RuntimeID & aRoutingRID,
		const RoutingData & aRoutingData, const Message & anOutputMsg)
{
AVM_IF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )
	AVM_OS_TRACE << TAB << "begin "
			"AvmCommunicationFactory::pushMessage_multicast" << std::endl;

	ENV.mARG->outED->getRuntime(aRoutingRID).toStream(
			AVM_OS_TRACE << INCR2_INDENT );
	AVM_OS_TRACE << DECR2_INDENT;
AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )

	bool oneSuccess = false;

	RuntimeID bufferDeclRID = aRoutingRID;

	ListOfInstanceOfBuffer::const_iterator itBuffer =
			aRoutingData.getBufferInstance().begin();
	ListOfInstanceOfBuffer::const_iterator endBuffer =
			aRoutingData.getBufferInstance().end();
	for( ; itBuffer != endBuffer ; ++itBuffer )
	{
		bufferDeclRID = ENV.mARG->outED->getRuntimeContainerRID(
				aRoutingRID, (*itBuffer));

		if( bufferDeclRID.valid() )
		{
			BaseBufferForm & bbf = ENV.mARG->outED.getWritableRuntime(
					bufferDeclRID ).getWritableBuffer( *itBuffer );

			if( bbf.push( anOutputMsg ) )
			{
				oneSuccess = true;

				BFCode aTraceOutput(OperatorManager::OPERATOR_OUTPUT,
						anOutputMsg.bfPort());

				aTraceOutput->append( anOutputMsg.getParameters() );

				ExecutionDataFactory::appendIOElementTrace(ENV.mARG->outED,
					BF( new ExecutionConfiguration(
						ENV.mARG->outED->mRID, aTraceOutput, anOutputMsg) ) );

				ENV.outEDS.append( ENV.mARG->outED );

AVM_IF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )
	ENV.mARG->outED->getRuntime(aRoutingRID).toStream(
			AVM_OS_TRACE << INCR2_INDENT );
	AVM_OS_TRACE << DECR2_INDENT_TAB
			<< "end AvmCommunicationFactory::pushMessage_buffer"
			<< std::endl;
AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )
			}
		}
	}

	return( oneSuccess );
}


bool AvmCommunicationFactory::pushMessage_anycast(
		ExecutionEnvironment & ENV, const RuntimeID & aRoutingRID,
		const RoutingData & aRoutingData, const Message & anOutputMsg)
{
	return( pushMessage_buffer(ENV, aRoutingRID, aRoutingData, anOutputMsg) );
//	return( true );
}



/*
 * PUSH MESSAGE TO
 */

bool AvmCommunicationFactory::pushMessageTo(
		ExecutionEnvironment & ENV, const Message & anOutputMsg)
{
	RuntimeID aRoutingRID = ENV.mARG->outED->mRID;
	InstanceOfPort * aPort = anOutputMsg.getPort();

	const RoutingData & aRoutingData =
			searchOutputRoutingData(ENV.mARG->outED, aPort, aRoutingRID);

	if( aRoutingData != NULL )
	{
		anOutputMsg.setMID( aRoutingData.getMID() );

		if( (anOutputMsg.getReceiverRID() == RuntimeLib::RID_ENVIRONMENT) ||
				(anOutputMsg.getReceiverRID() == RuntimeLib::RID_NIL) )
		{
			return( pushMessage_environment(ENV,
					aRoutingRID, aRoutingData, anOutputMsg) );
		}

		switch( aRoutingData.getProtocol() )
		{
			case ComProtocol::PROTOCOL_ENVIRONMENT_KIND:
			{
				return( pushMessage_environment(ENV,
						aRoutingRID, aRoutingData, anOutputMsg) );
			}

			case ComProtocol::PROTOCOL_TRANSFERT_KIND:
			{// aRoutingData.hasAttach() )
				return( pushMessageTo_transfert(ENV,
						aRoutingRID, aRoutingData, anOutputMsg) );
			}

			case ComProtocol::PROTOCOL_BUFFER_KIND:
			{
				return( pushMessageTo_buffer(ENV,
						aRoutingRID, aRoutingData, anOutputMsg) );
			}

			case ComProtocol::PROTOCOL_RDV_KIND:
			case ComProtocol::PROTOCOL_MULTIRDV_KIND:
			{
				return( pushMessageTo_rdv(ENV,
						aRoutingRID, aRoutingData, anOutputMsg) );
			}

			case ComProtocol::PROTOCOL_BROADCAST_KIND:
			{
				return( pushMessageTo_broadcast(ENV,
						aRoutingRID, aRoutingData, anOutputMsg) );
			}

			case ComProtocol::PROTOCOL_MULTICAST_KIND:
			{
				return( pushMessageTo_multicast(ENV,
						aRoutingRID, aRoutingData, anOutputMsg) );
			}
			case ComProtocol::PROTOCOL_UNICAST_KIND:
			{
				return( pushMessageTo_unicast(ENV,
						aRoutingRID, aRoutingData, anOutputMsg) );
			}

			case ComProtocol::PROTOCOL_ANYCAST_KIND:
			{
				return( pushMessageTo_anycast(ENV,
						aRoutingRID, aRoutingData, anOutputMsg) );
			}

			case ComProtocol::PROTOCOL_UNDEFINED_KIND:
			default:
			{
				AVM_OS_EXIT( FAILED )
						<< "pushMessageTo :> Unknown Protocol for interaction << "
						<< aPort->strComPointNature() << ": "
						<< aPort->getFullyQualifiedNameID() << " >> & << machine: "
						<< ENV.mARG->outED->mRID.getInstance()->getFullyQualifiedNameID()
						<< " >> !!!"
						<< SEND_EXIT;

				return( false );
			}
		}
	}
	else
	{
		AVM_OS_EXIT( FAILED )
				<< "pushMessageTo :> Unfound RoutingData for interaction << "
				<< aPort->strComPointNature() << ": "
				<< aPort->getFullyQualifiedNameID() << " >> & << machine: "
				<< aRoutingRID.getInstance()->getFullyQualifiedNameID()
				<< " >> in running context: << "
				<< ENV.mARG->outED->mRID.getInstance()->getFullyQualifiedNameID()
				<< " >> !!!"
				<< SEND_EXIT;
	}

	return( false );
}


bool AvmCommunicationFactory::pushMessageTo_transfert(
		ExecutionEnvironment & ENV, const RuntimeID & aRoutingRID,
		const RoutingData & aRoutingData, const Message & anOutputMsg)
{
	return( true );
}


bool AvmCommunicationFactory::pushMessageTo_buffer(
		ExecutionEnvironment & ENV, const RuntimeID & aRoutingRID,
		const RoutingData & aRoutingData, const Message & anOutputMsg)
{
AVM_IF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )
	AVM_OS_TRACE << TAB << "begin "
			"AvmCommunicationFactory::pushMessageTo_buffer" << std::endl;

	ENV.mARG->outED->getRuntime(aRoutingRID).toStream(
			AVM_OS_TRACE << INCR2_INDENT );
	AVM_OS_TRACE << DECR2_INDENT;
AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )

	// Search receiver machine in the INPUT MACHINE-PORT connected list
	bool oneSuccess = false;

	ListOfInstanceOfBuffer::const_iterator itbIn;
	ListOfInstanceOfBuffer::const_iterator itbInEnd;

	ListOfInstanceOfBuffer::const_iterator itbOut;
	ListOfInstanceOfBuffer::const_iterator itbOutEnd;

	const VectorOfPairMachinePort & theConnectedPort =
			aRoutingRID.getExecutable()->getConnect().at(
					aRoutingData.getConnect()->getOffset() ).
							getInputComRouteData().getMachinePorts();

	RuntimeID bufferDeclRID = aRoutingRID;

	VectorOfPairMachinePort::const_iterator itMP = theConnectedPort.begin();
	VectorOfPairMachinePort::const_iterator endMP = theConnectedPort.end();
	for( ; itMP != endMP ; ++itMP )
	{
		if( anOutputMsg.isReceiverMachine( (*itMP)->first() ) )
		{
			// get Routing Data of the connector input receiver candidate
			const RoutingData & connectInputRD =
					ENV.mARG->outED->getRuntime(
						anOutputMsg.getReceiverRID() ).getRouter().
						getInputRouting( (*itMP)->second()->getRouteOffset() );

			// Push the message in all COMMON buffer with the OUTPUT PORT!
			itbIn = connectInputRD.getBufferInstance().begin();
			itbInEnd = connectInputRD.getBufferInstance().end();
			for(  ; itbIn != itbInEnd ; ++itbIn )
			{
				itbOut = aRoutingData.getBufferInstance().begin();
				itbOutEnd = aRoutingData.getBufferInstance().end();
				for(  ; itbOut != itbOutEnd ; ++itbOut )
				{
					if( (*itbIn) == (*itbOut) )  // COMMON BUFFER found
					{
						bufferDeclRID = ENV.mARG->outED->getRuntimeContainerRID(
								anOutputMsg.getReceiverRID(), (*itbOut) );

						BaseBufferForm & bbf =
							ENV.mARG->outED.getWritableRuntime(
								bufferDeclRID ).getWritableBuffer( *itbOut );

						if( bbf.push( anOutputMsg ) )
						{
							oneSuccess = true;
						}
					}
				}
			}
		}
	}

	if( oneSuccess )
	{
		BFCode aTraceOutput(OperatorManager::OPERATOR_OUTPUT,
				anOutputMsg.bfPort());

		aTraceOutput->append( anOutputMsg.getParameters() );

		ExecutionDataFactory::appendIOElementTrace(ENV.mARG->outED,
				BF( new ExecutionConfiguration(
						ENV.mARG->outED->mRID, aTraceOutput, anOutputMsg) ) );

		ENV.outEDS.append( ENV.mARG->outED );


AVM_IF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )
	ENV.mARG->outED->getRuntime(aRoutingRID).toStream(
			AVM_OS_TRACE << INCR2_INDENT );
	AVM_OS_TRACE << DECR2_INDENT_TAB
			<< "end AvmCommunicationFactory::pushMessageTo_buffer"
			<< std::endl;
AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )

		return( true );
	}
	else
	{
		return( false );
	}
}


bool AvmCommunicationFactory::pushMessageTo_rdv(
		ExecutionEnvironment & ENV, const RuntimeID & aRoutingRID,
		const RoutingData & aRoutingData, const Message & anOutputMsg)
{
	ENV.mARG->outED.pushExecSyncPoint( new ExecutionSynchronizationPoint(
			AWAITING_POINT_OUTPUT_NATURE,
			aRoutingRID, aRoutingData, anOutputMsg) );

	ENV.appendSync_mwsetAEES(ENV.mARG->outED, AEES_WAITING_OUTCOM_RDV);

	return( true );
}


bool AvmCommunicationFactory::pushMessageTo_broadcast(
		ExecutionEnvironment & ENV, const RuntimeID & aRoutingRID,
		const RoutingData & aRoutingData, const Message & anOutputMsg)
{
	return( true );
}


bool AvmCommunicationFactory::pushMessageTo_multicast(
		ExecutionEnvironment & ENV, const RuntimeID & aRoutingRID,
		const RoutingData & aRoutingData, const Message & anOutputMsg)
{
AVM_IF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )
	AVM_OS_TRACE << TAB << "begin "
			"AvmCommunicationFactory::pushMessageTo_buffer" << std::endl;

	ENV.mARG->outED->getRuntime(aRoutingRID).toStream(
			AVM_OS_TRACE << INCR2_INDENT );
	AVM_OS_TRACE << DECR2_INDENT;
AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )

	// Search receiver machine in the INPUT MACHINE-PORT connected list
	bool oneSuccess = false;

	ListOfInstanceOfBuffer::const_iterator itbIn;
	ListOfInstanceOfBuffer::const_iterator itbInEnd;

	ListOfInstanceOfBuffer::const_iterator itbOut;
	ListOfInstanceOfBuffer::const_iterator itbOutEnd;

	const VectorOfPairMachinePort & theConnectedPort =
			aRoutingRID.getExecutable()->getConnect().at(
					aRoutingData.getConnect()->getOffset() ).
							getInputComRouteData().getMachinePorts();

	RuntimeID bufferDeclRID = aRoutingRID;

	VectorOfPairMachinePort::const_iterator itMP = theConnectedPort.begin();
	VectorOfPairMachinePort::const_iterator endMP = theConnectedPort.end();
	for( ; itMP != endMP ; ++itMP )
	{
		if( anOutputMsg.isReceiverMachine( (*itMP)->first() ) )
		{
			// get Routing Data of the connector input receiver candidate
			const RoutingData & connectInputRD =
					ENV.mARG->outED->getRuntime(
						anOutputMsg.getReceiverRID() ).getRouter().
						getInputRouting( (*itMP)->second()->getRouteOffset() );

			// Push the message in all COMMON buffer with the OUTPUT PORT!
			itbIn = connectInputRD.getBufferInstance().begin();
			itbInEnd = connectInputRD.getBufferInstance().end();
			for(  ; itbIn != itbInEnd ; ++itbIn )
			{
				itbOut = aRoutingData.getBufferInstance().begin();
				itbOutEnd = aRoutingData.getBufferInstance().end();
				for(  ; itbOut != itbOutEnd ; ++itbOut )
				{
					if( (*itbIn) == (*itbOut) )  // COMMON BUFFER found
					{
						bufferDeclRID = ENV.mARG->outED->getRuntimeContainerRID(
								anOutputMsg.getReceiverRID(), (*itbOut) );

						BaseBufferForm & bbf =
							ENV.mARG->outED.getWritableRuntime(
								bufferDeclRID ).getWritableBuffer( *itbOut );

						if( bbf.push( anOutputMsg ) )
						{
							oneSuccess = true;
						}
					}
				}
			}
		}
	}

	if( oneSuccess )
	{
		BFCode aTraceOutput(OperatorManager::OPERATOR_OUTPUT,
				anOutputMsg.bfPort());

		aTraceOutput->append( anOutputMsg.getParameters() );

		ExecutionDataFactory::appendIOElementTrace(ENV.mARG->outED,
				BF(new ExecutionConfiguration(
						ENV.mARG->outED->mRID, aTraceOutput, anOutputMsg) ) );

		ENV.outEDS.append( ENV.mARG->outED );


AVM_IF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )
	ENV.mARG->outED->getRuntime(aRoutingRID).toStream(
			AVM_OS_TRACE << INCR2_INDENT );
	AVM_OS_TRACE << DECR2_INDENT_TAB
			<< "end AvmCommunicationFactory::pushMessageTo_buffer"
			<< std::endl;
AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )

		return( true );
	}
	else
	{
		return( false );
	}
}


bool AvmCommunicationFactory::pushMessageTo_unicast(
		ExecutionEnvironment & ENV, const RuntimeID & aRoutingRID,
		const RoutingData & aRoutingData, const Message & anOutputMsg)
{
	return( true );
}


bool AvmCommunicationFactory::pushMessageTo_anycast(
		ExecutionEnvironment & ENV, const RuntimeID & aRoutingRID,
		const RoutingData & aRoutingData, const Message & anOutputMsg)
{
	return( pushMessageTo_buffer(ENV, aRoutingRID, aRoutingData, anOutputMsg) );
//	return( true );
}


/*
 * UPDATE BUFFER
 */
bool AvmCommunicationFactory::updateBuffer(APExecutionData & anED)
{
AVM_IF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )
	anED->getRuntime(1).toStream(AVM_OS_TRACE);
AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )

	TableOfBufferT & wrBufferTable = anED.getWritableRuntime(
			anED->mRID ).getWritableBufferTable();

	TableOfBufferT::const_iterator it = wrBufferTable.begin();
	TableOfBufferT::const_iterator itEnd = wrBufferTable.end();
	for( ; it != itEnd ; ++it )
	{
		switch( (*it)->classKind() )
		{
			case FORM_BUFFER_BROADCAST_KIND:
			{
				BroadcastBuffer * theBuffer = (*it)->to< BroadcastBuffer >();
				theBuffer->push( Message::_NULL_ );
				theBuffer->update();

				break;
			}

			default:
			{
				break;
			}
		}
	}

AVM_IF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )
	anED->getRuntime(1).toStream(AVM_OS_TRACE);
AVM_ENDIF_DEBUG_LEVEL_FLAG( HIGH , STATEMENT_COMMUNICATION )

	return( true );
}


/*
 * PRESENCE / ABSENCE status
 */
bool AvmCommunicationFactory::computePresence(const ExecutionData & anED,
		const RuntimeID & aReceiverRID, InstanceOfPort * aPort)
{
	RuntimeID aRoutingRID = aReceiverRID;

	const RoutingData & aRoutingData =
			searchInputRoutingData(anED, aPort, aRoutingRID);

	if( aRoutingData != NULL )
	{
		switch( aRoutingData.getProtocol() )
		{
			case ComProtocol::PROTOCOL_ENVIRONMENT_KIND:
			{
				return( true );
			}

			case ComProtocol::PROTOCOL_TRANSFERT_KIND: // inRD->hasAttach() )
			{
				return( false );
			}

			case ComProtocol::PROTOCOL_BUFFER_KIND:
			case ComProtocol::PROTOCOL_BROADCAST_KIND:
			case ComProtocol::PROTOCOL_MULTICAST_KIND:
			case ComProtocol::PROTOCOL_UNICAST_KIND:
			case ComProtocol::PROTOCOL_ANYCAST_KIND:
			{
				RuntimeID bufferDeclRID = aRoutingRID;

				ListOfInstanceOfBuffer::const_iterator itBuffer =
						aRoutingData.getBufferInstance().begin();
				ListOfInstanceOfBuffer::const_iterator endBuffer =
						aRoutingData.getBufferInstance().end();
				for( ; itBuffer != endBuffer ; ++itBuffer )
				{
					bufferDeclRID = anED.getRuntimeContainerRID(
							aReceiverRID, (*itBuffer) );

					if( bufferDeclRID.valid() )
					{
AVM_IF_DEBUG_LEVEL_FLAG( MEDIUM , STATEMENT_COMMUNICATION )
	AVM_OS_TRACE << "computePresence :> "
			<< str_header( aPort ) << std::endl
			<< "RoutingRID  : " << aRoutingRID.getFullyQualifiedNameID()
			<< std::endl
			<< "BufferRID   : " << bufferDeclRID.getFullyQualifiedNameID()
			<< std::endl
			<< "ReceiverRID : " << aReceiverRID.getFullyQualifiedNameID()
			<< std::endl;
	aRoutingData.toStream(AVM_OS_TRACE);
	anED.getRuntime(bufferDeclRID).toStream(AVM_OS_TRACE);
AVM_ENDIF_DEBUG_LEVEL_FLAG( MEDIUM , STATEMENT_COMMUNICATION )

						const BaseBufferForm & bbf = anED.getRuntime(
								bufferDeclRID ).getBuffer(*itBuffer);

						if( bbf.nonempty() )
						{
							if( aRoutingRID.getExecutable()->
									getSpecifier().hasFeatureInputEnabled() )
							{
								if( bbf.contains(
										aRoutingData.getMID(), aReceiverRID) )
								{
									return( true );
								}
							}
							else if( bbf.isTop(aRoutingData.getMID(),
									aReceiverRID) )
							{
								return( true );
							}
						}
					}
				}

				return( false );
			}

			case ComProtocol::PROTOCOL_RDV_KIND:
			case ComProtocol::PROTOCOL_MULTIRDV_KIND:

			case ComProtocol::PROTOCOL_UNDEFINED_KIND:
			default:
			{
				return( false );
			}
		}
	}

	return( false );
}


/*
 * Collect buffer message
 */
void AvmCommunicationFactory::collectBufferMessage(
		const ExecutionData & anED, BaseBufferForm & aBuffer)
{
	TableOfBufferT::const_iterator itBuffer;
	TableOfBufferT::const_iterator endBuffer;

	TableOfRuntimeT::const_iterator itRF = anED.getTableOfRuntime().begin();
	TableOfRuntimeT::const_iterator endRF = anED.getTableOfRuntime().end();
	for( ; itRF != endRF ; ++itRF )
	{
		if( (*itRF)->hasBufferTable() )
		{
			itBuffer = (*itRF)->getBufferTable().begin();
			endBuffer = (*itRF)->getBufferTable().end();
			for( ; itBuffer != endBuffer ; ++itBuffer )
			{
				(*itBuffer)->copyTo( aBuffer );
			}
		}
	}
}


}