////////////////////////////////////////////////////////////////////////////
//
//  multivalue.h  マルチヴァリュー
//
//  programmed by Robert (2002/06/09)
//

#ifndef ___MULTIVALUE_H__200206090545__INCLUDED___
#define ___MULTIVALUE_H__200206090545__INCLUDED___

/*
	マルチヴァリューを扱うためのテンプレートです
	普通の値であれば inline 展開により十分高速なコードが生成されます


	使用例）

	Type2<int, int> hoge()
	{
		return Value2(1, 2);
	}

	hoge() >> a >> b;  // >> 演算子で取り出します
	cout << a << ":" << b << endl;  // 1:2 と出力されます


	Type2<const char*, bool> sage()
	{
		// リテラル文字列は暗黙では char* になります
		return Value2<const char*>("sage", true);
	}

	if((sage() >> s).Get())  // Get を使うと変数に保存せずに使えます
		cout << s << endl;


	Type3<int, int, int> age(Value3(7, 8, 9));  // 普通の変数としても使えます

	age >> a >> b;  // 別に３つの値全てを取り出す必要はありません
	cout << a << ":" << b << endl;

	age = Value3(5, 6, 7);
	age.Skip() >> b;  // ２番目の値だけを取得します
	age >> b; cout << b << endl;

	age = RomanticAgeRuyo();  // 戻り値の型は Type3<int, int, int> です
	age >> a >> b >> c;
	cout << a << b << c << endl;
*/


/*
	複数の値を保持するためのクラス
	値を保持して、>> 演算子を使って値を取り出します
	通常、Value 系関数テンプレートを通じて構築します
	>> 演算子の引数で必然的に t_value1& という型を使うので、
	テンプレート引数は参照型にはできません
*/

// １つの値用のマルチ（？）ヴァリュークラステンプレート
template <typename t_value1>
class Type1
{
private:
	t_value1 m_value1;  // 保持する値

public:
	explicit Type1(t_value1& value1)
		: m_value1(value1) { }
	Type1() { }
	void operator>>(t_value1& value1) const    // 値の代入
		{ value1 = m_value1; }
	t_value1 Get() const { return m_value1; }  // 値の取得
};

// ２つの値用のマルチヴァリュークラステンプレート
template <typename t_value1, typename t_value2>
class Type2
{
private:
	typedef Type1 <t_value2> multi_t;
	t_value1 m_value1;
	multi_t  m_multi;

public:
	Type2(t_value1& value1, t_value2& value2)
		: m_value1(value1), m_multi(value2) { }
	Type2() { }

	const multi_t& operator>>(t_value1& value1) const  // 値の代入(const)
		{ value1 = m_value1; return m_multi; }
	multi_t& operator>>(t_value1& value1)              // 値の代入
		{ value1 = m_value1; return m_multi; }
	t_value1 Get() const { return m_value1; }          // 値の取得
	const multi_t& Skip() const { return m_multi; }    // 値のスキップ(const)
	multi_t& Skip() { return m_multi; }                // 値のスキップ
};

// ３つの値用のマルチヴァリュークラステンプレート
template <typename t_value1, typename t_value2, typename t_value3>
class Type3
{
private:
	typedef Type2 <t_value2, t_value3> multi_t;
	t_value1 m_value1;
	multi_t  m_multi;

public:
	Type3(t_value1& value1, t_value2& value2, t_value3& value3)
		: m_value1(value1), m_multi(value2, value3) { }
	Type3() { }

	const multi_t& operator>>(t_value1& value1) const  // 値の代入(const)
		{ value1 = m_value1; return m_multi; }
	multi_t& operator>>(t_value1& value1)              // 値の代入
		{ value1 = m_value1; return m_multi; }
	t_value1 Get() const { return m_value1; }          // 値の取得
	const multi_t& Skip() const { return m_multi; }    // 値のスキップ(const)
	multi_t& Skip() { return m_multi; }                // 値のスキップ
};

// ４つの値用のマルチヴァリュークラステンプレート
template <typename t_value1, typename t_value2, typename t_value3,
		  typename t_value4>
class Type4
{
private:
	typedef Type3 <t_value2, t_value3, t_value4> multi_t;
	t_value1 m_value1;
	multi_t  m_multi;

public:
	Type4(t_value1& value1, t_value2& value2, t_value3& value3,
		  t_value4& value4)
		: m_value1(value1), m_multi(value2, value3, value4) { }
	Type4() { }

	const multi_t& operator>>(t_value1& value1) const  // 値の代入(const)
		{ value1 = m_value1; return m_multi; }
	multi_t& operator>>(t_value1& value1)              // 値の代入
		{ value1 = m_value1; return m_multi; }
	t_value1 Get() const { return m_value1; }          // 値の取得
	const multi_t& Skip() const { return m_multi; }    // 値のスキップ(const)
	multi_t& Skip() { return m_multi; }                // 値のスキップ
};

// ５つの値用のマルチヴァリュークラステンプレート
template <typename t_value1, typename t_value2, typename t_value3,
		  typename t_value4, typename t_value5>
class Type5
{
private:
	typedef Type4 <t_value2, t_value3, t_value4, t_value5> multi_t;
	t_value1 m_value1;
	multi_t  m_multi;

public:
	Type5(t_value1& value1, t_value2& value2, t_value3& value3,
		  t_value4& value4, t_value5& value5)
		: m_value1(value1), m_multi(value2, value3, value4, value5) { }
	Type5() { }

	const multi_t& operator>>(t_value1& value1) const  // 値の代入(const)
		{ value1 = m_value1; return m_multi; }
	multi_t& operator>>(t_value1& value1)              // 値の代入
		{ value1 = m_value1; return m_multi; }
	t_value1 Get() const { return m_value1; }          // 値の取得
	const multi_t& Skip() const { return m_multi; }    // 値のスキップ(const)
	multi_t& Skip() { return m_multi; }                // 値のスキップ
};

// ６つの値用のマルチヴァリュークラステンプレート
template <typename t_value1, typename t_value2, typename t_value3,
		  typename t_value4, typename t_value5, typename t_value6>
class Type6
{
private:
	typedef Type5 <t_value2, t_value3, t_value4, t_value5, t_value6> multi_t;
	t_value1 m_value1;
	multi_t  m_multi;

public:
	Type6(t_value1& value1, t_value2& value2, t_value3& value3,
		  t_value4& value4, t_value5& value5, t_value6& value6)
		: m_value1(value1), m_multi(value2, value3, value4, value5, value6) { }
	Type6() { }

	const multi_t& operator>>(t_value1& value1) const  // 値の代入(const)
		{ value1 = m_value1; return m_multi; }
	multi_t& operator>>(t_value1& value1)              // 値の代入
		{ value1 = m_value1; return m_multi; }
	t_value1 Get() const { return m_value1; }          // 値の取得
	const multi_t& Skip() const { return m_multi; }    // 値のスキップ(const)
	multi_t& Skip() { return m_multi; }                // 値のスキップ
};

// これ以上は必要になったときに各自増やしてください
// 意外と簡単に増やせます

// １つの値用のマルチ（？）ヴァリューオブジェクトを返します
template <typename t_value1>
inline Type1<t_value1> Value1(t_value1 value1)
{
	return Type1<t_value1>
		(value1);
}

// ２つの値用のマルチヴァリューオブジェクトを返します
template <typename t_value1, typename t_value2>
inline Type2<t_value1, t_value2>
	Value2(t_value1 value1, t_value2 value2)
{
	return Type2<t_value1, t_value2>
		(value1, value2);
}

// ３つの値用のマルチヴァリューオブジェクトを返します
template <typename t_value1, typename t_value2, typename t_value3>
inline Type3<t_value1, t_value2, t_value3>
	Value3(t_value1 value1, t_value2 value2, t_value3 value3)
{
	return Type3<t_value1, t_value2, t_value3>
		(value1, value2, value3);
}

// ４つの値用のマルチヴァリューオブジェクトを返します
template <typename t_value1, typename t_value2, typename t_value3,
		  typename t_value4>
inline Type4<t_value1, t_value2, t_value3, t_value4>
	Value4(t_value1 value1, t_value2 value2, t_value3 value3,
		   t_value4 value4)
{
	return Type4<t_value1, t_value2, t_value3, t_value4>
		(value1, value2, value3, value4);
}

// ５つの値用のマルチヴァリューオブジェクトを返します
template <typename t_value1, typename t_value2, typename t_value3,
		  typename t_value4, typename t_value5>
inline Type5<t_value1, t_value2, t_value3, t_value4, t_value5>
	Value5(t_value1 value1, t_value2 value2, t_value3 value3,
		   t_value4 value4, t_value5 value5)
{
	return Type5<t_value1, t_value2, t_value3, t_value4, t_value5>
		(value1, value2, value3, value4, value5);
}

// ６つの値用のマルチヴァリューオブジェクトを返します
template <typename t_value1, typename t_value2, typename t_value3,
		  typename t_value4, typename t_value5, typename t_value6>
inline Type6<t_value1, t_value2, t_value3, t_value4, t_value5, t_value6>
	Value6(t_value1 value1, t_value2 value2, t_value3 value3,
		   t_value4 value4, t_value5 value5, t_value6 value6)
{
	return Type6<t_value1, t_value2, t_value3, t_value4, t_value5, t_value6>
		(value1, value2, value3, value4, value5, value6);
}

// これ以上は必要になったときに各自増やしてください

#endif  // #ifndef ___MULTIVALUE_H__200206090545__INCLUDED___