/*******************************************************************************
 * 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
 ******************************************************************************/
#ifndef AVMPROGRAM_H_
#define AVMPROGRAM_H_

#include <fml/executable/BaseAvmProgram.h>

#include <common/AvmPointer.h>

#include <collection/List.h>

#include <fml/expression/AvmCode.h>

#include <fml/executable/InstanceOfBuffer.h>
#include <fml/executable/InstanceOfData.h>
#include <fml/executable/InstanceOfPort.h>

#include <fml/common/ModifierElement.h>
#include <fml/common/SpecifierElement.h>

#include <fml/type/TableOfTypeSpecifier.h>

#include <fml/infrastructure/Transition.h>


namespace sep
{


class ExecutableForm;

class ObjectElement;

class TableOfAvmProgram;


class AvmProgram :
		public BaseAvmProgram ,
		public IStatementFamily ,
		AVM_INJECT_INSTANCE_COUNTER_CLASS( AvmProgram )
{

	AVM_DECLARE_CLONABLE_CLASS( AvmProgram )


protected:
	/*
	 * ATTRIBUTES
	 */
	avm_offset_t mOffset;

	Specifier::SCOPE_KIND mScope;


	avm_offset_t mParamOffset;
	avm_size_t   mParamCount;

	avm_offset_t mReturnOffset;
	avm_size_t   mReturnCount;

	TableOfInstanceOfData mConstData;

	TableOfTypeSpecifier mTableOfTypeSpecifier;

	BFCode mCode;

	// static class of Port/Message/Signal in communicated statement
	BF mCommunicationCode;

	BF mInternalCommunicationCode;

	ListOfInstanceOfPort mInputCom;
	ListOfInstanceOfPort mOutputCom;

	ListOfInstanceOfBuffer mInputEnabledBuffer;
	ListOfInstanceOfPort mInputEnabledCom;
	ListOfInstanceOfPort mInputEnabledSave;

	bool mMutableCommunicationFlag;

	BF mEnvironmentCom;
	BF mEnvironmentInputCom;
	BF mEnvironmentOutputCom;

public:
	/**
	 * STATIC
	 */
	static std::string ANONYM_UFI;


public:
	/**
	 * CONSTRUCTOR
	 * Default
	 */
	AvmProgram(Specifier::SCOPE_KIND aScope, AvmProgram * aContainer,
			const ObjectElement * astProgram, avm_size_t aSize)
	: BaseAvmProgram(CLASS_KIND_T( AvmProgram ), aContainer, astProgram, aSize),
	IStatementFamily( AVM_STATEMENT_UNDEFINED_FAMILY ),

	mOffset( 0 ),
	mScope( aScope ),

	mParamOffset( 0 ),
	mParamCount( 0 ),
	mReturnOffset( 0 ),
	mReturnCount( 0 ),

	mConstData( ),
	mTableOfTypeSpecifier( ),

	mCode( ),

	mCommunicationCode( ),
	mInternalCommunicationCode( ),

	mInputCom( ),
	mOutputCom( ),

	mInputEnabledBuffer( ),
	mInputEnabledCom( ),
	mInputEnabledSave( ),

	mMutableCommunicationFlag( false ),

	mEnvironmentCom( ),
	mEnvironmentInputCom( ),
	mEnvironmentOutputCom( )
	{
		updateFullyQualifiedNameID();
	}


	/**
	 * CONSTRUCTOR
	 * Default for Routine
	 */
	AvmProgram(Specifier::SCOPE_KIND aScope, AvmProgram * aContainer,
			const std::string & id, avm_size_t aSize)
	: BaseAvmProgram(CLASS_KIND_T( AvmProgram ), aContainer, id, aSize),
	IStatementFamily( AVM_STATEMENT_UNDEFINED_FAMILY ),

	mOffset( 0 ),
	mScope( aScope ),

	mParamOffset( 0 ),
	mParamCount( 0 ),
	mReturnOffset( 0 ),
	mReturnCount( 0 ),

	mConstData( ),
	mTableOfTypeSpecifier( ),

	mCode( ),

	mCommunicationCode( ),
	mInternalCommunicationCode( ),

	mInputCom( ),
	mOutputCom( ),

	mInputEnabledBuffer( ),
	mInputEnabledCom( ),
	mInputEnabledSave( ),

	mMutableCommunicationFlag( false ),

	mEnvironmentCom( ),
	mEnvironmentInputCom( ),
	mEnvironmentOutputCom( )
	{
		updateFullyQualifiedNameID();
	}


	/**
	 * CONSTRUCTOR
	 * Copy
	 */
	AvmProgram(const AvmProgram & aProgram)
	: BaseAvmProgram( aProgram ),
	IStatementFamily( aProgram ),

	mOffset( aProgram.mOffset ),
	mScope( aProgram.mScope ),

	mParamOffset( aProgram.mParamOffset ),
	mParamCount( aProgram.mParamCount ),
	mReturnOffset( aProgram.mReturnOffset ),
	mReturnCount( aProgram.mReturnCount ),

	mConstData( aProgram.mConstData ),
	mTableOfTypeSpecifier( aProgram.mTableOfTypeSpecifier ),

	mCode( aProgram.mCode ),

	mCommunicationCode( aProgram.mCommunicationCode ),
	mInternalCommunicationCode( aProgram.mInternalCommunicationCode ),

	mInputCom( aProgram.mInputCom ),
	mOutputCom( aProgram.mOutputCom ),

	mInputEnabledBuffer( aProgram.mInputEnabledBuffer ),
	mInputEnabledCom( aProgram.mInputEnabledCom ),
	mInputEnabledSave( aProgram.mInputEnabledSave ),

	mMutableCommunicationFlag( aProgram.mMutableCommunicationFlag ),

	mEnvironmentCom( aProgram.mEnvironmentCom ),
	mEnvironmentInputCom( aProgram.mEnvironmentInputCom ),
	mEnvironmentOutputCom( aProgram.mEnvironmentOutputCom )
	{
		// !! NOTHING
	}


	/**
	 * CONSTRUCTOR
	 * Other
	 */
	AvmProgram(class_kind_t aClassKind,
			Specifier::SCOPE_KIND aScope, AvmProgram * aContainer,
			ObjectElement * aCompiled, avm_size_t aSize)
	: BaseAvmProgram(aClassKind, aContainer, aCompiled, aSize),
	IStatementFamily( AVM_STATEMENT_UNDEFINED_FAMILY ),

	mOffset( 0 ),
	mScope( aScope ),

	mParamOffset( 0 ),
	mParamCount( 0 ),
	mReturnOffset( 0 ),
	mReturnCount( 0 ),

	mConstData( ),
	mTableOfTypeSpecifier( ),

	mCode( ),

	mCommunicationCode( ),
	mInternalCommunicationCode( ),

	mInputCom( ),
	mOutputCom( ),

	mInputEnabledBuffer( ),
	mInputEnabledCom( ),
	mInputEnabledSave( ),

	mMutableCommunicationFlag( false ),

	mEnvironmentCom( ),
	mEnvironmentInputCom( ),
	mEnvironmentOutputCom( )
	{
		//!! NOTHING
	}

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


	/**
	 * GETTER - SETTER
	 * mOffset
	 */
	inline avm_offset_t getOffset() const
	{
		return( mOffset );
	}

	inline void setOffset(avm_offset_t anOffset)
	{
		mOffset = anOffset;
	}


	/**
	 * GETTER - SETTER
	 * mScope
	 */
	inline Specifier::SCOPE_KIND getScope() const
	{
		return( mScope );
	}

	inline bool isScope(Specifier::SCOPE_KIND aScope) const
	{
		return( (mScope == aScope)
				|| ( aScope == Specifier::SCOPE_UNDEFINED_KIND) );
	}

	inline void setScope(Specifier::SCOPE_KIND aScope)
	{
		mScope = aScope;
	}


	inline bool isScopeTransition() const
	{
		return( mScope == Specifier::SCOPE_TRANSITION_KIND );
	}

	inline void setScopeTransition()
	{
		mScope = Specifier::SCOPE_TRANSITION_KIND;
	}

	inline bool isScopeMachine() const
	{
		return( mScope == Specifier::SCOPE_MACHINE_KIND );
	}

	inline void setScopeMachine()
	{
		mScope = Specifier::SCOPE_MACHINE_KIND;
	}


	inline bool isScopeRoutine() const
	{
		return( mScope == Specifier::SCOPE_ROUTINE_KIND );
	}

	inline void setScopeRoutine()
	{
		mScope = Specifier::SCOPE_ROUTINE_KIND;
	}


	inline bool isScopeProgram() const
	{
		return( mScope == Specifier::SCOPE_PROGRAM_KIND );
	}

	inline void setScopeProgram()
	{
		mScope = Specifier::SCOPE_PROGRAM_KIND;
	}


	/**
	 * GETTER - SETTER
	 * mParamOffset
	 * mParamCount
	 */
	inline const BF & getParam(avm_offset_t offset) const
	{
		return( getData().at(offset) );
	}

	inline BaseTypeSpecifier * getParamTypeSpecifier(avm_offset_t offset) const
	{
		return( getData().rawAt(offset)->getTypeSpecifier() );
	}


	inline avm_offset_t getParamOffset() const
	{
		return( mParamOffset );
	}

	inline avm_size_t getParamCount() const
	{
		return( mParamCount );
	}


	inline InstanceOfData * rawParamData(avm_offset_t offset) const
	{
		AVM_OS_ASSERT_FATAL_ARRAY_OFFSET_EXIT( offset , mParamCount )
				<< "Unbound Instance parameter offset !!!"
				<< SEND_EXIT;

		return( mData.rawAt(mParamOffset + offset) );
	}

	inline bool hasParam() const
	{
		return( mParamCount > 0 );
	}

	inline void setParamOffsetCount(avm_offset_t aParamOffset,
			avm_size_t aParamCount)
	{
		mParamOffset = aParamOffset;
		mParamCount  = aParamCount;
	}


	/**
	 * GETTER - SETTER
	 * mReturnOffset
	 * mReturnCount
	 */
	inline const BF & getReturn(avm_offset_t offset) const
	{
		return( getData().at(mReturnOffset + offset) );
	}

	inline BaseTypeSpecifier * getReturnTypeSpecifier(avm_offset_t offset) const
	{
		return( getData().rawAt(mReturnOffset + offset)->getTypeSpecifier() );
	}


	inline avm_offset_t getReturnOffset() const
	{
		return( mReturnOffset );
	}

	inline avm_offset_t returnOffset(avm_offset_t offset) const
	{
		return( mReturnOffset + offset );
	}

	inline avm_size_t getReturnCount() const
	{
		return( mReturnCount );
	}


	inline InstanceOfData * rawReturnData(avm_offset_t offset) const
	{
		AVM_OS_ASSERT_FATAL_ARRAY_OFFSET_EXIT( offset , mReturnCount )
				<< "Unbound Instance parameter offset !!!"
				<< SEND_EXIT;

		return( mData.rawAt(mReturnOffset + offset) );
	}


	inline bool hasReturn() const
	{
		return( mReturnCount > 0 );
	}

	inline void setReturnOffsetCount(avm_offset_t aReturnOffset,
			avm_size_t aReturnCount)
	{
		mReturnOffset = aReturnOffset;
		mReturnCount  = aReturnCount;
	}


	/**
	 * GETTER
	 * mParamCount
	 * mReturnCount
	 */
	inline avm_size_t getParamReturnCount() const
	{
		return( mParamCount + mReturnCount );
	}

	inline bool hasParamReturn() const
	{
		return( (mParamCount + mReturnCount) > 0 );
	}


	/**
	 * SETTER
	 * mFullyQualifiedNameID
	 */
	virtual void updateFullyQualifiedNameID();

	inline bool isAnonym() const
	{
		return( fqnEquals( ANONYM_UFI ) );
	}


	/*
	 * contains DATA
	 */
	inline bool containsData(InstanceOfData * anInstance) const
	{
		return( BaseAvmProgram::containsData(anInstance) ||
				mConstData.contains(anInstance) );
	}


	/**
	 * GETTER - SETTER
	 * mConstData
	 */
	inline void appendConstData(const BF & anInstance)
	{
		AVM_OS_ASSERT_FATAL_NULL_SMART_POINTER_EXIT( anInstance )
				<< "InstanceOfData !!!"
				<< SEND_EXIT;

		anInstance.to_ptr< InstanceOfData >()->setContainer(this);

		mConstData.append(anInstance);
	}

	inline void saveConstData(InstanceOfData * anInstance)
	{
		AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( anInstance )
				<< "InstanceOfData !!!"
				<< SEND_EXIT;

		anInstance->setContainer(this);

		mConstData.save(anInstance);
	}

	inline const TableOfInstanceOfData & getConstData() const
	{
		return( mConstData );
	}


	inline bool hasConstData() const
	{
		return( mConstData.nonempty() );
	}


	/**
	 * GETTER - SETTER
	 * mTypeSpecifier
	 */
	inline void appendTypeSpecifier(const TypeSpecifier & aTypeSpecifier)
	{
		AVM_OS_ASSERT_FATAL_NULL_SMART_POINTER_EXIT( aTypeSpecifier )
				<< "TypeSpecifier !!!"
				<< SEND_EXIT;

		mTableOfTypeSpecifier.append(aTypeSpecifier);
	}

	inline TableOfTypeSpecifier & getTypeSpecifier()
	{
		return( mTableOfTypeSpecifier );
	}

	inline const TableOfTypeSpecifier & getTypeSpecifier() const
	{
		return( mTableOfTypeSpecifier );
	}


	inline const TypeSpecifier & getTypeSpecifier(avm_offset_t offset) const
	{
		return( mTableOfTypeSpecifier.get(offset) );
	}

	inline const TypeSpecifier & getTypeSpecifier(
			const std::string & aFullyQualifiedNameID) const
	{
		return( mTableOfTypeSpecifier.getByFQNameID(
				aFullyQualifiedNameID ) );
	}


	inline const TypeSpecifier & getTypeSpecifier(
			const ObjectElement * astElement) const
	{
		return( mTableOfTypeSpecifier.getByAstElement(astElement) );
	}


	inline bool hasTypeSpecifier() const
	{
		return( mTableOfTypeSpecifier.nonempty() );
	}


	/**
	 * GETTER
	 * for EnumSymbolData
	 */
	inline const BF & getSymbolData(
			const std::string & aFullyQualifiedNameID) const
	{
		return( mTableOfTypeSpecifier.getSymbolData( aFullyQualifiedNameID ) );
	}

	inline const BF & getSymbolDataByQualifiedNameID(
			const std::string & aQualifiedNameID) const
	{
		return( mTableOfTypeSpecifier.
				getSymbolDataByQualifiedNameID(aQualifiedNameID) );
	}

	inline const BF & getSymbolDataByNameID(const std::string & aNameID) const
	{
		return( mTableOfTypeSpecifier.getSymbolDataByNameID( aNameID ) );
	}

	inline const BF & getSymbolDataByAstElement(
			const ObjectElement * astElement) const
	{
		return( mTableOfTypeSpecifier.getSymbolDataByAstElement(astElement) );
	}


	/**
	 * GETTER - SETTER
	 * mCode
	 */
	inline BFCode & getCode()
	{
		return( mCode );
	}

	inline const BFCode & getCode() const
	{
		return( mCode );
	}

	inline bool hasCode() const
	{
		return( mCode.valid() );
	}

	inline void setCode(const BFCode & aProgram)
	{
		mCode = aProgram;
	}


	/**
	 * GETTER - SETTER
	 * IOpcodeFamily
	 */
	inline virtual void updateOpcodeFamily()
	{
		IStatementFamily::updateStatementFamily( mCode );
	}


	/**
	 * GETTER
	 * any SYMBOL filtering by an optional type specifier family
	 */
	virtual const BF & getSymbol(
			const std::string & aFullyQualifiedNameID,
			avm_type_specifier_kind_t typeFamily) const;

	virtual const BF & getSymbolByQualifiedNameID(
			const std::string & aQualifiedNameID,
			avm_type_specifier_kind_t typeFamily) const;

	virtual const BF & getSymbolByNameID(const std::string & aNameID,
			avm_type_specifier_kind_t typeFamily) const;


	virtual const BF & getymbolByAstElement(const ObjectElement * astElement,
			avm_type_specifier_kind_t typeFamily) const;


	/**
	 * GETTER - SETTER
	 * mCommunicationCode
	 */
	inline BF & getCommunicationCode()
	{
		return( mCommunicationCode );
	}

	inline const BF & getCommunicationCode() const
	{
		return( mCommunicationCode );
	}

	inline bool hasCommunicationCode() const
	{
		return( mCommunicationCode.valid() );
	}

	inline void setCommunicationCode(const BF & comCode)
	{
		mCommunicationCode = comCode;
	}


	/**
	 * GETTER - SETTER
	 * mInternalCommunicationCode
	 */
	inline BF & getInternalCommunicationCode()
	{
		return( mInternalCommunicationCode );
	}

	inline const BF & getInternalCommunicationCode() const
	{
		return( mInternalCommunicationCode );
	}

	inline bool hasInternalCommunicationCode() const
	{
		return( mInternalCommunicationCode.valid() );
	}

	inline void setInternalCommunicationCode(const BF & comCode)
	{
		mInternalCommunicationCode = comCode;
	}


	/**
	 * GETTER - SETTER
	 * mInputCom
	 */
	inline void addInputCom(InstanceOfPort * aPort)
	{
		mInputCom.add_union( aPort );
	}

	inline void addInputCom(ListOfInstanceOfPort & inputEnabledPort)
	{
		mInputCom.add_union( inputEnabledPort );
	}


	inline ListOfInstanceOfPort & getInputCom()
	{
		return( mInputCom );
	}

	inline const ListOfInstanceOfPort & getInputCom() const
	{
		return( mInputCom );
	}


	bool containsInputCom(InstanceOfPort * aPort) const
	{
		return( mInputCom.contains(aPort) );
	}

	inline bool hasInputCom() const
	{
		return( mInputCom.nonempty() );
	}


	inline void setInputCom(ListOfInstanceOfPort & inputEnabledPort)
	{
		mInputCom.clear();

		mInputCom.add_union( inputEnabledPort );
	}


	/**
	 * GETTER - SETTER
	 * mOutputCom
	 */
	inline void addOutputCom(InstanceOfPort * aPort)
	{
		mOutputCom.add_union( aPort );
	}

	inline void addOutputCom(ListOfInstanceOfPort & inputEnabledPort)
	{
		mOutputCom.add_union( inputEnabledPort );
	}


	inline ListOfInstanceOfPort & getOutputCom()
	{
		return( mOutputCom );
	}

	inline const ListOfInstanceOfPort & getOutputCom() const
	{
		return( mOutputCom );
	}


	bool containsOutputCom(InstanceOfPort * aPort) const
	{
		return( mOutputCom.contains(aPort) );
	}

	inline bool hasOutputCom() const
	{
		return( mOutputCom.nonempty() );
	}


	inline void setOutputCom(ListOfInstanceOfPort & inputEnabledPort)
	{
		mOutputCom.clear();

		mOutputCom.add_union( inputEnabledPort );
	}


	/**
	 * GETTER - SETTER
	 * mInputEnabledBuffer
	 */
	inline void addInputEnabledBuffer(InstanceOfBuffer * aBuffer)
	{
		mInputEnabledBuffer.add_union( aBuffer );
	}

	inline void addInputEnabledBuffer(ListOfInstanceOfBuffer & inputEnabledBuffer)
	{
		mInputEnabledBuffer.add_union( inputEnabledBuffer );
	}


	inline ListOfInstanceOfBuffer & getInputEnabledBuffer()
	{
		return( mInputEnabledBuffer );
	}

	inline const ListOfInstanceOfBuffer & getInputEnabledBuffer() const
	{
		return( mInputEnabledBuffer );
	}


	bool containsInputEnabledBuffer(InstanceOfBuffer * aBuffer) const
	{
		return( mInputEnabledBuffer.contains(aBuffer) );
	}

	inline bool hasInputEnabledBuffer() const
	{
		return( mInputEnabledBuffer.nonempty() );
	}


	inline void setInputEnabledBuffer(ListOfInstanceOfBuffer & inputEnabledBuffer)
	{
		mInputEnabledBuffer.clear();

		mInputEnabledBuffer.add_union( inputEnabledBuffer );
	}


	/**
	 * GETTER - SETTER
	 * mInputEnabledCom
	 */
	inline void addInputEnabledCom(InstanceOfPort * aPort)
	{
		mInputEnabledCom.add_union( aPort );
	}

	inline void addInputEnabledCom(ListOfInstanceOfPort & inputEnabledPort)
	{
		mInputEnabledCom.add_union( inputEnabledPort );
	}


	inline ListOfInstanceOfPort & getInputEnabledCom()
	{
		return( mInputEnabledCom );
	}

	inline const ListOfInstanceOfPort & getInputEnabledCom() const
	{
		return( mInputEnabledCom );
	}


	bool containsInputEnabledCom(InstanceOfPort * aPort) const
	{
		return( mInputEnabledCom.contains(aPort) );
	}

	inline bool hasInputEnabledCom() const
	{
		return( mInputEnabledCom.nonempty() );
	}


	inline void setInputEnabledCom(ListOfInstanceOfPort & inputEnabledPort)
	{
		mInputEnabledCom.clear();

		mInputEnabledCom.add_union( inputEnabledPort );
	}


	/**
	 * GETTER - SETTER
	 * mInputEnabledSave
	 */
	inline void addInputEnabledSave(InstanceOfPort * aPort)
	{
		mInputEnabledSave.add_union( aPort );
	}

	inline void addInputEnabledSave(ListOfInstanceOfPort & inputEnabledSavePort)
	{
		mInputEnabledSave.add_union( inputEnabledSavePort );
	}


	inline ListOfInstanceOfPort & getInputEnabledSave()
	{
		return( mInputEnabledSave );
	}

	inline const ListOfInstanceOfPort & getInputEnabledSave() const
	{
		return( mInputEnabledSave );
	}


	bool containsInputEnabledSave(InstanceOfPort * aPort) const
	{
		return( mInputEnabledSave.contains(aPort) );
	}

	inline bool hasInputEnabledSave() const
	{
		return( mInputEnabledSave.nonempty() );
	}


	inline void setInputEnabledSave(ListOfInstanceOfPort & inputEnabledSavePort)
	{
		mInputEnabledSave.clear();

		mInputEnabledSave.add_union( inputEnabledSavePort );
	}


	/**
	 * GETTER - SETTER
	 * mMutableCommunicationFlag
	 * MOC Attribute for mutable Schedule
	 */
	bool isMutableCommunication() const
	{
		return( mMutableCommunicationFlag );
	}

	void setMutableCommunication(bool isMutableCommunication = true)
	{
		mMutableCommunicationFlag = isMutableCommunication;
	}


	/**
	 * GETTER - SETTER
	 * mEnvironmentCom
	 */
	inline BF & getEnvironmentCom()
	{
		return( mEnvironmentCom );
	}

	inline const BF & getEnvironmentCom() const
	{
		return( mEnvironmentCom );
	}

	inline bool hasEnvironmentCom() const
	{
		return( mEnvironmentCom.valid() );
	}

	inline void setEnvironmentCom(const BF & comCode)
	{
		mEnvironmentCom = comCode;
	}


	/**
	 * GETTER - SETTER
	 * mEnvironmentInputCom
	 */
	inline BF & getEnvironmentInputCom()
	{
		return( mEnvironmentInputCom );
	}

	inline const BF & getEnvironmentInputCom() const
	{
		return( mEnvironmentInputCom );
	}

	inline bool hasEnvironmentInputCom() const
	{
		return( mEnvironmentInputCom.valid() );
	}

	inline void setEnvironmentInputCom(const BF & comCode)
	{
		mEnvironmentInputCom = comCode;
	}


	/**
	 * GETTER - SETTER
	 * mEnvironmentOutputCom
	 */
	inline BF & getEnvironmentOutputCom()
	{
		return( mEnvironmentOutputCom );
	}

	inline const BF & getEnvironmentOutputCom() const
	{
		return( mEnvironmentOutputCom );
	}

	inline bool hasEnvironmentOutputCom() const
	{
		return( mEnvironmentOutputCom.valid() );
	}

	inline void setEnvironmentOutputCom(const BF & comCode)
	{
		mEnvironmentOutputCom = comCode;
	}


	/**
	 * Serialization
	 */
	virtual void strHeader(OutStream & out) const;

	void toStreamData(OutStream & out) const;

	void toStreamStaticCom(OutStream & out) const;

	virtual void toStream(OutStream & out) const;

};


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// AvmProgram
// TYPE DEFINITION for TABLE , SMART POINTER and CONTAINER
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

class TableOfAvmProgram :
		public TableOfBF_T< AvmProgram >,
		AVM_INJECT_INSTANCE_COUNTER_CLASS( TableOfAvmProgram )
{

	AVM_DECLARE_CLONABLE_CLASS( TableOfAvmProgram )


/**
 * TYPEDEF
 */
typedef  TableOfBF_T< AvmProgram >  BaseTableOfAvmProgram;


public:

	/**
	 * CONSTRUCTOR
	 * Default
	 */
	TableOfAvmProgram()
	: BaseTableOfAvmProgram()
	{
		//!! NOTHING
	}

	/**
	 * CONSTRUCTOR
	 * Copy
	 */
	TableOfAvmProgram(const TableOfAvmProgram & aTable)
	: BaseTableOfAvmProgram( aTable )
	{
		//!! NOTHING
	}


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


	/**
	 * GETTER
	 * For Instance
	 */
	inline const BF & getByQualifiedNameID(
			const std::string & aQualifiedNameID,
			NamedElement::op_comparer_t op,
			Specifier::SCOPE_KIND aScope) const
	{
		BaseTableOfAvmProgram::const_raw_iterator itProg = begin();
		BaseTableOfAvmProgram::const_raw_iterator endProg = end();
		for( ; itProg != endProg ; ++itProg )
		{
			if( itProg->isScope(aScope)
				&& static_cast< AvmProgram *>(
						itProg )->compareID(aQualifiedNameID, op) )
			{
				return( *itProg );
			}
		}

		return( BF::REF_NULL );
	}

	inline AvmProgram * rawByQualifiedNameID(
			const std::string & aQualifiedNameID,
			NamedElement::op_comparer_t op,
			Specifier::SCOPE_KIND aScope) const
	{
		BaseTableOfAvmProgram::const_raw_iterator itProg = begin();
		BaseTableOfAvmProgram::const_raw_iterator endProg = end();
		for( ; itProg != endProg ; ++itProg )
		{
			if( itProg->isScope(aScope)
				&& static_cast< AvmProgram *>(
						itProg )->compareID(aQualifiedNameID, op) )
			{
				return( itProg );
			}
		}

		return( NULL );
	}


	inline const BF & getByFQNameID(const std::string & aFullyQualifiedNameID,
		Specifier::SCOPE_KIND aScope = Specifier::SCOPE_UNDEFINED_KIND) const
	{
		BaseTableOfAvmProgram::const_raw_iterator itProg = begin();
		BaseTableOfAvmProgram::const_raw_iterator endProg = end();
		for( ; itProg != endProg ; ++itProg )
		{
			// STRICT:> compare LOCATOR & LOCATION (true:- retry only LOCATION)
			if( itProg->isScope(aScope)
				&& itProg->fqnEquals( aFullyQualifiedNameID , true ) )
			{
				return( *itProg );
			}
		}

		return( BF::REF_NULL );
	}

	inline const BF & getByQualifiedNameID(
			const std::string & aQualifiedNameID,
			Specifier::SCOPE_KIND aScope =
					Specifier::SCOPE_UNDEFINED_KIND) const
	{
		BaseTableOfAvmProgram::const_raw_iterator itProg = begin();
		BaseTableOfAvmProgram::const_raw_iterator endProg = end();
		for( ; itProg != endProg ; ++itProg )
		{
			if( itProg->isScope(aScope)
				&& itProg->fqnEndsWith(aQualifiedNameID) )
			{
				return( *itProg );
			}
		}

		return( BF::REF_NULL );
	}


	inline avm_size_t getByQualifiedNameID(
			const std::string & aQualifiedNameID,
			Specifier::SCOPE_KIND aScope, BFList & listofProgram) const
	{
		avm_size_t count = 0;

		BaseTableOfAvmProgram::const_raw_iterator itProg = begin();
		BaseTableOfAvmProgram::const_raw_iterator endProg = end();
		for( ; itProg != endProg ; ++itProg )
		{
			if( itProg->isScope(aScope)
				&& itProg->fqnEndsWith(aQualifiedNameID) )
			{
				listofProgram.append( *itProg );

				++count;
			}
		}

		return( count );
	}

	inline const BF & getByNameID(const std::string & id,
			Specifier::SCOPE_KIND aScope =
					Specifier::SCOPE_UNDEFINED_KIND) const
	{
		BaseTableOfAvmProgram::const_raw_iterator itProg = begin();
		BaseTableOfAvmProgram::const_raw_iterator endProg = end();
		for( ; itProg != endProg ; ++itProg )
		{
			if( itProg->isScope(aScope) && (itProg->getNameID() == id) )
			{
				return( *itProg );
			}
		}

		return( BF::REF_NULL );
	}


	inline const BF & getByAstElement(const ObjectElement * astElement) const
	{
		BaseTableOfAvmProgram::const_raw_iterator it = begin();
		BaseTableOfAvmProgram::const_raw_iterator endIt = end();
		for( ; it != endIt ; ++it )
		{
			if( (it)->isAstElement( astElement ) )
			{
				return( *it );
			}
		}

		return( BF::REF_NULL );
	}


	/**
	 * Serialization
	 */
	inline virtual void toStream(OutStream & os) const
	{
		BaseTableOfAvmProgram::const_raw_iterator itProg = begin();
		BaseTableOfAvmProgram::const_raw_iterator endProg = end();
		for( ; itProg != endProg ; ++itProg )
		{
			itProg->toStream(os);
			os << EOL;
		}
	}

	inline virtual void fqnStream(OutStream & os) const
	{
		BaseTableOfAvmProgram::const_raw_iterator itProg = begin();
		BaseTableOfAvmProgram::const_raw_iterator endProg = end();
		for( ; itProg != endProg ; ++itProg )
		{
			os << TAB << itProg->getFullyQualifiedNameID() << ";" << EOL;
		}
	}

};


}

#endif /*AVMPROGRAM_H_*/