#pragma once

namespace ActiveBasic{ namespace Common{ namespace Lexical{


class Prototype : public Symbol
{
public:
	enum Accessibility{
		None,
		Private,
		Protected,
		Public,
	};

private:
	mutable bool isUsing;


	// XMLシリアライズ用
private:
	friend class boost::serialization::access;
	template<class Archive> void serialize(Archive& ar, const unsigned int version)
	{
		ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Symbol );
		ar & BOOST_SERIALIZATION_NVP( isUsing );
	}


public:

	Prototype( const NamespaceScopes &namespaceScopes, const std::string &name )
		: Symbol( namespaceScopes, name )
		, isUsing( false )
	{
	}
	Prototype()
		: Symbol()
	{
	}
	~Prototype()
	{
	}

	//自身と等しいかどうかを確認
	bool IsEquals( const Prototype *prototype ) const
	{
		if( this == prototype ){
			return true;
		}
		return false;
	}

	// 利用状況
	bool IsUsing() const
	{
		return isUsing;
	}
	void Using() const
	{
		isUsing = true;
	}
};

class MemberPrototype
{
	Prototype::Accessibility accessibility;

	// XMLシリアライズ用
private:
	friend class boost::serialization::access;
	template<class Archive> void serialize(Archive& ar, const unsigned int version)
	{
		ar & BOOST_SERIALIZATION_NVP( accessibility );
	}

public:
	MemberPrototype( Prototype::Accessibility accessibility )
		: accessibility( accessibility )
	{
	}
	MemberPrototype()
		: accessibility( Prototype::None )
	{
	}

	Prototype::Accessibility GetAccessibility() const
	{
		return accessibility;
	}
	void SetAccessibility( Prototype::Accessibility accessibility ){
		this->accessibility = accessibility;
	}

	bool IsNoneAccess() const
	{
		return ( accessibility == Prototype::None );
	}
	bool IsPrivate() const
	{
		return ( accessibility == Prototype::Private );
	}
	bool IsProtected() const
	{
		return ( accessibility == Prototype::Protected );
	}
	bool IsPublic() const
	{
		return ( accessibility == Prototype::Public );
	}
};


}}}