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

#ifndef STATEMENTTYPECHECKER_H_
#define STATEMENTTYPECHECKER_H_

#include <common/BF.h>

#include <fml/expression/AvmCode.h>

#include <fml/operator/OperatorManager.h>


namespace sep
{


class Element;


class StatementTypeChecker
{

public:

	////////////////////////////////////////////////////////////////////////////
	// KIND CHECKER
	////////////////////////////////////////////////////////////////////////////

	inline static bool isStructured(const BF & aCode)
	{
		return( aCode.is< AvmCode >() &&
				isStructured(aCode.to_ptr< AvmCode >()) );
	}

	inline static bool isStructured(AvmCode * aCode)
	{
		return( OperatorManager::isSchedule( aCode->getOperator() ) ||
				OperatorManager::isConditionnal( aCode->getOperator() ) );
	}


	inline static bool isAssign(const BF & aCode)
	{
		return( aCode.is< AvmCode >() &&
				isAssign(aCode.to_ptr< AvmCode >()) );
	}

	inline static bool isAssign(AvmCode * aCode)
	{
		return( OperatorManager::isAssign( aCode->getOperator() ) );
	}


	inline static bool isSequence(const BF & aCode)
	{
		return( aCode.is< AvmCode >() &&
				isSequence(aCode.to_ptr< AvmCode >()) );
	}

	inline static bool isSequence(AvmCode * aCode)
	{
		return( OperatorManager::isSequence( aCode->getOperator() ) );
	}


	inline static bool isSchedule(const BF & aCode)
	{
		return( aCode.is< AvmCode >() &&
				isSchedule(aCode.to_ptr< AvmCode >()) );
	}

	inline static bool isSchedule(AvmCode * aCode)
	{
		return( OperatorManager::isSchedule( aCode->getOperator() ) );
	}


	inline static bool isMachine(const BF & aCode)
	{
		return( aCode.is< AvmCode >() &&
				isMachine(aCode.to_ptr< AvmCode >()) );
	}

	inline static bool isMachine(AvmCode * aCode)
	{
		return( OperatorManager::isMachine( aCode->getOperator() ) );
	}


	inline static bool isActivity(const BF & aCode)
	{
		return( aCode.is< AvmCode >() &&
				isActivity(aCode.to_ptr< AvmCode >()) );
	}

	inline static bool isActivity(AvmCode * aCode)
	{
		return( OperatorManager::isActivity( aCode->getOperator() ) );
	}


	inline static bool isInvokeNew(const BF & aCode)
	{
		return( aCode.is< AvmCode >() &&
				isInvokeNew(aCode.to_ptr< AvmCode >()) );
	}

	inline static bool isInvokeNew(AvmCode * aCode)
	{
		return( aCode->getOperator() == OperatorManager::OPERATOR_INVOKE_NEW );
	}


	inline static bool isCommunication(const BF & aCode)
	{
		return( aCode.is< AvmCode >() &&
				isCommunication(aCode.to_ptr< AvmCode >()) );
	}

	inline static bool isCommunication(AvmCode * aCode)
	{
		return( OperatorManager::isCommunication( aCode->getOperator() ) );
	}


	inline static bool isConditionnal(const BF & aCode)
	{
		return( aCode.is< AvmCode >() &&
				isConditionnal(aCode.to_ptr< AvmCode >()) );
	}

	inline static bool isConditionnal(AvmCode * aCode)
	{
		return( OperatorManager::isConditionnal( aCode->getOperator() ) );
	}


	inline static bool isStatement(const BF & aCode)
	{
		return( aCode.is< AvmCode >() &&
				isStatement(aCode.to_ptr< AvmCode >()) );
	}

	inline static bool isStatement(AvmCode * aCode)
	{
		return( OperatorManager::isStatement( aCode->getOperator() ) );
	}


	inline static bool isAtomicStatement(const BF & aCode)
	{
		return( aCode.is< AvmCode >() &&
				isAtomicStatement(aCode.to_ptr< AvmCode >()) );
	}

	inline static bool isAtomicStatement(AvmCode * aCode)
	{
		return( OperatorManager::isAtomicStatement( aCode->getOperator() ) );
	}


	inline static bool isAtomicSequence(const BF & aCode)
	{
		return( aCode.is< AvmCode >() &&
				isAtomicSequence(aCode.to_ptr< AvmCode >()) );
	}

	inline static bool isAtomicSequence(AvmCode * aCode)
	{
		return( aCode->isOpCode( AVM_OPCODE_ATOMIC_SEQUENCE ) );
	}


	inline static bool isStrongAtomicSequence(const BF & aCode)
	{
		return( aCode.is< AvmCode >() &&
				isStrongAtomicSequence(aCode.to_ptr< AvmCode >()) );
	}

	inline static bool isStrongAtomicSequence(AvmCode * aCode)
	{
		return( aCode->isOpCode( AVM_OPCODE_ATOMIC_SEQUENCE ) &&
				(aCode->empty() || isAtomicStatement(aCode->last()))  );
	}


	inline static bool isComment(const BF & aCode)
	{
		return( aCode.is< AvmCode >() &&
				isComment(aCode.to_ptr< AvmCode >()) );
	}

	inline static bool isComment(AvmCode * aCode)
	{
		return( aCode->isOpCode( AVM_OPCODE_COMMENT ) );
	}


	////////////////////////////////////////////////////////////////////////////
	// EMPTYNESS CHECKER
	////////////////////////////////////////////////////////////////////////////

	inline static bool isEmptySchedule(AvmCode * aCode)
	{
		return( aCode->empty() &&
				OperatorManager::isSchedule( aCode->getOperator() ) );
	}

	////////////////////////////////////////////////////////////////////////////
	// DO SOMETHING CHECKER
	////////////////////////////////////////////////////////////////////////////

	inline static bool doSomething(AvmCode * aCode)
	{
		return( aCode->nonempty() || (! isSchedule(aCode)) );
	}


};


}

#endif /* STATEMENTTYPECHECKER_H_ */