org.eclipse.efm.symbex/src/common/NamedElement.h - gerrit/efm/org.eclipse.efm-symbex - Git at Google

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

 #ifndef COMMON_NAMEDELEMENT_H_
 #define COMMON_NAMEDELEMENT_H_

 #include <common/Element.h>

 #include <collection/Collection.h>


 namespace sep
 {


 /**
  * DEFAULT
  * Fully Qualified Name ID SchemeSeparator
  */
 #define FQN_ID_SCHEME_PATH_SEPARATOR  ":/"

 #define FQN_ID_ROOT_SEPARATOR         "::"


 class NamedElement :
 		public Element ,
 		AVM_INJECT_INSTANCE_COUNTER_CLASS( NamedElement )
 {

 public:
 /**
  * TYPEDEF
  */
 	typedef avm_uint8_t               op_comparer_t;

 	enum {
 		OP_STRICT_COMPARER            = 0x001,

 		OP_ABSOLUTE_COMPARER          = 0x002, // Ignore LOCATOR

 		OP_RELATIVE_COMPARER          = 0x004,

 		OP_NAME_ID_COMPARER           = 0x008,

 		OP_UNRESTRICTED_NAME_COMPARER = 0x010,

 		OP_STRONG_COMPARER            = OP_STRICT_COMPARER
 		                              | OP_ABSOLUTE_COMPARER,

 		OP_QUALIFIED_NAME_ID_COMPARER = OP_STRICT_COMPARER
 		                              | OP_ABSOLUTE_COMPARER
 		                              | OP_RELATIVE_COMPARER
 		                              | OP_NAME_ID_COMPARER,

 		OP_WEAK_COMPARER              = OP_QUALIFIED_NAME_ID_COMPARER
 		                              | OP_UNRESTRICTED_NAME_COMPARER,

 		OP_ANY_COMPARER               = OP_STRONG_COMPARER
 		                              | OP_WEAK_COMPARER
 	};


 protected:
 	/**
 	 * ATTRIBUTES
 	 */
 	static const std::string UNNAMED_ID;

 	std::string mFullyQualifiedNameID;
 	std::string mNameID;
 	std::string mUnrestrictedName;


 public:
 	/**
 	 * CONSTRUCTOR
 	 * Default
 	 */
 	NamedElement(class_kind_t aClassKind)
 	: Element( aClassKind ),
 	mFullyQualifiedNameID( ),
 	mNameID( ),
 	mUnrestrictedName( )
 	{
 		//!! NOTHING
 	}

 	NamedElement(class_kind_t aClassKind, const std::string & aNameID)
 	: Element( aClassKind ),
 	mFullyQualifiedNameID( ),
 	mNameID( aNameID ),
 	mUnrestrictedName( aNameID )
 	{
 		//!! NOTHING
 	}

 	NamedElement(class_kind_t aClassKind,
 			const std::string & aFullyQualifiedNameID,
 			const std::string & aNameID,
 			const std::string & anUnrestrictedName)
 	: Element( aClassKind ),
 	mFullyQualifiedNameID( aFullyQualifiedNameID ),
 	mNameID( aNameID ),
 	mUnrestrictedName( anUnrestrictedName )
 	{
 		//!! NOTHING
 	}

 	NamedElement(class_kind_t aClassKind,
 			const std::string & aFullyQualifiedNameID,
 			const std::string & aNameID)
 	: Element( aClassKind ),
 	mFullyQualifiedNameID( aFullyQualifiedNameID ),
 	mNameID( aNameID ),
 	mUnrestrictedName( aNameID )
 	{
 		//!! NOTHING
 	}


 	NamedElement(class_kind_t aClassKind, const NamedElement & anElement)
 	: Element( aClassKind ),
 	mFullyQualifiedNameID( ),
 	mNameID( ),
 	mUnrestrictedName( )
 	{
 		setAllName( anElement );
 	}

 	NamedElement(class_kind_t aClassKind, NamedElement * anElement)
 	: Element( aClassKind ),
 	mFullyQualifiedNameID( ),
 	mNameID( ),
 	mUnrestrictedName( )
 	{
 		setAllName( anElement );
 	}

 	/**
 	 * CONSTRUCTOR
 	 * Copy
 	 */
 	NamedElement(const NamedElement & anElement)
 	: Element( anElement ),
 	mFullyQualifiedNameID( anElement.mFullyQualifiedNameID ),
 	mNameID( anElement.mNameID ),
 	mUnrestrictedName( anElement.mUnrestrictedName )
 	{
 		//!! NOTHING
 	}


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


 	/**
 	 * GETTER - SETTER
 	 * mFullyQualifiedNameID
 	 */
 	inline virtual const std::string & getFullyQualifiedNameID() const
 	{
 		return( mFullyQualifiedNameID );
 	}

 	inline bool hasFullyQualifiedNameID() const
 	{
 		return( not mFullyQualifiedNameID.empty() );
 	}

 	inline void setFullyQualifiedNameID(
 			const std::string & aFullyQualifiedNameID)
 	{
 		mFullyQualifiedNameID = aFullyQualifiedNameID;

 		extractSetNameID( aFullyQualifiedNameID );
 	}

 	inline void setFullyQualifiedNameContainer( NamedElement * anElement)
 	{
 		mFullyQualifiedNameID =
 				( OSS() << anElement->getFullyQualifiedNameID()
 						<< '.' << getNameID() );
 	}


 	/**
 	 * GETTER - SETTER
 	 * mNameID
 	 */
 	inline virtual const std::string & getNameID() const
 	{
 		return( mNameID );
 	}

 	inline bool hasNameID() const
 	{
 		return( not mNameID.empty() );
 	}

 	inline void setNameID(const std::string & aNameID)
 	{
 		mNameID = aNameID;
 	}

 	inline void extractSetNameID(const std::string & aQualifiedNameID)
 	{
 		mNameID = NamedElement::extractNameID( aQualifiedNameID );
 	}


 	/*
 	 * UTIL
 	 * return suffix of <container-id>.<name-id> i.e. <name-id>
 	 */
 	static std::string extractNameID(const std::string & aQualifiedNameID);

 	/**
 	 * GETTER - SETTER
 	 * mFullyQualifiedNameID
 	 */
 	inline void setAllNameID(const std::string & aFullyQualifiedNameID,
 			const std::string & aNameID)
 	{
 		mFullyQualifiedNameID = aFullyQualifiedNameID;

 		setNameID( aNameID );
 	}

 	inline void setAllNameID(const std::string & aFullyQualifiedNameID,
 			const std::string & aNameID, const std::string & name)
 	{
 		mFullyQualifiedNameID = aFullyQualifiedNameID;

 		mNameID = aNameID;

 		mUnrestrictedName = name;
 	}


 	/**
 	 * UTIL
 	 */
 	inline bool isNamed() const
 	{
 		return( not isUnamed() );
 	}

 	inline bool isUnamed() const
 	{
 		return( mFullyQualifiedNameID.empty() &&
 				mNameID.empty() && mUnrestrictedName.empty() );
 	}


 	inline void setAllName(const NamedElement & anElement)
 	{
 		mFullyQualifiedNameID = anElement.mFullyQualifiedNameID;
 		mNameID = anElement.mNameID;
 		mUnrestrictedName = anElement.mUnrestrictedName;
 	}

 	inline void setAllName(NamedElement * anElement)
 	{
 		if( anElement != NULL )
 		{
 			mFullyQualifiedNameID = anElement->mFullyQualifiedNameID;
 			mNameID = anElement->mNameID;
 			mUnrestrictedName = anElement->mUnrestrictedName;
 		}
 	}


 	/**
 	 * COMPARISON
 	 * OPERATOR
 	 */
 	inline int compareFQN(const NamedElement & other) const
 	{
 		return( mFullyQualifiedNameID.compare( other.mFullyQualifiedNameID ) );
 	}

 	// STRICT:> compare LOCATOR & LOCATION [true:- retry only only LOCATION]
 	inline bool fqnEquals(const std::string & aFullyQualifiedNameID,
 			bool enabledOnlyLocationComparisonElse = false) const
 	{
 		return( (mFullyQualifiedNameID == aFullyQualifiedNameID)
 				|| (enabledOnlyLocationComparisonElse
 					&& NamedElement::compareLocation(
 							this, aFullyQualifiedNameID)) );
 	}

 	inline bool fqnEndsWith(const std::string & aQualifiedNameID) const
 	{
 		return( (mNameID == aQualifiedNameID)
 				|| NamedElement::fqnEndsWith(
 						mFullyQualifiedNameID, aQualifiedNameID) );
 	}

 	inline bool fqnStartsWith(const std::string & aQualifiedNameID) const
 	{
 		return( mFullyQualifiedNameID.find(aQualifiedNameID) == 0 );
 	}

 	/**
 	 * GETTER
 	 * Qualified Name IDentifier
 	 * QualifiedNameID
 	 */
 	inline virtual std::string getQualifiedNameID() const
 	{
 		return( NamedElement::makeQualifiedNameID(
 				mFullyQualifiedNameID , mNameID ) );
 	}


 	inline bool isRelative() const
 	{
 		return( NamedElement::isRelative(mFullyQualifiedNameID) );
 	}


 	/**
 	 * UTIL
 	 * return <container-id>.<name-id>
 	 */
 	static std::string makeQualifiedNameID(
 			const std::string & aQualifiedNameID);

 	static std::string makeQualifiedNameID(
 			const std::string & aQualifiedNameID, const std::string & aNameID);

 	static std::string getContainerQualifiedNameID(
 			const std::string & aQualifiedNameID);

 	/**
 	 * Loacation
 	 * Locator
 	 */
 	inline static std::string location(const std::string & aQualifiedNameID)
 	{
 		std::string::size_type pos =
 				aQualifiedNameID.find(FQN_ID_ROOT_SEPARATOR);

 		return( (pos != std::string::npos) ?
 				aQualifiedNameID.substr(pos + 2 ) : aQualifiedNameID );
 	}

 	inline static std::string locator(const std::string & aQualifiedNameID)
 	{
 		std::string::size_type pos =
 				aQualifiedNameID.find(FQN_ID_ROOT_SEPARATOR);

 		return( (pos != std::string::npos) ?
 				aQualifiedNameID.substr(0, pos) : "" );
 	}


 	inline static bool compareID(
 			const std::string & aQualifiedNameID_1,
 			const std::string & aQualifiedNameID_2)
 	{
 		return( aQualifiedNameID_1 == aQualifiedNameID_2 );
 	}

 	inline static bool compareLocation(
 			const std::string & aQualifiedNameID_1,
 			const std::string & aQualifiedNameID_2)
 	{
 		return( NamedElement::location(aQualifiedNameID_1)
 				== NamedElement::location(aQualifiedNameID_2) );
 	}

 	/**
 	 * isAbsolute
 	 * isRelative
 	 */
 	inline static bool isAbsolute(const std::string & aQualifiedNameID)
 	{
 		return( aQualifiedNameID.find(FQN_ID_ROOT_SEPARATOR)
 				!= std::string::npos );
 	}

 	inline static bool isRelative(const std::string & aQualifiedNameID)
 	{
 		return( aQualifiedNameID.find(FQN_ID_ROOT_SEPARATOR)
 				== std::string::npos );
 	}


 	inline static bool isNull(const std::string & aQualifiedNameID)
 	{
 		return( (not aQualifiedNameID.empty())
 				&& (aQualifiedNameID[ 0 ] == '<')
 				&& (aQualifiedNameID.find_last_of(":null")
 						!= std::string::npos) );
 	}

 	inline static bool isSimplenameID(const std::string & aQualifiedNameID)
 	{
 		return( (aQualifiedNameID.find_last_of('.') == std::string::npos)
 				&& (aQualifiedNameID.find(FQN_ID_ROOT_SEPARATOR)
 					== std::string::npos) );
 	}


 	/**
 	 * GETTER
 	 * "name" of a USER FORM
 	 */
 	inline const std::string & getUnrestrictedName() const
 	{
 		return( mUnrestrictedName );
 	}

 	inline bool hasUnrestrictedName() const
 	{
 		return( not mUnrestrictedName.empty() );
 	}

 	inline bool hasReallyUnrestrictedName() const
 	{
 		return( (not mUnrestrictedName.empty()) &&
 				(mUnrestrictedName != mNameID ) );
 	}

 	inline void setUnrestrictedName(const std::string & name)
 	{
 		mUnrestrictedName = name;
 	}


 	/*
 	 ***************************************************************************
 	 * COMPARER  FOR  QUALIFIED NAME ID  STRING
 	 ***************************************************************************
 	 */
 	bool compareID(const std::string & aQualifiedNameID,
 			op_comparer_t op) const;

 	/*
 	 * !UNUSED!
 	static bool compareID(const std::string & aFullyQualifiedNameID,
 			const std::string & aQualifiedNameID, op_comparer_t op);

 	inline static bool compareFullyQualifiedNameID(
 			const NamedElement * anElement,
 			const std::string & aQualifiedNameID)
 	{
 		return( anElement->compareID(aQualifiedNameID, OP_STRONG_COMPARER) );
 	}
 	* !UNUSED!
 	*/

 	inline static bool compareLocation(const NamedElement * anElement,
 			const std::string & aQualifiedNameID)
 	{
 		return( anElement->compareID(aQualifiedNameID, OP_ABSOLUTE_COMPARER) );
 	}

 	/*
 	 * !UNUSED!
 	inline static bool compareQualifiedNameID(
 			const NamedElement * anElement,
 			const std::string & aQualifiedNameID)
 	{
 		return( compareID(anElement,
 				aQualifiedNameID, OP_QUALIFIED_NAME_ID_COMPARER) );
 	}
 	* !UNUSED!
 	*/

 	inline static bool fqnStartsWith(
 			const std::string & aFullyQualifiedNameID,
 			const std::string & aQualifiedNameID)
 	{
 		return( aFullyQualifiedNameID.find(aQualifiedNameID) == 0 );
 	}

 	inline static bool fqnEndsWith(
 			const std::string & aFullyQualifiedNameID,
 			const std::string & aQualifiedNameID)
 	{
 		std::size_t rpos = aFullyQualifiedNameID.rfind(aQualifiedNameID);

 		return( (rpos != std::string::npos)
 				&& (rpos == (aFullyQualifiedNameID.length()
 						- aQualifiedNameID.length()))
 				&& ( (rpos == 0)
 					|| (aFullyQualifiedNameID[rpos-1] == '.')
 					|| (aFullyQualifiedNameID[rpos-1] == ':') ) );
 	}


 	/*
 	 ***************************************************************************
 	 * LIST of ID of QUALIFIED NAME ID
 	 ***************************************************************************
 	 */
 	static avm_size_t collectNameID(Collection< std::string > & listNameID,
 			const std::string & aQualifiedNameID, std::string::size_type pos);

 	inline static avm_size_t collectNameID(
 			Collection< std::string > & listNameID,
 		const std::string & aQualifiedNameID, const std::string & ignorePrefix)
 	{
 		AVM_OS_ASSERT_FATAL_ERROR_EXIT(
 				aQualifiedNameID.find(ignorePrefix) == 0 )
 				<< "Bad prefix string in NamedElement::listofID("
 				<< aQualifiedNameID << ", " << ignorePrefix << ") !!!"
 				<< SEND_EXIT;

 		return NamedElement::collectNameID(listNameID,
 				aQualifiedNameID, ignorePrefix.size());
 	}

 	static avm_size_t collectNameID(Collection< std::string > & listNameID,
 			const std::string & aQualifiedNameID);


 	/**
 	 * Serialization
 	 */
 	inline virtual std::string strFQN(
 			const std::string & defaultFQN = "<unamed-element>") const
 	{
 		return( hasFullyQualifiedNameID() ? mFullyQualifiedNameID
 				: ( hasNameID() ? mNameID
 					: ( hasUnrestrictedName() ? ("'" + mUnrestrictedName + "'")
 						: defaultFQN ) ) );

 		return( defaultFQN );
 	}

 	inline void virtual strFQN(OutStream & os) const
 	{
 		os << strFQN();
 	}


 	/**
 	 * Serialization
 	 */
 	inline virtual std::string str() const
 	{
 		if( not getFullyQualifiedNameID().empty() )
 		{
 			return( getFullyQualifiedNameID() );
 		}
 		else if( not getNameID().empty() )
 		{
 			return( getNameID() );
 		}
 		return( getUnrestrictedName() );
 	}

 };


 } /* namespace sep */

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

	#ifndef COMMON_NAMEDELEMENT_H_
	#define COMMON_NAMEDELEMENT_H_

	#include <common/Element.h>

	#include <collection/Collection.h>



	namespace sep
	{


	/**
	* DEFAULT
	* Fully Qualified Name ID SchemeSeparator
	*/
	#define FQN_ID_SCHEME_PATH_SEPARATOR ":/"

	#define FQN_ID_ROOT_SEPARATOR "::"


	class NamedElement :
	public Element ,
	AVM_INJECT_INSTANCE_COUNTER_CLASS( NamedElement )
	{

	public:
	/**
	* TYPEDEF
	*/
	typedef avm_uint8_t op_comparer_t;

	enum {
	OP_STRICT_COMPARER = 0x001,

	OP_ABSOLUTE_COMPARER = 0x002, // Ignore LOCATOR

	OP_RELATIVE_COMPARER = 0x004,

	OP_NAME_ID_COMPARER = 0x008,

	OP_UNRESTRICTED_NAME_COMPARER = 0x010,

	OP_STRONG_COMPARER = OP_STRICT_COMPARER
	\| OP_ABSOLUTE_COMPARER,

	OP_QUALIFIED_NAME_ID_COMPARER = OP_STRICT_COMPARER
	\| OP_ABSOLUTE_COMPARER
	\| OP_RELATIVE_COMPARER
	\| OP_NAME_ID_COMPARER,

	OP_WEAK_COMPARER = OP_QUALIFIED_NAME_ID_COMPARER
	\| OP_UNRESTRICTED_NAME_COMPARER,

	OP_ANY_COMPARER = OP_STRONG_COMPARER
	\| OP_WEAK_COMPARER
	};


	protected:
	/**
	* ATTRIBUTES
	*/
	static const std::string UNNAMED_ID;

	std::string mFullyQualifiedNameID;
	std::string mNameID;
	std::string mUnrestrictedName;


	public:
	/**
	* CONSTRUCTOR
	* Default
	*/
	NamedElement(class_kind_t aClassKind)
	: Element( aClassKind ),
	mFullyQualifiedNameID( ),
	mNameID( ),
	mUnrestrictedName( )
	{
	//!! NOTHING
	}

	NamedElement(class_kind_t aClassKind, const std::string & aNameID)
	: Element( aClassKind ),
	mFullyQualifiedNameID( ),
	mNameID( aNameID ),
	mUnrestrictedName( aNameID )
	{
	//!! NOTHING
	}

	NamedElement(class_kind_t aClassKind,
	const std::string & aFullyQualifiedNameID,
	const std::string & aNameID,
	const std::string & anUnrestrictedName)
	: Element( aClassKind ),
	mFullyQualifiedNameID( aFullyQualifiedNameID ),
	mNameID( aNameID ),
	mUnrestrictedName( anUnrestrictedName )
	{
	//!! NOTHING
	}

	NamedElement(class_kind_t aClassKind,
	const std::string & aFullyQualifiedNameID,
	const std::string & aNameID)
	: Element( aClassKind ),
	mFullyQualifiedNameID( aFullyQualifiedNameID ),
	mNameID( aNameID ),
	mUnrestrictedName( aNameID )
	{
	//!! NOTHING
	}


	NamedElement(class_kind_t aClassKind, const NamedElement & anElement)
	: Element( aClassKind ),
	mFullyQualifiedNameID( ),
	mNameID( ),
	mUnrestrictedName( )
	{
	setAllName( anElement );
	}

	NamedElement(class_kind_t aClassKind, NamedElement * anElement)
	: Element( aClassKind ),
	mFullyQualifiedNameID( ),
	mNameID( ),
	mUnrestrictedName( )
	{
	setAllName( anElement );
	}

	/**
	* CONSTRUCTOR
	* Copy
	*/
	NamedElement(const NamedElement & anElement)
	: Element( anElement ),
	mFullyQualifiedNameID( anElement.mFullyQualifiedNameID ),
	mNameID( anElement.mNameID ),
	mUnrestrictedName( anElement.mUnrestrictedName )
	{
	//!! NOTHING
	}


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


	/**
	* GETTER - SETTER
	* mFullyQualifiedNameID
	*/
	inline virtual const std::string & getFullyQualifiedNameID() const
	{
	return( mFullyQualifiedNameID );
	}

	inline bool hasFullyQualifiedNameID() const
	{
	return( not mFullyQualifiedNameID.empty() );
	}

	inline void setFullyQualifiedNameID(
	const std::string & aFullyQualifiedNameID)
	{
	mFullyQualifiedNameID = aFullyQualifiedNameID;

	extractSetNameID( aFullyQualifiedNameID );
	}

	inline void setFullyQualifiedNameContainer( NamedElement * anElement)
	{
	mFullyQualifiedNameID =
	( OSS() << anElement->getFullyQualifiedNameID()
	<< '.' << getNameID() );
	}


	/**
	* GETTER - SETTER
	* mNameID
	*/
	inline virtual const std::string & getNameID() const
	{
	return( mNameID );
	}

	inline bool hasNameID() const
	{
	return( not mNameID.empty() );
	}

	inline void setNameID(const std::string & aNameID)
	{
	mNameID = aNameID;
	}

	inline void extractSetNameID(const std::string & aQualifiedNameID)
	{
	mNameID = NamedElement::extractNameID( aQualifiedNameID );
	}


	/*
	* UTIL
	* return suffix of <container-id>.<name-id> i.e. <name-id>
	*/
	static std::string extractNameID(const std::string & aQualifiedNameID);

	/**
	* GETTER - SETTER
	* mFullyQualifiedNameID
	*/
	inline void setAllNameID(const std::string & aFullyQualifiedNameID,
	const std::string & aNameID)
	{
	mFullyQualifiedNameID = aFullyQualifiedNameID;

	setNameID( aNameID );
	}

	inline void setAllNameID(const std::string & aFullyQualifiedNameID,
	const std::string & aNameID, const std::string & name)
	{
	mFullyQualifiedNameID = aFullyQualifiedNameID;

	mNameID = aNameID;

	mUnrestrictedName = name;
	}


	/**
	* UTIL
	*/
	inline bool isNamed() const
	{
	return( not isUnamed() );
	}

	inline bool isUnamed() const
	{
	return( mFullyQualifiedNameID.empty() &&
	mNameID.empty() && mUnrestrictedName.empty() );
	}


	inline void setAllName(const NamedElement & anElement)
	{
	mFullyQualifiedNameID = anElement.mFullyQualifiedNameID;
	mNameID = anElement.mNameID;
	mUnrestrictedName = anElement.mUnrestrictedName;
	}

	inline void setAllName(NamedElement * anElement)
	{
	if( anElement != NULL )
	{
	mFullyQualifiedNameID = anElement->mFullyQualifiedNameID;
	mNameID = anElement->mNameID;
	mUnrestrictedName = anElement->mUnrestrictedName;
	}
	}


	/**
	* COMPARISON
	* OPERATOR
	*/
	inline int compareFQN(const NamedElement & other) const
	{
	return( mFullyQualifiedNameID.compare( other.mFullyQualifiedNameID ) );
	}

	// STRICT:> compare LOCATOR & LOCATION [true:- retry only only LOCATION]
	inline bool fqnEquals(const std::string & aFullyQualifiedNameID,
	bool enabledOnlyLocationComparisonElse = false) const
	{
	return( (mFullyQualifiedNameID == aFullyQualifiedNameID)
	\|\| (enabledOnlyLocationComparisonElse
	&& NamedElement::compareLocation(
	this, aFullyQualifiedNameID)) );
	}

	inline bool fqnEndsWith(const std::string & aQualifiedNameID) const
	{
	return( (mNameID == aQualifiedNameID)
	\|\| NamedElement::fqnEndsWith(
	mFullyQualifiedNameID, aQualifiedNameID) );
	}

	inline bool fqnStartsWith(const std::string & aQualifiedNameID) const
	{
	return( mFullyQualifiedNameID.find(aQualifiedNameID) == 0 );
	}

	/**
	* GETTER
	* Qualified Name IDentifier
	* QualifiedNameID
	*/
	inline virtual std::string getQualifiedNameID() const
	{
	return( NamedElement::makeQualifiedNameID(
	mFullyQualifiedNameID , mNameID ) );
	}


	inline bool isRelative() const
	{
	return( NamedElement::isRelative(mFullyQualifiedNameID) );
	}


	/**
	* UTIL
	* return <container-id>.<name-id>
	*/
	static std::string makeQualifiedNameID(
	const std::string & aQualifiedNameID);

	static std::string makeQualifiedNameID(
	const std::string & aQualifiedNameID, const std::string & aNameID);

	static std::string getContainerQualifiedNameID(
	const std::string & aQualifiedNameID);

	/**
	* Loacation
	* Locator
	*/
	inline static std::string location(const std::string & aQualifiedNameID)
	{
	std::string::size_type pos =
	aQualifiedNameID.find(FQN_ID_ROOT_SEPARATOR);

	return( (pos != std::string::npos) ?
	aQualifiedNameID.substr(pos + 2 ) : aQualifiedNameID );
	}

	inline static std::string locator(const std::string & aQualifiedNameID)
	{
	std::string::size_type pos =
	aQualifiedNameID.find(FQN_ID_ROOT_SEPARATOR);

	return( (pos != std::string::npos) ?
	aQualifiedNameID.substr(0, pos) : "" );
	}


	inline static bool compareID(
	const std::string & aQualifiedNameID_1,
	const std::string & aQualifiedNameID_2)
	{
	return( aQualifiedNameID_1 == aQualifiedNameID_2 );
	}

	inline static bool compareLocation(
	const std::string & aQualifiedNameID_1,
	const std::string & aQualifiedNameID_2)
	{
	return( NamedElement::location(aQualifiedNameID_1)
	== NamedElement::location(aQualifiedNameID_2) );
	}

	/**
	* isAbsolute
	* isRelative
	*/
	inline static bool isAbsolute(const std::string & aQualifiedNameID)
	{
	return( aQualifiedNameID.find(FQN_ID_ROOT_SEPARATOR)
	!= std::string::npos );
	}

	inline static bool isRelative(const std::string & aQualifiedNameID)
	{
	return( aQualifiedNameID.find(FQN_ID_ROOT_SEPARATOR)
	== std::string::npos );
	}


	inline static bool isNull(const std::string & aQualifiedNameID)
	{
	return( (not aQualifiedNameID.empty())
	&& (aQualifiedNameID[ 0 ] == '<')
	&& (aQualifiedNameID.find_last_of(":null")
	!= std::string::npos) );
	}

	inline static bool isSimplenameID(const std::string & aQualifiedNameID)
	{
	return( (aQualifiedNameID.find_last_of('.') == std::string::npos)
	&& (aQualifiedNameID.find(FQN_ID_ROOT_SEPARATOR)
	== std::string::npos) );
	}


	/**
	* GETTER
	* "name" of a USER FORM
	*/
	inline const std::string & getUnrestrictedName() const
	{
	return( mUnrestrictedName );
	}

	inline bool hasUnrestrictedName() const
	{
	return( not mUnrestrictedName.empty() );
	}

	inline bool hasReallyUnrestrictedName() const
	{
	return( (not mUnrestrictedName.empty()) &&
	(mUnrestrictedName != mNameID ) );
	}

	inline void setUnrestrictedName(const std::string & name)
	{
	mUnrestrictedName = name;
	}


	/*
	***************************************************************************
	* COMPARER FOR QUALIFIED NAME ID STRING
	***************************************************************************
	*/
	bool compareID(const std::string & aQualifiedNameID,
	op_comparer_t op) const;

	/*
	* !UNUSED!
	static bool compareID(const std::string & aFullyQualifiedNameID,
	const std::string & aQualifiedNameID, op_comparer_t op);

	inline static bool compareFullyQualifiedNameID(
	const NamedElement * anElement,
	const std::string & aQualifiedNameID)
	{
	return( anElement->compareID(aQualifiedNameID, OP_STRONG_COMPARER) );
	}
	* !UNUSED!
	*/

	inline static bool compareLocation(const NamedElement * anElement,
	const std::string & aQualifiedNameID)
	{
	return( anElement->compareID(aQualifiedNameID, OP_ABSOLUTE_COMPARER) );
	}

	/*
	* !UNUSED!
	inline static bool compareQualifiedNameID(
	const NamedElement * anElement,
	const std::string & aQualifiedNameID)
	{
	return( compareID(anElement,
	aQualifiedNameID, OP_QUALIFIED_NAME_ID_COMPARER) );
	}
	* !UNUSED!
	*/

	inline static bool fqnStartsWith(
	const std::string & aFullyQualifiedNameID,
	const std::string & aQualifiedNameID)
	{
	return( aFullyQualifiedNameID.find(aQualifiedNameID) == 0 );
	}

	inline static bool fqnEndsWith(
	const std::string & aFullyQualifiedNameID,
	const std::string & aQualifiedNameID)
	{
	std::size_t rpos = aFullyQualifiedNameID.rfind(aQualifiedNameID);

	return( (rpos != std::string::npos)
	&& (rpos == (aFullyQualifiedNameID.length()
	- aQualifiedNameID.length()))
	&& ( (rpos == 0)
	\|\| (aFullyQualifiedNameID[rpos-1] == '.')
	\|\| (aFullyQualifiedNameID[rpos-1] == ':') ) );
	}


	/*
	***************************************************************************
	* LIST of ID of QUALIFIED NAME ID
	***************************************************************************
	*/
	static avm_size_t collectNameID(Collection< std::string > & listNameID,
	const std::string & aQualifiedNameID, std::string::size_type pos);

	inline static avm_size_t collectNameID(
	Collection< std::string > & listNameID,
	const std::string & aQualifiedNameID, const std::string & ignorePrefix)
	{
	AVM_OS_ASSERT_FATAL_ERROR_EXIT(
	aQualifiedNameID.find(ignorePrefix) == 0 )
	<< "Bad prefix string in NamedElement::listofID("
	<< aQualifiedNameID << ", " << ignorePrefix << ") !!!"
	<< SEND_EXIT;

	return NamedElement::collectNameID(listNameID,
	aQualifiedNameID, ignorePrefix.size());
	}

	static avm_size_t collectNameID(Collection< std::string > & listNameID,
	const std::string & aQualifiedNameID);


	/**
	* Serialization
	*/
	inline virtual std::string strFQN(
	const std::string & defaultFQN = "<unamed-element>") const
	{
	return( hasFullyQualifiedNameID() ? mFullyQualifiedNameID
	: ( hasNameID() ? mNameID
	: ( hasUnrestrictedName() ? ("'" + mUnrestrictedName + "'")
	: defaultFQN ) ) );

	return( defaultFQN );
	}

	inline void virtual strFQN(OutStream & os) const
	{
	os << strFQN();
	}


	/**
	* Serialization
	*/
	inline virtual std::string str() const
	{
	if( not getFullyQualifiedNameID().empty() )
	{
	return( getFullyQualifiedNameID() );
	}
	else if( not getNameID().empty() )
	{
	return( getNameID() );
	}
	return( getUnrestrictedName() );
	}

	};


	} /* namespace sep */

	#endif /* COMMON_NAMEDELEMENT_H_ */