git-svn-id: svn://db.shs.com.ru/pip@181 12ceb7fc-bf1f-11e4-8940-5bc7170c53b5

main.cpp

@@ -3,17 +3,36 @@
 #include "piconfig.h"
 #include "piscreentiles.h"
 #include "piscreen.h"
+#include "piethernet.h"
 
 
 int main (int argc, char * argv[]) {
-	PIScreen screen;
+	PIVector<PIVariant> vl;
+	vl << PIVariant('2') << PIVariant(-5.5) << PIVariant(10) << PIVariant(complexd(2,3)) << PIVariant("text") << PIVariant(PIByteArray("bytearray", 9)) << PIVariant(PIDateTime::current());
+	piForeachC (PIVariant v, vl)
+		piCout << v << v.value<PIString>();
+	PIByteArray ba; ba << PIString("500");
+	piCout << PIVariant::fromValue(ba, "PIString");
+	piCout << PIVariant("PIString");
+	piCout << __PIVariantFunctions__<int>::typeNameHelper();
+	piCout << __PIVariantInfoStorage__::get()->map->size();
+	/*Variant v = v2;
+	piCout << v;
+	piCout << vv;*/
+
+	for (PIMap<PIString, __PIVariantInfo__*>::iterator i = __PIVariantInfoStorage__::get()->map->begin(); i != __PIVariantInfoStorage__::get()->map->end(); ++i)
+		piCout << i.key() << i.value()->cast.size();
+
+	PIEthernet eth;
+	piCout << eth.properties();
+	/*PIScreen screen;
 	TileSimple window;
 	window.back_format.color_back = PIScreenTypes::Red;
 	window.content << TileSimple::Row("label", PIScreenTypes::CellFormat(PIScreenTypes::Black, PIScreenTypes::Transparent));
 	screen.rootTile()->addTile(&window);
 	screen.enableExitCapture(PIKbdListener::F10);
 	screen.start();
-	screen.waitForFinish();
+	screen.waitForFinish();*/
 	return 0;
 }
 

src/core/pibytearray.h

@@ -138,6 +138,10 @@ inline PICout operator <<(PICout s, const PIByteArray & ba) {s.space(); s.setCon
 
 #define PBA_OPERATOR_TO int os = s.size_s(); s.enlarge(sizeof(v)); memcpy(s.data(os), &v, sizeof(v));
 
+//! \relatesalso PIByteArray \brief Store operator
+inline PIByteArray & operator <<(PIByteArray & s, bool v) {s.push_back(v); return s;}
+//! \relatesalso PIByteArray \brief Store operator
+inline PIByteArray & operator <<(PIByteArray & s, char v) {s.push_back(v); return s;}
 //! \relatesalso PIByteArray \brief Store operator
 inline PIByteArray & operator <<(PIByteArray & s, uchar v) {s.push_back(v); return s;}
 //! \relatesalso PIByteArray \brief Store operator
@@ -160,6 +164,8 @@ inline PIByteArray & operator <<(PIByteArray & s, const ullong & v) {PBA_OPERATO
 inline PIByteArray & operator <<(PIByteArray & s, const float v) {PBA_OPERATOR_TO return s;}
 //! \relatesalso PIByteArray \brief Store operator
 inline PIByteArray & operator <<(PIByteArray & s, const double & v) {PBA_OPERATOR_TO return s;}
+//! \relatesalso PIByteArray \brief Store operator
+inline PIByteArray & operator <<(PIByteArray & s, const ldouble & v) {PBA_OPERATOR_TO return s;}
 //! \relatesalso PIByteArray \brief Store operator, see \ref PIByteArray_sec1 for details
 inline PIByteArray & operator <<(PIByteArray & s, const PIByteArray & v) {s << int(v.size_s()); int os = s.size_s(); s.enlarge(v.size_s()); if (v.size_s() > 0) memcpy(s.data(os), v.data(), v.size()); return s;}
 //! \relatesalso PIByteArray \brief Store operator, see \ref PIByteArray_sec1 for details
@@ -184,6 +190,10 @@ inline PIByteArray & operator <<(PIByteArray & s, const T & v) {PBA_OPERATOR_TO
 #undef PBA_OPERATOR_TO
 #define PBA_OPERATOR_FROM memcpy(&v, s.data(), sizeof(v)); s.remove(0, sizeof(v));
 
+//! \relatesalso PIByteArray \brief Restore operator
+inline PIByteArray & operator >>(PIByteArray & s, bool & v) {assert(s.size() >= 1u); v = s.take_front(); return s;}
+//! \relatesalso PIByteArray \brief Restore operator
+inline PIByteArray & operator >>(PIByteArray & s, char & v) {assert(s.size() >= 1u); v = s.take_front(); return s;}
 //! \relatesalso PIByteArray \brief Restore operator
 inline PIByteArray & operator >>(PIByteArray & s, uchar & v) {assert(s.size() >= 1u); v = s.take_front(); return s;}
 //! \relatesalso PIByteArray \brief Restore operator
@@ -206,6 +216,8 @@ inline PIByteArray & operator >>(PIByteArray & s, ullong & v) {assert(s.size() >
 inline PIByteArray & operator >>(PIByteArray & s, float & v) {assert(s.size() >= sizeof(v)); PBA_OPERATOR_FROM return s;}
 //! \relatesalso PIByteArray \brief Restore operator
 inline PIByteArray & operator >>(PIByteArray & s, double & v) {assert(s.size() >= sizeof(v)); PBA_OPERATOR_FROM return s;}
+//! \relatesalso PIByteArray \brief Restore operator
+inline PIByteArray & operator >>(PIByteArray & s, ldouble & v) {assert(s.size() >= sizeof(v)); PBA_OPERATOR_FROM return s;}
 //! \relatesalso PIByteArray \brief Restore operator, see \ref PIByteArray_sec1 for details
 inline PIByteArray & operator >>(PIByteArray & s, PIByteArray & v) {assert(s.size_s() >= 4); int sz; s >> sz; v.resize(sz); if (sz > 0) memcpy(v.data(), s.data(), v.size()); s.remove(0, v.size()); return s;}
 //! \relatesalso PIByteArray \brief Restore operator, see \ref PIByteArray_sec1 for details

src/core/piobject.cpp

@@ -73,6 +73,7 @@ PIString PIObject::__EHFunc::fullFormat() const {
 
 PIObject::PIObject(const PIString & name): _signature_(__PIOBJECT_SIGNATURE__), emitter_(0), thread_safe_(false) {
 	piMonitor.objects++;
+	__PIVariantInitBuiltin__();
 	setName(name);
 	setDebug(true);
 	objects << this;

src/core/pivariant.cpp

@@ -40,7 +40,7 @@
  * \endcode
  * Result:
  * \code{cpp}
- * {PIVariant(Int, 10), PIVariant(Double, 1,61), PIVariant(Bool, true), PIVariant(String, 0xFF)}
+ * {PIVariant(int, 10), PIVariant(double, 1,61), PIVariant(bool, true), PIVariant(PIString, 0xFF)}
  * 10
  * 1
  * 1
@@ -48,487 +48,240 @@
  * \endcode
  * */
 
+PIMap<PIString, __PIVariantInfo__ * > * __PIVariantInfoStorage__::map = 0;
 
-PIVariant::PIVariant() {
+REGISTER_VARIANT_CPP(bool)
-	type_ = PIVariant::Invalid;
+REGISTER_VARIANT_CPP(char)
-	memset(_vraw, 0, __PIVARIANT_UNION_SIZE__);
+REGISTER_VARIANT_CPP(uchar)
-}
+REGISTER_VARIANT_CPP(short)
-
+REGISTER_VARIANT_CPP(ushort)
-
+REGISTER_VARIANT_CPP(int)
-PIVariant & PIVariant::operator =(const PIVariant & v) {
+REGISTER_VARIANT_CPP(uint)
-	type_ = v.type_;
+REGISTER_VARIANT_CPP(llong)
-	memcpy(_vraw, v._vraw, __PIVARIANT_UNION_SIZE__);
+REGISTER_VARIANT_CPP(ullong)
-	_vbytearray = v._vbytearray;
+REGISTER_VARIANT_CPP(float)
-	_vbitarray = v._vbitarray;
+REGISTER_VARIANT_CPP(double)
-	_vstring = v._vstring;
+REGISTER_VARIANT_CPP(ldouble)
-	_vstringlist = v._vstringlist;
+REGISTER_VARIANT_CPP(complexf)
-	_vcustom = v._vcustom;
+REGISTER_VARIANT_CPP(complexd)
-	return *this;
+REGISTER_VARIANT_CPP(complexld)
-}
+REGISTER_VARIANT_CPP(PIChar)
-
+REGISTER_VARIANT_CPP(PIString)
-
+REGISTER_VARIANT_CPP(PIStringList)
-bool PIVariant::operator ==(const PIVariant & v) const {
+REGISTER_VARIANT_CPP(PIByteArray)
-	if (type_ != v.type_) return false;
+REGISTER_VARIANT_CPP(PISystemTime)
-	switch (type_) {
+REGISTER_VARIANT_CPP(PITime)
-	case PIVariant::Bool:
+REGISTER_VARIANT_CPP(PIDate)
-	case PIVariant::Char:
+REGISTER_VARIANT_CPP(PIDateTime)
-	case PIVariant::UChar:
+
-	case PIVariant::Short:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, char)
-	case PIVariant::UShort:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, uchar)
-	case PIVariant::Int:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, short)
-	case PIVariant::UInt:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, ushort)
-	case PIVariant::Long:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, int)
-	case PIVariant::ULong: return _vint == v._vint;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, uint)
-	case PIVariant::LLong:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, llong)
-	case PIVariant::ULLong: return _vllong == v._vllong;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, ullong)
-	case PIVariant::Float: return _vfloat == v._vfloat;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, float)
-	case PIVariant::Double: return _vdouble == v._vdouble;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, double)
-	case PIVariant::LDouble: return _vldouble == v._vldouble;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, ldouble)
-	case PIVariant::Complexd: return _vcomplexd == _vvcomplexd(v);
+
-	case PIVariant::Complexld: return _vcomplexld == _vvcomplexld(v);
+REGISTER_VARIANT_CAST_SIMPLE_CPP(char, bool)
-	case PIVariant::BitArray: return _vbitarray == v._vbitarray;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(char, uchar)
-	case PIVariant::ByteArray: return _vbytearray == v._vbytearray;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(char, short)
-	case PIVariant::String: return _vstring == v._vstring;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(char, ushort)
-	case PIVariant::StringList: return _vstringlist == v._vstringlist;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(char, int)
-	case PIVariant::Time: return _vtime == _vvtime(v);
+REGISTER_VARIANT_CAST_SIMPLE_CPP(char, uint)
-	case PIVariant::Date: return _vdate == _vvdate(v);
+REGISTER_VARIANT_CAST_SIMPLE_CPP(char, llong)
-	case PIVariant::DateTime: return _vdatetime == _vvdatetime(v);
+REGISTER_VARIANT_CAST_SIMPLE_CPP(char, ullong)
-	case PIVariant::SystemTime: return _vsystime == _vvsystime(v);
+REGISTER_VARIANT_CAST_SIMPLE_CPP(char, float)
-	default: break;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(char, double)
-	};
+REGISTER_VARIANT_CAST_SIMPLE_CPP(char, ldouble)
-	return false;
+
-}
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, bool)
-
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, char)
-
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, short)
-PIVariant::Type PIVariant::typeFromName(const PIString & tname) {
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, ushort)
-	PIString s = tname.trimmed().toLowerCase().replaceAll(" ", "");
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, int)
-	if (s == "bool" || s == "boolean") return PIVariant::Bool;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, uint)
-	if (s == "char" || s == "sbyte") return PIVariant::Char;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, llong)
-	if (s == "short" || s == "shortint" || s == "signedshort" || s == "signedshortint" || s == "sword") return PIVariant::Short;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, ullong)
-	if (s == "int" || s == "signed" || s == "signedint") return PIVariant::Int;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, float)
-	if (s == "long" || s == "longint" || s == "signedlong" || s == "signedlongint" || s == "sdword") return PIVariant::Long;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, double)
-	if (s == "llong" || s == "longlong" || s == "longlongint" || s == "signedlonglong" || s == "signedlonglongint" || s == "sqword") return PIVariant::LLong;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, ldouble)
-	if (s == "uchar" || s == "byte") return PIVariant::UChar;
+
-	if (s == "ushort" || s == "unsignedshort" || s == "unsignedshortint" || s == "word") return PIVariant::UShort;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(short, bool)
-	if (s == "uint" || s == "unsigned" || s == "unsignedint") return PIVariant::UInt;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(short, char)
-	if (s == "ulong" || s == "unsignedlong" || s == "unsignedlongint" || s == "dword") return PIVariant::ULong;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(short, uchar)
-	if (s == "ullong" || s == "unsignedlonglong" || s == "unsignedlonglongint" || s == "qword") return PIVariant::ULLong;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(short, ushort)
-	if (s == "float") return PIVariant::Float;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(short, int)
-	if (s == "double" || s == "real") return PIVariant::Double;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(short, uint)
-	if (s == "ldouble" || s == "longdouble") return PIVariant::LDouble;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(short, llong)
-	if (s == "complexd" || s == "complex<double>") return PIVariant::Complexd;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(short, ullong)
-	if (s == "complexld" || s == "complex<ldouble>" || s == "complex<longdouble>") return PIVariant::Complexld;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(short, float)
-	if (s == "pibitarray" || s == "bitarray") return PIVariant::BitArray;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(short, double)
-	if (s == "pibytearray" || s == "bytearray" || s == "vector<uchar>" || s == "pivector<uchar>" || s == "vector<unsignedchar>" || s == "pivector<unsignedchar>" ||
+REGISTER_VARIANT_CAST_SIMPLE_CPP(short, ldouble)
-		s == "vector<char>" || s == "pivector<char>") return PIVariant::ByteArray;
+
-	if (s == "pistring" || s == "string") return PIVariant::String;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, bool)
-	if (s == "pistringlist" || s == "stringlist" || s == "vector<string>" || s == "vector<pistring>" || s == "pivector<string>" || s == "pivector<pistring>") return PIVariant::StringList;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, char)
-	if (s == "pitime" || s == "time") return PIVariant::Time;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, uchar)
-	if (s == "pidate" || s == "date") return PIVariant::Date;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, short)
-	if (s == "pidatetime" || s == "datetime") return PIVariant::DateTime;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, int)
-	if (s == "pisystemtime" || s == "systemtime") return PIVariant::SystemTime;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, uint)
-	return PIVariant::Invalid;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, llong)
-}
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, ullong)
-
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, float)
-
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, double)
-PIString PIVariant::typeName(PIVariant::Type type) {
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, ldouble)
-	switch (type) {
+
-	case PIVariant::Bool: return "Bool";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(int, bool)
-	case PIVariant::Char: return "Char";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(int, char)
-	case PIVariant::UChar: return "UChar";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(int, uchar)
-	case PIVariant::Short: return "Short";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(int, short)
-	case PIVariant::UShort: return "UShort";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(int, ushort)
-	case PIVariant::Int: return "Int";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(int, uint)
-	case PIVariant::UInt: return "UInt";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(int, llong)
-	case PIVariant::Long: return "Long";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(int, ullong)
-	case PIVariant::ULong: return "ULong";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(int, float)
-	case PIVariant::LLong: return "LLong";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(int, double)
-	case PIVariant::ULLong: return "ULLong";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(int, ldouble)
-	case PIVariant::Float: return "Float";
+
-	case PIVariant::Double: return "Double";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, bool)
-	case PIVariant::LDouble: return "LDouble";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, char)
-	case PIVariant::Complexd: return "Complexd";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, uchar)
-	case PIVariant::Complexld: return "Complexld";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, short)
-	case PIVariant::BitArray: return "BitArray";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, ushort)
-	case PIVariant::ByteArray: return "ByteArray";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, int)
-	case PIVariant::String: return "String";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, llong)
-	case PIVariant::StringList: return "StringList";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, ullong)
-	case PIVariant::Time: return "Time";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, float)
-	case PIVariant::Date: return "Date";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, double)
-	case PIVariant::DateTime: return "DateTime";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, ldouble)
-	case PIVariant::SystemTime: return "SystemTime";
+
-	case PIVariant::Custom: return "Custom";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, bool)
-	default: break;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, char)
-	}
+REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, uchar)
-	return "Invalid";
+REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, short)
-}
+REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, ushort)
-
+REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, int)
-
+REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, uint)
-/** \brief Returns variant content as boolean
+REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, ullong)
- * \details In case of numeric types returns \b true if value != 0. \n
+REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, float)
- * In case of String type returns \a PIString::toBool(). \n
+REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, double)
- * In case of StringList type returns \b false if string list is empty,
+REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, ldouble)
- * otherwise returns \a PIString::toBool() of first string. \n
+
- * In case of other types returns \b false. */
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, bool)
-bool PIVariant::toBool() const {
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, char)
-	switch (type_) {
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, uchar)
-	case PIVariant::Bool:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, short)
-	case PIVariant::Char:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, ushort)
-	case PIVariant::UChar:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, int)
-	case PIVariant::Short:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, uint)
-	case PIVariant::UShort:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, llong)
-	case PIVariant::Int:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, float)
-	case PIVariant::UInt:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, double)
-	case PIVariant::Long:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, ldouble)
-	case PIVariant::ULong: return _vint != 0;
+
-	case PIVariant::LLong:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(float, bool)
-	case PIVariant::ULLong: return _vllong != 0;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(float, char)
-	case PIVariant::Float: return _vfloat != 0;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(float, uchar)
-	case PIVariant::Double: return _vdouble != 0;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(float, short)
-	case PIVariant::LDouble: return _vldouble != 0;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(float, ushort)
-	case PIVariant::Complexd: return _vcomplexd.real() != 0;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(float, int)
-	case PIVariant::Complexld: return _vcomplexld.real() != 0;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(float, uint)
-	case PIVariant::String: return _vstring.toBool();
+REGISTER_VARIANT_CAST_SIMPLE_CPP(float, llong)
-	case PIVariant::StringList: if (_vstringlist.isEmpty()) return false; return _vstringlist.front().toBool();
+REGISTER_VARIANT_CAST_SIMPLE_CPP(float, ullong)
-	default: break;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(float, double)
-	}
+REGISTER_VARIANT_CAST_SIMPLE_CPP(float, ldouble)
-	return false;
+
-}
+REGISTER_VARIANT_CAST_SIMPLE_CPP(double, bool)
-
+REGISTER_VARIANT_CAST_SIMPLE_CPP(double, char)
-
+REGISTER_VARIANT_CAST_SIMPLE_CPP(double, uchar)
-
+REGISTER_VARIANT_CAST_SIMPLE_CPP(double, short)
-/** \brief Returns variant content as int
+REGISTER_VARIANT_CAST_SIMPLE_CPP(double, ushort)
- * \details In case of numeric types returns integer value. \n
+REGISTER_VARIANT_CAST_SIMPLE_CPP(double, int)
- * In case of String type returns \a PIString::toInt(). \n
+REGISTER_VARIANT_CAST_SIMPLE_CPP(double, uint)
- * In case of StringList type returns \b 0 if string list is empty,
+REGISTER_VARIANT_CAST_SIMPLE_CPP(double, llong)
- * otherwise returns \a PIString::toInt() of first string. \n
+REGISTER_VARIANT_CAST_SIMPLE_CPP(double, ullong)
- * In case of other types returns \b 0. */
+REGISTER_VARIANT_CAST_SIMPLE_CPP(double, float)
-int PIVariant::toInt() const {
+REGISTER_VARIANT_CAST_SIMPLE_CPP(double, ldouble)
-	switch (type_) {
+
-	case PIVariant::Bool:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, bool)
-	case PIVariant::Char:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, char)
-	case PIVariant::UChar:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, uchar)
-	case PIVariant::Short:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, short)
-	case PIVariant::UShort:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, ushort)
-	case PIVariant::Int:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, int)
-	case PIVariant::UInt:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, uint)
-	case PIVariant::Long:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, llong)
-	case PIVariant::ULong: return _vint;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, ullong)
-	case PIVariant::LLong:
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, float)
-	case PIVariant::ULLong: return _vllong;
+REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, double)
-	case PIVariant::Float: return _vfloat;
+
-	case PIVariant::Double: return _vdouble;
+REGISTER_VARIANT_CAST_CPP(bool, PIString) {return PIString::fromBool(v);}
-	case PIVariant::LDouble: return _vldouble;
+REGISTER_VARIANT_CAST_CPP(char, PIString) {return PIString(PIChar(v));}
-	case PIVariant::Complexd: return _vcomplexd.real();
+REGISTER_VARIANT_CAST_CPP(uchar, PIString) {return PIString::fromNumber(v);}
-	case PIVariant::Complexld: return _vcomplexld.real();
+REGISTER_VARIANT_CAST_CPP(short, PIString) {return PIString::fromNumber(v);}
-	case PIVariant::String: return _vstring.toInt();
+REGISTER_VARIANT_CAST_CPP(ushort, PIString) {return PIString::fromNumber(v);}
-	case PIVariant::StringList: if (_vstringlist.isEmpty()) return 0; return _vstringlist.front().toInt();
+REGISTER_VARIANT_CAST_CPP(int, PIString) {return PIString::fromNumber(v);}
-	default: break;
+REGISTER_VARIANT_CAST_CPP(uint, PIString) {return PIString::fromNumber(v);}
-	}
+REGISTER_VARIANT_CAST_CPP(llong, PIString) {return PIString::fromNumber(v);}
-	return 0;
+REGISTER_VARIANT_CAST_CPP(ullong, PIString) {return PIString::fromNumber(v);}
-}
+REGISTER_VARIANT_CAST_CPP(float, PIString) {return PIString::fromNumber(v);}
-
+REGISTER_VARIANT_CAST_CPP(double, PIString) {return PIString::fromNumber(v);}
-
+REGISTER_VARIANT_CAST_CPP(ldouble, PIString) {return PIString::fromNumber(v);}
-/** \brief Returns variant content as long long
+REGISTER_VARIANT_CAST_CPP(complexf, PIString) {return "(" + PIString::fromNumber(v.real()) + " + " + PIString::fromNumber(v.imag()) + "i)";}
- * \details In case of numeric types returns integer value. \n
+REGISTER_VARIANT_CAST_CPP(complexd, PIString) {return "(" + PIString::fromNumber(v.real()) + " + " + PIString::fromNumber(v.imag()) + "i)";}
- * In case of String type returns \a PIString::toLLong(). \n
+REGISTER_VARIANT_CAST_CPP(complexld, PIString) {return "(" + PIString::fromNumber(v.real()) + " + " + PIString::fromNumber(v.imag()) + "i)";}
- * In case of StringList type returns \b 0L if string list is empty,
+REGISTER_VARIANT_CAST_CPP(PIChar, PIString) {return PIString(v);}
- * otherwise returns \a PIString::toLLong() of first string. \n
+REGISTER_VARIANT_CAST_CPP(PIString, PIString) {return v;}
- * In case of other types returns \b 0L. */
+REGISTER_VARIANT_CAST_CPP(PIStringList, PIString) {return v.join(", ");}
-llong PIVariant::toLLong() const {
+REGISTER_VARIANT_CAST_CPP(PIByteArray, PIString) {return v.toString();}
-	switch (type_) {
+REGISTER_VARIANT_CAST_CPP(PISystemTime, PIString) {return PIString::fromNumber(v.seconds) + " s, " + PIString::fromNumber(v.nanoseconds) + " ns";}
-	case PIVariant::Bool:
+REGISTER_VARIANT_CAST_CPP(PITime, PIString) {return v.toString();}
-	case PIVariant::Char:
+REGISTER_VARIANT_CAST_CPP(PIDate, PIString) {return v.toString();}
-	case PIVariant::UChar:
+REGISTER_VARIANT_CAST_CPP(PIDateTime, PIString) {return v.toString();}
-	case PIVariant::Short:
+
-	case PIVariant::UShort:
+REGISTER_VARIANT_CAST_CPP(PIString, bool) {return v.toBool();}
-	case PIVariant::Int:
+REGISTER_VARIANT_CAST_CPP(PIString, char) {return v.toChar();}
-	case PIVariant::UInt:
+REGISTER_VARIANT_CAST_CPP(PIString, uchar) {return v.toChar();}
-	case PIVariant::Long:
+REGISTER_VARIANT_CAST_CPP(PIString, short) {return v.toShort();}
-	case PIVariant::ULong: return _vint;
+REGISTER_VARIANT_CAST_CPP(PIString, ushort) {return v.toUShort();}
-	case PIVariant::LLong:
+REGISTER_VARIANT_CAST_CPP(PIString, int) {return v.toInt();}
-	case PIVariant::ULLong: return _vllong;
+REGISTER_VARIANT_CAST_CPP(PIString, uint) {return v.toUInt();}
-	case PIVariant::Float: return _vfloat;
+REGISTER_VARIANT_CAST_CPP(PIString, llong) {return v.toLLong();}
-	case PIVariant::Double: return _vdouble;
+REGISTER_VARIANT_CAST_CPP(PIString, ullong) {return v.toULLong();}
-	case PIVariant::LDouble: return _vldouble;
+REGISTER_VARIANT_CAST_CPP(PIString, float) {return v.toFloat();}
-	case PIVariant::Complexd: return _vcomplexd.real();
+REGISTER_VARIANT_CAST_CPP(PIString, double) {return v.toDouble();}
-	case PIVariant::Complexld: return _vcomplexld.real();
+REGISTER_VARIANT_CAST_CPP(PIString, ldouble) {return v.toLDouble();}
-	case PIVariant::String: return _vstring.toLLong();
+REGISTER_VARIANT_CAST_CPP(PIString, PIByteArray) {return v.toByteArray();}
-	case PIVariant::StringList: if (_vstringlist.isEmpty()) return 0L; return _vstringlist.front().toLLong();
+REGISTER_VARIANT_CAST_CPP(PIString, PIStringList) {return PIStringList(v);}
-	default: break;
+
-	}
+void __PIVariantInitBuiltin__() {
-	return 0L;
+	static bool first = true;
-}
+	if (!first) return;
-
+	first = false;
-
+	INIT_VARIANT(bool)
-/** \brief Returns variant content as float
+	INIT_VARIANT(char)
- * \details In case of numeric types returns float value. \n
+	INIT_VARIANT(uchar)
- * In case of String type returns \a PIString::toFloat(). \n
+	INIT_VARIANT(short)
- * In case of StringList type returns \b 0.f if string list is empty,
+	INIT_VARIANT(ushort)
- * otherwise returns \a PIString::toFloat() of first string. \n
+	INIT_VARIANT(int)
- * In case of other types returns \b 0.f. */
+	INIT_VARIANT(uint)
-float PIVariant::toFloat() const {
+	INIT_VARIANT(llong)
-	switch (type_) {
+	INIT_VARIANT(ullong)
-	case PIVariant::Bool:
+	INIT_VARIANT(float)
-	case PIVariant::Char:
+	INIT_VARIANT(double)
-	case PIVariant::UChar:
+	INIT_VARIANT(ldouble)
-	case PIVariant::Short:
+	INIT_VARIANT(complexf)
-	case PIVariant::UShort:
+	INIT_VARIANT(complexd)
-	case PIVariant::Int:
+	INIT_VARIANT(complexld)
-	case PIVariant::UInt:
+	INIT_VARIANT(PIChar)
-	case PIVariant::Long:
+	INIT_VARIANT(PIString)
-	case PIVariant::ULong: return _vint;
+	INIT_VARIANT(PIStringList)
-	case PIVariant::LLong:
+	INIT_VARIANT(PIByteArray)
-	case PIVariant::ULLong: return _vllong;
+	INIT_VARIANT(PISystemTime)
-	case PIVariant::Float: return _vfloat;
+	INIT_VARIANT(PITime)
-	case PIVariant::Double: return _vdouble;
+	INIT_VARIANT(PIDate)
-	case PIVariant::LDouble: return _vldouble;
+	INIT_VARIANT(PIDateTime)
-	case PIVariant::Complexd: return _vcomplexd.real();
-	case PIVariant::Complexld: return _vcomplexld.real();
-	case PIVariant::String: return _vstring.toFloat();
-	case PIVariant::StringList: if (_vstringlist.isEmpty()) return 0.f; return _vstringlist.front().toFloat();
-	default: break;
-	}
-	return 0.f;
-}
-
-
-/** \brief Returns variant content as double
- * \details In case of numeric types returns double value. \n
- * In case of String type returns \a PIString::toDouble(). \n
- * In case of StringList type returns \b 0. if string list is empty,
- * otherwise returns \a PIString::toDouble() of first string. \n
- * In case of other types returns \b 0.. */
-double PIVariant::toDouble() const {
-	switch (type_) {
-	case PIVariant::Bool:
-	case PIVariant::Char:
-	case PIVariant::UChar:
-	case PIVariant::Short:
-	case PIVariant::UShort:
-	case PIVariant::Int:
-	case PIVariant::UInt:
-	case PIVariant::Long:
-	case PIVariant::ULong: return _vint;
-	case PIVariant::LLong:
-	case PIVariant::ULLong: return _vllong;
-	case PIVariant::Float: return _vfloat;
-	case PIVariant::Double: return _vdouble;
-	case PIVariant::LDouble: return _vldouble;
-	case PIVariant::Complexd: return _vcomplexd.real();
-	case PIVariant::Complexld: return _vcomplexld.real();
-	case PIVariant::String: return _vstring.toDouble();
-	case PIVariant::StringList: if (_vstringlist.isEmpty()) return 0.; return _vstringlist.front().toDouble();
-	default: break;
-	}
-	return 0.;
-}
-
-
-/** \brief Returns variant content as long double
- * \details In case of numeric types returns long double value. \n
- * In case of String type returns \a PIString::toLDouble(). \n
- * In case of StringList type returns \b 0. if string list is empty,
- * otherwise returns \a PIString::toLDouble() of first string. \n
- * In case of other types returns \b 0.. */
-ldouble PIVariant::toLDouble() const {
-	switch (type_) {
-	case PIVariant::Bool:
-	case PIVariant::Char:
-	case PIVariant::UChar:
-	case PIVariant::Short:
-	case PIVariant::UShort:
-	case PIVariant::Int:
-	case PIVariant::UInt:
-	case PIVariant::Long:
-	case PIVariant::ULong: return _vint;
-	case PIVariant::LLong:
-	case PIVariant::ULLong: return _vllong;
-	case PIVariant::Float: return _vfloat;
-	case PIVariant::Double: return _vdouble;
-	case PIVariant::LDouble: return _vldouble;
-	case PIVariant::Complexd: return _vcomplexd.real();
-	case PIVariant::Complexld: return _vcomplexld.real();
-	case PIVariant::String: return _vstring.toLDouble();
-	case PIVariant::StringList: if (_vstringlist.isEmpty()) return 0.; return _vstringlist.front().toLDouble();
-	default: break;
-	}
-	return 0.;
-}
-
-
-/** \brief Returns variant content as complex
- * \details In case of numeric types returns complex value. \n
- * In case of String type returns \a PIString::toDouble(). \n
- * In case of StringList type returns \b 0. if string list is empty,
- * otherwise returns \a PIString::toDouble() of first string. \n
- * In case of other types returns \b 0.. */
-complexd PIVariant::toComplexd() const {
-	switch (type_) {
-	case PIVariant::Bool:
-	case PIVariant::Char:
-	case PIVariant::UChar:
-	case PIVariant::Short:
-	case PIVariant::UShort:
-	case PIVariant::Int:
-	case PIVariant::UInt:
-	case PIVariant::Long:
-	case PIVariant::ULong: return _vint;
-	case PIVariant::LLong:
-	case PIVariant::ULLong: return _vllong;
-	case PIVariant::Float: return _vfloat;
-	case PIVariant::Double: return _vdouble;
-	case PIVariant::LDouble: return _vldouble;
-	case PIVariant::Complexd: return _vcomplexd.real();
-	case PIVariant::Complexld: return _vcomplexld.real();
-	case PIVariant::String: return _vstring.toDouble();
-	case PIVariant::StringList: if (_vstringlist.isEmpty()) return complexd_0; return _vstringlist.front().toDouble();
-	default: break;
-	}
-	return complexd_0;
-}
-
-
-/** \brief Returns variant content as long complex
- * \details In case of numeric types returns long complex value. \n
- * In case of String type returns \a PIString::toLDouble(). \n
- * In case of StringList type returns \b 0. if string list is empty,
- * otherwise returns \a PIString::toLDouble() of first string. \n
- * In case of other types returns \b 0.. */
-complexld PIVariant::toComplexld() const {
-	switch (type_) {
-	case PIVariant::Bool:
-	case PIVariant::Char:
-	case PIVariant::UChar:
-	case PIVariant::Short:
-	case PIVariant::UShort:
-	case PIVariant::Int:
-	case PIVariant::UInt:
-	case PIVariant::Long:
-	case PIVariant::ULong: return _vint;
-	case PIVariant::LLong:
-	case PIVariant::ULLong: return _vllong;
-	case PIVariant::Float: return _vfloat;
-	case PIVariant::Double: return _vdouble;
-	case PIVariant::LDouble: return _vldouble;
-	case PIVariant::Complexd: return _vcomplexd.real();
-	case PIVariant::Complexld: return _vcomplexld.real();
-	case PIVariant::String: return _vstring.toLDouble();
-	case PIVariant::StringList: if (_vstringlist.isEmpty()) return complexld_0; return _vstringlist.front().toLDouble();
-	default: break;
-	}
-	return complexld_0;
-}
-
-
-/** \brief Returns variant content as time
- * \details In case of Time type returns time value. \n
- * In case of DateTime type returns time part of value. \n
- * In case of other types returns \a PITime(). */
-PITime PIVariant::toTime() const {
-	if (type_ == PIVariant::Time) return _vtime;
-	if (type_ == PIVariant::DateTime) return _vtime;
-	return PITime();
-}
-
-
-/** \brief Returns variant content as date
- * \details In case of Date type returns date value. \n
- * In case of DateTime type returns date part of value. \n
- * In case of other types returns \a PIDate(). */
-PIDate PIVariant::toDate() const {
-	if (type_ == PIVariant::Date) return _vdate;
-	if (type_ == PIVariant::DateTime) return *((PIDate*)(&(_vdatetime.day)));
-	return PIDate();
-}
-
-
-/** \brief Returns variant content as date and time
- * \details In case of Time type returns time value with null date. \n
- * In case of Date type returns date value with null time. \n
- * In case of DateTime type returns date and time. \n
- * In case of other types returns \a PIDateTime(). */
-PIDateTime PIVariant::toDateTime() const {
-	if (type_ == PIVariant::DateTime) return _vdatetime;
-	if (type_ == PIVariant::Time) return PIDateTime(_vtime);
-	if (type_ == PIVariant::Date) return PIDateTime(_vdate);
-	return PIDateTime();
-}
-
-
-/** \brief Returns variant content as system time
- * \details In case of SystemTime type returns system time. \n
- * In case of other types returns \a PISystemTime::fromSeconds() from
- * double value of variant content. */
-PISystemTime PIVariant::toSystemTime() const {
-	if (type_ == PIVariant::SystemTime) return _vsystime;
-	return PISystemTime::fromSeconds(toDouble());
-}
-
-
-/** \brief Returns variant content as string
- * \details In case of numeric types returns \a PIString::fromNumber(). \n
- * In case of String type returns string value. \n
- * In case of StringList type returns joined string ("(" + PIStringList::join("; ") + ")"). \n
- * In case of BitArray or ByteArray types returns number of bits/bytes. \n
- * In case of Time, Date or DateTime types returns toString() of this values. \n
- * In case of SystemTime types returns second and nanoseconds of time
- * ("(PISystemTime::seconds s, PISystemTime::nanoseconds ns)"). \n
- * In case of other types returns \b "". */
-PIString PIVariant::toString() const {
-	switch (type_) {
-	case PIVariant::Bool: return _vint == 0 ? "false" : "true";
-	case PIVariant::Char:
-	case PIVariant::UChar:
-	case PIVariant::Short:
-	case PIVariant::UShort:
-	case PIVariant::Int:
-	case PIVariant::UInt:
-	case PIVariant::Long:
-	case PIVariant::ULong: return PIString::fromNumber(_vint);
-	case PIVariant::LLong:
-	case PIVariant::ULLong: return PIString::fromNumber(_vllong);
-	case PIVariant::Float: return PIString::fromNumber(_vfloat);
-	case PIVariant::Double: return PIString::fromNumber(_vdouble);
-	case PIVariant::LDouble: return PIString::fromNumber(_vldouble);
-	case PIVariant::Complexd: return "(" + PIString::fromNumber(_vcomplexd.real()) + "; " + PIString::fromNumber(_vcomplexd.imag()) + ")";
-	case PIVariant::Complexld: return "(" + PIString::fromNumber(_vcomplexld.real()) + "; " + PIString::fromNumber(_vcomplexld.imag()) + ")";
-	case PIVariant::BitArray: return PIString::fromNumber(_vbitarray.bitSize()) + " bits";
-	case PIVariant::ByteArray: return _vbytearray.toString();
-	case PIVariant::String: return _vstring;
-	case PIVariant::StringList: return "(" + _vstringlist.join("; ") + ")";
-	case PIVariant::Time: return _vtime.toString();
-	case PIVariant::Date: return _vdate.toString();
-	case PIVariant::DateTime: return _vdatetime.toString();
-	case PIVariant::SystemTime: return "(" + PIString::fromNumber(_vsystime.seconds) + " s, " + PIString::fromNumber(_vsystime.nanoseconds) + " ns)";
-	default: break;
-	}
-	return "";
-}
-
-
-/** \brief Returns variant content as strings list
- * \details In case of StringList type returns strings list value. \n
- * In case of other types returns \a PIStringList with one string value of variant content. */
-PIStringList PIVariant::toStringList() const {
-	if (type_ == PIVariant::StringList) return _vstringlist;
-	return PIStringList(toString());
-}
-
-
-/** \brief Returns variant content as bit array
- * \details In case of BitArray type returns bit array value. \n
- * In case of other types returns \a PIBitArray from \a toLLong() value. */
-PIBitArray PIVariant::toBitArray() const {
-	if (type_ == PIVariant::BitArray) return _vbitarray;
-	return PIBitArray(ullong(toLLong()));
-}
-
-
-/** \brief Returns variant content as byte array
- * \details In case of ByteArray type returns byte array value. \n
- * In case of other types returns empty \a PIByteArray. */
-PIByteArray PIVariant::toByteArray() const {
-	if (type_ == PIVariant::ByteArray) return _vbytearray;
-	return PIByteArray();
 }

src/core/pivariant.h

@@ -1,11 +1,11 @@
 /*! \file pivariant.h
- * \brief Variant type
+ * \brief PIVariant type
  * 
  * This file declares PIVariant
 */
 /*
     PIP - Platform Independent Primitives
-    Variant type
+	PIVariant type
     Copyright (C) 2015  Ivan Pelipenko peri4ko@gmail.com
 
     This program is free software: you can redistribute it and/or modify
@@ -30,432 +30,407 @@
 #include "pitime.h"
 #include "pimathbase.h"
 
-#define __PIVARIANT_UNION_SIZE__ 32
 
-#define _vcomplexd (*((complexd*)_vraw))
+template<typename T>
-#define _vcomplexld (*((complexld*)_vraw))
+class __PIVariantFunctions__ {
-#define _vtime (*((PITime*)_vraw))
-#define _vdate (*((PIDate*)_vraw))
-#define _vdatetime (*((PIDateTime*)_vraw))
-#define _vsystime (*((PISystemTime*)_vraw))
-
-#define _vvcomplexd(v) (*((complexd*)v._vraw))
-#define _vvcomplexld(v) (*((complexld*)v._vraw))
-#define _vvtime(v) (*((PITime*)v._vraw))
-#define _vvdate(v) (*((PIDate*)v._vraw))
-#define _vvdatetime(v) (*((PIDateTime*)v._vraw))
-#define _vvsystime(v) (*((PISystemTime*)v._vraw))
-
-class PIP_EXPORT PIVariant {
-	friend PICout operator <<(PICout s, const PIVariant & v);
 public:
-	
+	static PIString typeNameHelper() {return PIStringAscii("");}
-	//! Type of %PIVariant content
+
-	enum Type {
+	static bool isSimpleHelper() {return false;}
-		Invalid /** Invalid type , default type of empty contructor */ = 0 ,
+	template<typename C> static PIByteArray castHelper(PIByteArray ba) {return PIByteArray();}
-		Bool /** bool */ ,
+	template<typename C> static C castVariant(const T & v) {return C();}
-		Char /** char */ ,
-		UChar /** uchar */ ,
-		Short /** short */ ,
-		UShort /** ushort */ ,
-		Int /** int */ ,
-		UInt /** uint */ ,
-		Long /** long */ ,
-		ULong /** ulong */ ,
-		LLong /** llong */ ,
-		ULLong /** ullong */ ,
-		Float /** float */ ,
-		Double /** double */ ,
-		LDouble /** ldouble */ ,
-		Complexd /** complexd */ ,
-		Complexld /** complexld */ ,
-		BitArray /** PIBitArray */ ,
-		ByteArray /** PIByteArray */ ,
-		String /** PIString */ ,
-		StringList /** PIStringList */ ,
-		Time /** PITime */ ,
-		Date /** PIDate */ ,
-		DateTime /** PIDateTime */ ,
-		SystemTime /** PISystemTime */ ,
-		Custom /** Custom */ = 0xFF
-	};
-	
-	//! Empty constructor, \a type() will be set to \a Invalid
-	PIVariant();
-	
-	//! Constructs variant from string
-	PIVariant(const char * v) {setValue(PIString(v));}
-	
-	//! Constructs variant from boolean
-	PIVariant(const bool v) {setValue(v);}
-	
-	//! Constructs variant from char
-	PIVariant(const char v) {setValue(v);}
-	
-	//! Constructs variant from integer
-	PIVariant(const uchar v) {setValue(v);}
-	
-	//! Constructs variant from integer
-	PIVariant(const short v) {setValue(v);}
-	
-	//! Constructs variant from integer
-	PIVariant(const ushort v) {setValue(v);}
-	
-	//! Constructs variant from integer
-	PIVariant(const int & v) {setValue(v);}
-	
-	//! Constructs variant from integer
-	PIVariant(const uint & v) {setValue(v);}
-	
-	//! Constructs variant from integer
-	PIVariant(const long & v) {setValue(v);}
-	
-	//! Constructs variant from integer
-	PIVariant(const ulong & v) {setValue(v);}
-	
-	//! Constructs variant from integer
-	PIVariant(const llong & v) {setValue(v);}
-	
-	//! Constructs variant from integer
-	PIVariant(const ullong & v) {setValue(v);}
-	
-	//! Constructs variant from float
-	PIVariant(const float & v) {setValue(v);}
-	
-	//! Constructs variant from double
-	PIVariant(const double & v) {setValue(v);}
-	
-	//! Constructs variant from long double
-	PIVariant(const ldouble & v) {setValue(v);}
-	
-	//! Constructs variant from complex
-	PIVariant(const complexd & v) {setValue(v);}
-	
-	//! Constructs variant from complex
-	PIVariant(const complexld & v) {setValue(v);}
-	
-	//! Constructs variant from bit array
-	PIVariant(const PIBitArray & v) {setValue(v);}
-	
-	//! Constructs variant from byte array
-	PIVariant(const PIByteArray & v) {setValue(v);}
-	
-	//! Constructs variant from string
-	PIVariant(const PIString & v) {setValue(v);}
-	
-	//! Constructs variant from strings list
-	PIVariant(const PIStringList & v) {setValue(v);}
-	
-	//! Constructs variant from time
-	PIVariant(const PITime & v) {setValue(v);}
-	
-	//! Constructs variant from date
-	PIVariant(const PIDate & v) {setValue(v);}
-	
-	//! Constructs variant from date and time
-	PIVariant(const PIDateTime & v) {setValue(v);}
-	
-	//! Constructs variant from system time
-	PIVariant(const PISystemTime & v) {setValue(v);}
-	
-	
-	//! Set variant content and type to string
-	void setValue(const char * v) {setValue(PIString(v));}
-	
-	//! Set variant content and type to boolean
-	void setValue(const bool v) {type_ = PIVariant::Bool; _vint = (v ? 1 : 0);}
-	
-	//! Set variant content and type to char
-	void setValue(const char v) {type_ = PIVariant::Char; _vint = v;}
-	
-	//! Set variant content and type to integer
-	void setValue(const uchar v) {type_ = PIVariant::UChar; _vint = v;}
-	
-	//! Set variant content and type to integer
-	void setValue(const short v) {type_ = PIVariant::Short; _vint = v;}
-	
-	//! Set variant content and type to integer
-	void setValue(const ushort v) {type_ = PIVariant::UShort; _vint = v;}
-	
-	//! Set variant content and type to integer
-	void setValue(const int & v) {type_ = PIVariant::Int; _vint = v;}
-	
-	//! Set variant content and type to integer
-	void setValue(const uint & v) {type_ = PIVariant::UInt; _vint = v;}
-	
-	//! Set variant content and type to integer
-	void setValue(const long & v) {type_ = PIVariant::Long; _vint = v;}
-	
-	//! Set variant content and type to integer
-	void setValue(const ulong & v) {type_ = PIVariant::ULong; _vint = v;}
-	
-	//! Set variant content and type to integer
-	void setValue(const llong & v) {type_ = PIVariant::LLong; _vllong = v;}
-	
-	//! Set variant content and type to integer
-	void setValue(const ullong & v) {type_ = PIVariant::ULLong; _vllong = v;}
-	
-	//! Set variant content and type to float
-	void setValue(const float & v) {type_ = PIVariant::Float; _vfloat = v;}
-	
-	//! Set variant content and type to double
-	void setValue(const double & v) {type_ = PIVariant::Double; _vdouble = v;}
-	
-	//! Set variant content and type to long double
-	void setValue(const ldouble & v) {type_ = PIVariant::LDouble; _vldouble = v;}
-	
-	//! Set variant content and type to complex
-	void setValue(const complexd & v) {type_ = PIVariant::Complexd; _vcomplexd = v;}
-	
-	//! Set variant content and type to complex
-	void setValue(const complexld & v) {type_ = PIVariant::Complexld; _vcomplexld = v;}
-	
-	//! Set variant content and type to bit array
-	void setValue(const PIBitArray & v) {type_ = PIVariant::BitArray; _vbitarray = v;}
-	
-	//! Set variant content and type to byte array
-	void setValue(const PIByteArray & v) {type_ = PIVariant::ByteArray; _vbytearray = v;}
-	
-	//! Set variant content and type to string
-	void setValue(const PIString & v) {type_ = PIVariant::String; _vstring = v;}
-	
-	//! Set variant content and type to strings list
-	void setValue(const PIStringList & v) {type_ = PIVariant::StringList; _vstringlist = v;}
-	
-	//! Set variant content and type to time
-	void setValue(const PITime & v) {type_ = PIVariant::Time; _vtime = v;}
-	
-	//! Set variant content and type to date
-	void setValue(const PIDate & v) {type_ = PIVariant::Date; _vdate = v;}
-	
-	//! Set variant content and type to date and time
-	void setValue(const PIDateTime & v) {type_ = PIVariant::DateTime; _vdatetime = v;}
-	
-	//! Set variant content and type to system time
-	void setValue(const PISystemTime & v) {type_ = PIVariant::SystemTime; _vsystime = v;}
-	
-	
-	bool toBool() const;
-	int toInt() const;
-	llong toLLong() const;
-	float toFloat() const;
-	double toDouble() const;
-	ldouble toLDouble() const;
-	complexd toComplexd() const;
-	complexld toComplexld() const;
-	PITime toTime() const;
-	PIDate toDate() const;
-	PIDateTime toDateTime() const;
-	PISystemTime toSystemTime() const;
-	PIString toString() const;
-	PIStringList toStringList() const;
-	PIBitArray toBitArray() const;
-	PIByteArray toByteArray() const;
-	
-	
-	/** \brief Returns variant content as custom type
-	* \details In case of known types this function equivalent \a to<Type> function. \n
-	* Otherwise returns content as type T. */
-	template<typename T>
-	T toValue() const {if (_vcustom.size() != sizeof(T)) return T(); return *((T*)_vcustom.data());}
-	/*
-	operator bool() const {return toBool();}
-	operator char() const {return toInt();}
-	operator uchar() const {return toInt();}
-	operator short() const {return toInt();}
-	operator ushort() const {return toInt();}
-	operator int() const {return toInt();}
-	operator uint() const {return toInt();}
-	operator long() const {return toInt();}
-	operator ulong() const {return toInt();}
-	operator llong() const {return toLLong();}
-	operator ullong() const {return (ullong)toLLong();}
-	operator float() const {return toFloat();}
-	operator double() const {return toDouble();}
-	operator ldouble() const {return toLDouble();}
-	operator complexd() const {return toComplexd();}
-	operator complexld() const {return toComplexld();}
-	operator PITime() const {return toTime();}
-	operator PIDate() const {return toDate();}
-	operator PIDateTime() const {return toDateTime();}
-	operator PIString() const {return toString();}
-	operator PIStringList() const {return toStringList();}
-	operator PIBitArray() const {return toBitArray();}
-	operator PIByteArray() const {return toByteArray();}
-	operator const char*() const {return toString().data();}
-	operator void*() const {return (void*)(toLLong());}
-	*/
-	
-	//! Assign operator
-	PIVariant & operator =(const PIVariant & v);
-	//! Assign operator
-	PIVariant & operator =(const char * v) {setValue(PIString(v)); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const bool v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const char v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const uchar v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const short v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const ushort v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const int & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const uint & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const long & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const ulong & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const llong & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const ullong & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const float & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const double & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const ldouble & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const complexd & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const complexld & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const PIBitArray & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const PIByteArray & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const PIString & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const PIStringList & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const PITime & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const PIDate & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const PIDateTime & v) {setValue(v); return *this;}
-	//! Assign operator
-	PIVariant & operator =(const PISystemTime & v) {setValue(v); return *this;}
-	
-	
-	//! Compare operator
-	bool operator ==(const PIVariant & v) const;
-	//! Compare operator
-	bool operator !=(const PIVariant & v) const {return !(*this == v);}
-	
-	
-	//! Returns type of variant content
-	PIVariant::Type type() const {return type_;}
-	
-	//! Returns type name of variant content
-	PIString typeName() const {return typeName(type_);}
-	
-	
-	//! Returns \b true if type is not Invalid
-	bool isValid() const {return type_ != PIVariant::Invalid;}
-	
-	
-	/** \brief Returns new variant from custom type
-	* \details In case of known types this function equivalent \a PIVariant(T) constructors. \n
-	* Otherwise returns variant with content \a v and type Custom. */
-	template <typename T>
-	static PIVariant fromValue(const T & v) {PIVariant ret; ret._vcustom.resize(sizeof(T)); new((T*)(ret._vcustom.data()))T(v); ret.type_ = PIVariant::Custom; return ret;}
-	
-	
-	//! Returns type from name
-	static PIVariant::Type typeFromName(const PIString & tname);
-	
-	//! Returns type name
-	static PIString typeName(PIVariant::Type type);
-	
-private:
-	void destroy() {_vcustom.clear();}
-	
-	union {
-		int _vint;
-		llong _vllong;
-		float _vfloat;
-		double _vdouble;
-		ldouble _vldouble;
-		uchar _vraw[__PIVARIANT_UNION_SIZE__];
-		/*complexd _vcomplexd;
-		complexld _vcomplexld;
-		PITime _vtime;
-		PIDate _vdate;
-		PIDateTime _vdatetime;
-		PISystemTime _vsystime;*/
-	};
-	PIBitArray _vbitarray;
-	PIByteArray _vbytearray;
-	PIString _vstring;
-	PIStringList _vstringlist;
-	PIByteArray _vcustom;
-	PIVariant::Type type_;
-	
 };
 
-template<> inline bool PIVariant::toValue() const {return toBool();}
+struct __PIVariantInfo__ {
-template<> inline char PIVariant::toValue() const {return (char)toInt();}
+	__PIVariantInfo__() {
-template<> inline uchar PIVariant::toValue() const {return (uchar)toInt();}
+		simple = false;
-template<> inline short PIVariant::toValue() const {return (short)toInt();}
+	}
-template<> inline ushort PIVariant::toValue() const {return (ushort)toInt();}
+	typedef PIByteArray(*castHelperFunc)(PIByteArray);
-template<> inline int PIVariant::toValue() const {return toInt();}
+	PIMap<PIString, castHelperFunc> cast;
-template<> inline uint PIVariant::toValue() const {return (uint)toInt();}
+	PIString typeName;
-template<> inline long PIVariant::toValue() const {return (long)toInt();}
+	bool simple;
-template<> inline ulong PIVariant::toValue() const {return (ulong)toInt();}
+};
-template<> inline llong PIVariant::toValue() const {return toLLong();}
-template<> inline ullong PIVariant::toValue() const {return (ullong)toLLong();}
-template<> inline float PIVariant::toValue() const {return toFloat();}
-template<> inline double PIVariant::toValue() const {return toDouble();}
-template<> inline ldouble PIVariant::toValue() const {return toLDouble();}
-template<> inline complexd PIVariant::toValue() const {return toComplexd();}
-template<> inline complexld PIVariant::toValue() const {return toComplexld();}
-template<> inline void* PIVariant::toValue() const {return (void*)toLLong();}
-template<> inline const char* PIVariant::toValue() const {return toString().data();}
-template<> inline PITime PIVariant::toValue() const {return toTime();}
-template<> inline PIDate PIVariant::toValue() const {return toDate();}
-template<> inline PIDateTime PIVariant::toValue() const {return toDateTime();}
-template<> inline PIString PIVariant::toValue() const {return toString();}
-template<> inline PIStringList PIVariant::toValue() const {return toStringList();}
-template<> inline PIBitArray PIVariant::toValue() const {return toBitArray();}
-template<> inline PIByteArray PIVariant::toValue() const {return toByteArray();}
 
-//template<> inline PIVariant PIVariant::fromValue(const char * v) {return PIVariant(PIString(v));}
+class __PIVariantInfoStorage__ {
-template<> inline PIVariant PIVariant::fromValue(const bool & v) {return PIVariant(v);}
+public:
-template<> inline PIVariant PIVariant::fromValue(const char & v) {return PIVariant(v);}
+	__PIVariantInfoStorage__() {if (!map) map = new PIMap<PIString, __PIVariantInfo__ * >();}
-template<> inline PIVariant PIVariant::fromValue(const uchar & v) {return PIVariant(v);}
+	static __PIVariantInfoStorage__ * get() {static __PIVariantInfoStorage__ * r = new __PIVariantInfoStorage__(); return r;}
-template<> inline PIVariant PIVariant::fromValue(const short & v) {return PIVariant(v);}
+	static PIMap<PIString, __PIVariantInfo__ * > * map;
-template<> inline PIVariant PIVariant::fromValue(const ushort & v) {return PIVariant(v);}
+};
-template<> inline PIVariant PIVariant::fromValue(const int & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const uint & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const long & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const ulong & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const llong & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const ullong & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const float & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const double & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const ldouble & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const complexd & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const complexld & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const PIBitArray & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const PIByteArray & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const PIString & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const PIStringList & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const PITime & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const PIDate & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const PIDateTime & v) {return PIVariant(v);}
-template<> inline PIVariant PIVariant::fromValue(const PISystemTime & v) {return PIVariant(v);}
 
-inline PICout operator <<(PICout s, const PIVariant & v) {
-	s.space(); s.setControl(0, true);
-	s << "PIVariant(" << PIVariant::typeName(v.type()) << ", ";
-	if (v.type() == PIVariant::Custom) s << v._vcustom.size() << " bytes";
-	else s << v.toString();
-	s << ")";
-	s.restoreControl(); return s;
-}
 
+#define REGISTER_VARIANT_H(classname) \
+template<> inline PIString __PIVariantFunctions__< classname >::typeNameHelper() {static PIString tn = PIStringAscii(#classname); return tn;}
+
+#define REGISTER_VARIANT_CPP(classname) \
+template <typename T> \
+class __##classname##_PIVariantInitializer__ { \
+public: \
+	__##classname##_PIVariantInitializer__(const PIString & name) { \
+		if (__PIVariantInfoStorage__::get()->map->contains(name)) \
+			return; \
+		__PIVariantInfo__ * vi = new __PIVariantInfo__(); \
+		vi->typeName = name; \
+		(*(__PIVariantInfoStorage__::get()->map))[name] = vi; \
+	} \
+};
+
+#define INIT_VARIANT(classname) \
+	__##classname##_PIVariantInitializer__< classname > __##classname##_pivariant_initializer__(#classname);
+
+#define REGISTER_VARIANT(classname) \
+	REGISTER_VARIANT_H(classname) \
+	REGISTER_VARIANT_CPP(classname) \
+	static INIT_VARIANT(classname)
+
+
+#define REGISTER_VARIANT_CAST_H(classname_from, classname_to) \
+template<> template<> inline \
+classname_to __PIVariantFunctions__<classname_from>::castVariant<classname_to>(const classname_from & v);
+
+#define REGISTER_VARIANT_CAST_CPP(classname_from, classname_to) \
+template<> template<> inline \
+PIByteArray __PIVariantFunctions__<classname_from>::castHelper<classname_to>(PIByteArray v) { \
+	classname_from f; v >> f; \
+	classname_to t = __PIVariantFunctions__<classname_from>::castVariant<classname_to>(f); \
+	PIByteArray ret; ret << t; \
+	return ret;} \
+template <typename T, typename C> \
+class __##classname_from##_##classname_to##_PIVariantCastInitializer__ { \
+public: \
+	__##classname_from##_##classname_to##_PIVariantCastInitializer__(const PIString & name, const PIString & cname) { \
+		__PIVariantInfo__ * vi(__PIVariantInfoStorage__::get()->map->value(name, 0)); \
+		if (!vi) { \
+			piCout << "Warning! Using REGISTER_VARIANT_CAST("#classname_from", "#classname_to") before REGISTER_VARIANT("#classname_from"), ignore."; \
+			return; \
+		} \
+		vi->cast[cname] = __PIVariantFunctions__<classname_from>::castHelper<classname_to>; \
+	} \
+}; \
+static __##classname_from##_##classname_to##_PIVariantCastInitializer__< classname_from, classname_to > __##classname_from##_##classname_to##_pivariant_cast_initializer__(#classname_from, #classname_to); \
+template<> template<> \
+classname_to __PIVariantFunctions__<classname_from>::castVariant<classname_to>(const classname_from & v)
+
+#define REGISTER_VARIANT_CAST(classname_from, classname_to) \
+	REGISTER_VARIANT_CAST_H(classname_from, classname_to) \
+	REGISTER_VARIANT_CAST_CPP(classname_from, classname_to)
+
+
+#define REGISTER_VARIANT_CAST_SIMPLE(classname_from, classname_to) REGISTER_VARIANT_CAST(classname_from, classname_to) {return classname_to(v);}
+#define REGISTER_VARIANT_CAST_SIMPLE_H(classname_from, classname_to) REGISTER_VARIANT_CAST_H(classname_from, classname_to)
+#define REGISTER_VARIANT_CAST_SIMPLE_CPP(classname_from, classname_to) REGISTER_VARIANT_CAST_CPP(classname_from, classname_to) {return classname_to(v);}
+
+class PIP_EXPORT PIVariant {
+public:
+	PIVariant(char v) {initType(v);}
+	PIVariant(uchar v) {initType(v);}
+	PIVariant(short v) {initType(v);}
+	PIVariant(ushort v) {initType(v);}
+	PIVariant(int v = 0) {initType(v);}
+	PIVariant(uint v) {initType(v);}
+	PIVariant(llong v) {initType(v);}
+	PIVariant(ullong v) {initType(v);}
+	PIVariant(float v) {initType(v);}
+	PIVariant(double v) {initType(v);}
+	PIVariant(ldouble v) {initType(v);}
+	PIVariant(complexf v) {initType(v);}
+	PIVariant(complexd v) {initType(v);}
+	PIVariant(complexld v) {initType(v);}
+	PIVariant(PIString v) {initType(v);}
+	PIVariant(const char * v) {initType(PIString(v));}
+	PIVariant(PIStringList v) {initType(v);}
+	PIVariant(PIByteArray v) {initType(v);}
+	PIVariant(PISystemTime v) {initType(v);}
+	PIVariant(PITime v) {initType(v);}
+	PIVariant(PIDate v) {initType(v);}
+	PIVariant(PIDateTime v) {initType(v);}
+
+	bool isValid() const {return !typeName().isEmpty();}
+	PIString typeName() const {return _info ? _info->typeName : PIString();}
+	PIByteArray content() const {return _content;}
+
+	bool toBool() const {return value<bool>();}
+	char toChar() const {return value<char>();}
+	uchar toUChar() const {return value<uchar>();}
+	short toShort() const {return value<short>();}
+	ushort toUShort() const {return value<ushort>();}
+	int toInt() const {return value<int>();}
+	uint toUInt() const {return value<uint>();}
+	llong toLLong() const {return value<llong>();}
+	ullong toULLong() const {return value<ullong>();}
+	float toFloat() const {return value<float>();}
+	double toDouble() const {return value<double>();}
+	ldouble toLDouble() const {return value<ldouble>();}
+	complexf toComplexf() const {return value<complexf>();}
+	complexd toComplexd() const {return value<complexd>();}
+	complexld toComplexld() const {return value<complexld>();}
+	PIString toString() const {return value<PIString>();}
+	PIStringList toStringList() const {return value<PIStringList>();}
+	PIByteArray toByteArray() const {return value<PIByteArray>();}
+	PISystemTime toSystemTime() const {return value<PISystemTime>();}
+	PITime toTime() const {return value<PITime>();}
+	PIDate toDate() const {return value<PIDate>();}
+	PIDateTime toDateTime() const {return value<PIDateTime>();}
+
+	template <typename T>
+	static PIVariant fromValue(const T & v) {
+		PIVariant ret;
+		ret.initType<T>(v);
+		return ret;
+	}
+
+	static PIVariant fromValue(const PIByteArray & c, const PIString & type) {
+		PIVariant ret;
+		ret._info = __PIVariantInfoStorage__::get()->map->value(type, 0);
+		if (!ret._info) {
+			piCout << "Can`t initialize PIVariant from unregistered type \"" << type << "\"!";
+			return ret;
+		}
+		ret._content = c;
+		return ret;
+	}
+
+	template<typename T>
+	T value() const {
+		if (_content.isEmpty() || !_info) return T();
+		PIString cn = __PIVariantFunctions__<T>::typeNameHelper();
+		//bool cs = __PIVariantFunctions__<T>::isSimpleHelper();
+		PIByteArray ba;
+		if (cn == _info->typeName) {
+			ba = _content;
+		} else {
+			__PIVariantInfo__::castHelperFunc cf = _info->cast.value(cn);
+			if (!cf) return T();
+			ba = cf(_content);
+		}
+		T ret; ba >> ret;
+		return ret;
+	}
+private:
+	template <typename T>
+	void initType(const T & v) {
+		_content.clear();
+		_content << v;
+		_info = __PIVariantInfoStorage__::get()->map->value(__PIVariantFunctions__<T>::typeNameHelper(), 0);
+		if (!_info)
+			piCout << "Can`t initialize PIVariant from unregistered type!";
+	}
+
+	PIByteArray _content;
+	__PIVariantInfo__ * _info;
+
+};
+
+void __PIVariantInitBuiltin__();
+
+inline PICout operator <<(PICout c, const PIVariant & v) {c.setControl(0, true); c << "PIVariant(" << v.typeName() << ", " << v.toString() << ")"; c.restoreControl(); return c;}
+
+
+REGISTER_VARIANT_H(bool)
+REGISTER_VARIANT_H(char)
+REGISTER_VARIANT_H(uchar)
+REGISTER_VARIANT_H(short)
+REGISTER_VARIANT_H(ushort)
+REGISTER_VARIANT_H(int)
+REGISTER_VARIANT_H(uint)
+REGISTER_VARIANT_H(llong)
+REGISTER_VARIANT_H(ullong)
+REGISTER_VARIANT_H(float)
+REGISTER_VARIANT_H(double)
+REGISTER_VARIANT_H(ldouble)
+REGISTER_VARIANT_H(complexf)
+REGISTER_VARIANT_H(complexd)
+REGISTER_VARIANT_H(complexld)
+REGISTER_VARIANT_H(PIChar)
+REGISTER_VARIANT_H(PIString)
+REGISTER_VARIANT_H(PIStringList)
+REGISTER_VARIANT_H(PIByteArray)
+REGISTER_VARIANT_H(PISystemTime)
+REGISTER_VARIANT_H(PITime)
+REGISTER_VARIANT_H(PIDate)
+REGISTER_VARIANT_H(PIDateTime)
+
+REGISTER_VARIANT_CAST_SIMPLE_H(bool, char)
+REGISTER_VARIANT_CAST_SIMPLE_H(bool, uchar)
+REGISTER_VARIANT_CAST_SIMPLE_H(bool, short)
+REGISTER_VARIANT_CAST_SIMPLE_H(bool, ushort)
+REGISTER_VARIANT_CAST_SIMPLE_H(bool, int)
+REGISTER_VARIANT_CAST_SIMPLE_H(bool, uint)
+REGISTER_VARIANT_CAST_SIMPLE_H(bool, llong)
+REGISTER_VARIANT_CAST_SIMPLE_H(bool, ullong)
+REGISTER_VARIANT_CAST_SIMPLE_H(bool, float)
+REGISTER_VARIANT_CAST_SIMPLE_H(bool, double)
+REGISTER_VARIANT_CAST_SIMPLE_H(bool, ldouble)
+
+REGISTER_VARIANT_CAST_SIMPLE_H(char, bool)
+REGISTER_VARIANT_CAST_SIMPLE_H(char, uchar)
+REGISTER_VARIANT_CAST_SIMPLE_H(char, short)
+REGISTER_VARIANT_CAST_SIMPLE_H(char, ushort)
+REGISTER_VARIANT_CAST_SIMPLE_H(char, int)
+REGISTER_VARIANT_CAST_SIMPLE_H(char, uint)
+REGISTER_VARIANT_CAST_SIMPLE_H(char, llong)
+REGISTER_VARIANT_CAST_SIMPLE_H(char, ullong)
+REGISTER_VARIANT_CAST_SIMPLE_H(char, float)
+REGISTER_VARIANT_CAST_SIMPLE_H(char, double)
+REGISTER_VARIANT_CAST_SIMPLE_H(char, ldouble)
+
+REGISTER_VARIANT_CAST_SIMPLE_H(uchar, bool)
+REGISTER_VARIANT_CAST_SIMPLE_H(uchar, char)
+REGISTER_VARIANT_CAST_SIMPLE_H(uchar, short)
+REGISTER_VARIANT_CAST_SIMPLE_H(uchar, ushort)
+REGISTER_VARIANT_CAST_SIMPLE_H(uchar, int)
+REGISTER_VARIANT_CAST_SIMPLE_H(uchar, uint)
+REGISTER_VARIANT_CAST_SIMPLE_H(uchar, llong)
+REGISTER_VARIANT_CAST_SIMPLE_H(uchar, ullong)
+REGISTER_VARIANT_CAST_SIMPLE_H(uchar, float)
+REGISTER_VARIANT_CAST_SIMPLE_H(uchar, double)
+REGISTER_VARIANT_CAST_SIMPLE_H(uchar, ldouble)
+
+REGISTER_VARIANT_CAST_SIMPLE_H(short, bool)
+REGISTER_VARIANT_CAST_SIMPLE_H(short, char)
+REGISTER_VARIANT_CAST_SIMPLE_H(short, uchar)
+REGISTER_VARIANT_CAST_SIMPLE_H(short, ushort)
+REGISTER_VARIANT_CAST_SIMPLE_H(short, int)
+REGISTER_VARIANT_CAST_SIMPLE_H(short, uint)
+REGISTER_VARIANT_CAST_SIMPLE_H(short, llong)
+REGISTER_VARIANT_CAST_SIMPLE_H(short, ullong)
+REGISTER_VARIANT_CAST_SIMPLE_H(short, float)
+REGISTER_VARIANT_CAST_SIMPLE_H(short, double)
+REGISTER_VARIANT_CAST_SIMPLE_H(short, ldouble)
+
+REGISTER_VARIANT_CAST_SIMPLE_H(ushort, bool)
+REGISTER_VARIANT_CAST_SIMPLE_H(ushort, char)
+REGISTER_VARIANT_CAST_SIMPLE_H(ushort, uchar)
+REGISTER_VARIANT_CAST_SIMPLE_H(ushort, short)
+REGISTER_VARIANT_CAST_SIMPLE_H(ushort, int)
+REGISTER_VARIANT_CAST_SIMPLE_H(ushort, uint)
+REGISTER_VARIANT_CAST_SIMPLE_H(ushort, llong)
+REGISTER_VARIANT_CAST_SIMPLE_H(ushort, ullong)
+REGISTER_VARIANT_CAST_SIMPLE_H(ushort, float)
+REGISTER_VARIANT_CAST_SIMPLE_H(ushort, double)
+REGISTER_VARIANT_CAST_SIMPLE_H(ushort, ldouble)
+
+REGISTER_VARIANT_CAST_SIMPLE_H(int, bool)
+REGISTER_VARIANT_CAST_SIMPLE_H(int, char)
+REGISTER_VARIANT_CAST_SIMPLE_H(int, uchar)
+REGISTER_VARIANT_CAST_SIMPLE_H(int, short)
+REGISTER_VARIANT_CAST_SIMPLE_H(int, ushort)
+REGISTER_VARIANT_CAST_SIMPLE_H(int, uint)
+REGISTER_VARIANT_CAST_SIMPLE_H(int, llong)
+REGISTER_VARIANT_CAST_SIMPLE_H(int, ullong)
+REGISTER_VARIANT_CAST_SIMPLE_H(int, float)
+REGISTER_VARIANT_CAST_SIMPLE_H(int, double)
+REGISTER_VARIANT_CAST_SIMPLE_H(int, ldouble)
+
+REGISTER_VARIANT_CAST_SIMPLE_H(uint, bool)
+REGISTER_VARIANT_CAST_SIMPLE_H(uint, char)
+REGISTER_VARIANT_CAST_SIMPLE_H(uint, uchar)
+REGISTER_VARIANT_CAST_SIMPLE_H(uint, short)
+REGISTER_VARIANT_CAST_SIMPLE_H(uint, ushort)
+REGISTER_VARIANT_CAST_SIMPLE_H(uint, int)
+REGISTER_VARIANT_CAST_SIMPLE_H(uint, llong)
+REGISTER_VARIANT_CAST_SIMPLE_H(uint, ullong)
+REGISTER_VARIANT_CAST_SIMPLE_H(uint, float)
+REGISTER_VARIANT_CAST_SIMPLE_H(uint, double)
+REGISTER_VARIANT_CAST_SIMPLE_H(uint, ldouble)
+
+REGISTER_VARIANT_CAST_SIMPLE_H(llong, bool)
+REGISTER_VARIANT_CAST_SIMPLE_H(llong, char)
+REGISTER_VARIANT_CAST_SIMPLE_H(llong, uchar)
+REGISTER_VARIANT_CAST_SIMPLE_H(llong, short)
+REGISTER_VARIANT_CAST_SIMPLE_H(llong, ushort)
+REGISTER_VARIANT_CAST_SIMPLE_H(llong, int)
+REGISTER_VARIANT_CAST_SIMPLE_H(llong, uint)
+REGISTER_VARIANT_CAST_SIMPLE_H(llong, ullong)
+REGISTER_VARIANT_CAST_SIMPLE_H(llong, float)
+REGISTER_VARIANT_CAST_SIMPLE_H(llong, double)
+REGISTER_VARIANT_CAST_SIMPLE_H(llong, ldouble)
+
+REGISTER_VARIANT_CAST_SIMPLE_H(ullong, bool)
+REGISTER_VARIANT_CAST_SIMPLE_H(ullong, char)
+REGISTER_VARIANT_CAST_SIMPLE_H(ullong, uchar)
+REGISTER_VARIANT_CAST_SIMPLE_H(ullong, short)
+REGISTER_VARIANT_CAST_SIMPLE_H(ullong, ushort)
+REGISTER_VARIANT_CAST_SIMPLE_H(ullong, int)
+REGISTER_VARIANT_CAST_SIMPLE_H(ullong, uint)
+REGISTER_VARIANT_CAST_SIMPLE_H(ullong, llong)
+REGISTER_VARIANT_CAST_SIMPLE_H(ullong, float)
+REGISTER_VARIANT_CAST_SIMPLE_H(ullong, double)
+REGISTER_VARIANT_CAST_SIMPLE_H(ullong, ldouble)
+
+REGISTER_VARIANT_CAST_SIMPLE_H(float, bool)
+REGISTER_VARIANT_CAST_SIMPLE_H(float, char)
+REGISTER_VARIANT_CAST_SIMPLE_H(float, uchar)
+REGISTER_VARIANT_CAST_SIMPLE_H(float, short)
+REGISTER_VARIANT_CAST_SIMPLE_H(float, ushort)
+REGISTER_VARIANT_CAST_SIMPLE_H(float, int)
+REGISTER_VARIANT_CAST_SIMPLE_H(float, uint)
+REGISTER_VARIANT_CAST_SIMPLE_H(float, llong)
+REGISTER_VARIANT_CAST_SIMPLE_H(float, ullong)
+REGISTER_VARIANT_CAST_SIMPLE_H(float, double)
+REGISTER_VARIANT_CAST_SIMPLE_H(float, ldouble)
+
+REGISTER_VARIANT_CAST_SIMPLE_H(double, bool)
+REGISTER_VARIANT_CAST_SIMPLE_H(double, char)
+REGISTER_VARIANT_CAST_SIMPLE_H(double, uchar)
+REGISTER_VARIANT_CAST_SIMPLE_H(double, short)
+REGISTER_VARIANT_CAST_SIMPLE_H(double, ushort)
+REGISTER_VARIANT_CAST_SIMPLE_H(double, int)
+REGISTER_VARIANT_CAST_SIMPLE_H(double, uint)
+REGISTER_VARIANT_CAST_SIMPLE_H(double, llong)
+REGISTER_VARIANT_CAST_SIMPLE_H(double, ullong)
+REGISTER_VARIANT_CAST_SIMPLE_H(double, float)
+REGISTER_VARIANT_CAST_SIMPLE_H(double, ldouble)
+
+REGISTER_VARIANT_CAST_SIMPLE_H(ldouble, bool)
+REGISTER_VARIANT_CAST_SIMPLE_H(ldouble, char)
+REGISTER_VARIANT_CAST_SIMPLE_H(ldouble, uchar)
+REGISTER_VARIANT_CAST_SIMPLE_H(ldouble, short)
+REGISTER_VARIANT_CAST_SIMPLE_H(ldouble, ushort)
+REGISTER_VARIANT_CAST_SIMPLE_H(ldouble, int)
+REGISTER_VARIANT_CAST_SIMPLE_H(ldouble, uint)
+REGISTER_VARIANT_CAST_SIMPLE_H(ldouble, llong)
+REGISTER_VARIANT_CAST_SIMPLE_H(ldouble, ullong)
+REGISTER_VARIANT_CAST_SIMPLE_H(ldouble, float)
+REGISTER_VARIANT_CAST_SIMPLE_H(ldouble, double)
+
+REGISTER_VARIANT_CAST_H(bool, PIString)
+REGISTER_VARIANT_CAST_H(char, PIString)
+REGISTER_VARIANT_CAST_H(uchar, PIString)
+REGISTER_VARIANT_CAST_H(short, PIString)
+REGISTER_VARIANT_CAST_H(ushort, PIString)
+REGISTER_VARIANT_CAST_H(int, PIString)
+REGISTER_VARIANT_CAST_H(uint, PIString)
+REGISTER_VARIANT_CAST_H(llong, PIString)
+REGISTER_VARIANT_CAST_H(ullong, PIString)
+REGISTER_VARIANT_CAST_H(float, PIString)
+REGISTER_VARIANT_CAST_H(double, PIString)
+REGISTER_VARIANT_CAST_H(ldouble, PIString)
+REGISTER_VARIANT_CAST_H(complexf, PIString)
+REGISTER_VARIANT_CAST_H(complexd, PIString)
+REGISTER_VARIANT_CAST_H(complexld, PIString)
+REGISTER_VARIANT_CAST_H(PIChar, PIString)
+REGISTER_VARIANT_CAST_H(PIString, PIString)
+REGISTER_VARIANT_CAST_H(PIStringList, PIString)
+REGISTER_VARIANT_CAST_H(PIByteArray, PIString)
+REGISTER_VARIANT_CAST_H(PISystemTime, PIString)
+REGISTER_VARIANT_CAST_H(PITime, PIString)
+REGISTER_VARIANT_CAST_H(PIDate, PIString)
+REGISTER_VARIANT_CAST_H(PIDateTime, PIString)
+
+REGISTER_VARIANT_CAST_H(PIString, bool)
+REGISTER_VARIANT_CAST_H(PIString, char)
+REGISTER_VARIANT_CAST_H(PIString, uchar)
+REGISTER_VARIANT_CAST_H(PIString, short)
+REGISTER_VARIANT_CAST_H(PIString, ushort)
+REGISTER_VARIANT_CAST_H(PIString, int)
+REGISTER_VARIANT_CAST_H(PIString, uint)
+REGISTER_VARIANT_CAST_H(PIString, llong)
+REGISTER_VARIANT_CAST_H(PIString, ullong)
+REGISTER_VARIANT_CAST_H(PIString, float)
+REGISTER_VARIANT_CAST_H(PIString, double)
+REGISTER_VARIANT_CAST_H(PIString, ldouble)
+REGISTER_VARIANT_CAST_H(PIString, PIByteArray)
+REGISTER_VARIANT_CAST_H(PIString, PIStringList)
 
 #endif // PIVARIANT_H

src/math/pimathbase.h

@@ -153,6 +153,20 @@ inline double toDeg(double rad) {return rad * M_180_PI;}
 template<typename T>
 inline PICout operator <<(PICout s, const complex<T> & v) {s.space(); s.setControl(0, true); s << "(" << v.real() << "; " << v.imag() << ")"; s.restoreControl(); return s;}
 
+//! \relatesalso PIByteArray \brief Store operator
+inline PIByteArray & operator <<(PIByteArray & s, complexf v) {float t; t = v.real(); s << t; t = v.imag(); s << t; return s;}
+//! \relatesalso PIByteArray \brief Store operator
+inline PIByteArray & operator <<(PIByteArray & s, complexd v) {double t; t = v.real(); s << t; t = v.imag(); s << t; return s;}
+//! \relatesalso PIByteArray \brief Store operator
+inline PIByteArray & operator <<(PIByteArray & s, complexld v) {ldouble t; t = v.real(); s << t; t = v.imag(); s << t; return s;}
+
+//! \relatesalso PIByteArray \brief Restore operator
+inline PIByteArray & operator >>(PIByteArray & s, complexf & v) {float t; s >> t; v.real() = t; s >> t; v.imag() = t; return s;}
+//! \relatesalso PIByteArray \brief Restore operator
+inline PIByteArray & operator >>(PIByteArray & s, complexd & v) {double t; s >> t; v.real() = t; s >> t; v.imag() = t; return s;}
+//! \relatesalso PIByteArray \brief Restore operator
+inline PIByteArray & operator >>(PIByteArray & s, complexld & v) {ldouble t; s >> t; v.real() = t; s >> t; v.imag() = t; return s;}
+
 void randomize();
 
 // [-1 ; 1]