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

#ifndef ABSTRACTPROCESSORUNIT_H_
#define ABSTRACTPROCESSORUNIT_H_

#include <common/RunnableElement.h>
#include <fam/api/IProcessorUnitTest.h>
#include <fam/api/ProcessorUnitAutoRegistration.h>

#include <computer/EvaluationEnvironment.h>

#include <fml/runtime/ExecutionContext.h>

#include <fml/workflow/WObject.h>


namespace sep
{


typedef avm_uint8_t  avm_computing_process_stage_t;

enum {
	AVM_UNDEFINED_STAGE            = 0x0000,

	AVM_PRE_PROCESSING_STAGE       = 0x0001,
	AVM_POST_PROCESSING_STAGE      = 0x0002,

	AVM_PREPOST_PROCESSING_STAGE   = AVM_PRE_PROCESSING_STAGE
	                               | AVM_POST_PROCESSING_STAGE,

	AVM_PRE_FILTERING_STAGE        = 0x0004,
	AVM_POST_FILTERING_STAGE       = 0x0008,

	AVM_PREPOST_FILTERING_STAGE    = AVM_PRE_FILTERING_STAGE
	                               | AVM_POST_FILTERING_STAGE,

	AVM_COMPUTING_ALL_STAGE        = AVM_PREPOST_PROCESSING_STAGE
	                               | AVM_PREPOST_FILTERING_STAGE,

	AVM_COMPUTING_COMPOSITE_STAGE  = 0x0010,

};


class WaitingStrategy;
class AvmPrimitiveProcessor;

class Builder;

class Configuration;

class ExecutableForm;
class ExecutionContext;
class ExecutionQueue;

class MainProcessorUnit;

class SymbexDispatcher;
class SymbexControllerRequestManager;
class SymbexControllerUnitManager;
class SymbexEngine;
class SymbexEventManager;


////////////////////////////////////////////////////////////////////////////////
// FORMAL ANALYSIS MODULE POINTER
////////////////////////////////////////////////////////////////////////////////

class AbstractProcessorUnit :
		public RunnableElement ,
		public IProcessorUnitTest ,
		AVM_INJECT_INSTANCE_COUNTER_CLASS( AbstractProcessorUnit )
{

public:
	/**
	 * PROCESSOR FACTORY
	 * for automatic registration in the processor repository
	 */
	virtual const IProcessorUnitRegistration & REGISTER_TOOL() const = 0;

	inline bool isRegisterTool(
			const IProcessorUnitRegistration & aRegisterTool) const
	{
		return( REGISTER_TOOL().isEquals( aRegisterTool ) );
	}


protected:
	/**
	 * ATTRIBUTES
	 */
	SymbexControllerUnitManager & mControllerUnitManager;

	EvaluationEnvironment ENV;

	avm_computing_process_stage_t mComputingStageRequired;
	avm_computing_process_stage_t mComputingStageEnabled;

	bool mAutoConfigure;
	bool mAutoStart;

	avm_uint8_t mPrecedenceOfPreProcess;
	avm_uint8_t mPrecedenceOfPostProcess;

	avm_uint8_t mPrecedenceOfInitFilter;

	avm_uint8_t mPrecedenceOfPreFilter;
	avm_uint8_t mPrecedenceOfPostFilter;

	avm_size_t mBeginningStepTimout;

	avm_size_t mSliceCount;

	// For eval / report Trace format
	std::string mPreEvalTraceFormatter;
	std::string mPostEvalTraceFormatter;

	std::string mBoundEvalTraceFormatter;
	std::string mReportEvalTraceFormatter;

	////////////////////////////////////////////////////////////////////////////
	// Computing Variables
	ListOfExecutionContext * ecQueue;

	ListOfExecutionContext::iterator ecQueueIt;
	ListOfExecutionContext::iterator ecQueueItEnd;

	ExecutionContext::rw_child_iterator ecChildIt;
	ExecutionContext::rw_child_iterator ecChildItEnd;


public:
	/*
	 * Precedence for processor, based on resource consumption,
	 * used to order processor in the Diversity process !
	 * For info: 0 for minimum resource requirement reserved by STOP CRITERIA FILTER,
	 * and 255 maximum value for example REDUNDANCY FILTER
	 * Default value is the max !
	 * Processing: pre  = 255  , post = 255
	 * Filtering : init = 255
	 * Filtering : pre  = 255  , post = 255
	 */
	static const avm_uint8_t DEFAULT_PRECEDENCE_OF_PROCESSOR[5];

	static const avm_uint8_t DEFAULT_PRECEDENCE_OF_MAIN_PROCESSOR[5];


	static const avm_uint8_t PRECEDENCE_OF_ACTIVE_COVERAGE_PROCESSOR[5];

	static const avm_uint8_t PRECEDENCE_OF_PASSIVE_COVERAGE_PROCESSOR[5];


	static const avm_uint8_t PRECEDENCE_OF_MAIN_PROCESSOR[5];

	static const avm_uint8_t PRECEDENCE_OF_EXTENDER_PROCESSOR[5];

	static const avm_uint8_t PRECEDENCE_OF_REDUNDANCY[5];


	static const avm_uint8_t PRECEDENCE_OF_TRANSITION_COVERAGE[5];

	static const avm_uint8_t PRECEDENCE_OF_HIT_OR_JUMP[5];


	static const avm_uint8_t PRECEDENCE_OF_FORMULA_COVERAGE[5];

	static const avm_uint8_t PRECEDENCE_OF_MACHINE_COVERAGE[5];

	static const avm_uint8_t PRECEDENCE_OF_TEST_OFFLINE[5];


	static const avm_uint8_t DEFAULT_PRECEDENCE_OF_SERIALIZER_PROCESSOR[5];


	/**
	 * CONSTRUCTOR
	 * Default
	 */
	AbstractProcessorUnit(
			SymbexControllerUnitManager & aManager, WObject * wfParameterObject,
			avm_computing_process_stage_t requiredStage,
			const avm_uint8_t * aPrecedence = DEFAULT_PRECEDENCE_OF_PROCESSOR);

	AbstractProcessorUnit(
			SymbexControllerUnitManager & aManager, WObject * wfParameterObject,
			const avm_uint8_t * aPrecedence = DEFAULT_PRECEDENCE_OF_PROCESSOR);

	/**
	 * CONSTRUCTOR
	 * Other
	 */
	AbstractProcessorUnit(class_kind_t aClassKind,
			SymbexControllerUnitManager & aManager, WObject * wfParameterObject);

	AbstractProcessorUnit(class_kind_t aClassKind, SymbexEngine & anEngine,
			SymbexControllerUnitManager & aManager, WObject * wfParameterObject);


	/**
	 * DESTRUCTOR
	 */
	virtual ~AbstractProcessorUnit()
	{
		//!! NOTHING
	}


	/**
	 * GETTERS
	 * mPrecedenceOfPreProcess
	 * mPrecedenceOfPostProcess
	 */
	avm_uint8_t getPrecedenceOfPreProcess() const
	{
		return mPrecedenceOfPreProcess;
	}

	avm_uint8_t getPrecedenceOfPostProcess() const
	{
		return mPrecedenceOfPostProcess;
	}

	/**
	 * GETTERS
	 * mPrecedenceOfInitFilter
	 * mPrecedenceOfPreFilter
	 * mPrecedenceOfPostFilter
	 */
	avm_uint8_t getPrecedenceOfInitFilter() const
	{
		return mPrecedenceOfInitFilter;
	}

	avm_uint8_t getPrecedenceOfPreFilter() const
	{
		return mPrecedenceOfPreFilter;
	}

	avm_uint8_t getPrecedenceOfPostFilter() const
	{
		return mPrecedenceOfPostFilter;
	}


	/**
	 * new local ExecutableForm for ProcessorT usage
	 */
	ExecutableForm * newLocalExecutableForm();


	/**
	 * GETTER
	 * mProcessorManager
	 */
	inline SymbexControllerUnitManager & getControllerUnitManager()
	{
		return( mControllerUnitManager );
	}

	inline const SymbexControllerUnitManager & getControllerUnitManager() const
	{
		return( mControllerUnitManager );
	}

	/**
	 * GETTER
	 * SymbexEngine
	 * Configuration
	 * SymbexDispatcher
	 *
	 */
	SymbexEngine & getSymbexEngine() const;

	Configuration & getConfiguration() const;

	SymbexDispatcher & getSymbexDispatcher() const;

	SymbexEventManager & getSymbexEventManager() const;

	SymbexControllerRequestManager & getSymbexRequestManager() const;


//	/**
//	 * GETTER
//	 * mProcessorManager
//	 */
//	MainProcessorUnit & getMainProcessor();
//
//	const MainProcessorUnit & getMainProcessor() const;
//
//
//	/**
//	 * GETTER
//	 * the Builder
//	 */
//	Builder & getBuilder();
//
//	/**
//	 * GETTER
//	 * AvmPrimitiveProcessor
//	 */
//	AvmPrimitiveProcessor & getPrimitiveProcessor();


	/**
	 * GETTER - SETTER
	 * theExecutionQueue
	 */
	ExecutionQueue & getExecutionQueue();


	/**
	 * GETTER
	 * EvaluationEnvironment ENV
	 */
	inline EvaluationEnvironment & getENV()
	{
		return( ENV );
	}


	////////////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////////
	// PLUGIN PROCESSOR KIND
	////////////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////////

	/**
	 * GETTER
	 * mAutoConfigure
	 */
	inline bool isAutoConfigure() const
	{
		return( mAutoConfigure );
	}

	/**
	 * GETTER - SETTER
	 * mComputingStageEnabled
	 */
#define DISABLE_PLUGIN( kind , FLAG )  kind &= ( ~ ( FLAG ) )

#define ENABLE_PLUGIN( kind , FLAG )   kind |= ( FLAG )


#define IS_DISABLE_PLUGIN( kind , FLAG )        ( (kind & ( FLAG )) == 0 )

#define IS_ENABLE_PLUGIN( kind , FLAG )         ( (kind & ( FLAG )) != 0 )

#define IS_STRONG_ENABLE_PLUGIN( kind , FLAG )  ( (kind & ( FLAG )) == ( FLAG ) )


	inline void enablePlugin(avm_computing_process_stage_t requiredStage,
			bool bEnabled = true)
	{
		if( bEnabled )
		{
			ENABLE_PLUGIN( mComputingStageEnabled , requiredStage );
		}
		else
		{
			DISABLE_PLUGIN( mComputingStageEnabled , requiredStage );
		}
	}

	inline bool isDisablePlugin() const
	{
		return( mComputingStageEnabled == AVM_UNDEFINED_STAGE );
	}

	inline bool isEnablePlugin() const
	{
		return( mComputingStageEnabled != AVM_UNDEFINED_STAGE );
	}

	inline bool isDisablePlugin(
			avm_computing_process_stage_t requiredStage) const
	{
		return( IS_DISABLE_PLUGIN(
				mComputingStageEnabled, requiredStage) );
	}

	inline bool isEnablePlugin(
			avm_computing_process_stage_t requiredStage) const
	{
		return( IS_STRONG_ENABLE_PLUGIN(
				mComputingStageEnabled, requiredStage) );
	}


	////////////////////////////////////////////////////////////////////////////
	// PRE PROCESS
	////////////////////////////////////////////////////////////////////////////

	inline void enablePreprocess(bool bEnabled = true)
	{
		enablePlugin( AVM_PRE_PROCESSING_STAGE , bEnabled );
	}

	void enablePreprocess(AbstractProcessorUnit * aProcessor);

	inline bool isDisablePreprocess() const
	{
		return( IS_DISABLE_PLUGIN(
				mComputingStageEnabled, AVM_PRE_PROCESSING_STAGE) );
	}

	inline bool isEnablePreprocess() const
	{
		return( IS_STRONG_ENABLE_PLUGIN(
				mComputingStageEnabled, AVM_PRE_PROCESSING_STAGE) );
	}


	// POST PROCESS
	inline void enablePostprocess(bool bEnabled = true)
	{
		enablePlugin( AVM_POST_PROCESSING_STAGE , bEnabled );
	}

	void enablePostprocess(AbstractProcessorUnit * aProcessor);

	inline bool isEnablePostprocess() const
	{
		return( IS_STRONG_ENABLE_PLUGIN(
				mComputingStageEnabled, AVM_POST_PROCESSING_STAGE) );
	}

	inline bool isDisablePostprocess() const
	{
		return( IS_DISABLE_PLUGIN(
				mComputingStageEnabled, AVM_POST_PROCESSING_STAGE) );
	}


	// PROCESS
	inline void enableProcess(bool bEnabled)
	{
		enablePlugin( AVM_PREPOST_PROCESSING_STAGE , bEnabled );
	}

	inline bool isStrongDisableProcess() const
	{
		return( IS_DISABLE_PLUGIN(
				mComputingStageEnabled, AVM_PREPOST_PROCESSING_STAGE) );
	}


	inline bool isStrongEnableProcess() const
	{
		return( IS_STRONG_ENABLE_PLUGIN(
				mComputingStageEnabled, AVM_PREPOST_PROCESSING_STAGE) );
	}

	inline bool isWeakEnableProcess() const
	{
		return( IS_ENABLE_PLUGIN(
				mComputingStageEnabled, AVM_PREPOST_PROCESSING_STAGE) );
	}


	////////////////////////////////////////////////////////////////////////////
	// PRE FILTER
	////////////////////////////////////////////////////////////////////////////

	inline void enablePrefilter(bool bEnabled = true)
	{
		enablePlugin( AVM_PRE_FILTERING_STAGE , bEnabled );
	}

	void enablePrefilter(AbstractProcessorUnit * aProcessor);

	inline bool isDisablePrefilter() const
	{
		return( IS_DISABLE_PLUGIN(
				mComputingStageEnabled, AVM_PRE_FILTERING_STAGE) );
	}

	inline bool isEnablePrefilter() const
	{
		return( IS_STRONG_ENABLE_PLUGIN(
				mComputingStageEnabled, AVM_PRE_FILTERING_STAGE) );
	}


	// POST FILTER
	inline void enablePostfilter(bool bEnabled = true)
	{
		enablePlugin( AVM_POST_FILTERING_STAGE , bEnabled );
	}

	void enablePostfilter(AbstractProcessorUnit * aProcessor);

	inline bool isEnablePostfilter() const
	{
		return( IS_STRONG_ENABLE_PLUGIN(
				mComputingStageEnabled, AVM_POST_FILTERING_STAGE) );
	}

	inline bool isDisablePostfilter() const
	{
		return( IS_DISABLE_PLUGIN(
				mComputingStageEnabled, AVM_POST_FILTERING_STAGE) );
	}


	// FILTER
	inline void enableFilter(bool bEnabled)
	{
		enablePlugin( AVM_PREPOST_FILTERING_STAGE , bEnabled );
	}

	inline bool isDisableFilter() const
	{
		return( IS_DISABLE_PLUGIN(
				mComputingStageEnabled, AVM_PREPOST_FILTERING_STAGE) );
	}

	inline bool isStrongEnableFilter() const
	{
		return( IS_STRONG_ENABLE_PLUGIN(
				mComputingStageEnabled, AVM_PREPOST_FILTERING_STAGE) );
	}

	inline bool requiresStrongEnableFilter() const
	{
		return( IS_STRONG_ENABLE_PLUGIN(
				mComputingStageRequired, AVM_PREPOST_FILTERING_STAGE) );
	}


	inline bool isWeakEnableFilter() const
	{
		return( IS_ENABLE_PLUGIN(
				mComputingStageEnabled, AVM_PREPOST_FILTERING_STAGE) );
	}


	////////////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////////
	// PLUGIN PROCESSOR API
	////////////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////////

	/**
	 * FORMATTER
	 */
	inline virtual std::string getDefaultPreEvalTraceFormatter() const
	{
		return( "" );
	}

	inline virtual std::string getDefaultPostEvalTraceFormatter() const
	{
		return( "" );
	}


	inline virtual std::string getDefaultBoundEvalTraceFormatter() const
	{
		return( "" );
	}

	inline virtual std::string getDefaultReportEvalTraceFormatter() const
	{
		return( "" );
	}


	////////////////////////////////////////////////////////////////////////////
	// CONFIGURE API
	////////////////////////////////////////////////////////////////////////////

	virtual bool preConfigure();

	virtual bool configure();

	virtual bool configureImpl() = 0;


	bool configureCommon();

	bool configureLog();

	bool checkingConfiguration();

	/**
	 * API
	 * Auto configure Model Of Execution in CPU
	 */
	virtual bool autoConfigureMOE();

	virtual bool autoConfigureMOEImpl();// = 0;


	////////////////////////////////////////////////////////////////////////////
	// INIT / EXIT  API
	////////////////////////////////////////////////////////////////////////////

	virtual bool initImpl()
	{
		//!! NOTHING
		return true;
	}

	virtual bool exitImpl()
	{
		//!! NOTHING
		return true;
	}


	////////////////////////////////////////////////////////////////////////////
	// FILTERING API
	////////////////////////////////////////////////////////////////////////////

	inline virtual bool filteringInitialize()
	{
		//!! NOTHING
		return( true );
	}

	inline virtual bool filteringFinalize()
	{
		//!! NOTHING
		return( true );
	}


	virtual bool prefilter();
	inline virtual bool prefilter(ExecutionContext & anEC)
	{
		//!! NOTHING
		return( true );
	}

	virtual bool postfilter();
	inline virtual bool postfilter(ExecutionContext & anEC)
	{
		//!! NOTHING
		return( true );
	}


	/**
	 * REPORT
	 */
	void reportHeader(OutStream & os, const std::string & processorName) const;

	virtual void reportDefault(OutStream & os) const;


	/**
	 * EVAL TRACE
	 */
	inline virtual void tracePreEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		AVM_VERBOSITY_SWITCH_SILENT

			traceSilentPreEval(os, anEC);

		AVM_VERBOSITY_SWITCH_CASE_MINIMUM

			traceMinimumPreEval(os, anEC);

		AVM_VERBOSITY_SWITCH_CASE_MEDIUM

			traceMediumPreEval(os, anEC);

		AVM_VERBOSITY_SWITCH_CASE_MAXIMUM

			traceMaximumPreEval(os, anEC);

		AVM_VERBOSITY_SWITCH_END
	}


	inline virtual void traceSilentPreEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		// SILENT => NOTHING
	}

	inline virtual void traceMinimumPreEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		traceDefaultPreEval(os, anEC);
	}

	inline virtual void traceMediumPreEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		traceDefaultPreEval(os, anEC);
	}

	inline virtual void traceMaximumPreEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		traceDefaultPreEval(os, anEC);
	}

	inline virtual void traceDefaultPreEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		//!! NOTHING
	}


	inline virtual void tracePostEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		AVM_VERBOSITY_SWITCH_SILENT

			traceSilentPostEval(os, anEC);

		AVM_VERBOSITY_SWITCH_CASE_MINIMUM

			traceMinimumPostEval(os, anEC);

		AVM_VERBOSITY_SWITCH_CASE_MEDIUM

			traceMediumPostEval(os, anEC);

		AVM_VERBOSITY_SWITCH_CASE_MAXIMUM

			traceMaximumPostEval(os, anEC);

		AVM_VERBOSITY_SWITCH_END
	}


	inline virtual void traceSilentPostEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		// SILENT => NOTHING
	}

	inline virtual void traceMinimumPostEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		traceDefaultPostEval(os, anEC);
	}

	inline virtual void traceMediumPostEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		traceDefaultPostEval(os, anEC);
	}

	inline virtual void traceMaximumPostEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		traceDefaultPostEval(os, anEC);
	}

	inline virtual void traceDefaultPostEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		//!! NOTHING
	}


	inline virtual void traceBoundEval(OutStream & os) const
	{
		//!! NOTHING
	}

	inline virtual void reportEval(OutStream & os) const
	{
		//!! NOTHING
	}


	////////////////////////////////////////////////////////////////////////////
	// PROCESSOR REQUEST API
	////////////////////////////////////////////////////////////////////////////

	/**
	 * STOP  | RELEASE
	 * RESET | RESTART | CONTINUE
	 * REQUEUE_WAITING | REQUEUE_RESERVE
	 * HEURISTIC | GOAL_ACHIEVED
	 */
	inline virtual void handleRequestStop()
	{
		//!! NOTHING
	}

	inline virtual void handleRequestRelease()
	{
		RunnableElement::setLifecycleReleased();
	}


	inline virtual void handleRequestReset()
	{
		//!! NOTHING
	}

	inline virtual void handleRequestRestart()
	{
		//!! NOTHING
	}

	inline virtual void handleRequestContinue()
	{
		//!! NOTHING
	}


	// the Waiting Queue Table
	inline virtual void handleRequestRequeueWaitingTable(
			WaitingStrategy & aWaitingStrategy,
			avm_uint8_t aWeightMin, avm_uint8_t aWeightMax)
	{
		//!! NOTHING
	}

	virtual void handleRequestRequeueReserveTable(
			WaitingStrategy & aWaitingStrategy,
			ListOfExecutionContext & aReserveQueue,
			avm_uint8_t aWeightMin, avm_uint8_t aWeightMax);


	inline virtual void handleRequestHeuristic()
	{
		//!! NOTHING
	}


	inline virtual void handleRequestGoalAchieved()
	{
		//!! NOTHING
	}


	////////////////////////////////////////////////////////////////////////////
	// REMOVE EC TOOLS
	////////////////////////////////////////////////////////////////////////////

	avm_size_t remove(ExecutionContext * anEC,
			OutStream & logger = AVM_OS_TRACE, const std::string & msg = "");


	////////////////////////////////////////////////////////////////////////////
	// FINAL SLICING TOOLS
	////////////////////////////////////////////////////////////////////////////
	virtual bool isSliceableContext(ExecutionContext & anEC) const;

	void computeLeafEC(const ListOfExecutionContext & listOfEC,
			ListOfExecutionContext & listOfLeafEC);

	void slice(ListOfExecutionContext & listOfLeafEC);

	void slice(ListOfExecutionContext & listOfLeafEC,
			ExecutionContext * leafEC);


	////////////////////////////////////////////////////////////////////////////
	// SERIALIZATION API
	////////////////////////////////////////////////////////////////////////////

	virtual std::string strTypeId() const
	{
		return( OSS() << "[p:" << (int)mPrecedenceOfPreProcess << ']'
				<< ( (mParameterWObject == WObject::_NULL_)
						? "fqn<process#unknown>"
						: mParameterWObject->hasQualifiedTypeNameID()
								? mParameterWObject->getQualifiedTypeNameID()
								: mParameterWObject->strUniqId() ) );
	}

	virtual std::string strUniqId() const
	{
		return( OSS() << "[p:" << (int)mPrecedenceOfPreProcess << ']'
				<< ( (mParameterWObject == NULL)
						? strFQN("null<WObject>")
						: mParameterWObject->strFQN("<unamed-fam>") ) );
	}

	virtual void toStream(OutStream & os) const
	{
		if( mParameterWObject != NULL )
		{
			mParameterWObject->toStream(os);
		}
		else
		{
			os << TAB << "null<WObject as Parameter>" << EOL;
		}
	}

};


////////////////////////////////////////////////////////////////////////////////
// FORMAL ANALYSIS MODULE SMART POINTER
////////////////////////////////////////////////////////////////////////////////

class FAM :
		public SmartPointer< AbstractProcessorUnit , DestroyElementPolicy >,
		AVM_INJECT_INSTANCE_COUNTER_CLASS( FAM )
{

private:
	/**
	 * TYPEDEF
	 */
	typedef SmartPointer< AbstractProcessorUnit ,
							DestroyElementPolicy >  base_this_type;


public:
	/**
	 * CONSTRUCTOR
	 * Default
	 */
	FAM()
	: base_this_type( )
	{
		//!! NOTHING
	}

	/**
	 * CONSTRUCTOR
	 * Default
	 */
	explicit FAM(AbstractProcessorUnit * aFAM)
	: base_this_type( aFAM )
	{
		//!! NOTHING
	}

public:
	/**
	 * DESTRUCTOR
	 */
	virtual ~FAM()
	{
		//!! NOTHING
	}


	////////////////////////////////////////////////////////////////////////////
	// COMPUTING STAGE ENABLED API
	////////////////////////////////////////////////////////////////////////////

	inline void enablePlugin(
			avm_computing_process_stage_t requiredStage,
			bool bEnabled = true)
	{
		mPTR->enablePlugin(requiredStage, bEnabled);
	}

	inline bool isDisablePlugin() const
	{
		return( mPTR->isDisablePlugin() );
	}

	inline bool isEnablePlugin() const
	{
		return( mPTR->isEnablePlugin() );
	}


	inline bool isEnablePreprocess() const
	{
		return( mPTR->isEnablePreprocess() );
	}

	inline bool isEnablePostprocess() const
	{
		return( mPTR->isEnablePostprocess() );
	}


	inline bool isEnablePrefilter() const
	{
		return( mPTR->isEnablePrefilter() );
	}

	inline bool isEnablePostfilter() const
	{
		return( mPTR->isEnablePostfilter() );
	}


	inline bool isWeakEnableFilter() const
	{
		return( mPTR->isWeakEnableFilter() );
	}


	////////////////////////////////////////////////////////////////////////////
	// CONFIGURE  API
	////////////////////////////////////////////////////////////////////////////

	inline WObject * getParameterWObject() const
	{
		return mPTR->getParameterWObject();
	}


	inline bool configure()
	{
		return mPTR->configure();
	}


	////////////////////////////////////////////////////////////////////////////
	// INIT / EXIT  API
	////////////////////////////////////////////////////////////////////////////

	inline bool init()
	{
		return mPTR->init();
	}

	inline bool exit()
	{
		return mPTR->exit();
	}


	////////////////////////////////////////////////////////////////////////////
	// ( PRE / POST ) PROCESS  API
	////////////////////////////////////////////////////////////////////////////

	inline bool preprocess()
	{
		return mPTR->preprocess();
	}

	inline bool postprocess()
	{
		return mPTR->postprocess();
	}


	////////////////////////////////////////////////////////////////////////////
	// FILTERING  API
	////////////////////////////////////////////////////////////////////////////

	inline bool filteringInitialize()
	{
		return mPTR->filteringInitialize();
	}

	inline bool filteringFinalize()
	{
		return mPTR->filteringFinalize();
	}


	////////////////////////////////////////////////////////////////////////////
	// ( PRE / POST ) FILTER  API
	////////////////////////////////////////////////////////////////////////////

	inline bool prefilter()
	{
		return mPTR->prefilter();
	}

	inline bool prefilter(ExecutionContext & anEC)
	{
		return mPTR->prefilter( anEC );
	}


	inline bool postfilter()
	{
		return mPTR->postfilter();
	}

	inline bool postfilter(ExecutionContext & anEC)
	{
		return mPTR->postfilter( anEC );
	}


	////////////////////////////////////////////////////////////////////////////
	// REPORT API
	////////////////////////////////////////////////////////////////////////////

	inline void report(OutStream & os) const
	{
		mPTR->report( os );
	}


	////////////////////////////////////////////////////////////////////////////
	// UNIT TEST API
	////////////////////////////////////////////////////////////////////////////

	inline void tddUnitReport(OutStream & os) const
	{
		mPTR->tddUnitReport( os );
	}


	////////////////////////////////////////////////////////////////////////////
	// NON-REGRESSION TEST API
	////////////////////////////////////////////////////////////////////////////

	inline void tddRegressionReport(OutStream & os) const
	{
		mPTR->tddRegressionReport( os );
	}


	/**
	 * REPORT
	 */
	inline void reportHeader(
			OutStream & os, const std::string & processorName) const
	{
		mPTR->reportHeader(os, processorName);
	}


	/**
	 * EVAL TRACE
	 */
	inline void tracePreEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		mPTR->tracePreEval(os, anEC);
	}


	inline void traceSilentPreEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		mPTR->traceSilentPreEval(os, anEC);
	}

	inline void traceMinimumPreEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		mPTR->traceMinimumPreEval(os, anEC);
	}

	inline void traceMediumPreEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		mPTR->traceMediumPreEval(os, anEC);
	}

	inline void traceMaximumPreEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		mPTR->traceMaximumPreEval(os, anEC);
	}

	inline void traceDefaultPreEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		mPTR->traceDefaultPreEval(os, anEC);
	}


	inline void tracePostEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		mPTR->tracePostEval(os, anEC);
	}


	inline void traceSilentPostEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		mPTR->traceSilentPostEval(os, anEC);
	}

	inline void traceMinimumPostEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		mPTR->traceMinimumPostEval(os, anEC);
	}

	inline void traceMediumPostEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		mPTR->traceMediumPostEval(os, anEC);
	}

	inline void traceMaximumPostEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		mPTR->traceMaximumPostEval(os, anEC);
	}

	inline void traceDefaultPostEval(
			OutStream & os, const ExecutionContext & anEC) const
	{
		mPTR->traceDefaultPostEval(os, anEC);
	}


	inline void traceBoundEval(OutStream & os) const
	{
		mPTR->traceBoundEval( os );
	}

	inline void reportEval(OutStream & os) const
	{
		mPTR->reportEval( os );
	}


	////////////////////////////////////////////////////////////////////////////
	// PROCESSOR REQUEST API
	////////////////////////////////////////////////////////////////////////////

	/**
	 * STOP  | RELEASE
	 * RESET | RESTART | CONTINUE
	 * REQUEUE_WAITING | REQUEUE_RESERVE
	 * HEURISTIC | GOAL_ACHIEVED
	 */
	inline virtual void handleRequestStop()
	{
		mPTR->handleRequestStop();
	}

	inline virtual void handleRequestRelease()
	{
		mPTR->handleRequestRelease();
	}


	inline virtual void handleRequestReset()
	{
		mPTR->handleRequestReset();
	}

	inline virtual void handleRequestRestart()
	{
		mPTR->handleRequestRestart();
	}

	inline virtual void handleRequestContinue()
	{
		mPTR->handleRequestContinue();
	}


	// the Waiting Queue Table
	inline virtual void handleRequestRequeueWaitingTable(
			WaitingStrategy & aWaitingStrategy,
			avm_uint8_t aWeightMin, avm_uint8_t aWeightMax)
	{
		mPTR->handleRequestRequeueWaitingTable(
				aWaitingStrategy, aWeightMin, aWeightMax);
	}

	virtual void handleRequestRequeueReserveTable(
			WaitingStrategy & aWaitingStrategy,
			ListOfExecutionContext & aReserveQueue,
			avm_uint8_t aWeightMin, avm_uint8_t aWeightMax)
	{
		mPTR->handleRequestRequeueReserveTable(
				aWaitingStrategy, aReserveQueue, aWeightMin, aWeightMax);
	}


	inline virtual void handleRequestHeuristic()
	{
		mPTR->handleRequestHeuristic();
	}


	inline virtual void handleRequestGoalAchieved()
	{
		mPTR->handleRequestGoalAchieved();
	}

	////////////////////////////////////////////////////////////////////////////
	// SERIALIZATION API
	////////////////////////////////////////////////////////////////////////////

	inline std::string strTypeId() const
	{
		return mPTR->strTypeId();
	}

	inline std::string strUniqId() const
	{
		return mPTR->strUniqId();
	}

	inline void toStream(OutStream & os) const
	{
		mPTR->toStream( os );
	}

};


////////////////////////////////////////////////////////////////////////////////
// PROCESSOR UNIT AUTO REGISTRATION FACTORY
// for automatic registration in the processor repository
////////////////////////////////////////////////////////////////////////////////

template< class ProcessorT >
class AutoRegisteredProcessorUnit :  public  AbstractProcessorUnit
{

public:
	/**
	 * TYPDEDEF
	 */
	typedef AutoRegisteredProcessorUnit< ProcessorT >  RegisteredProcessorUnit;


	/**
	 * CONSTRUCTOR
	 * Default
	 */
	AutoRegisteredProcessorUnit(SymbexControllerUnitManager & aManager,
			WObject * wfParameterObject, avm_computing_process_stage_t requiredStage,
			const avm_uint8_t * aPrecedence = DEFAULT_PRECEDENCE_OF_PROCESSOR)
	: AbstractProcessorUnit(aManager, wfParameterObject, requiredStage, aPrecedence)
	{
		//!! NOTHING
	}

	AutoRegisteredProcessorUnit(
			SymbexControllerUnitManager & aManager, WObject * wfParameterObject,
			const avm_uint8_t * aPrecedence = DEFAULT_PRECEDENCE_OF_PROCESSOR)
	: AbstractProcessorUnit(aManager, wfParameterObject, aPrecedence)
	{
		//!! NOTHING
	}

	/**
	 * CONSTRUCTOR
	 * Other
	 */
	AutoRegisteredProcessorUnit(class_kind_t aClassKind,
			SymbexControllerUnitManager & aManager, WObject * wfParameterObject)
	: AbstractProcessorUnit(aClassKind, aManager, wfParameterObject)
	{
		//!! NOTHING
	}

	AutoRegisteredProcessorUnit(class_kind_t aClassKind, SymbexEngine & anEngine,
			SymbexControllerUnitManager & aManager, WObject * wfParameterObject)
	: AbstractProcessorUnit(aClassKind, anEngine, aManager, wfParameterObject)
	{
		//!! NOTHING
	}

	/**
	 * DESTRUCTOR
	 */
	virtual ~AutoRegisteredProcessorUnit()
	{
		// Force Instanciate
		(void) & AUTO_REGISTER_TOOL;
	}


	/**
	 * PROCESSOR FACTORY
	 * for automatic registration in the processor repository
	 */
	static struct AutoRegisterProcessorFactory  :
			public ProcessorUnitRegistrationImpl< ProcessorT >
	{
		AutoRegisterProcessorFactory()
		: ProcessorUnitRegistrationImpl< ProcessorT >(
				ProcessorT::QNID() , ProcessorT::QNID1() ,
				ProcessorT::QNID2(), ProcessorT::QNID3() )
		{
			//!! NOTHING
		}

	}  AUTO_REGISTER_TOOL;
	// end registration


	inline virtual IProcessorUnitRegistration & REGISTER_TOOL() const
	{
		return( AUTO_REGISTER_TOOL );
	}

	inline bool isRegisterTool(
			const IProcessorUnitRegistration & aRegisterTool) const
	{
		return( AUTO_REGISTER_TOOL.isEquals( aRegisterTool ) );
	}

};


template< class ProcessorT > typename
AutoRegisteredProcessorUnit< ProcessorT >::AutoRegisterProcessorFactory
AutoRegisteredProcessorUnit< ProcessorT >::AUTO_REGISTER_TOOL;


#define AVM_INJECT_AUTO_REGISTER_QUALIFIED_ID_KEY( qnid ) \
	public: \
		static std::string QNID () { return( qnid  ); } \
		static std::string QNID1() { return( ""    ); } \
		static std::string QNID2() { return( ""    ); } \
		static std::string QNID3() { return( ""    ); }

#define AVM_INJECT_AUTO_REGISTER_QUALIFIED_ID_KEY_2( qnid , qnid1 ) \
	public: \
		static std::string QNID () { return( qnid  ); } \
		static std::string QNID1() { return( qnid1 ); } \
		static std::string QNID2() { return( ""    ); } \
		static std::string QNID3() { return( ""    ); }

#define AVM_INJECT_AUTO_REGISTER_QUALIFIED_ID_KEY_3( qnid , qnid1 , qnid2 ) \
	public: \
		static std::string QNID () { return( qnid  ); } \
		static std::string QNID1() { return( qnid1 ); } \
		static std::string QNID2() { return( qnid2 ); } \
		static std::string QNID3() { return( ""    ); }

#define AVM_INJECT_AUTO_REGISTER_QUALIFIED_ID_KEY_4(qnid, qnid1, qnid2, qnid3) \
	public: \
		static std::string QNID () { return( qnid  ); } \
		static std::string QNID1() { return( qnid1 ); } \
		static std::string QNID2() { return( qnid2 ); } \
		static std::string QNID3() { return( qnid3 ); }


} /* namespace sep */
#endif /* ABSTRACTPROCESSORUNIT_H_ */