/*******************************************************************************
 * 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
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and implementation
 ******************************************************************************/

#include "ExecutionData.h"

#include <fml/executable/BaseInstanceForm.h>

#include <fml/runtime/ExecutionConfiguration.h>
#include <fml/runtime/ExecutionContext.h>
#include <fml/runtime/RuntimeDef.h>

#include <boost/format.hpp>


namespace sep
{


/*ATTRIBUTES*/
avm_size_t ExecutionData::PARAM_MACHINE_RUNTIME_OFFSET = 0;
avm_size_t ExecutionData::SYSTEM_RUNTIME_OFFSET        = 1;



/**
 * GETTER
 * mTableOfRuntimeForm
 */

const RuntimeID & ExecutionData::getRuntimeID(
		const ExecutableForm * anExecutable) const
{
	TableOfRuntimeT::const_iterator it = mTableOfRuntime.begin();
	TableOfRuntimeT::const_iterator itEnd = mTableOfRuntime.end();
	for( ; it != itEnd ; ++it )
	{
		if( (*it)->getRID().getExecutable() == anExecutable )
		{
			return( (*it)->getRID() );
		}
	}

	return( RuntimeID::REF_NULL );
}


const RuntimeID & ExecutionData::getRuntimeID(
		InstanceOfMachine * anInstance) const
{
	if( anInstance->hasRuntimeRID() )
	{
		return( anInstance->getRuntimeRID() );
	}
	else if( anInstance->isAlias() )
	{
		if( anInstance->hasAliasTarget() &&
				anInstance->getAliasTarget()->as< InstanceOfMachine >()->
						hasRuntimeRID() )
		{
			const RuntimeID & tmpRID =
					anInstance->getAliasTarget()->getRuntimeContainerRID();

			anInstance->setRuntimeRID( tmpRID );

			return( tmpRID );
		}

		ArrayOfInstanceOfMachine::iterator it =
				anInstance->getMachinePath()->begin();

		RuntimeID tmpRID = mRID;

		// SEARCH of the LCA(RID) of the current RID an the ALIAS container
		tmpRID = tmpRID.getAncestorContaining( *it );
		if( tmpRID.valid() )
		{
			ArrayOfInstanceOfMachine::iterator itEnd =
					anInstance->getMachinePath()->end();

			// Use of Alias PATH to find the INSTANCE of variable
			for( ; it != itEnd ; ++it )
			{
				tmpRID = getRuntime(tmpRID).getChild((*it)->getOffset());
			}

			AVM_OS_ASSERT_FATAL_ERROR_EXIT(
				tmpRID.getExecutable()->getBuffer().at( anInstance
				->getOffset() ).isAstElement( anInstance->getAstElement() ) )
					<< "Assign error " << tmpRID.getExecutable()->getBuffer().at(
							anInstance->getOffset()).getFullyQualifiedNameID()
					<< " != " << anInstance->getFullyQualifiedNameID()
					<< SEND_EXIT;

			return( getRuntime(tmpRID).getChild(anInstance->getOffset()) );
		}
	}

//	if( anInstance->getSpecifier().isDesignInstanceStatic() )
	{
		for( RuntimeID aRID = mRID ; aRID.valid() ; aRID = aRID.getPRID() )
		{
			if( anInstance->getContainer() == aRID.getExecutable() )
			{
				return( getRuntime(aRID).getChild(anInstance->getOffset()) );
			}
		}
	}
//	else if( anInstance->getSpecifier().isDesignModel() )
//	{
//		return( mTableOfRuntimeForm->getRID(anInstance->getExecutable()) );
//	}

	TableOfRuntimeT::const_iterator it = mTableOfRuntime.begin();
	TableOfRuntimeT::const_iterator itEnd = mTableOfRuntime.end();
	for( ; it != itEnd ; ++it )
	{
		if( (*it)->getRID().getInstance() == anInstance )
		{
			return( (*it)->getRID() );
		}
	}

	return( RuntimeID::REF_NULL );
}


const RuntimeID & ExecutionData::getRuntimeID(
		const std::string & aFullyQualifiedNameID) const
{
	TableOfRuntimeT::const_iterator it = mTableOfRuntime.begin();
	TableOfRuntimeT::const_iterator itEnd = mTableOfRuntime.end();
	for( ; it != itEnd ; ++it )
	{
		if( NamedElement::compareLocation(
				(*it)->getFullyQualifiedNameID(), aFullyQualifiedNameID) )
		{
			return( (*it)->getRID() );
		}
	}

	return( RuntimeID::REF_NULL );
}

const RuntimeID & ExecutionData::getRuntimeIDByNameID(
		const std::string & aNameID) const
{
	TableOfRuntimeT::const_iterator it = mTableOfRuntime.begin();
	TableOfRuntimeT::const_iterator itEnd = mTableOfRuntime.end();
	for( ; it != itEnd ; ++it )
	{
		if( (*it)->getNameID() == aNameID )
		{
			return( (*it)->getRID() );
		}
	}

	return( RuntimeID::REF_NULL );
}


RuntimeID ExecutionData::getRuntimeContainerRID(
		const RuntimeID & aRID, BaseInstanceForm * anInstance) const
{
	if( anInstance->hasRuntimeContainerRID() )
	{
		return( anInstance->getRuntimeContainerRID() );
	}
	else if( anInstance->isAlias() )
	{
		RuntimeID tmpRID = aRID;

		if( anInstance->hasAliasTarget() &&
				anInstance->getAliasTarget()->hasRuntimeContainerRID() )
		{
			anInstance->setRuntimeContainerRID( tmpRID =
					anInstance->getAliasTarget()->getRuntimeContainerRID() );

			return( tmpRID );
		}

		ArrayOfInstanceOfMachine::iterator it =
				anInstance->getMachinePath()->begin();

		// SEARCH of the LCA(RID) of the current RID an the ALIAS container
		tmpRID = tmpRID.getAncestorContaining( *it );
		if( tmpRID.valid() )
		{
			ArrayOfInstanceOfMachine::iterator itEnd =
					anInstance->getMachinePath()->end();

			// Use of Alias PATH to find the INSTANCE of variable
			for( ; it != itEnd ; ++it )
			{
				tmpRID = getRuntimeFormChild(tmpRID, (*it));
			}

			AVM_OS_ASSERT_FATAL_ERROR_EXIT(
				tmpRID.getExecutable()->getBuffer().at( anInstance
				->getOffset() ).isAstElement( anInstance->getAstElement() ) )
					<< "Assign error " << tmpRID.getExecutable()->getBuffer().
						at(anInstance->getOffset()).getFullyQualifiedNameID()
					<< " != " << anInstance->getFullyQualifiedNameID()
					<< SEND_EXIT;

			return( tmpRID );
		}
	}
	else
	{
		// SEARCH of the RUNTIME FORM container
		// where this INSTANCE of variable was declared
		return( aRID.getAncestorContaining( anInstance ) );
	}

	return( RuntimeID::REF_NULL );
}


/**
 * GETTER
 * for data in RuntimeForm DataTable
 */
//const BF & ExecutionData::getData(const std::string & aFullyQualifiedNameID) const
//{
//	TableOfRuntimeT::const_iterator it = mTableOfRuntime.begin();
//	TableOfRuntimeT::const_iterator itEnd = mTableOfRuntime.end();
//	for( ; it != itEnd ; ++it )
//	{
//		const BF & foundData = (*it)->getData(aFullyQualifiedNameID);
//		if( foundData.valid() )
//		{
//			return( foundData );
//		}
//	}
//
//	return( BF::REF_NULL );
//}

const BF & ExecutionData::getDataByQualifiedNameID(
		const std::string & aQualifiedNameID, InstanceOfData * & var) const
{
	TableOfRuntimeT::const_iterator it = mTableOfRuntime.begin();
	TableOfRuntimeT::const_iterator itEnd = mTableOfRuntime.end();
	for( ; it != itEnd ; ++it )
	{
		const BF & foundData =
				 (*it)->getDataByQualifiedNameID(aQualifiedNameID, var);
		if( foundData.valid() )
		{
			return( foundData );
		}
	}

	return( BF::REF_NULL );
}

const BF & ExecutionData::getDataByNameID(const std::string & aNameID) const
{
	TableOfRuntimeT::const_iterator it = mTableOfRuntime.begin();
	TableOfRuntimeT::const_iterator itEnd = mTableOfRuntime.end();
	for( ; it != itEnd ; ++it )
	{
		const BF & foundData = (*it)->getDataByNameID(aNameID);
		if( foundData.valid() )
		{
			return( foundData );
		}
	}

	return( BF::REF_NULL );
}


/**
 * GETTER
 * mSaveTableOfAssignedFlag
 */
TableOfRuntimeFormState::TableOfAssignedFlag
ExecutionData::getSaveTableOfAssignedFlag() const
{
	return( mExecutionContext->getTableOfAssignedFlag() );
}



/**
 * GETTER
 * tableOfRuntimeFormState
 */
bool ExecutionData::checkRunningForm(const BF & aRunnableElementTrace,
		const RuntimeID & aRID)
{
	if( aRunnableElementTrace.is< ExecutionConfiguration >() )
	{
		ExecutionConfiguration * anExecConf =
				aRunnableElementTrace.to_ptr< ExecutionConfiguration >();

		return( anExecConf->getRuntimeID() == aRID );
	}

	else if( aRunnableElementTrace.is< AvmCode >() )
	{
		AvmCode * aCode = aRunnableElementTrace.to_ptr< AvmCode >();

		for( AvmCode::iterator it = aCode->begin() ; it != aCode->end() ; ++it )
		{
			if( checkRunningForm(*it, aRID) )
			{
				return( true );
			}
		}
	}

	return( false);
}


/**
 * INSTANCIATION BOUND TEST
 */
bool ExecutionData::couldBeInstanciated(InstanceOfMachine * anInstance) const
{
	ExecutableForm * anExecutable = anInstance->getExecutable();

	if( anExecutable->hasMaximalInstance() )
	{
		avm_size_t anInstanciationCount = 0;

		TableOfRuntimeT::const_iterator it = mTableOfRuntime.begin();
		TableOfRuntimeT::const_iterator endIt = mTableOfRuntime.end();
		for( ; it != endIt ; ++it )
		{
			if( (*it)->getExecutable() == anExecutable )
			{
				++anInstanciationCount;
			}
		}

//!![TRACE]: to delete
//AVM_OS_DEBUG << "Instanciation Count: " << anInstanciationCount
//		<< " ?<=? max: " << anExecutable->getMaximalInstanceCount() << std::endl;

		return( anInstanciationCount <= anExecutable->getMaximalInstanceCount() );
	}

	return( true );
}




/**
 * string of a state configuration of an ExecutionData
 */
void ExecutionData::toStreamStateIdleOrRunning(
		OutStream & os, const RuntimeForm & aRF) const
{
	if( aRF.hasOnSchedule()
		&& aRF.getOnSchedule()->singleton()
		&& aRF.getOnSchedule()->first().is< RuntimeID >()
		/*&& (aRF.getRID() != aRF.getOnSchedule()->first().bfRID())*/ )
	{
		if( aRF.getExecutable()->hasTransition() )
		{
			os << aRF.getRID().strUniqId() << " ( ";
		}

		if( isIdleOrRunning(aRF.getOnSchedule()->first().bfRID()) )
		{
			toStreamStateIdleOrRunning(os,
					getRuntime(aRF.getOnSchedule()->first().bfRID()) );

			if( aRF.getExecutable()->hasTransition() )
			{
				os << " )";
			}
		}
	}

	else if( aRF.hasChild() )
	{
		TableOfRuntimeID::const_iterator itRID = aRF.beginChild();
		TableOfRuntimeID::const_iterator itRIDEnd = aRF.endChild();

		if( aRF.getExecutable()->hasTransition() )
		{
			os << aRF.getRID().strUniqId() << " ";
		}

		bool needComa = false;
		for( ; itRID != itRIDEnd ; ++itRID )
		{
			if( isIdleOrRunning( *itRID ) )
			{
				if( needComa )
				{
					os << " , ";
				}
				else
				{
					os << "( ";
					needComa = true;
				}
				toStreamStateIdleOrRunning(os, getRuntime(*itRID));
			}
		}
		if( needComa )
		{
			os << " )";
		}
	}
	else
	{
		os << aRF.getRID().strUniqId();
	}
}


/**
 * string of a state configuration of an ExecutionData
 *
 * LIFELINE STATE IDENTIFIER
 * %1% --> lifeline runtime pid
 * %2% --> lifeline identifier
 * %3% --> state runtime pid
 * %4% --> state identifier
 */
OutStream & ExecutionData::toStreamLifelineStateFormat(
		OutStream & os, const RuntimeForm & aRF,
		const std::string & formatLifelineStatePattern) const
{
	boost::format formatter(formatLifelineStatePattern);
	formatter.exceptions( boost::io::no_error_bits );

	RuntimeID ridLifeline = aRF.getRID().getLifeline();

	os << formatter
			% ridLifeline.strPid()
			% ridLifeline.getInstance()->getNameID()
			% aRF.getRID().strPid()
			% aRF.getRID().getNameID();

	return( os );
}


void ExecutionData::toStreamStateConf(
		OutStream & os, const RuntimeForm & aRF,
		const std::string & formatLifelineStatePattern) const
{
	if ( aRF.hasOnSchedule() )
	{
		if( aRF.getOnSchedule()->singleton()
			&& aRF.getOnSchedule()->first().is< RuntimeID >()
			&& (aRF.getRID() != aRF.getOnSchedule()->first().bfRID()) )
		{
			if( aRF.getExecutable()->hasTransition() )
			{
				toStreamLifelineStateFormat(os, aRF, formatLifelineStatePattern)
						<< " ( ";
			}

			toStreamStateConf(os,
					getRuntime( aRF.getOnSchedule()->first().bfRID() ),
					formatLifelineStatePattern );

			if( aRF.getExecutable()->hasTransition() )
			{
				os << " )";
			}

			return;
		}
	}

	if( aRF.hasChild() )
	{
		TableOfRuntimeID::const_iterator itRID = aRF.beginChild();
		TableOfRuntimeID::const_iterator itRIDEnd = aRF.endChild();

		if( aRF.getExecutable()->hasTransition() )
		{
			toStreamLifelineStateFormat(os, aRF, formatLifelineStatePattern)
					<< " ";
		}

		os << "( ";
		for( bool needComa = false ; itRID != itRIDEnd ; ++itRID )
		{
			if( (*itRID).getExecutable()->hasOnInitOrEnableOrRun() )
			{
				if( isRunnable( *itRID ) || isFinalizedOrDestroyed( *itRID ) )
				{
					if( needComa )
					{
						os << " , ";
					}
					else
					{
						needComa = true;
					}
					toStreamStateConf(os, getRuntime(*itRID),
							formatLifelineStatePattern );
				}
			}
		}
		os << " )";
	}
	else
	{
		if( isFinalized( aRF.getRID() ) )
		{
			os << "<final>";
		}
		else if( isDestroyed( aRF.getRID() ) )
		{
			os << "<destroy>";
		}

		toStreamLifelineStateFormat(os, aRF, formatLifelineStatePattern);
	}
}


/**
 * string of a state configuration of an ExecutionData to Fscn
 */
void ExecutionData::toStreamStateConfToFscn(
		OutStream & os, const RuntimeForm & aRF) const
{
	if ( aRF.hasOnSchedule() )
	{
		if( aRF.getOnSchedule()->singleton()
			&& aRF.getOnSchedule()->first().is< RuntimeID >()
			&& getRuntime(aRF.getOnSchedule()->first().bfRID()).isInstanciated() )
		{
			toStreamStateConfToFscn(os,
					getRuntime( aRF.getOnSchedule()->first().bfRID() ) );

			return;
		}
	}

	if( aRF.hasChild() )
	{
		TableOfRuntimeID::const_iterator itRID = aRF.beginChild();
		TableOfRuntimeID::const_iterator itRIDEnd = aRF.endChild();

		os << "( " ;
		for( bool needComa = false ; itRID != itRIDEnd ; ++itRID )
		{
			if( (*itRID).getExecutable()->hasOnInitOrEnableOrRun()
				&& getRuntime(*itRID).isInstanciated() )
			{
				if( needComa )
				{
					os << " , ";
				}
				else
				{
					needComa = true;
				}
				toStreamStateConfToFscn(os, getRuntime((*itRID)) );
			}
		}
		os << " )";
	}
	else
	{
		os << aRF.getRID().strUniqId();
	}
}


/**
 * Serialization
 */
void ExecutionData::toStream(OutStream & os) const
{
	os << TAB << "ed";

	const std::string conf = strStateConf();
	if( conf[0] == '(' )
	{
		os << conf;
	}
	else
	{
		os << '(' << conf << ')';
	}

	AVM_DEBUG_REF_COUNTER(os);
	os << " {" << EOL_FLUSH;

//	os << TAB2 << "name = \"" << strStateConf() << "\";" << EOL_FLUSH;

	if ( hasRunnableElementTrace() )
	{
		os << TAB2 << "fired = " << getRunnableElementTrace().str()
				<< ";" << EOL_FLUSH;
	}

	if ( hasIOElementTrace() )
	{
		os << TAB2 << "trace = " << getIOElementTrace().str() << ";" << EOL_FLUSH;
	}

	os << TAB2 << "exec_status = "
			<< RuntimeDef::strAEES( getAEES() ) << ";" << EOL_FLUSH;

	if ( hasNodeCondition() && getNodeCondition().isNotEqualTrue() )
	{
		os << TAB2 << "firedcondition = "
				<< getNodeCondition().wrapStr( os.INDENT.tab2Size(18) )
				<< ";" << EOL;
	}

	if ( hasNodeTimedCondition() &&
		getNodeTimedCondition().isNotEqualTrue() )
	{
		os << TAB2 << "firedtimedcondition = "
				<< getNodeTimedCondition().wrapStr( os.INDENT.tab2Size(23) )
				<< ";" << EOL;
	}

	if( hasPathCondition() && getPathCondition().isNotEqualTrue() )
	{
		os << TAB2 << "pathcondition = "
				<< getPathCondition().wrapStr( os.INDENT.tab2Size(17) )
				<< ";";
		getPathCondition().AVM_DEBUG_REF_COUNTER(os);
		os << EOL_FLUSH;
	}
	else if( not hasPathCondition() )
	{
		os << TAB2 << "pathcondition = NULL;" << EOL;
	}

	if( hasPathTimedCondition() && getPathTimedCondition().isNotEqualTrue() )
	{
		os << TAB2 << "pathtimedcondition = "
				<< getPathTimedCondition().wrapStr( os.INDENT.tab2Size(22) )
				<< ";";
		getPathTimedCondition().AVM_DEBUG_REF_COUNTER(os);
		os << EOL_FLUSH;
	}
	else if( not hasPathTimedCondition() )
	{
		os << TAB2 << "pathtimedcondition = NULL;" << EOL;
	}

	os << TAB2 << "@init{" << INCR2_INDENT;
	getOnInit()->toStreamRoutine( os );
	os << DECR2_INDENT_TAB2 << "}" << EOL_FLUSH;

	os << TAB2 << "@schedule{" << INCR2_INDENT;
	getOnSchedule()->toStreamRoutine( os );
	os << DECR2_INDENT_TAB2 << "}" << EOL_FLUSH;

	os << TAB2 << "rid = " << getRID().str() << ";" << EOL_FLUSH;


//	if( hasParam() )
//	{
//		os << EOL;
//		os << TAB << "parameter:";
//		tableOfParam->AVM_DEBUG_REF_COUNTER(os);
//		os << EOL;
//
//		tableOfParam->toStream(os);
//	}


//AVM_IF_DEBUG_ENABLED_AND( hasTableOfRID() )
//	os << EOL;
//
//	AVM_IF_DEBUG_LEVEL_GT_MEDIUM
//		os << TAB << "rid:" << EOL_INCR_INDENT;
//		TableOfRuntimeID::const_iterator it = mTableOfRID->begin();
//		TableOfRuntimeID::const_iterator itEnd = mTableOfRID->end();
//		for( ; it != itEnd ; ++it )
//		{
//			(*it).toStream(os);
//		}
//		os << DECR_INDENT;
//	AVM_ELSEIF_DEBUG_LEVEL_GT_LOW
//		os << TAB2 << "rid = [| ";
//		TableOfRuntimeID::const_iterator it = mTableOfRID->begin();
//		TableOfRuntimeID::const_iterator itEnd = mTableOfRID->end();
//		for( ; it != itEnd ; ++it )
//		{
//			os << (*it).getOffset() << " ";
//		}
//		os << "|];" << EOL_FLUSH;
//	AVM_ENDIF_DEBUG_LEVEL_GT_LOW
//AVM_ENDIF_DEBUG_ENABLED_AND


	if( hasLocalRuntimeStack() )
	{
		os << EOL_TAB << "local: ";
		getLocalRuntimes()->AVM_DEBUG_REF_COUNTER(os);

		os << EOL_INCR_INDENT;
		getLocalRuntimes()->toStream(os);
		os << DECR_INDENT;
	}

	if ( getTableOfRuntime().nonempty() )
	{
		os << EOL_TAB << "runtime#state:" << EOL_INCR_INDENT;
		mTableOfRFStateFlags->toStream(*this, os);

		os << EOL_DECR_INDENT << TAB << "runtime:" << EOL_INCR_INDENT;

AVM_IF_DEBUG_LEVEL_GTE_MEDIUM
		TableOfRuntimeT::const_iterator it = mTableOfRuntime.begin();
		TableOfRuntimeT::const_iterator itEnd = mTableOfRuntime.end();
		for( ; it != itEnd ; ++it )
		{
			(*it)->toStream(this, os);
		}
AVM_ENDIF_DEBUG_LEVEL_GTE_MEDIUM

		os << DECR_INDENT;
	}

	if( mSTATEMENT_QUEUE.nonempty() )
	{
		os << EOL_INCR_INDENT;
		mSTATEMENT_QUEUE.toStream(os);
		os << DECR_INDENT;
	}

	if( mEXEC_SYNC_POINT != NULL )
	{
		os << EOL_INCR_INDENT;
		mEXEC_SYNC_POINT->toStream(os);
		os << DECR_INDENT;
	}

	os << TAB << "}" << EOL_FLUSH;
}

void ExecutionData::toStreamData(OutStream & os) const
{

	os << TAB << "ed<data>";
	AVM_DEBUG_REF_COUNTER(os);
	os << " {" << EOL;

	os << TAB2 << "name = \"" << strStateConf() << "\";" << EOL_FLUSH;


	if ( hasRunnableElementTrace() )
	{
		os << TAB2 << "fired = " << getRunnableElementTrace().str()
					<< ";" << EOL_FLUSH;
	}

	if ( hasIOElementTrace() )
	{
		os << TAB2 << "trace = " << getIOElementTrace().str() << ";" << EOL_FLUSH;
	}

	os << TAB2 << "exec_status = "
			<< RuntimeDef::strAEES( getAEES() ) << ";" << EOL_FLUSH;

	if ( hasNodeCondition() && getNodeCondition().isNotEqualTrue() )
	{
		os << TAB2 << "nodecondition = "
				<< getNodeCondition().wrapStr( os.INDENT.tab2Size(18) )
				<< ";" << EOL_FLUSH;
	}

	if ( hasPathCondition() && getPathCondition().isNotEqualTrue() )
	{
		os << TAB2 << "pathcondition = "
				<< getPathCondition().wrapStr( os.INDENT.tab2Size(17) )
				<< ";" << EOL_FLUSH;
	}

	if( hasOnInit() )
	{
		os << TAB2 << "@init{" << INCR2_INDENT;
		getOnInit()->toStreamRoutine( os );
		os << DECR2_INDENT_TAB2 << "}" << EOL_FLUSH;
	}

	if( hasOnSchedule() )
	{
		os << TAB2 << "@schedule{" << INCR2_INDENT;
		getOnSchedule()->toStreamRoutine( os );
		os << DECR2_INDENT_TAB2 << "}" << EOL_FLUSH;
	}

//	if( hasParam() )
//	{
//		os << EOL;
//		os << TAB << "parameter:" << EOL;
//		tableOfParam->toStream(os, TAB2, CHAR, EOL);
//	}

	if ( getTableOfRuntime().nonempty() )
	{
		os << EOL_TAB << "runtime:" << EOL_INCR_INDENT;

		TableOfRuntimeT::const_iterator it = mTableOfRuntime.begin();
		TableOfRuntimeT::const_iterator itEnd = mTableOfRuntime.end();
		for( ; it != itEnd ; ++it )
		{
			if( (*it)->hasDataTable() )
			{
				(*it)->toStreamData(this, os);
			}
		}

		os << DECR_INDENT;
	}

	if( mSTATEMENT_QUEUE.nonempty() )
	{
		os << EOL_INCR_INDENT;
		mSTATEMENT_QUEUE.toStream(os);
		os << DECR_INDENT;
	}

	if( mEXEC_SYNC_POINT != NULL )
	{
		os << EOL_INCR_INDENT;
		mEXEC_SYNC_POINT->toStream(os);
		os << DECR_INDENT;
	}

	os << TAB << "}" << EOL_FLUSH;
}

void ExecutionData::toFscn(OutStream & os,
		const ExecutionData * aPreviousExecData) const
{
//	os << TAB << "SC: " << strStateConfToFscn() << EOL;

	if( (aPreviousExecData == NULL)
		|| (aPreviousExecData->getPathCondition()
			!= getPathCondition()) )
	{
		os << TAB << "PC: "
				<< getPathCondition().wrapStr( os.INDENT.tab2Size(4) )
				<< EOL;
	}

	if( (aPreviousExecData == NULL)
		|| (aPreviousExecData->getPathTimedCondition()
			!= getPathTimedCondition()) )
	{
		os << TAB << "PtC: "
				<< getPathTimedCondition().wrapStr( os.INDENT.tab2Size(5) )
				<< EOL;
	}

	// DATA
	StringOutStream oss( os.INDENT );
	oss << INCR_INDENT;

	TableOfRuntimeT::const_iterator it = mTableOfRuntime.begin();
	TableOfRuntimeT::const_iterator itEnd = mTableOfRuntime.end();

	if( aPreviousExecData != NULL )
	{
		TableOfRuntimeT::const_iterator itPrev =
				aPreviousExecData->mTableOfRuntime.begin();
		TableOfRuntimeT::const_iterator itPrevEnd =
				aPreviousExecData->mTableOfRuntime.end();
		TableOfRuntimeT::const_iterator it = mTableOfRuntime.begin();
		TableOfRuntimeT::const_iterator itEnd = mTableOfRuntime.end();
		for( ; (it != itEnd) && (itPrev != itPrevEnd) ; ++it , ++itPrev )
		{
			if( (*it)->hasDataTable() && (*it)->isNTEQ(*itPrev) )
			{
				(*it)->toFscnData(oss, this, *itPrev);
			}
		}

		for( ; (it != itEnd) ; ++it)
		{
			if( (*it)->hasDataTable() )
			{
				(*it)->toFscnData(oss, this, NULL);
			}
		}
	}
	else
	{
		TableOfRuntimeT::const_iterator it = mTableOfRuntime.begin();
		TableOfRuntimeT::const_iterator itEnd = mTableOfRuntime.end();
		for( ; it != itEnd ; ++it )
		{
			if( (*it)->hasDataTable() )
			{
				(*it)->toFscnData(oss, this, NULL);
			}
		}
	}

	if( not oss.str().empty() )
	{
		os << TAB << "DATA{" << EOL;
		os << oss.str();
		os << TAB << "}" << EOL;
	}
	// END DATA

	// BUFFER
	StringOutStream osb( os.INDENT );
	osb << INCR_INDENT;

	it = getTableOfRuntime().begin();
	itEnd = getTableOfRuntime().end();

	if( aPreviousExecData != NULL )
	{
		TableOfRuntimeT::const_iterator itPrev =
				aPreviousExecData->getTableOfRuntime().begin();
		TableOfRuntimeT::const_iterator itPrevEnd =
				aPreviousExecData->getTableOfRuntime().end();
		for( ; (it != itEnd) && (itPrev != itPrevEnd) ; ++it , ++itPrev )
		{
			if( (*it)->hasBufferTable() && (*it)->isNTEQ(*itPrev) )
			{
				(*it)->toFscnBuffer(osb, this, (*itPrev));
			}
		}

		for( ; (it != itEnd) ; ++it)
		{
			if( (*it)->hasBufferTable() )
			{
				(*it)->toFscnBuffer(osb, this, NULL);
			}
		}
	}
	else
	{
		TableOfRuntimeT::const_iterator it = mTableOfRuntime.begin();
		TableOfRuntimeT::const_iterator itEnd = mTableOfRuntime.end();
		for( ; it != itEnd ; ++it )
		{
			if( (*it)->hasBufferTable() )
			{
				(*it)->toFscnBuffer(osb, this, NULL);
			}
		}
	}

	if( not osb.str().empty() )
	{
		os << TAB << "BUFFER{" << EOL;
		os << osb.str();
		os << TAB << "}" << EOL;
	}
	// END BUFFER


	if( mSTATEMENT_QUEUE.nonempty() )
	{
		os << TAB << "/*" << EOL;
		mSTATEMENT_QUEUE.toStream(os);
		os << TAB << "*/" << EOL;
	}

	if( mEXEC_SYNC_POINT != NULL )
	{
		os << TAB << "/*" << EOL;
		mEXEC_SYNC_POINT->toStream(os);
		os << TAB << "*/" << EOL;
	}
}



////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

/**
 * DEFAULT NULL
 */
APExecutionData APExecutionData::REF_NULL;



/**
 * GETTER - SETTER
 * the Previous ExecutionData
 */

APExecutionData & APExecutionData::getPrevious()
{
	return( raw_pointer()->getExecutionContext()->getPreviousExecutionData() );
}

const APExecutionData & APExecutionData::getPrevious() const
{
	return( raw_pointer()->getExecutionContext()->getPreviousExecutionData() );
}

bool APExecutionData::hasPrevious() const
{
	return( raw_pointer()->hasExecutionContext() &&
			raw_pointer()->getExecutionContext()->hasPrevious() );
}



}