#include "pip.h"
#include "pivariantsimple.h"


template<typename T>
struct __VariantTypeInfo__ {
	typedef T PureType;
	typedef const T ConstPureType;
	typedef T * PointerType;
	typedef const T * ConstPointerType;
	typedef T & ReferenceType;
	typedef const T & ConstReferenceType;
};

#define __TYPEINFO_SINGLE(PT, T) \
	template<> struct __PIVariantTypeInfo__<T> { \
		typedef PT PureType; \
		typedef const PT ConstPureType; \
		typedef PT * PointerType; \
		typedef const PT * ConstPointerType; \
		typedef PT & ReferenceType; \
		typedef const PT & ConstReferenceType; \
	};

#define REGISTER_VARIANT_TYPEINFO(T) \
	__TYPEINFO_SINGLE(T, T &) \
	__TYPEINFO_SINGLE(T, const T) \
	__TYPEINFO_SINGLE(T, const T &)



struct SwitchChannel {
	SwitchChannel(bool on_ = true, float dur_ = 10.f, int m_count = 0, short unrely = -1) {
		on = on_ ? 1 : 0;
		duration = dur_;
		max_count = m_count;
		overload[0] = overload[1] = false;
		unreliability = unrely;
	}
	uchar on;
	short unreliability;
	float duration;
	int max_count;
	bool overload[2];
};
/*
inline PIByteArray & operator <<(PIByteArray & ba, const SwitchChannel & v) {
	PIChunkStream cs;
	cs << cs.chunk(1, v.on)
	   << cs.chunk(2, v.duration)
	   << cs.chunk(3, v.max_count)
	   << cs.chunk(4, v.unreliability);
	ba << cs.data();
	return ba;
}
inline PIByteArray & operator >>(PIByteArray & ba, SwitchChannel & v) {
	PIByteArray src; ba >> src; PIChunkStream cs(src);
	while (!cs.atEnd()) {
		switch (cs.read()) {
		case 1: cs.get(v.on); break;
		case 2: cs.get(v.duration); break;
		case 3: cs.get(v.max_count); break;
		case 4: cs.get(v.unreliability); break;
		}
	}
	return ba;
}*/
inline PICout operator <<(PICout c, const SwitchChannel & v) {
	c << v.on << v.duration << v.max_count << v.unreliability;
	return c;
}



int Acnt = 0;

class A {
public:
	A() {moved = false; i = "constructor"; piCout << "A()"; ++Acnt;}
	A(const PIString & s): i(s) {moved = false; piCout << "A(String)"; ++Acnt;}
	A(const A & a): i(a.i) {moved = false; piCout << "copy A(&)"; ++Acnt;}
	A(A && a): i(std::move(a.i)) {moved = false; a.moved = true; piCout << "copy A(&&)"; ++Acnt;}
	~A() {piCout << "~A()" << moved; --Acnt;}
	void swap(A & a) {piCout << "swap A()"; piSwap(i, a.i);}
	A & operator =(const A & a) {i = a.i; piCout << "= A&"; return *this;}
	A & operator =(A && a) {piSwap(i, a.i); a.moved = true; piCout << "= A&&)"; return *this;}
	PIString i;
	bool moved;
	static void F(int) {}
};
PIByteArray & operator <<(PIByteArray & ba, const A & v) {ba << v.i; return ba;}
PIByteArray & operator >>(PIByteArray & ba,       A & v) {ba >> v.i; return ba;}


int main() {
	A a;
	PIByteArray ba;
	ba >> a;
}