diff --git a/src/core/piobject.cpp b/src/core/piobject.cpp index ddb4bd03..23e601bc 100755 --- a/src/core/piobject.cpp +++ b/src/core/piobject.cpp @@ -73,7 +73,7 @@ PIString PIObject::__EHFunc::fullFormat() const { PIObject::PIObject(const PIString & name): _signature_(__PIOBJECT_SIGNATURE__), emitter_(0), thread_safe_(false) { piMonitor.objects++; - __PIVariantInitBuiltin__(); + //__PIVariantInitBuiltin__(); setName(name); setDebug(true); objects << this; diff --git a/src/core/pivariant.cpp b/src/core/pivariant.cpp index 21cba7dc..8df7ac70 100755 --- a/src/core/pivariant.cpp +++ b/src/core/pivariant.cpp @@ -1,20 +1,20 @@ /* - PIP - Platform Independent Primitives - Variant type - Copyright (C) 2015 Ivan Pelipenko peri4ko@gmail.com + PIP - Platform Independent Primitives + Variant type + Copyright (C) 2015 Ivan Pelipenko peri4ko@gmail.com - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. - You should have received a copy of the GNU General Public License - along with this program. If not, see . + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ #include "pivariant.h" @@ -27,7 +27,7 @@ * This class provides general type that can contains all standard types, some * PIP types or custom type. In case of standard types this class also provides * convertions between them. - * + * * \section PIVariant_sec1 Usage * %PIVariant useful if you want pass many variables with different types in * single array, e.g.: @@ -40,7 +40,7 @@ * \endcode * Result: * \code{cpp} - * {PIVariant(int, 10), PIVariant(double, 1,61), PIVariant(bool, true), PIVariant(PIString, 0xFF)} + * {PIVariant(Int, 10), PIVariant(Double, 1,61), PIVariant(Bool, true), PIVariant(String, 0xFF)} * 10 * 1 * 1 @@ -48,240 +48,487 @@ * \endcode * */ -PIMap * __PIVariantInfoStorage__::map = 0; -REGISTER_VARIANT_CPP(bool) -REGISTER_VARIANT_CPP(char) -REGISTER_VARIANT_CPP(uchar) -REGISTER_VARIANT_CPP(short) -REGISTER_VARIANT_CPP(ushort) -REGISTER_VARIANT_CPP(int) -REGISTER_VARIANT_CPP(uint) -REGISTER_VARIANT_CPP(llong) -REGISTER_VARIANT_CPP(ullong) -REGISTER_VARIANT_CPP(float) -REGISTER_VARIANT_CPP(double) -REGISTER_VARIANT_CPP(ldouble) -REGISTER_VARIANT_CPP(complexf) -REGISTER_VARIANT_CPP(complexd) -REGISTER_VARIANT_CPP(complexld) -REGISTER_VARIANT_CPP(PIChar) -REGISTER_VARIANT_CPP(PIString) -REGISTER_VARIANT_CPP(PIStringList) -REGISTER_VARIANT_CPP(PIByteArray) -REGISTER_VARIANT_CPP(PISystemTime) -REGISTER_VARIANT_CPP(PITime) -REGISTER_VARIANT_CPP(PIDate) -REGISTER_VARIANT_CPP(PIDateTime) - -REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, char) -REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, uchar) -REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, short) -REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, ushort) -REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, int) -REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, uint) -REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, llong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, ullong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, float) -REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, double) -REGISTER_VARIANT_CAST_SIMPLE_CPP(bool, ldouble) - -REGISTER_VARIANT_CAST_SIMPLE_CPP(char, bool) -REGISTER_VARIANT_CAST_SIMPLE_CPP(char, uchar) -REGISTER_VARIANT_CAST_SIMPLE_CPP(char, short) -REGISTER_VARIANT_CAST_SIMPLE_CPP(char, ushort) -REGISTER_VARIANT_CAST_SIMPLE_CPP(char, int) -REGISTER_VARIANT_CAST_SIMPLE_CPP(char, uint) -REGISTER_VARIANT_CAST_SIMPLE_CPP(char, llong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(char, ullong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(char, float) -REGISTER_VARIANT_CAST_SIMPLE_CPP(char, double) -REGISTER_VARIANT_CAST_SIMPLE_CPP(char, ldouble) - -REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, bool) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, char) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, short) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, ushort) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, int) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, uint) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, llong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, ullong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, float) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, double) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uchar, ldouble) - -REGISTER_VARIANT_CAST_SIMPLE_CPP(short, bool) -REGISTER_VARIANT_CAST_SIMPLE_CPP(short, char) -REGISTER_VARIANT_CAST_SIMPLE_CPP(short, uchar) -REGISTER_VARIANT_CAST_SIMPLE_CPP(short, ushort) -REGISTER_VARIANT_CAST_SIMPLE_CPP(short, int) -REGISTER_VARIANT_CAST_SIMPLE_CPP(short, uint) -REGISTER_VARIANT_CAST_SIMPLE_CPP(short, llong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(short, ullong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(short, float) -REGISTER_VARIANT_CAST_SIMPLE_CPP(short, double) -REGISTER_VARIANT_CAST_SIMPLE_CPP(short, ldouble) - -REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, bool) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, char) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, uchar) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, short) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, int) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, uint) -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) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ushort, ldouble) - -REGISTER_VARIANT_CAST_SIMPLE_CPP(int, bool) -REGISTER_VARIANT_CAST_SIMPLE_CPP(int, char) -REGISTER_VARIANT_CAST_SIMPLE_CPP(int, uchar) -REGISTER_VARIANT_CAST_SIMPLE_CPP(int, short) -REGISTER_VARIANT_CAST_SIMPLE_CPP(int, ushort) -REGISTER_VARIANT_CAST_SIMPLE_CPP(int, uint) -REGISTER_VARIANT_CAST_SIMPLE_CPP(int, llong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(int, ullong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(int, float) -REGISTER_VARIANT_CAST_SIMPLE_CPP(int, double) -REGISTER_VARIANT_CAST_SIMPLE_CPP(int, ldouble) - -REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, bool) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, char) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, uchar) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, short) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, ushort) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, int) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, llong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, ullong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, float) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, double) -REGISTER_VARIANT_CAST_SIMPLE_CPP(uint, ldouble) - -REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, bool) -REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, char) -REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, uchar) -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) -REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, ullong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, float) -REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, double) -REGISTER_VARIANT_CAST_SIMPLE_CPP(llong, ldouble) - -REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, bool) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, char) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, uchar) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, short) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, ushort) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, int) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, uint) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, llong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, float) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, double) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ullong, ldouble) - -REGISTER_VARIANT_CAST_SIMPLE_CPP(float, bool) -REGISTER_VARIANT_CAST_SIMPLE_CPP(float, char) -REGISTER_VARIANT_CAST_SIMPLE_CPP(float, uchar) -REGISTER_VARIANT_CAST_SIMPLE_CPP(float, short) -REGISTER_VARIANT_CAST_SIMPLE_CPP(float, ushort) -REGISTER_VARIANT_CAST_SIMPLE_CPP(float, int) -REGISTER_VARIANT_CAST_SIMPLE_CPP(float, uint) -REGISTER_VARIANT_CAST_SIMPLE_CPP(float, llong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(float, ullong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(float, double) -REGISTER_VARIANT_CAST_SIMPLE_CPP(float, ldouble) - -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) -REGISTER_VARIANT_CAST_SIMPLE_CPP(double, ushort) -REGISTER_VARIANT_CAST_SIMPLE_CPP(double, int) -REGISTER_VARIANT_CAST_SIMPLE_CPP(double, uint) -REGISTER_VARIANT_CAST_SIMPLE_CPP(double, llong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(double, ullong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(double, float) -REGISTER_VARIANT_CAST_SIMPLE_CPP(double, ldouble) - -REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, bool) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, char) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, uchar) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, short) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, ushort) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, int) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, uint) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, llong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, ullong) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, float) -REGISTER_VARIANT_CAST_SIMPLE_CPP(ldouble, double) - -REGISTER_VARIANT_CAST_CPP(bool, PIString) {return PIString::fromBool(v);} -REGISTER_VARIANT_CAST_CPP(char, PIString) {return PIString(PIChar(v));} -REGISTER_VARIANT_CAST_CPP(uchar, PIString) {return PIString::fromNumber(v);} -REGISTER_VARIANT_CAST_CPP(short, PIString) {return PIString::fromNumber(v);} -REGISTER_VARIANT_CAST_CPP(ushort, PIString) {return PIString::fromNumber(v);} -REGISTER_VARIANT_CAST_CPP(int, PIString) {return PIString::fromNumber(v);} -REGISTER_VARIANT_CAST_CPP(uint, PIString) {return PIString::fromNumber(v);} -REGISTER_VARIANT_CAST_CPP(llong, PIString) {return PIString::fromNumber(v);} -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);} -REGISTER_VARIANT_CAST_CPP(complexf, PIString) {return "(" + PIString::fromNumber(v.real()) + " + " + PIString::fromNumber(v.imag()) + "i)";} -REGISTER_VARIANT_CAST_CPP(complexd, PIString) {return "(" + PIString::fromNumber(v.real()) + " + " + PIString::fromNumber(v.imag()) + "i)";} -REGISTER_VARIANT_CAST_CPP(complexld, PIString) {return "(" + PIString::fromNumber(v.real()) + " + " + PIString::fromNumber(v.imag()) + "i)";} -REGISTER_VARIANT_CAST_CPP(PIChar, PIString) {return PIString(v);} -REGISTER_VARIANT_CAST_CPP(PIString, PIString) {return v;} -REGISTER_VARIANT_CAST_CPP(PIStringList, PIString) {return v.join(", ");} -REGISTER_VARIANT_CAST_CPP(PIByteArray, PIString) {return v.toString();} -REGISTER_VARIANT_CAST_CPP(PISystemTime, PIString) {return PIString::fromNumber(v.seconds) + " s, " + PIString::fromNumber(v.nanoseconds) + " ns";} -REGISTER_VARIANT_CAST_CPP(PITime, PIString) {return v.toString();} -REGISTER_VARIANT_CAST_CPP(PIDate, PIString) {return v.toString();} -REGISTER_VARIANT_CAST_CPP(PIDateTime, PIString) {return v.toString();} - -REGISTER_VARIANT_CAST_CPP(PIString, bool) {return v.toBool();} -REGISTER_VARIANT_CAST_CPP(PIString, char) {return v.toChar();} -REGISTER_VARIANT_CAST_CPP(PIString, uchar) {return v.toChar();} -REGISTER_VARIANT_CAST_CPP(PIString, short) {return v.toShort();} -REGISTER_VARIANT_CAST_CPP(PIString, ushort) {return v.toUShort();} -REGISTER_VARIANT_CAST_CPP(PIString, int) {return v.toInt();} -REGISTER_VARIANT_CAST_CPP(PIString, uint) {return v.toUInt();} -REGISTER_VARIANT_CAST_CPP(PIString, llong) {return v.toLLong();} -REGISTER_VARIANT_CAST_CPP(PIString, ullong) {return v.toULLong();} -REGISTER_VARIANT_CAST_CPP(PIString, float) {return v.toFloat();} -REGISTER_VARIANT_CAST_CPP(PIString, double) {return v.toDouble();} -REGISTER_VARIANT_CAST_CPP(PIString, ldouble) {return v.toLDouble();} -REGISTER_VARIANT_CAST_CPP(PIString, PIByteArray) {return v.toByteArray();} -REGISTER_VARIANT_CAST_CPP(PIString, PIStringList) {return PIStringList(v);} - -void __PIVariantInitBuiltin__() { - static bool first = true; - if (!first) return; - first = false; - INIT_VARIANT(bool) - INIT_VARIANT(char) - INIT_VARIANT(uchar) - INIT_VARIANT(short) - INIT_VARIANT(ushort) - INIT_VARIANT(int) - INIT_VARIANT(uint) - INIT_VARIANT(llong) - INIT_VARIANT(ullong) - INIT_VARIANT(float) - INIT_VARIANT(double) - INIT_VARIANT(ldouble) - INIT_VARIANT(complexf) - INIT_VARIANT(complexd) - INIT_VARIANT(complexld) - INIT_VARIANT(PIChar) - INIT_VARIANT(PIString) - INIT_VARIANT(PIStringList) - INIT_VARIANT(PIByteArray) - INIT_VARIANT(PISystemTime) - INIT_VARIANT(PITime) - INIT_VARIANT(PIDate) - INIT_VARIANT(PIDateTime) +PIVariant::PIVariant() { + type_ = PIVariant::Invalid; + memset(_vraw, 0, __PIVARIANT_UNION_SIZE__); +} + + +PIVariant & PIVariant::operator =(const PIVariant & v) { + type_ = v.type_; + memcpy(_vraw, v._vraw, __PIVARIANT_UNION_SIZE__); + _vbytearray = v._vbytearray; + _vbitarray = v._vbitarray; + _vstring = v._vstring; + _vstringlist = v._vstringlist; + _vcustom = v._vcustom; + return *this; +} + + +bool PIVariant::operator ==(const PIVariant & v) const { + if (type_ != v.type_) return false; + 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 == v._vint; + case PIVariant::LLong: + case PIVariant::ULLong: return _vllong == v._vllong; + case PIVariant::Float: return _vfloat == v._vfloat; + case PIVariant::Double: return _vdouble == v._vdouble; + case PIVariant::LDouble: return _vldouble == v._vldouble; + case PIVariant::Complexd: return _vcomplexd == _vvcomplexd(v); + case PIVariant::Complexld: return _vcomplexld == _vvcomplexld(v); + case PIVariant::BitArray: return _vbitarray == v._vbitarray; + case PIVariant::ByteArray: return _vbytearray == v._vbytearray; + case PIVariant::String: return _vstring == v._vstring; + case PIVariant::StringList: return _vstringlist == v._vstringlist; + case PIVariant::Time: return _vtime == _vvtime(v); + case PIVariant::Date: return _vdate == _vvdate(v); + case PIVariant::DateTime: return _vdatetime == _vvdatetime(v); + case PIVariant::SystemTime: return _vsystime == _vvsystime(v); + default: break; + }; + return false; +} + + +PIVariant::Type PIVariant::typeFromName(const PIString & tname) { + PIString s = tname.trimmed().toLowerCase().replaceAll(" ", ""); + if (s == "bool" || s == "boolean") return PIVariant::Bool; + if (s == "char" || s == "sbyte") return PIVariant::Char; + if (s == "short" || s == "shortint" || s == "signedshort" || s == "signedshortint" || s == "sword") return PIVariant::Short; + if (s == "int" || s == "signed" || s == "signedint") return PIVariant::Int; + if (s == "long" || s == "longint" || s == "signedlong" || s == "signedlongint" || s == "sdword") return PIVariant::Long; + if (s == "llong" || s == "longlong" || s == "longlongint" || s == "signedlonglong" || s == "signedlonglongint" || s == "sqword") return PIVariant::LLong; + if (s == "uchar" || s == "byte") return PIVariant::UChar; + if (s == "ushort" || s == "unsignedshort" || s == "unsignedshortint" || s == "word") return PIVariant::UShort; + if (s == "uint" || s == "unsigned" || s == "unsignedint") return PIVariant::UInt; + if (s == "ulong" || s == "unsignedlong" || s == "unsignedlongint" || s == "dword") return PIVariant::ULong; + if (s == "ullong" || s == "unsignedlonglong" || s == "unsignedlonglongint" || s == "qword") return PIVariant::ULLong; + if (s == "float") return PIVariant::Float; + if (s == "double" || s == "real") return PIVariant::Double; + if (s == "ldouble" || s == "longdouble") return PIVariant::LDouble; + if (s == "complexd" || s == "complex") return PIVariant::Complexd; + if (s == "complexld" || s == "complex" || s == "complex") return PIVariant::Complexld; + if (s == "pibitarray" || s == "bitarray") return PIVariant::BitArray; + if (s == "pibytearray" || s == "bytearray" || s == "vector" || s == "pivector" || s == "vector" || s == "pivector" || + s == "vector" || s == "pivector") return PIVariant::ByteArray; + if (s == "pistring" || s == "string") return PIVariant::String; + if (s == "pistringlist" || s == "stringlist" || s == "vector" || s == "vector" || s == "pivector" || s == "pivector") return PIVariant::StringList; + if (s == "pitime" || s == "time") return PIVariant::Time; + if (s == "pidate" || s == "date") return PIVariant::Date; + if (s == "pidatetime" || s == "datetime") return PIVariant::DateTime; + if (s == "pisystemtime" || s == "systemtime") return PIVariant::SystemTime; + return PIVariant::Invalid; +} + + +PIString PIVariant::typeName(PIVariant::Type type) { + switch (type) { + case PIVariant::Bool: return "Bool"; + case PIVariant::Char: return "Char"; + case PIVariant::UChar: return "UChar"; + case PIVariant::Short: return "Short"; + case PIVariant::UShort: return "UShort"; + case PIVariant::Int: return "Int"; + case PIVariant::UInt: return "UInt"; + case PIVariant::Long: return "Long"; + case PIVariant::ULong: return "ULong"; + case PIVariant::LLong: return "LLong"; + case PIVariant::ULLong: return "ULLong"; + case PIVariant::Float: return "Float"; + case PIVariant::Double: return "Double"; + case PIVariant::LDouble: return "LDouble"; + case PIVariant::Complexd: return "Complexd"; + case PIVariant::Complexld: return "Complexld"; + case PIVariant::BitArray: return "BitArray"; + case PIVariant::ByteArray: return "ByteArray"; + case PIVariant::String: return "String"; + case PIVariant::StringList: return "StringList"; + case PIVariant::Time: return "Time"; + case PIVariant::Date: return "Date"; + case PIVariant::DateTime: return "DateTime"; + case PIVariant::SystemTime: return "SystemTime"; + case PIVariant::Custom: return "Custom"; + default: break; + } + return "Invalid"; +} + + +/** \brief Returns variant content as boolean + * \details In case of numeric types returns \b true if value != 0. \n + * In case of String type returns \a PIString::toBool(). \n + * In case of StringList type returns \b false if string list is empty, + * otherwise returns \a PIString::toBool() of first string. \n + * In case of other types returns \b false. */ +bool PIVariant::toBool() 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 != 0; + case PIVariant::LLong: + case PIVariant::ULLong: return _vllong != 0; + case PIVariant::Float: return _vfloat != 0; + case PIVariant::Double: return _vdouble != 0; + case PIVariant::LDouble: return _vldouble != 0; + case PIVariant::Complexd: return _vcomplexd.real() != 0; + case PIVariant::Complexld: return _vcomplexld.real() != 0; + case PIVariant::String: return _vstring.toBool(); + case PIVariant::StringList: if (_vstringlist.isEmpty()) return false; return _vstringlist.front().toBool(); + default: break; + } + return false; +} + + + +/** \brief Returns variant content as int + * \details In case of numeric types returns integer value. \n + * In case of String type returns \a PIString::toInt(). \n + * In case of StringList type returns \b 0 if string list is empty, + * otherwise returns \a PIString::toInt() of first string. \n + * In case of other types returns \b 0. */ +int PIVariant::toInt() 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.toInt(); + case PIVariant::StringList: if (_vstringlist.isEmpty()) return 0; return _vstringlist.front().toInt(); + default: break; + } + return 0; +} + + +/** \brief Returns variant content as long long + * \details In case of numeric types returns integer value. \n + * In case of String type returns \a PIString::toLLong(). \n + * In case of StringList type returns \b 0L if string list is empty, + * otherwise returns \a PIString::toLLong() of first string. \n + * In case of other types returns \b 0L. */ +llong PIVariant::toLLong() 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.toLLong(); + case PIVariant::StringList: if (_vstringlist.isEmpty()) return 0L; return _vstringlist.front().toLLong(); + default: break; + } + return 0L; +} + + +/** \brief Returns variant content as float + * \details In case of numeric types returns float value. \n + * In case of String type returns \a PIString::toFloat(). \n + * In case of StringList type returns \b 0.f if string list is empty, + * otherwise returns \a PIString::toFloat() of first string. \n + * In case of other types returns \b 0.f. */ +float PIVariant::toFloat() 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.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(); } diff --git a/src/core/pivariant.h b/src/core/pivariant.h index f47b3d4d..effb2d63 100755 --- a/src/core/pivariant.h +++ b/src/core/pivariant.h @@ -1,25 +1,25 @@ /*! \file pivariant.h - * \brief PIVariant type - * + * \brief Variant type + * * This file declares PIVariant */ /* - PIP - Platform Independent Primitives - PIVariant type - Copyright (C) 2015 Ivan Pelipenko peri4ko@gmail.com + PIP - Platform Independent Primitives + Variant type + Copyright (C) 2015 Ivan Pelipenko peri4ko@gmail.com - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. - You should have received a copy of the GNU General Public License - along with this program. If not, see . + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ #ifndef PIVARIANT_H @@ -30,407 +30,432 @@ #include "pitime.h" #include "pimathbase.h" +#define __PIVARIANT_UNION_SIZE__ 32 -template -class __PIVariantFunctions__ { -public: - static PIString typeNameHelper() {return PIStringAscii("");} +#define _vcomplexd (*((complexd*)_vraw)) +#define _vcomplexld (*((complexld*)_vraw)) +#define _vtime (*((PITime*)_vraw)) +#define _vdate (*((PIDate*)_vraw)) +#define _vdatetime (*((PIDateTime*)_vraw)) +#define _vsystime (*((PISystemTime*)_vraw)) - static bool isSimpleHelper() {return false;} - template static PIByteArray castHelper(PIByteArray ba) {return PIByteArray();} - template static C castVariant(const T & v) {return C();} -}; - -struct __PIVariantInfo__ { - __PIVariantInfo__() { - simple = false; - } - typedef PIByteArray(*castHelperFunc)(PIByteArray); - PIMap cast; - PIString typeName; - bool simple; -}; - -class __PIVariantInfoStorage__ { -public: - __PIVariantInfoStorage__() {if (!map) map = new PIMap();} - static __PIVariantInfoStorage__ * get() {static __PIVariantInfoStorage__ * r = new __PIVariantInfoStorage__(); return r;} - static PIMap * map; -}; - - -#define REGISTER_VARIANT_H(classname) \ -template<> inline PIString __PIVariantFunctions__< classname >::typeNameHelper() {static PIString tn = PIStringAscii(#classname); return tn;} - -#define REGISTER_VARIANT_CPP(classname) \ -template \ -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__::castVariant(const classname_from & v); - -#define REGISTER_VARIANT_CAST_CPP(classname_from, classname_to) \ -template<> template<> inline \ -PIByteArray __PIVariantFunctions__::castHelper(PIByteArray v) { \ - classname_from f; v >> f; \ - classname_to t = __PIVariantFunctions__::castVariant(f); \ - PIByteArray ret; ret << t; \ - return ret;} \ -template \ -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__::castHelper; \ - } \ -}; \ -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__::castVariant(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);} +#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: - 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;} + //! Type of %PIVariant content + enum Type { + Invalid /** Invalid type , default type of empty contructor */ = 0 , + Bool /** bool */ , + 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 + }; - bool toBool() const {return value();} - char toChar() const {return value();} - uchar toUChar() const {return value();} - short toShort() const {return value();} - ushort toUShort() const {return value();} - int toInt() const {return value();} - uint toUInt() const {return value();} - llong toLLong() const {return value();} - ullong toULLong() const {return value();} - float toFloat() const {return value();} - double toDouble() const {return value();} - ldouble toLDouble() const {return value();} - complexf toComplexf() const {return value();} - complexd toComplexd() const {return value();} - complexld toComplexld() const {return value();} - PIString toString() const {return value();} - PIStringList toStringList() const {return value();} - PIByteArray toByteArray() const {return value();} - PISystemTime toSystemTime() const {return value();} - PITime toTime() const {return value();} - PIDate toDate() const {return value();} - PIDateTime toDateTime() const {return value();} + //! Empty constructor, \a type() will be set to \a Invalid + PIVariant(); - template - static PIVariant fromValue(const T & v) { - PIVariant ret; - ret.initType(v); - return ret; - } + //! Constructs variant from string + PIVariant(const char * v) {setValue(PIString(v));} - 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; - } + //! 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 function. \n + * Otherwise returns content as type T. */ template - T value() const { - if (_content.isEmpty() || !_info) return T(); - PIString cn = __PIVariantFunctions__::typeNameHelper(); - //bool cs = __PIVariantFunctions__::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 - void initType(const T & v) { - _content.clear(); - _content << v; - _info = __PIVariantInfoStorage__::get()->map->value(__PIVariantFunctions__::typeNameHelper(), 0); - if (!_info) - piCout << "Can`t initialize PIVariant from unregistered type!"; - } + 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());} + */ - PIByteArray _content; - __PIVariantInfo__ * _info; + //! 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 + 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_; }; -void __PIVariantInitBuiltin__(); +template<> inline bool PIVariant::toValue() const {return toBool();} +template<> inline char PIVariant::toValue() const {return (char)toInt();} +template<> inline uchar PIVariant::toValue() const {return (uchar)toInt();} +template<> inline short PIVariant::toValue() const {return (short)toInt();} +template<> inline ushort PIVariant::toValue() const {return (ushort)toInt();} +template<> inline int PIVariant::toValue() const {return toInt();} +template<> inline uint PIVariant::toValue() const {return (uint)toInt();} +template<> inline long PIVariant::toValue() const {return (long)toInt();} +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();} -inline PICout operator <<(PICout c, const PIVariant & v) {c.setControl(0, true); c << "PIVariant(" << v.typeName() << ", " << v.toString() << ")"; c.restoreControl(); return c;} +//template<> inline PIVariant PIVariant::fromValue(const char * v) {return PIVariant(PIString(v));} +template<> inline PIVariant PIVariant::fromValue(const bool & v) {return PIVariant(v);} +template<> inline PIVariant PIVariant::fromValue(const char & v) {return PIVariant(v);} +template<> inline PIVariant PIVariant::fromValue(const uchar & v) {return PIVariant(v);} +template<> inline PIVariant PIVariant::fromValue(const short & v) {return PIVariant(v);} +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; +} -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