#ifndef CLASSDESC_SIMPLE_BUFFER_H

#define CLASSDESC_SIMPLE_BUFFER_H

#include <json_pack_base.h>

#include <boost/variant.hpp>

#include <deque>

namespace classdesc

{

struct TypeVisitor: public boost::static_visitor<RESTProcessType::Type>, public RESTProcessType

};

struct ToJsonVisitor: public boost::static_visitor<json_pack_t>

};

using SuperVariant=boost::variant<bool,int,double,string,json_pack_t,std::deque<json_pack_t>>;

struct SimpleBuffer: public SuperVariant

};

const SimpleBuffer& operator>>(const SimpleBuffer& b, bool& x)

{x=boost::get<bool>(b); return b;}

SimpleBuffer& operator<<(SimpleBuffer& b, const bool& x)

{b=x; return b;}

const SimpleBuffer& operator>>(const SimpleBuffer& b, char& x)

{x=boost::get<string>(b)[0]; return b;}

SimpleBuffer& operator<<(SimpleBuffer& b, const char& x)

{b=string{x}; return b;}

// numbers

template <class T>

typename enable_if<

And<is_arithmetic<T>,Not<is_same<T,bool>>,Not<is_const<T>>>,

const SimpleBuffer&>::T

operator>>(const SimpleBuffer& b, T& x)

{

switch (b.type())

{

case RESTProcessType::float_number:

x=boost::get<double>(b);

break;

case RESTProcessType::int_number:

x=boost::get<int>(b);

break;

case RESTProcessType::object:

boost::get<json_pack_t>(b)>>x;

break;

default:

throw std::runtime_error("Invalid variant type");

}

return b;

}

template <class T>

typename enable_if<

And<is_arithmetic<T>,Not<is_same<T,bool>>>,

SimpleBuffer&>::T

operator<<(SimpleBuffer& b, const T& x)

{b=double(x); return b;}

// strings

template <class T>

typename enable_if<And<is_string<T>,Not<is_const<T>>>, const SimpleBuffer&>::T

operator>>(const SimpleBuffer& b, T& x)

{x=boost::get<string>(b); return b;}

template <class T>

typename enable_if<And<is_string<T>>, SimpleBuffer&>::T

operator<<(SimpleBuffer& b, const T& x)

{b=string(x); return b;}

// enums

template <class T>

typename enable_if<And<is_enum<T>,Not<is_const<T>>>, const SimpleBuffer&>::T

operator>>(const SimpleBuffer& b, T& x)

{auto tmp=boost::get<string>(b); x=enum_keys<T>()(tmp); return b;}

template <class T>

typename enable_if<And<is_enum<T>>, SimpleBuffer&>::T

operator<<(SimpleBuffer& b, const T& x)

{b=to_string(x); return b;}

// sequences

template <class T>

typename enable_if<And<is_sequence<T>,Not<is_const<T>>>, const SimpleBuffer&>::T

operator>>(const SimpleBuffer& b, T& x)

{

resize(x,0);

if (b.type()!=RESTProcessType::array) return b;

auto& arr=b.array();

for (auto& i: arr)

{

typename T::value_type e;

i>>e;

push_back(x,e);

}

return b;

}

template <class T>

typename enable_if<is_sequence<T>, SimpleBuffer&>::T

operator<<(SimpleBuffer& b, const T& x)

{

std::deque<json_pack_t> tmp;

for (auto& i: x)

{

tmp.emplace_back();

tmp.back()<<i;

}

b=SimpleBuffer(tmp);

return b;

}

// const

template <class T>

typename enable_if<is_const<T>, const SimpleBuffer&>::T

operator>>(const SimpleBuffer& b, T& x)

{return b;}

const SimpleBuffer& operator>>(const SimpleBuffer& b, const char* x)

{

throw std::runtime_error("cannot unpack to char*, please use string instead");

}

// everything else

template <class T>

typename enable_if<

And<

Not<is_arithmetic<T>>,

Not<is_string<T>>,

Not<is_sequence<T>>,

Not<is_enum<T>>,

Not<is_const<T>>

>, const SimpleBuffer&>::T

operator>>(const SimpleBuffer& b, T& x)

{

boost::get<json_pack_t>(b)>>x;

return b;

}

template <class T>

typename enable_if<

And<

Not<is_arithmetic<T>>,

Not<is_string<T>>,

Not<is_sequence<T>>,

Not<is_enum<T>>

>, SimpleBuffer&>::T

operator<<(SimpleBuffer& b, const T& x)

{

json_pack_t tmp; tmp<<x;

b=tmp;

return b;

}

template <>

std::string typeName<SimpleBuffer>() {return "SimpleBuffer";}

}

#pragma omit json_pack classdesc::SimpleBuffer

#pragma omit json_unpack classdesc::SimpleBuffer

#pragma omit RESTProcess classdesc::SimpleBuffer

#endif