#pragma once

using namespace std;

class UserProc;
class CClass;

class CMethod : public MemberPrototype
{
	const UserProc *pUserProc;

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

		ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( MemberPrototype );
		ar & boost::serialization::make_nvp("pUserProc", const_cast<UserProc *&>(pUserProc));
	}

public:
	CMethod( const UserProc *pUserProc, Prototype::Accessibility accessibility )
		: MemberPrototype( accessibility )
		, pUserProc( pUserProc )
	{
	}
	CMethod()
	{
	}

	const UserProc &GetUserProc() const
	{
		return *pUserProc;
	}
	void SetUserProcPtr( const UserProc *pUserProc )
	{
		this->pUserProc = pUserProc;
	}

	virtual bool Override( const UserProc *pUserProc, Prototype::Accessibility accessibility, bool isOverrideModifier ) = 0;

	virtual bool IsAbstract() const = 0;
	virtual void SetAbstractMark( bool isAbstractMark ) = 0;
	virtual bool IsVirtual() const = 0;
	virtual bool IsConst() const = 0;
	virtual bool IsDynamic() const = 0;
	virtual bool IsStatic() const = 0;
	virtual const CClass *GetInheritsClassPtr() const = 0;
	virtual void SetInheritsClassPtr( const CClass *pInheritsClass ) = 0;
	virtual bool IsNotUse() const = 0;
	virtual void SetNotUseMark( bool isNotUse ) = 0;
};

class DynamicMethod : public CMethod
{
	bool isAbstract;
	bool isVirtual;
	bool isConst;
	const CClass *pInheritsClass;

	// 他のインターフェイスへ実装が移った場合（基底クラスメソッドのインターフェイス実装）はこのフラグをオンにする
	bool isNotUse;

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

		ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( CMethod );
		ar & BOOST_SERIALIZATION_NVP( isAbstract );
		ar & BOOST_SERIALIZATION_NVP( isVirtual );
		ar & BOOST_SERIALIZATION_NVP( isConst );
		ar & boost::serialization::make_nvp("pInheritsClass", const_cast<CClass *&>(pInheritsClass));
		ar & BOOST_SERIALIZATION_NVP( isNotUse );
	}

public:
	DynamicMethod( UserProc *pUserProc, Prototype::Accessibility accessibility, bool isAbstract, bool isVirtual, bool isConst, const CClass *pInheritsClass = NULL )
		: CMethod( pUserProc, accessibility )
		, isAbstract( isAbstract )
		, isVirtual( isVirtual )
		, isConst( isConst )
		, pInheritsClass( pInheritsClass )
		, isNotUse( false )
	{
	}
	DynamicMethod( const CMethod &method )
		: CMethod( &method.GetUserProc(), method.GetAccessibility() )
		, isAbstract( method.IsAbstract() )
		, isVirtual( method.IsVirtual() )
		, isConst( method.IsConst() )
		, pInheritsClass( method.GetInheritsClassPtr() )
		, isNotUse( false )
	{
	}
	DynamicMethod()
	{
	}

	virtual bool Override( const UserProc *pUserProc, Prototype::Accessibility accessibility, bool isOverrideModifier );

	virtual bool IsAbstract() const
	{
		return isAbstract;
	}
	virtual void SetAbstractMark( bool isAbstract )
	{
		this->isAbstract = isAbstract;
	}
	virtual bool IsVirtual() const
	{
		return isVirtual;
	}
	virtual bool IsConst() const
	{
		return isConst;
	}
	virtual bool IsDynamic() const
	{
		return true;
	}
	virtual bool IsStatic() const
	{
		return false;
	}
	virtual const CClass *GetInheritsClassPtr() const
	{
		return pInheritsClass;
	}
	virtual void SetInheritsClassPtr( const CClass *pInheritsClass )
	{
		this->pInheritsClass = pInheritsClass;
	}
	virtual bool IsNotUse() const
	{
		return isNotUse;
	}
	virtual void SetNotUseMark( bool isNotUse )
	{
		this->isNotUse = isNotUse;
	}
};
BOOST_CLASS_EXPORT( DynamicMethod );
class StaticMethod : public CMethod
{
	// XMLシリアライズ用
private:
	friend class boost::serialization::access;
	template<class Archive> void serialize(Archive& ar, const unsigned int version)
	{
		trace_for_serialize( "serializing - StaticMethod" );

		ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( CMethod );
	}

public:

	// コンストラクタ
	StaticMethod( UserProc *pUserProc, Prototype::Accessibility accessibility )
		: CMethod( pUserProc, accessibility )
	{
	}

	// コピーコンストラクタ
	StaticMethod( const StaticMethod &staticMethod );

	// デストラクタ
	StaticMethod()
	{
	}

	virtual bool Override( const UserProc *pUserProc, Prototype::Accessibility accessibility, bool isOverrideModifier )
	{
		throw;
	}

	virtual bool IsAbstract() const
	{
		throw;
	}
	virtual void SetAbstractMark( bool isAbstract )
	{
		throw;
	}
	virtual bool IsVirtual() const{
		return false;
	}
	virtual bool IsConst() const
	{
		throw;
	}
	virtual bool IsDynamic() const
	{
		return false;
	}
	virtual bool IsStatic() const
	{
		return true;
	}
	virtual const CClass *GetInheritsClassPtr() const
	{
		throw;
	}
	virtual void SetInheritsClassPtr( const CClass *pInheritsClass )
	{
		throw;
	}
	virtual bool IsNotUse() const
	{
		return false;
	}
	virtual void SetNotUseMark( bool isNotUse )
	{
		throw;
	}
};
BOOST_CLASS_EXPORT( StaticMethod );

class Methods : public vector<CMethod *>
{
	// XMLシリアライズ用
private:
	friend class boost::serialization::access;
	template<class Archive> void serialize(Archive& ar, const unsigned int version)
	{
		trace_for_serialize( "serializing - Methods" );

		ar & boost::serialization::make_nvp("vector_CMethod", boost::serialization::base_object<vector<CMethod *>>(*this));
	}

public:
	// コンストラクタ
	Methods();

	// コピーコンストラクタ
	Methods( const Methods &methods );

	// デストラクタ
	~Methods();

	//メンバ、メソッドの追加
	void Add( UserProc *pUserProc, Prototype::Accessibility accessibility, bool isConst, bool isAbstract, bool isVirtual );
	void AddStatic(UserProc *pUserProc,Prototype::Accessibility accessibility);

	/*!
	@brief	オーバーライドのための検索
	@param	actualTypeParametersForThisMethods thisオブジェクトで保有するメソッド群を対象とした実型パラメータ
			pUserProc 照らし合わせる関数
	*/
	CMethod *FindForOverride( const Types &actualTypeParametersForThisMethods, const UserProc *pUserProc );

	const CMethod *GetMethodPtr( const UserProc *pUserProc ) const;
	bool IsExist( const char *name ) const;
	virtual void Enum( const char *methodName, vector<const UserProc *> &subs ) const;
	virtual void Enum( BYTE idOperatorCalc, vector<const UserProc *> &subs ) const;

	// 仮想メソッドの個数を取得
	int GetVtblNum() const;

	// vtblを生成
	void GenerateVTablePart( long &vtableDataTableOffset ) const;
};