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

#ifndef MODIFIERELEMENT_H_
#define MODIFIERELEMENT_H_

#include <string>

#include <util/avm_numeric.h>


namespace sep
{


struct Modifier
{

	/**
	 * VISIBILITY_KIND
	 * 2 bits
	 */
	enum VISIBILITY_KIND
	{
		VISIBILITY_UNDEFINED_KIND  = 0x00, // DEFAULT
		VISIBILITY_PRIVATE_KIND    = 0x00, // DEFAULT

		VISIBILITY_PUBLIC_KIND     = 0x01,

		VISIBILITY_PROTECTED_KIND  = 0x02,

		VISIBILITY_PACKAGE_KIND    = 0x03

	};


	/**
	 * DIRECTION_KIND
	 * 3 bits
	 */
	enum DIRECTION_KIND
	{
		DIRECTION_UNDEFINED_KIND   = 0x00, // DEFAULT

		DIRECTION_INPUT_KIND       = 0x01,

		DIRECTION_OUTPUT_KIND      = 0x02,

		DIRECTION_INOUT_KIND       = DIRECTION_INPUT_KIND
		                           | DIRECTION_OUTPUT_KIND,

		DIRECTION_RETURN_KIND      = 0x04

	};


	/**
	 * NATURE_KIND
	 * 4 bits
	 */
	enum NATURE_KIND
	{
		NATURE_UNDEFINED_KIND            = 0x000, // DEFAULT
		NATURE_VARIABLE_KIND             = 0x000, // DEFAULT

		NATURE_PARAMETER_KIND            = 0x001,

		NATURE_REFERENCE_KIND            = 0x002,

		NATURE_MACRO_KIND                = 0x004,

		NATURE_BIND_KIND                 = 0x008,

		NATURE_PARAMETER_BIND_KIND       = NATURE_PARAMETER_KIND
		                                 | NATURE_BIND_KIND,

		NATURE_REFERENCE_MACRO_KIND      = NATURE_REFERENCE_KIND
		                                 | NATURE_MACRO_KIND,

		NATURE_PARAMETER_REFERENCE_MACRO_KIND
		                                 = NATURE_PARAMETER_KIND
		                                 | NATURE_REFERENCE_KIND
		                                 | NATURE_MACRO_KIND

	};


	/**
	 * FEATURE_KIND
	 * 5 bits
	 */
	enum FEATURE_KIND
	{
		FEATURE_UNDEFINED_KIND     = 0x000, // DEFAULT

		FEATURE_FINAL_KIND         = 0x001,
		FEATURE_CONST_KIND         = 0x001,

		FEATURE_STATIC_KIND        = 0x002,

		FEATURE_TRANSIENT_KIND     = 0x004,

		FEATURE_VOLATILE_KIND      = 0x008,

		FEATURE_UNSAFE_KIND        = 0x010,

		FEATURE_FINAL_STATIC_KIND  = FEATURE_FINAL_KIND
		                           | FEATURE_STATIC_KIND

	};


	/**
	 * TYPEDEF
	 */
	typedef unsigned short  bit_field_t;

	/**
	 * BIT FIELDS
	 */
	bit_field_t visibility     : 2;

	bit_field_t direction      : 3;

	bit_field_t nature         : 4;

	bit_field_t feature        : 5;


	/**
	 * ENABLING POSITION
	 */
	enum
	{
		FIELD_VISIBILITY_POSITION        = 0x01,
		FIELD_DIRECTION_POSITION         = 0x02,
		FIELD_NATURE_POSITION            = 0x04,
		FIELD_FEATURE_POSITION           = 0x08,

		ENABLE_ALL_FIELDS                = 0xFF,

		DISABLE_VISIBILITY_FIELD         = (~ FIELD_VISIBILITY_POSITION),
		DISABLE_DIRECTION_FIELD          = (~ FIELD_DIRECTION_POSITION ),
		DISABLE_FEATURE_DESIGN_FIELD     = (~ FIELD_FEATURE_POSITION   ),
		DISABLE_NATURE_FIELD             = (~ FIELD_NATURE_POSITION    )

	};


	/**
	 * STATIC PROPERTY MODIFIER
	 */
	static Modifier PROPERTY_UNDEFINED_MODIFIER;

	/**
	 * VISIBILITY
	 */
	static Modifier PROPERTY_PUBLIC_MODIFIER;

	static Modifier PROPERTY_PROTECTED_MODIFIER;

	static Modifier PROPERTY_PRIVATE_MODIFIER;

	/**
	 * DIRECTION
	 */
	static Modifier PROPERTY_INOUT_DIRECTION;

	/**
	 * NATURE
	 */
	static Modifier PROPERTY_MACRO_MODIFIER;

	/**
	 * ALIAS
	 */
	static Modifier PROPERTY_PUBLIC_VOLATILE_MODIFIER;

	static Modifier PROPERTY_PUBLIC_FINAL_STATIC_MODIFIER;

	static Modifier PARAMETER_PUBLIC_FINAL_STATIC_MODIFIER;

	/**
	 * [ DIRECTION ] PARAMETER
	 */
	static Modifier PROPERTY_PARAMETER_MODIFIER;

	static Modifier PROPERTY_INPUT_PARAMETER_MODIFIER;

	static Modifier PROPERTY_OUTPUT_PARAMETER_MODIFIER;

	static Modifier PROPERTY_INOUT_PARAMETER_MODIFIER;

	static Modifier PROPERTY_RETURN_PARAMETER_MODIFIER;

	/**
	 * [ BIND ] PARAMETER
	 */
	static Modifier PROPERTY_PARAMETER_BIND_MODIFIER;


	/**
	 * CONSTRUCTORS
	 */
	Modifier()
	: visibility( VISIBILITY_UNDEFINED_KIND ),
	direction   ( DIRECTION_UNDEFINED_KIND  ),
	nature      ( NATURE_UNDEFINED_KIND     ),
	feature     ( FEATURE_UNDEFINED_KIND    )
	{
		//!! NOTHING
	}

//	Modifier(const Modifier & aModifier)
//	: visibility( aModifier.visibility ),
//	direction   ( aModifier.direction  ),
//	nature      ( aModifier.nature     ),
//	feature     ( aModifier.feature    )
//	{
//		//!! NOTHING
//	}

	Modifier(bit_field_t visibilityKind, bit_field_t directionKind,
			bit_field_t natureKind, bit_field_t featureKind)
	: visibility( visibilityKind ),
	direction   ( directionKind  ),
	nature      ( natureKind  ),
	feature     ( featureKind )
	{
		//!! NOTHING
	}

	Modifier(NATURE_KIND natureKindind, FEATURE_KIND featureKindind)
	: visibility( VISIBILITY_UNDEFINED_KIND ),
	direction   ( DIRECTION_UNDEFINED_KIND  ),
	nature      ( natureKindind  ),
	feature     ( featureKindind )
	{
		//!! NOTHING
	}


	Modifier(VISIBILITY_KIND visibilityKind)
	: visibility( visibilityKind ),
	direction   ( DIRECTION_UNDEFINED_KIND  ),
	nature      ( NATURE_UNDEFINED_KIND     ),
	feature     ( FEATURE_UNDEFINED_KIND    )
	{
		//!! NOTHING
	}

	Modifier(DIRECTION_KIND directionKind)
	: visibility( VISIBILITY_UNDEFINED_KIND ),
	direction   ( directionKind             ),
	nature      ( NATURE_UNDEFINED_KIND     ),
	feature     ( FEATURE_UNDEFINED_KIND    )
	{
		//!! NOTHING
	}

	Modifier(NATURE_KIND natureKind)
	: visibility( VISIBILITY_UNDEFINED_KIND ),
	direction   ( DIRECTION_UNDEFINED_KIND  ),
	nature      ( natureKind                ),
	feature     ( FEATURE_UNDEFINED_KIND    )
	{
		//!! NOTHING
	}

	Modifier(FEATURE_KIND featureKind)
	: visibility( VISIBILITY_UNDEFINED_KIND ),
	direction   ( DIRECTION_UNDEFINED_KIND  ),
	nature      ( NATURE_UNDEFINED_KIND     ),
	feature     ( featureKind               )
	{
		//!! NOTHING
	}


	/**
	 * DESTRUCTOR
	 */
	~Modifier()
	{
		//!! NOTHING
	}


	/**
	 * TESTER
	 */
	inline bool hasModifier() const
	{
		return(    (visibility != VISIBILITY_UNDEFINED_KIND)
				|| (direction  != DIRECTION_UNDEFINED_KIND )
				|| (nature     != NATURE_UNDEFINED_KIND    )
				|| (feature    != FEATURE_UNDEFINED_KIND   ) );
	}


	////////////////////////////////////////////////////////////////////////////
	// OPERATOR =
	////////////////////////////////////////////////////////////////////////////

	inline Modifier & override_ifdef(const Modifier & other)
	{
		if( other.visibility != VISIBILITY_UNDEFINED_KIND )
		{
			visibility = other.visibility;
		}
		if( other.direction != DIRECTION_UNDEFINED_KIND )
		{
			direction = other.direction;
		}

		nature  |= other.nature;
		feature |= other.feature;

		return( *this );
	}

	inline Modifier & ifnot_define(const Modifier & other)
	{
		if( visibility == VISIBILITY_UNDEFINED_KIND )
		{
			visibility = other.visibility;
		}
		if( direction == DIRECTION_UNDEFINED_KIND )
		{
			direction = other.direction;
		}

		nature  |= other.nature;
		feature |= other.feature;

		return( *this );
	}


	inline Modifier & operator=(const Modifier & other)
	{
		visibility = other.visibility;
		direction  = other.direction;
		nature     = other.nature;
		feature    = other.feature;

		return( *this );
	}

	inline Modifier & operator=(VISIBILITY_KIND visibilityKind)
	{
		visibility = visibilityKind;

		return( *this );
	}

	inline Modifier & operator=(DIRECTION_KIND directionKind)
	{
		direction = directionKind;

		return( *this );
	}

	inline Modifier & operator=(NATURE_KIND natureKind)
	{
		nature = natureKind;

		return( *this );
	}

	inline Modifier & operator=(FEATURE_KIND featureKind)
	{
		feature = featureKind;

		return( *this );
	}


	////////////////////////////////////////////////////////////////////////////
	// OPERATOR |=
	////////////////////////////////////////////////////////////////////////////

	inline Modifier & operator|=(const Modifier & other)
	{
		visibility |= other.visibility;
		direction  |= other.direction;
		nature     |= other.nature;
		feature    |= other.feature;

		return( *this );
	}

	inline Modifier & operator|=(VISIBILITY_KIND visibilityKind)
	{
		visibility |= visibilityKind;

		return( *this );
	}

	inline Modifier & operator|=(DIRECTION_KIND directionKind)
	{
		direction |= directionKind;

		return( *this );
	}

	inline Modifier & operator|=(NATURE_KIND natureKind)
	{
		nature |= natureKind;

		return( *this );
	}

	inline Modifier & operator|=(FEATURE_KIND featureKind)
	{
		feature |= featureKind;

		return( *this );
	}


	////////////////////////////////////////////////////////////////////////////
	// OPERATOR &=
	////////////////////////////////////////////////////////////////////////////

	inline Modifier & operator&=(const Modifier & other)
	{
		visibility &= other.visibility;
		direction  &= other.direction;
		nature     &= other.nature;
		feature    &= other.feature;

		return( *this );
	}

	inline Modifier & operator&=(VISIBILITY_KIND visibilityKind)
	{
		visibility &= visibilityKind;

		return( *this );
	}

	inline Modifier & operator&=(DIRECTION_KIND directionKind)
	{
		direction &= directionKind;

		return( *this );
	}

	inline Modifier & operator&=(NATURE_KIND natureKind)
	{
		nature &= natureKind;

		return( *this );
	}

	inline Modifier & operator&=(FEATURE_KIND featureKind)
	{
		feature &= featureKind;

		return( *this );
	}


	////////////////////////////////////////////////////////////////////////////
	// OPERATOR ==  !=
	////////////////////////////////////////////////////////////////////////////

	inline bool operator==(const Modifier & other) const
	{
		return(    (visibility == other.visibility)
				&& (direction  == other.direction )
				&& (nature     == other.nature    )
				&& (feature    == other.feature   ) );
	}

	inline bool operator!=(const Modifier & other) const
	{
		return(    (visibility != other.visibility)
				|| (direction  != other.direction )
				|| (nature     != other.nature    )
				|| (feature    != other.feature   ) );
	}


	////////////////////////////////////////////////////////////////////////////
	// OPERATOR |
	////////////////////////////////////////////////////////////////////////////

	inline Modifier operator|(const Modifier & other) const
	{
		return( Modifier(
				visibility | other.visibility,
				direction  | other.direction,
				nature     | other.nature,
				feature    | other.feature) );
	}

	inline Modifier operator|(VISIBILITY_KIND visibilityKind) const
	{
		return( Modifier(visibility | visibilityKind,
				direction, nature, feature) );
	}

	inline Modifier operator|(DIRECTION_KIND directionKind) const
	{
		return( Modifier(visibility,
				direction | directionKind, nature, feature) );
	}

	inline Modifier operator|(NATURE_KIND natureKind) const
	{
		return( Modifier(visibility,
				direction, nature | natureKind, feature) );
	}

	inline Modifier operator|(FEATURE_KIND featureKind) const
	{
		return( Modifier(visibility,
				direction, nature, feature | featureKind) );
	}


	////////////////////////////////////////////////////////////////////////////
	// OPERATOR &
	////////////////////////////////////////////////////////////////////////////

	inline Modifier operator&(const Modifier & other) const
	{
		return( Modifier(
				visibility & other.visibility,
				direction  & other.direction,
				nature     & other.nature,
				feature    & other.feature) );
	}

	inline Modifier operator&(VISIBILITY_KIND visibilityKind) const
	{
		return( Modifier(visibility & visibilityKind,
				direction, nature, feature) );
	}

	inline Modifier operator&(DIRECTION_KIND directionKind) const
	{
		return( Modifier(visibility,
				direction & directionKind, nature, feature) );
	}

	inline Modifier operator&(NATURE_KIND natureKind) const
	{
		return( Modifier(visibility,
				direction, nature & natureKind, feature) );
	}

	inline Modifier operator&(FEATURE_KIND featureKind) const
	{
		return( Modifier(visibility,
				direction, nature, feature & featureKind) );
	}


	////////////////////////////////////////////////////////////////////////////
	// VISIBILITY KIND
	////////////////////////////////////////////////////////////////////////////

	/**
	 * GETTER - SETTER
	 * visibility
	 */
	inline VISIBILITY_KIND getVisibilityKind() const
	{
		return( static_cast< VISIBILITY_KIND >( visibility ) );
	}

	inline bool hasVisibilityKind() const
	{
		return( visibility != VISIBILITY_UNDEFINED_KIND );
	}

	inline bool isVisibilityKind(VISIBILITY_KIND visibilityKind) const
	{
		return( visibility == visibilityKind );
	}

	inline Modifier & setVisibilityKind(VISIBILITY_KIND visibilityKind)
	{
		visibility = visibilityKind;

		return( *this );
	}

	inline Modifier & unsetVisibilityKind()
	{
		visibility = VISIBILITY_UNDEFINED_KIND;

		return( *this );
	}


	/**
	 * GETTER - SETTER
	 * "public" visibility
	 */
	inline bool isVisibilityPublic() const
	{
		return( visibility == VISIBILITY_PUBLIC_KIND );
	}

	inline bool isVisibilityPublic(const Modifier & mask) const
	{
		return( ((visibility | mask.visibility) & VISIBILITY_PUBLIC_KIND) != 0 );
	}

	inline Modifier & setVisibilityPublic()
	{
		visibility = VISIBILITY_PUBLIC_KIND;

		return( *this );
	}

	/**
	 * GETTER - SETTER
	 * "private" visibility
	 */
	inline bool isVisibilityPrivate() const
	{
		return( visibility == VISIBILITY_PRIVATE_KIND );
	}

	inline Modifier & setVisibilityPrivate()
	{
		visibility = VISIBILITY_PRIVATE_KIND;

		return( *this );
	}

	/**
	 * GETTER - SETTER
	 * "protected" visibility
	 */
	inline bool isVisibilityProtected() const
	{
		return( visibility == VISIBILITY_PROTECTED_KIND );
	}

	inline Modifier & setVisibilityProtected()
	{
		visibility = VISIBILITY_PROTECTED_KIND;

		return( *this );
	}

	/**
	 * GETTER - SETTER
	 * "package" visibility
	 */
	inline bool isVisibilityPackage() const
	{
		return( visibility == VISIBILITY_PACKAGE_KIND );
	}

	inline Modifier & setVisibilityPackage()
	{
		visibility = VISIBILITY_PACKAGE_KIND;

		return( *this );
	}


	////////////////////////////////////////////////////////////////////////////
	// DIRECTION KIND
	////////////////////////////////////////////////////////////////////////////

	/**
	 * GETTER - SETTER
	 * direction
	 */
	inline DIRECTION_KIND getDirectionKind() const
	{
		return( static_cast< DIRECTION_KIND >( direction ) );
	}

	inline bool hasDirectionKind() const
	{
		return( direction != DIRECTION_UNDEFINED_KIND );
	}

	inline bool hasDirectionKind(DIRECTION_KIND directionKind) const
	{
		return( (direction & directionKind) != 0 );
	}


	inline bool isDirectionKind(DIRECTION_KIND directionKind) const
	{
		return( direction == directionKind );
	}

	inline bool isnotDirectionKind(DIRECTION_KIND directionKind) const
	{
		return( direction != directionKind );
	}


	inline bool isDirectionKind(
			DIRECTION_KIND directionKind, bool isStrongly) const
	{
		return( isStrongly ? (direction == directionKind)
				: ((direction & directionKind) != 0) );
	}

	inline bool isnotDirectionKind(
			DIRECTION_KIND directionKind, bool isStrongly) const
	{
		return( isStrongly ? (direction != directionKind)
				: ((direction & directionKind) == 0) );
	}


	inline bool isDirectionUndefined() const
	{
		return( direction == DIRECTION_UNDEFINED_KIND );
	}

	inline Modifier & setDirectionKind(DIRECTION_KIND directionKind)
	{
		direction = directionKind;

		return( *this );
	}

	inline Modifier & unsetDirectionKind()
	{
		direction = DIRECTION_UNDEFINED_KIND;

		return( *this );
	}


	inline std::string strDirection() const
	{
		switch( direction )
		{
			case DIRECTION_INPUT_KIND:	   return( "input"  );
			case DIRECTION_OUTPUT_KIND:	   return( "output" );
			case DIRECTION_INOUT_KIND:     return( "inout"  );
			case DIRECTION_RETURN_KIND:	   return( "return" );

			case DIRECTION_UNDEFINED_KIND: return( "undefined<direction#kind>" );

			default: return( "unknown<direction#kind>" );
		}
	}


	/**
	 * GETTER - SETTER
	 * "input" direction modifier
	 */
	inline bool isDirectionInput() const
	{
		return( direction == DIRECTION_INPUT_KIND );
	}

	inline bool hasDirectionInput() const
	{
		return( (direction & DIRECTION_INPUT_KIND) != 0 );
	}

	inline Modifier & setDirectionInput()
	{
		direction = DIRECTION_INPUT_KIND;

		return( *this );
	}


	/**
	 * GETTER - SETTER
	 * "instance" direction modifier
	 */
	inline bool isDirectionOutput() const
	{
		return( direction == DIRECTION_OUTPUT_KIND );
	}

	inline bool hasDirectionOutput() const
	{
		return( (direction & DIRECTION_OUTPUT_KIND) != 0 );
	}

	inline Modifier & setDirectionOutput()
	{
		direction = DIRECTION_OUTPUT_KIND;

		return( *this );
	}

	/**
	 * GETTER - SETTER
	 * "prototype" direction modifier
	 */
	inline bool isDirectionInout() const
	{
		return( direction == DIRECTION_INOUT_KIND );
	}


	inline Modifier & setDirectionInout()
	{
		direction = DIRECTION_INOUT_KIND;

		return( *this );
	}

	inline Modifier & setDirectionInoutElse()
	{
		if( direction == DIRECTION_UNDEFINED_KIND )
		{
			direction = DIRECTION_INOUT_KIND;
		}

		return( *this );
	}

	/**
	 * GETTER - SETTER
	 * "runtime" direction modifier
	 */
	inline bool isDirectionReturn() const
	{
		return( direction == DIRECTION_RETURN_KIND );
	}

	inline bool noDirectionReturn() const
	{
		return( direction != DIRECTION_RETURN_KIND );
	}

	inline Modifier & setDirectionReturn()
	{
		direction = DIRECTION_RETURN_KIND;

		return( *this );
	}

	inline bool hasDirectionOtheThanReturn() const
	{
		return( (direction & DIRECTION_INOUT_KIND) != 0 );
	}

	////////////////////////////////////////////////////////////////////////////
	// NATURE KIND
	////////////////////////////////////////////////////////////////////////////

	/**
	 * GETTER - SETTER
	 * nature
	 */
	inline bit_field_t getNatureKind() const
	{
		return( nature );
	}

	inline bool hasNatureKind() const
	{
		return( nature != NATURE_UNDEFINED_KIND );
	}

	inline bool hasNatureKind(bit_field_t kind) const
	{
		return( (nature & kind) != 0 );
	}

	inline bool isNatureKind(bit_field_t kind) const
	{
		return( nature == kind );
	}

	inline Modifier & addNatureKind(bit_field_t kind)
	{
		nature |= kind;

		return( *this );
	}

	inline Modifier & remNatureKind(bit_field_t kind)
	{
		nature &= (~ kind);

		return( *this );
	}

	inline Modifier & setNatureKind(bit_field_t kind)
	{
		nature = kind;

		return( *this );
	}


	////////////////////////////////////////////////////////////////////////////
	// FEATURE KIND
	////////////////////////////////////////////////////////////////////////////

	/**
	 * GETTER - SETTER
	 * feature
	 */
	inline bit_field_t getFeatureKind() const
	{
		return( feature );
	}

	inline bool hasFeatureKind() const
	{
		return( feature != FEATURE_UNDEFINED_KIND );
	}

	inline bool hasFeatureKind(bit_field_t kind) const
	{
		return( (feature & kind) != 0 );
	}

	inline bool isFeatureKind(bit_field_t kind) const
	{
		return( feature == kind );
	}


	inline Modifier & addFeatureKind(bit_field_t kind)
	{
		feature |= kind;

		return( *this );
	}

	inline Modifier & remFeatureKind(bit_field_t kind)
	{
		feature &= (~ kind);

		return( *this );
	}

	inline Modifier & setFeatureKind(bit_field_t kind)
	{
		feature = kind;

		return( *this );
	}


	/**
	 * GETTER - SETTER
	 * "variable" nature
	 */
	inline bool hasNatureVariable() const
	{
		return( (nature & NATURE_VARIABLE_KIND) != 0 );
	}

	inline Modifier & setNatureVariable(bool bNatureVariable = true)
	{
		if( bNatureVariable )
		{
			nature |= NATURE_VARIABLE_KIND;
		}
		else
		{
			nature &= (~ NATURE_VARIABLE_KIND);
		}

		return( *this );
	}

	/**
	 * GETTER - SETTER
	 * "parameter" nature
	 */
	inline bool hasNatureParameter() const
	{
		return( (nature & NATURE_PARAMETER_KIND) != 0 );
	}

	inline bool noNatureParameter() const
	{
		return( (nature & NATURE_PARAMETER_KIND) == 0 );
	}

	inline Modifier & setNatureParameter(bool bNatureParameter = true)
	{
		if( bNatureParameter )
		{
			nature |= NATURE_PARAMETER_KIND;
		}
		else
		{
			nature &= (~ NATURE_PARAMETER_KIND);
		}

		return( *this );
	}

	/**
	 * GETTER - SETTER
	 * "reference" nature
	 */
	inline bool hasNatureReference() const
	{
		return( (nature & NATURE_REFERENCE_KIND) != 0 );
	}

	inline Modifier & setNatureReference(bool bNatureReference = true)
	{
		if( bNatureReference )
		{
			nature |= NATURE_REFERENCE_KIND;
		}
		else
		{
			nature &= (~ NATURE_REFERENCE_KIND);
		}

		return( *this );
	}

	/**
	 * GETTER - SETTER
	 * "macro" nature
	 */
	inline bool hasNatureMacro() const
	{
		return( (nature & NATURE_MACRO_KIND) != 0 );
	}

	inline Modifier & setNatureMacro(bool bNatureMacro = true)
	{
		if( bNatureMacro )
		{
			nature |= NATURE_MACRO_KIND;
		}
		else
		{
			nature &= (~ NATURE_MACRO_KIND);
		}

		return( *this );
	}


	/**
	 * ALIAS
	 * GETTER - SETTER
	 * "reference" or "macro" modifier
	 */
	inline bool anyNatureReferenceMacro() const
	{
		return( (nature & NATURE_REFERENCE_MACRO_KIND) != 0 );
	}

	inline bool noneNatureReferenceMacro() const
	{
		return( (nature & NATURE_REFERENCE_MACRO_KIND) == 0 );
	}


	/**
	 * ALIAS
	 * GETTER - SETTER
	 * "parameter" or "reference" or "macro" modifier
	 */
	inline bool anyNatureParameterReferenceMacro() const
	{
		return( (nature & NATURE_PARAMETER_REFERENCE_MACRO_KIND) != 0 );
	}

	inline bool noneNatureParameterReferenceMacro() const
	{
		return( (nature & NATURE_PARAMETER_REFERENCE_MACRO_KIND) == 0 );
	}

	/**
	 * GETTER - SETTER
	 * "bind" nature
	 */
	inline bool hasNatureBind() const
	{
		return( (nature & NATURE_BIND_KIND) != 0 );
	}

	inline Modifier & setNatureBind(bool bNatureBind = true)
	{
		if( bNatureBind )
		{
			nature |= NATURE_BIND_KIND;
		}
		else
		{
			nature &= (~ NATURE_BIND_KIND);
		}

		return( *this );
	}


	/**
	 * ALIAS
	 * GETTER - SETTER
	 * "parameter" or "bind" modifier
	 */
	inline bool hasNatureParameterBind() const
	{
		return( (nature & NATURE_PARAMETER_BIND_KIND) ==
						NATURE_PARAMETER_BIND_KIND );
	}

	inline Modifier & setNatureParameterBind(bool bNatureParameterBind = true)
	{
		if( bNatureParameterBind )
		{
			nature |= NATURE_PARAMETER_BIND_KIND;
		}
		else
		{
			nature &= (~ NATURE_PARAMETER_BIND_KIND);
		}

		return( *this );
	}


	/**
	 * GETTER - SETTER
	 * "final" or "const" feature
	 */
	inline bool hasFeatureFinal() const
	{
		return( (feature & FEATURE_FINAL_KIND) != 0 );
	}

	inline bool noFeatureFinal() const
	{
		return( (feature & FEATURE_FINAL_KIND) == 0 );
	}

	inline Modifier & setFeatureFinal(bool bFeatureFinal = true)
	{
		if( bFeatureFinal )
		{
			feature |= FEATURE_FINAL_KIND;
		}
		else
		{
			feature &= (~ FEATURE_FINAL_KIND);
		}

		return( *this );
	}


	inline bool hasFeatureConst() const
	{
		return( (feature & FEATURE_CONST_KIND) != 0 );
	}

	inline Modifier & setFeatureConst(bool bFeatureConst = true)
	{
		if( bFeatureConst )
		{
			feature |= FEATURE_CONST_KIND;
		}
		else
		{
			feature &= (~ FEATURE_CONST_KIND);
		}

		return( *this );
	}


	inline bool hasFeatureMutable() const
	{
		return( (feature & FEATURE_FINAL_KIND) == 0 );
	}

	inline Modifier & setFeatureMutable(bool bFeatureMutable = true)
	{
		if( bFeatureMutable )
		{
			feature &= (~ FEATURE_FINAL_KIND);
		}
		else
		{
			feature |= FEATURE_FINAL_KIND;
		}

		return( *this );
	}


	/**
	 * GETTER - SETTER
	 * "static" feature
	 */
	inline bool hasFeatureStatic() const
	{
		return( (feature & FEATURE_STATIC_KIND) != 0 );
	}

	inline Modifier & setFeatureStatic(bool bFeatureStatic = true)
	{
		if( bFeatureStatic )
		{
			feature |= FEATURE_STATIC_KIND;
		}
		else
		{
			feature &= (~ FEATURE_STATIC_KIND);
		}

		return( *this );
	}


	/**
	 * ALIAS
	 * GETTER - SETTER
	 * "final static" modifier
	 */
	inline bool hasFeatureFinalStatic() const
	{
		return( (feature & FEATURE_FINAL_STATIC_KIND) ==
					FEATURE_FINAL_STATIC_KIND );
	}

	inline Modifier & setFeatureFinalStatic(bool bFeatureFinalStatic = true)
	{
		if( bFeatureFinalStatic )
		{
			feature |= FEATURE_FINAL_STATIC_KIND;
		}
		else
		{
			feature &= (~ FEATURE_FINAL_STATIC_KIND);
		}

		return( *this );
	}


	/**
	 * GETTER - SETTER
	 * "transient" feature
	 */
	inline bool hasFeatureTransient() const
	{
		return( (feature & FEATURE_TRANSIENT_KIND) != 0 );
	}

	inline bool noFeatureTransient() const
	{
		return( (feature & FEATURE_TRANSIENT_KIND) == 0 );
	}

	inline Modifier & setFeatureTransient(bool bFeatureTransient = true)
	{
		if( bFeatureTransient )
		{
			feature |= FEATURE_TRANSIENT_KIND;
		}
		else
		{
			feature &= (~ FEATURE_TRANSIENT_KIND);
		}

		return( *this );
	}


	/**
	 * GETTER - SETTER
	 * "volatile" feature
	 */
	inline bool hasFeatureVolatile() const
	{
		return( (feature & FEATURE_VOLATILE_KIND) != 0 );
	}

	inline bool hasFeatureVolatile(const Modifier & mask) const
	{
		return( ((feature | mask.feature) & FEATURE_VOLATILE_KIND) != 0 );
	}

	inline Modifier & setFeatureVolatile(bool bFeatureVolatile = true)
	{
		if( bFeatureVolatile )
		{
			feature |= FEATURE_VOLATILE_KIND;
		}
		else
		{
			feature &= (~ FEATURE_VOLATILE_KIND);
		}

		return( *this );
	}


	/**
	 * GETTER - SETTER
	 * "unsafe" feature
	 */
	inline bool hasFeatureUnsafe() const
	{
		return( (feature & FEATURE_UNSAFE_KIND) != 0 );
	}

	inline Modifier & setFeatureUnsafe(bool bFeatureUnsafe = true)
	{
		if( bFeatureUnsafe )
		{
			feature |= FEATURE_UNSAFE_KIND;
		}
		else
		{
			feature &= (~ FEATURE_UNSAFE_KIND);
		}

		return( *this );
	}


	inline bool hasFeatureSafe() const
	{
		return( (feature & FEATURE_UNSAFE_KIND) == 0 );
	}

	inline Modifier & setFeatureSafe(bool bFeatureSafe = true)
	{
		if( bFeatureSafe )
		{
			feature &= (~ FEATURE_UNSAFE_KIND);
		}
		else
		{
			feature |= FEATURE_UNSAFE_KIND;
		}

		return( *this );
	}


	////////////////////////////////////////////////////////////////////////////
	// MIX-IN MODIFIER
	////////////////////////////////////////////////////////////////////////////

	/**
	 * HYBRID ALIAS
	 * GETTER - SETTER
	 * "public final static" modifier
	 */
	inline bool hasModifierPublicFinalStatic() const
	{
		return( isVisibilityPublic()
				&& hasFeatureFinalStatic() );
	}

	inline Modifier & setModifierPublicFinalStatic()
	{
		setVisibilityPublic();

		setFeatureFinalStatic();

		return( *this );
	}


	inline bool hasModifierPublicFinalStaticParameter() const
	{
		return( isVisibilityPublic()
				&& hasFeatureFinalStatic()
				&& hasNatureParameter() );
	}

	inline Modifier & setModifierPublicFinalStaticParameter()
	{
		setVisibilityPublic();

		setModifierPublicFinalStatic();

		setNatureParameter( true );

		return( *this );
	}


	/**
	 * HYBRID ALIAS
	 * GETTER - SETTER
	 * "public volatile" modifier
	 */
	inline bool hasModifierPublicVolatile() const
	{
		return( isVisibilityPublic()
				&& hasFeatureVolatile() );
	}

	inline Modifier & setModifierPublicVolatile()
	{
		setVisibilityPublic();

		setFeatureVolatile( true );

		return( *this );
	}


	/**
	 * ALIAS
	 * GETTER - SETTER
	 * "reference" , "macro" , final modifier
	 */
	inline bool anyModifierFinalReferenceMacro() const
	{
		return( hasFeatureFinal()
				|| anyNatureReferenceMacro() );
	}

	inline bool noneModifierFinalReferenceMacro() const
	{
		return( noFeatureFinal()
				&& noneNatureReferenceMacro() );
	}


	/**
	 * ALIAS
	 * GETTER - SETTER
	 * "reference" , "macro" , "transient" modifier
	 */
	inline bool anyModifierTransientReferenceMacro() const
	{
		return( hasFeatureTransient()
				|| anyNatureReferenceMacro() );
	}

	inline bool noneModifierTransientReferenceMacro() const
	{
		return( noFeatureTransient()
				&& noneNatureReferenceMacro() );
	}


	/**
	 * ALIAS
	 * GETTER - SETTER
	 * "bind return" modifier
	 */
	inline bool hasModifierReturnBind() const
	{
		return( isDirectionReturn()
				&& hasNatureBind() );
	}

	inline Modifier & setModifierReturnBind()
	{
		setDirectionReturn();

		setNatureBind( true );

		return( *this );
	}

	/**
	 * ALIAS
	 * TEST
	 * for state data var modifier
	 * "reference" , "macro" , "transient" , "parameter" , "return"
	 */
	bool anyModifierOfStateData() const
	{
		return( noFeatureTransient()
				&& noneNatureParameterReferenceMacro() );
	}


	////////////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////////
	/**
	 * Serialization
	 */
	static std::string strVisibility(bit_field_t visibilityKind,
			const std::string & separator = " ");

	static std::string xstrVisibility(bit_field_t directionKind,
			const std::string & separator = " ");


	static std::string strDirection(bit_field_t directionKind,
			const std::string & separator = " ");


	static std::string xstrDirection(bit_field_t directionKind,
			const std::string & separator = " ");

	static Modifier::DIRECTION_KIND toDirectionKind(const std::string & id);

	static std::string strFeature(bit_field_t featureKind,
			const std::string & separator = " ");

	static std::string strNature(bit_field_t natureKind,
			const std::string & separator = " ");


	std::string toString(bit_field_t enabledFields = ENABLE_ALL_FIELDS,
			const std::string & separator = " ") const;

	inline std::string toString(const std::string & separator) const
	{
		return( toString( ENABLE_ALL_FIELDS , separator) );
	}

	inline std::string toString_not(DIRECTION_KIND directionKind,
			const std::string & separator = " ") const
	{
		if( isDirectionKind(directionKind) )
		{
			Modifier mdfr( *this );

			return( mdfr.unsetDirectionKind().toString(separator) );
		}
		else
		{
			return( toString(separator) );
		}
	}

	inline std::string toString_not(NATURE_KIND natureKind,
			const std::string & separator = " ") const
	{
		if( hasNatureKind(natureKind) )
		{
			Modifier mdfr( *this );

			return( mdfr.remNatureKind(natureKind).toString(separator) );
		}
		else
		{
			return( toString(separator) );
		}
	}

	inline std::string toString_not(FEATURE_KIND featureKind,
			const std::string & separator = " ") const
	{
		if( hasFeatureKind(featureKind) )
		{
			Modifier mdfr( *this );

			return( mdfr.remFeatureKind(featureKind).toString(separator) );
		}
		else
		{
			return( toString(separator) );
		}
	}


};


//ostream & operator<<(ostream & os, const Modifier & aModifier)
//{
//	os  << Modifier::strVisibility( aModifier.visibility )
//		<< Modifier::strDirection(  aModifier.direction )
//		<< Modifier::strFeature(  aModifier.feature )
//		<< Modifier::strNature(  aModifier.nature );
//
//	return( os );
//}


/**
 * Modifier Implementation
 */
class ModifierImpl
{

protected:
	/**
	 * ATTRIBUTES
	 */
	Modifier mModifier;


public:
	/**
	 * CONSTRUCTOR
	 */
	ModifierImpl()
	: mModifier( )
	{
		//!! NOTHING
	}

	ModifierImpl(const Modifier & aModifier)
	: mModifier( aModifier )
	{
		//!! NOTHING
	}

	ModifierImpl(const ModifierImpl & aCopy)
	: mModifier( aCopy.mModifier )
	{
		//!! NOTHING
	}

	ModifierImpl(const ModifierImpl * aCopy)
	: mModifier( (aCopy != NULL) ?
			aCopy->mModifier : Modifier::PROPERTY_UNDEFINED_MODIFIER )
	{
		//!! NOTHING
	}


	/**
	 * DESTRUCTOR
	 */
	~ModifierImpl()
	{
		//!! NOTHING
	}


	/**
	 * GETTER
	 * mModifier
	 */
	inline const Modifier & getModifier() const
	{
		return( mModifier );
	}

	inline Modifier & getwModifier()
	{
		return( mModifier );
	}

	inline bool hasModifier() const
	{
		return( mModifier != Modifier::PROPERTY_UNDEFINED_MODIFIER );
	}

	inline void setModifier(const Modifier & aModifier)
	{
		mModifier = aModifier;
	}

};


}

#endif /* MODIFIERELEMENT_H_ */