SHS/pip
4
3
Fork 0
Code Issues 67 Pull Requests 1 Actions Releases Wiki Activity

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

Browse Source
This commit is contained in:
Бычков Андрей
2016-09-22 14:56:32 +00:00
parent 617ce394af
commit 7264ef12f6
2 changed files with 272 additions and 272 deletions
Download Patch File Download Diff File Expand all files Collapse all files

442
src/core/pivariant.cpp
View File

@@ -54,7 +54,7 @@ PIMap<PIString, __PIVariantInfo__ * > * __PIVariantInfoStorage__::map = 0;
PIVariant::PIVariant() { PIVariant::PIVariant() {
_type = PIVariant::Invalid; _type = PIVariant::pivInvalid;
} }
@@ -75,38 +75,38 @@ bool PIVariant::operator ==(const PIVariant & v) const {
PIVariant::Type PIVariant::typeFromName(const PIString & tname) { PIVariant::Type PIVariant::typeFromName(const PIString & tname) {
PIString s = tname.trimmed().toLowerCase().replaceAll(" ", ""); PIString s = tname.trimmed().toLowerCase().replaceAll(" ", "");
if (s == "bool" || s == "boolean") return PIVariant::Bool; if (s == "bool" || s == "boolean") return PIVariant::pivBool;
if (s == "char" || s == "sbyte") return PIVariant::Char; if (s == "char" || s == "sbyte") return PIVariant::pivChar;
if (s == "short" || s == "shortint" || s == "signedshort" || s == "signedshortint" || s == "sword") return PIVariant::Short; if (s == "short" || s == "shortint" || s == "signedshort" || s == "signedshortint" || s == "sword") return PIVariant::pivShort;
if (s == "int" || s == "signed" || s == "signedint") return PIVariant::Int; if (s == "int" || s == "signed" || s == "signedint") return PIVariant::pivInt;
if (s == "long" || s == "longint" || s == "signedlong" || s == "signedlongint" || s == "sdword") return PIVariant::Int; if (s == "long" || s == "longint" || s == "signedlong" || s == "signedlongint" || s == "sdword") return PIVariant::pivInt;
if (s == "llong" || s == "longlong" || s == "longlongint" || s == "signedlonglong" || s == "signedlonglongint" || s == "sqword") return PIVariant::LLong; if (s == "llong" || s == "longlong" || s == "longlongint" || s == "signedlonglong" || s == "signedlonglongint" || s == "sqword") return PIVariant::pivLLong;
if (s == "uchar" || s == "byte") return PIVariant::UChar; if (s == "uchar" || s == "byte") return PIVariant::pivUChar;
if (s == "ushort" || s == "unsignedshort" || s == "unsignedshortint" || s == "word") return PIVariant::UShort; if (s == "ushort" || s == "unsignedshort" || s == "unsignedshortint" || s == "word") return PIVariant::pivUShort;
if (s == "uint" || s == "unsigned" || s == "unsignedint") return PIVariant::UInt; if (s == "uint" || s == "unsigned" || s == "unsignedint") return PIVariant::pivUInt;
if (s == "ulong" || s == "unsignedlong" || s == "unsignedlongint" || s == "dword") return PIVariant::UInt; if (s == "ulong" || s == "unsignedlong" || s == "unsignedlongint" || s == "dword") return PIVariant::pivUInt;
if (s == "ullong" || s == "unsignedlonglong" || s == "unsignedlonglongint" || s == "qword") return PIVariant::ULLong; if (s == "ullong" || s == "unsignedlonglong" || s == "unsignedlonglongint" || s == "qword") return PIVariant::pivULLong;
if (s == "float") return PIVariant::Float; if (s == "float") return PIVariant::pivFloat;
if (s == "double" || s == "real") return PIVariant::Double; if (s == "double" || s == "real") return PIVariant::pivDouble;
if (s == "ldouble" || s == "longdouble") return PIVariant::LDouble; if (s == "ldouble" || s == "longdouble") return PIVariant::pivLDouble;
if (s == "complexd" || s == "complex<double>") return PIVariant::Complexd; if (s == "complexd" || s == "complex<double>") return PIVariant::pivComplexd;
if (s == "complexld" || s == "complex<ldouble>" || s == "complex<longdouble>") return PIVariant::Complexld; if (s == "complexld" || s == "complex<ldouble>" || s == "complex<longdouble>") return PIVariant::pivComplexld;
if (s == "pibitarray" || s == "bitarray") return PIVariant::BitArray; if (s == "pibitarray" || s == "bitarray") return PIVariant::pivBitArray;
if (s == "pibytearray" || s == "bytearray" || s == "vector<uchar>" || s == "pivector<uchar>" || s == "vector<unsignedchar>" || s == "pivector<unsignedchar>" || if (s == "pibytearray" || s == "bytearray" || s == "vector<uchar>" || s == "pivector<uchar>" || s == "vector<unsignedchar>" || s == "pivector<unsignedchar>" ||
s == "vector<char>" || s == "pivector<char>") return PIVariant::ByteArray; s == "vector<char>" || s == "pivector<char>") return PIVariant::pivByteArray;
if (s == "pistring" || s == "string") return PIVariant::String; if (s == "pistring" || s == "string") return PIVariant::pivString;
if (s == "pistringlist" || s == "stringlist" || s == "vector<string>" || s == "vector<pistring>" || s == "pivector<string>" || s == "pivector<pistring>") return PIVariant::StringList; if (s == "pistringlist" || s == "stringlist" || s == "vector<string>" || s == "vector<pistring>" || s == "pivector<string>" || s == "pivector<pistring>") return PIVariant::pivStringList;
if (s == "pitime" || s == "time") return PIVariant::Time; if (s == "pitime" || s == "time") return PIVariant::pivTime;
if (s == "pidate" || s == "date") return PIVariant::Date; if (s == "pidate" || s == "date") return PIVariant::pivDate;
if (s == "pidatetime" || s == "datetime") return PIVariant::DateTime; if (s == "pidatetime" || s == "datetime") return PIVariant::pivDateTime;
if (s == "pisystemtime" || s == "systemtime") return PIVariant::SystemTime; if (s == "pisystemtime" || s == "systemtime") return PIVariant::pivSystemTime;
return PIVariant::Invalid; return PIVariant::pivInvalid;
} }
PIString PIVariant::typeName() const { PIString PIVariant::typeName() const {
#ifdef CUSTOM_PIVARIANT #ifdef CUSTOM_PIVARIANT
if ((_type == Custom) && _info) if ((_type == pivCustom) && _info)
return _info->typeName; return _info->typeName;
#endif #endif
return typeName(_type); return typeName(_type);
@@ -115,29 +115,29 @@ PIString PIVariant::typeName() const {
PIString PIVariant::typeName(PIVariant::Type type) { PIString PIVariant::typeName(PIVariant::Type type) {
switch (type) { switch (type) {
case PIVariant::Bool: return "Bool"; case PIVariant::pivBool: return "Bool";
case PIVariant::Char: return "Char"; case PIVariant::pivChar: return "Char";
case PIVariant::UChar: return "UChar"; case PIVariant::pivUChar: return "UChar";
case PIVariant::Short: return "Short"; case PIVariant::pivShort: return "Short";
case PIVariant::UShort: return "UShort"; case PIVariant::pivUShort: return "UShort";
case PIVariant::Int: return "Int"; case PIVariant::pivInt: return "Int";
case PIVariant::UInt: return "UInt"; case PIVariant::pivUInt: return "UInt";
case PIVariant::LLong: return "LLong"; case PIVariant::pivLLong: return "LLong";
case PIVariant::ULLong: return "ULLong"; case PIVariant::pivULLong: return "ULLong";
case PIVariant::Float: return "Float"; case PIVariant::pivFloat: return "Float";
case PIVariant::Double: return "Double"; case PIVariant::pivDouble: return "Double";
case PIVariant::LDouble: return "LDouble"; case PIVariant::pivLDouble: return "LDouble";
case PIVariant::Complexd: return "Complexd"; case PIVariant::pivComplexd: return "Complexd";
case PIVariant::Complexld: return "Complexld"; case PIVariant::pivComplexld: return "Complexld";
case PIVariant::BitArray: return "BitArray"; case PIVariant::pivBitArray: return "BitArray";
case PIVariant::ByteArray: return "ByteArray"; case PIVariant::pivByteArray: return "ByteArray";
case PIVariant::String: return "String"; case PIVariant::pivString: return "String";
case PIVariant::StringList: return "StringList"; case PIVariant::pivStringList: return "StringList";
case PIVariant::Time: return "Time"; case PIVariant::pivTime: return "Time";
case PIVariant::Date: return "Date"; case PIVariant::pivDate: return "Date";
case PIVariant::DateTime: return "DateTime"; case PIVariant::pivDateTime: return "DateTime";
case PIVariant::SystemTime: return "SystemTime"; case PIVariant::pivSystemTime: return "SystemTime";
case PIVariant::Custom: return "Custom"; case PIVariant::pivCustom: return "Custom";
default: break; default: break;
} }
return "Invalid"; return "Invalid";
@@ -153,23 +153,23 @@ PIString PIVariant::typeName(PIVariant::Type type) {
bool PIVariant::toBool() const { bool PIVariant::toBool() const {
PIByteArray ba(_content); PIByteArray ba(_content);
switch (_type) { switch (_type) {
case PIVariant::Bool: {bool r; ba >> r; return r;} case PIVariant::pivBool: {bool r; ba >> r; return r;}
case PIVariant::Char: {char r; ba >> r; return r != 0;} case PIVariant::pivChar: {char r; ba >> r; return r != 0;}
case PIVariant::UChar: {uchar r; ba >> r; return r != 0;} case PIVariant::pivUChar: {uchar r; ba >> r; return r != 0;}
case PIVariant::Short: {short r; ba >> r; return r != 0;} case PIVariant::pivShort: {short r; ba >> r; return r != 0;}
case PIVariant::UShort: {ushort r; ba >> r; return r != 0;} case PIVariant::pivUShort: {ushort r; ba >> r; return r != 0;}
case PIVariant::Int: {int r; ba >> r; return r != 0;} case PIVariant::pivInt: {int r; ba >> r; return r != 0;}
case PIVariant::UInt: {uint r; ba >> r; return r != 0;} case PIVariant::pivUInt: {uint r; ba >> r; return r != 0;}
case PIVariant::LLong: {llong r; ba >> r; return r != 0;} case PIVariant::pivLLong: {llong r; ba >> r; return r != 0;}
case PIVariant::ULLong: {ullong r; ba >> r; return r != 0;} case PIVariant::pivULLong: {ullong r; ba >> r; return r != 0;}
case PIVariant::Float: {float r; ba >> r; return r > 0.f;} case PIVariant::pivFloat: {float r; ba >> r; return r > 0.f;}
case PIVariant::Double: {double r; ba >> r; return r > 0.;} case PIVariant::pivDouble: {double r; ba >> r; return r > 0.;}
case PIVariant::LDouble: {ldouble r; ba >> r; return r > 0.;} case PIVariant::pivLDouble: {ldouble r; ba >> r; return r > 0.;}
case PIVariant::Complexd: {complexd r; ba >> r; return r.real() != 0;} case PIVariant::pivComplexd: {complexd r; ba >> r; return r.real() != 0;}
case PIVariant::Complexld: {complexld r; ba >> r; return r.real() != 0;} case PIVariant::pivComplexld: {complexld r; ba >> r; return r.real() != 0;}
case PIVariant::String: {PIString r; ba >> r; return r.toBool();} case PIVariant::pivString: {PIString r; ba >> r; return r.toBool();}
case PIVariant::StringList: {PIStringList r; ba >> r; if (r.isEmpty()) return false; return r.front().toBool();} case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return false; return r.front().toBool();}
case PIVariant::Custom: case PIVariant::pivCustom:
return getAsValue<bool>(*this); return getAsValue<bool>(*this);
default: break; default: break;
} }
@@ -187,23 +187,23 @@ bool PIVariant::toBool() const {
int PIVariant::toInt() const { int PIVariant::toInt() const {
PIByteArray ba(_content); PIByteArray ba(_content);
switch (_type) { switch (_type) {
case PIVariant::Bool: {bool r; ba >> r; return r;} case PIVariant::pivBool: {bool r; ba >> r; return r;}
case PIVariant::Char: {char r; ba >> r; return r;} case PIVariant::pivChar: {char r; ba >> r; return r;}
case PIVariant::UChar: {uchar r; ba >> r; return r;} case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
case PIVariant::Short: {short r; ba >> r; return r;} case PIVariant::pivShort: {short r; ba >> r; return r;}
case PIVariant::UShort: {ushort r; ba >> r; return r;} case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
case PIVariant::Int: {int r; ba >> r; return r;} case PIVariant::pivInt: {int r; ba >> r; return r;}
case PIVariant::UInt: {uint r; ba >> r; return r;} case PIVariant::pivUInt: {uint r; ba >> r; return r;}
case PIVariant::LLong: {llong r; ba >> r; return r;} case PIVariant::pivLLong: {llong r; ba >> r; return r;}
case PIVariant::ULLong: {ullong r; ba >> r; return r;} case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
case PIVariant::Float: {float r; ba >> r; return r;} case PIVariant::pivFloat: {float r; ba >> r; return r;}
case PIVariant::Double: {double r; ba >> r; return r;} case PIVariant::pivDouble: {double r; ba >> r; return r;}
case PIVariant::LDouble: {ldouble r; ba >> r; return r;} case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
case PIVariant::Complexd: {complexd r; ba >> r; return r.real();} case PIVariant::pivComplexd: {complexd r; ba >> r; return r.real();}
case PIVariant::Complexld: {complexld r; ba >> r; return r.real();} case PIVariant::pivComplexld: {complexld r; ba >> r; return r.real();}
case PIVariant::String: {PIString r; ba >> r; return r.toInt();} case PIVariant::pivString: {PIString r; ba >> r; return r.toInt();}
case PIVariant::StringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0; return r.front().toInt();} case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0; return r.front().toInt();}
case PIVariant::Custom: case PIVariant::pivCustom:
return getAsValue<int>(*this); return getAsValue<int>(*this);
default: break; default: break;
} }
@@ -220,23 +220,23 @@ int PIVariant::toInt() const {
llong PIVariant::toLLong() const { llong PIVariant::toLLong() const {
PIByteArray ba(_content); PIByteArray ba(_content);
switch (_type) { switch (_type) {
case PIVariant::Bool: {bool r; ba >> r; return r;} case PIVariant::pivBool: {bool r; ba >> r; return r;}
case PIVariant::Char: {char r; ba >> r; return r;} case PIVariant::pivChar: {char r; ba >> r; return r;}
case PIVariant::UChar: {uchar r; ba >> r; return r;} case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
case PIVariant::Short: {short r; ba >> r; return r;} case PIVariant::pivShort: {short r; ba >> r; return r;}
case PIVariant::UShort: {ushort r; ba >> r; return r;} case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
case PIVariant::Int: {int r; ba >> r; return r;} case PIVariant::pivInt: {int r; ba >> r; return r;}
case PIVariant::UInt: {uint r; ba >> r; return r;} case PIVariant::pivUInt: {uint r; ba >> r; return r;}
case PIVariant::LLong: {llong r; ba >> r; return r;} case PIVariant::pivLLong: {llong r; ba >> r; return r;}
case PIVariant::ULLong: {ullong r; ba >> r; return r;} case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
case PIVariant::Float: {float r; ba >> r; return r;} case PIVariant::pivFloat: {float r; ba >> r; return r;}
case PIVariant::Double: {double r; ba >> r; return r;} case PIVariant::pivDouble: {double r; ba >> r; return r;}
case PIVariant::LDouble: {ldouble r; ba >> r; return r;} case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
case PIVariant::Complexd: {complexd r; ba >> r; return r.real();} case PIVariant::pivComplexd: {complexd r; ba >> r; return r.real();}
case PIVariant::Complexld: {complexld r; ba >> r; return r.real();} case PIVariant::pivComplexld: {complexld r; ba >> r; return r.real();}
case PIVariant::String: {PIString r; ba >> r; return r.toLLong();} case PIVariant::pivString: {PIString r; ba >> r; return r.toLLong();}
case PIVariant::StringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0L; return r.front().toLLong();} case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0L; return r.front().toLLong();}
case PIVariant::Custom: case PIVariant::pivCustom:
return getAsValue<llong>(*this); return getAsValue<llong>(*this);
} }
return 0L; return 0L;
@@ -252,23 +252,23 @@ llong PIVariant::toLLong() const {
float PIVariant::toFloat() const { float PIVariant::toFloat() const {
PIByteArray ba(_content); PIByteArray ba(_content);
switch (_type) { switch (_type) {
case PIVariant::Bool: {bool r; ba >> r; return r;} case PIVariant::pivBool: {bool r; ba >> r; return r;}
case PIVariant::Char: {char r; ba >> r; return r;} case PIVariant::pivChar: {char r; ba >> r; return r;}
case PIVariant::UChar: {uchar r; ba >> r; return r;} case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
case PIVariant::Short: {short r; ba >> r; return r;} case PIVariant::pivShort: {short r; ba >> r; return r;}
case PIVariant::UShort: {ushort r; ba >> r; return r;} case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
case PIVariant::Int: {int r; ba >> r; return r;} case PIVariant::pivInt: {int r; ba >> r; return r;}
case PIVariant::UInt: {uint r; ba >> r; return r;} case PIVariant::pivUInt: {uint r; ba >> r; return r;}
case PIVariant::LLong: {llong r; ba >> r; return r;} case PIVariant::pivLLong: {llong r; ba >> r; return r;}
case PIVariant::ULLong: {ullong r; ba >> r; return r;} case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
case PIVariant::Float: {float r; ba >> r; return r;} case PIVariant::pivFloat: {float r; ba >> r; return r;}
case PIVariant::Double: {double r; ba >> r; return r;} case PIVariant::pivDouble: {double r; ba >> r; return r;}
case PIVariant::LDouble: {ldouble r; ba >> r; return r;} case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
case PIVariant::Complexd: {complexd r; ba >> r; return r.real();} case PIVariant::pivComplexd: {complexd r; ba >> r; return r.real();}
case PIVariant::Complexld: {complexld r; ba >> r; return r.real();} case PIVariant::pivComplexld: {complexld r; ba >> r; return r.real();}
case PIVariant::String: {PIString r; ba >> r; return r.toFloat();} case PIVariant::pivString: {PIString r; ba >> r; return r.toFloat();}
case PIVariant::StringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0.f; return r.front().toFloat();} case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0.f; return r.front().toFloat();}
case PIVariant::Custom: case PIVariant::pivCustom:
return getAsValue<float>(*this); return getAsValue<float>(*this);
} }
return 0.f; return 0.f;
@@ -284,23 +284,23 @@ float PIVariant::toFloat() const {
double PIVariant::toDouble() const { double PIVariant::toDouble() const {
PIByteArray ba(_content); PIByteArray ba(_content);
switch (_type) { switch (_type) {
case PIVariant::Bool: {bool r; ba >> r; return r;} case PIVariant::pivBool: {bool r; ba >> r; return r;}
case PIVariant::Char: {char r; ba >> r; return r;} case PIVariant::pivChar: {char r; ba >> r; return r;}
case PIVariant::UChar: {uchar r; ba >> r; return r;} case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
case PIVariant::Short: {short r; ba >> r; return r;} case PIVariant::pivShort: {short r; ba >> r; return r;}
case PIVariant::UShort: {ushort r; ba >> r; return r;} case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
case PIVariant::Int: {int r; ba >> r; return r;} case PIVariant::pivInt: {int r; ba >> r; return r;}
case PIVariant::UInt: {uint r; ba >> r; return r;} case PIVariant::pivUInt: {uint r; ba >> r; return r;}
case PIVariant::LLong: {llong r; ba >> r; return r;} case PIVariant::pivLLong: {llong r; ba >> r; return r;}
case PIVariant::ULLong: {ullong r; ba >> r; return r;} case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
case PIVariant::Float: {float r; ba >> r; return r;} case PIVariant::pivFloat: {float r; ba >> r; return r;}
case PIVariant::Double: {double r; ba >> r; return r;} case PIVariant::pivDouble: {double r; ba >> r; return r;}
case PIVariant::LDouble: {ldouble r; ba >> r; return r;} case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
case PIVariant::Complexd: {complexd r; ba >> r; return r.real();} case PIVariant::pivComplexd: {complexd r; ba >> r; return r.real();}
case PIVariant::Complexld: {complexld r; ba >> r; return r.real();} case PIVariant::pivComplexld: {complexld r; ba >> r; return r.real();}
case PIVariant::String: {PIString r; ba >> r; return r.toDouble();} case PIVariant::pivString: {PIString r; ba >> r; return r.toDouble();}
case PIVariant::StringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0.; return r.front().toDouble();} case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0.; return r.front().toDouble();}
case PIVariant::Custom: case PIVariant::pivCustom:
return getAsValue<double>(*this); return getAsValue<double>(*this);
} }
return 0.; return 0.;
@@ -316,23 +316,23 @@ double PIVariant::toDouble() const {
ldouble PIVariant::toLDouble() const { ldouble PIVariant::toLDouble() const {
PIByteArray ba(_content); PIByteArray ba(_content);
switch (_type) { switch (_type) {
case PIVariant::Bool: {bool r; ba >> r; return r;} case PIVariant::pivBool: {bool r; ba >> r; return r;}
case PIVariant::Char: {char r; ba >> r; return r;} case PIVariant::pivChar: {char r; ba >> r; return r;}
case PIVariant::UChar: {uchar r; ba >> r; return r;} case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
case PIVariant::Short: {short r; ba >> r; return r;} case PIVariant::pivShort: {short r; ba >> r; return r;}
case PIVariant::UShort: {ushort r; ba >> r; return r;} case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
case PIVariant::Int: {int r; ba >> r; return r;} case PIVariant::pivInt: {int r; ba >> r; return r;}
case PIVariant::UInt: {uint r; ba >> r; return r;} case PIVariant::pivUInt: {uint r; ba >> r; return r;}
case PIVariant::LLong: {llong r; ba >> r; return r;} case PIVariant::pivLLong: {llong r; ba >> r; return r;}
case PIVariant::ULLong: {ullong r; ba >> r; return r;} case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
case PIVariant::Float: {float r; ba >> r; return r;} case PIVariant::pivFloat: {float r; ba >> r; return r;}
case PIVariant::Double: {double r; ba >> r; return r;} case PIVariant::pivDouble: {double r; ba >> r; return r;}
case PIVariant::LDouble: {ldouble r; ba >> r; return r;} case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
case PIVariant::Complexd: {complexd r; ba >> r; return r.real();} case PIVariant::pivComplexd: {complexd r; ba >> r; return r.real();}
case PIVariant::Complexld: {complexld r; ba >> r; return r.real();} case PIVariant::pivComplexld: {complexld r; ba >> r; return r.real();}
case PIVariant::String: {PIString r; ba >> r; return r.toLDouble();} case PIVariant::pivString: {PIString r; ba >> r; return r.toLDouble();}
case PIVariant::StringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0.; return r.front().toLDouble();} case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0.; return r.front().toLDouble();}
case PIVariant::Custom: case PIVariant::pivCustom:
return getAsValue<float>(*this); return getAsValue<float>(*this);
} }
return 0.; return 0.;
@@ -348,23 +348,23 @@ ldouble PIVariant::toLDouble() const {
complexd PIVariant::toComplexd() const { complexd PIVariant::toComplexd() const {
PIByteArray ba(_content); PIByteArray ba(_content);
switch (_type) { switch (_type) {
case PIVariant::Bool: {bool r; ba >> r; return r;} case PIVariant::pivBool: {bool r; ba >> r; return r;}
case PIVariant::Char: {char r; ba >> r; return r;} case PIVariant::pivChar: {char r; ba >> r; return r;}
case PIVariant::UChar: {uchar r; ba >> r; return r;} case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
case PIVariant::Short: {short r; ba >> r; return r;} case PIVariant::pivShort: {short r; ba >> r; return r;}
case PIVariant::UShort: {ushort r; ba >> r; return r;} case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
case PIVariant::Int: {int r; ba >> r; return r;} case PIVariant::pivInt: {int r; ba >> r; return r;}
case PIVariant::UInt: {uint r; ba >> r; return r;} case PIVariant::pivUInt: {uint r; ba >> r; return r;}
case PIVariant::LLong: {llong r; ba >> r; return r;} case PIVariant::pivLLong: {llong r; ba >> r; return r;}
case PIVariant::ULLong: {ullong r; ba >> r; return r;} case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
case PIVariant::Float: {float r; ba >> r; return r;} case PIVariant::pivFloat: {float r; ba >> r; return r;}
case PIVariant::Double: {double r; ba >> r; return r;} case PIVariant::pivDouble: {double r; ba >> r; return r;}
case PIVariant::LDouble: {ldouble r; ba >> r; return r;} case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
case PIVariant::Complexd: {complexd r; ba >> r; return r.real();} case PIVariant::pivComplexd: {complexd r; ba >> r; return r.real();}
case PIVariant::Complexld: {complexld r; ba >> r; return r.real();} case PIVariant::pivComplexld: {complexld r; ba >> r; return r.real();}
case PIVariant::String: {PIString r; ba >> r; return r.toDouble();} case PIVariant::pivString: {PIString r; ba >> r; return r.toDouble();}
case PIVariant::StringList: {PIStringList r; ba >> r; if (r.isEmpty()) return complexd_0; return r.front().toDouble();} case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return complexd_0; return r.front().toDouble();}
case PIVariant::Custom: case PIVariant::pivCustom:
return getAsValue<complexd>(*this); return getAsValue<complexd>(*this);
} }
return complexd_0; return complexd_0;
@@ -380,23 +380,23 @@ complexd PIVariant::toComplexd() const {
complexld PIVariant::toComplexld() const { complexld PIVariant::toComplexld() const {
PIByteArray ba(_content); PIByteArray ba(_content);
switch (_type) { switch (_type) {
case PIVariant::Bool: {bool r; ba >> r; return r;} case PIVariant::pivBool: {bool r; ba >> r; return r;}
case PIVariant::Char: {char r; ba >> r; return r;} case PIVariant::pivChar: {char r; ba >> r; return r;}
case PIVariant::UChar: {uchar r; ba >> r; return r;} case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
case PIVariant::Short: {short r; ba >> r; return r;} case PIVariant::pivShort: {short r; ba >> r; return r;}
case PIVariant::UShort: {ushort r; ba >> r; return r;} case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
case PIVariant::Int: {int r; ba >> r; return r;} case PIVariant::pivInt: {int r; ba >> r; return r;}
case PIVariant::UInt: {uint r; ba >> r; return r;} case PIVariant::pivUInt: {uint r; ba >> r; return r;}
case PIVariant::LLong: {llong r; ba >> r; return r;} case PIVariant::pivLLong: {llong r; ba >> r; return r;}
case PIVariant::ULLong: {ullong r; ba >> r; return r;} case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
case PIVariant::Float: {float r; ba >> r; return r;} case PIVariant::pivFloat: {float r; ba >> r; return r;}
case PIVariant::Double: {double r; ba >> r; return r;} case PIVariant::pivDouble: {double r; ba >> r; return r;}
case PIVariant::LDouble: {ldouble r; ba >> r; return r;} case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
case PIVariant::Complexd: {complexd r; ba >> r; return r.real();} case PIVariant::pivComplexd: {complexd r; ba >> r; return r.real();}
case PIVariant::Complexld: {complexld r; ba >> r; return r.real();} case PIVariant::pivComplexld: {complexld r; ba >> r; return r.real();}
case PIVariant::String: {PIString r; ba >> r; return r.toLDouble();} case PIVariant::pivString: {PIString r; ba >> r; return r.toLDouble();}
case PIVariant::StringList: {PIStringList r; ba >> r; if (r.isEmpty()) return complexld_0; return r.front().toLDouble();} case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return complexld_0; return r.front().toLDouble();}
case PIVariant::Custom: case PIVariant::pivCustom:
return getAsValue<complexld>(*this); return getAsValue<complexld>(*this);
} }
return complexld_0; return complexld_0;
@@ -409,9 +409,9 @@ complexld PIVariant::toComplexld() const {
* In case of other types returns \a PITime(). */ * In case of other types returns \a PITime(). */
PITime PIVariant::toTime() const { PITime PIVariant::toTime() const {
PIByteArray ba(_content); PIByteArray ba(_content);
if (_type == PIVariant::Time) {PITime r; ba >> r; return r;} if (_type == PIVariant::pivTime) {PITime r; ba >> r; return r;}
if (_type == PIVariant::DateTime) {PIDateTime r; ba >> r; return r.time();} if (_type == PIVariant::pivDateTime) {PIDateTime r; ba >> r; return r.time();}
if (_type == PIVariant::Custom) {return getAsValue<PITime>(*this);} if (_type == PIVariant::pivCustom) {return getAsValue<PITime>(*this);}
return PITime(); return PITime();
} }
@@ -422,9 +422,9 @@ PITime PIVariant::toTime() const {
* In case of other types returns \a PIDate(). */ * In case of other types returns \a PIDate(). */
PIDate PIVariant::toDate() const { PIDate PIVariant::toDate() const {
PIByteArray ba(_content); PIByteArray ba(_content);
if (_type == PIVariant::Date) {PIDate r; ba >> r; return r;} if (_type == PIVariant::pivDate) {PIDate r; ba >> r; return r;}
if (_type == PIVariant::DateTime) {PIDateTime r; ba >> r; return r.date();} if (_type == PIVariant::pivDateTime) {PIDateTime r; ba >> r; return r.date();}
if (_type == PIVariant::Custom) {return getAsValue<PIDate>(*this);} if (_type == PIVariant::pivCustom) {return getAsValue<PIDate>(*this);}
return PIDate(); return PIDate();
} }
@@ -436,10 +436,10 @@ PIDate PIVariant::toDate() const {
* In case of other types returns \a PIDateTime(). */ * In case of other types returns \a PIDateTime(). */
PIDateTime PIVariant::toDateTime() const { PIDateTime PIVariant::toDateTime() const {
PIByteArray ba(_content); PIByteArray ba(_content);
if (_type == PIVariant::Time) {PITime r; ba >> r; return PIDateTime(r);} if (_type == PIVariant::pivTime) {PITime r; ba >> r; return PIDateTime(r);}
if (_type == PIVariant::Date) {PIDate r; ba >> r; return PIDateTime(r);} if (_type == PIVariant::pivDate) {PIDate r; ba >> r; return PIDateTime(r);}
if (_type == PIVariant::DateTime) {PIDateTime r; ba >> r; return r;} if (_type == PIVariant::pivDateTime) {PIDateTime r; ba >> r; return r;}
if (_type == PIVariant::Custom) {return getAsValue<PIDateTime>(*this);} if (_type == PIVariant::pivCustom) {return getAsValue<PIDateTime>(*this);}
return PIDateTime(); return PIDateTime();
} }
@@ -450,8 +450,8 @@ PIDateTime PIVariant::toDateTime() const {
* double value of variant content. */ * double value of variant content. */
PISystemTime PIVariant::toSystemTime() const { PISystemTime PIVariant::toSystemTime() const {
PIByteArray ba(_content); PIByteArray ba(_content);
if (_type == PIVariant::SystemTime) {PISystemTime r; ba >> r; return r;} if (_type == PIVariant::pivSystemTime) {PISystemTime r; ba >> r; return r;}
if (_type == PIVariant::Custom) {return getAsValue<PISystemTime>(*this);} if (_type == PIVariant::pivCustom) {return getAsValue<PISystemTime>(*this);}
return PISystemTime::fromSeconds(toDouble()); return PISystemTime::fromSeconds(toDouble());
} }
@@ -468,23 +468,23 @@ PISystemTime PIVariant::toSystemTime() const {
PIString PIVariant::toString() const { PIString PIVariant::toString() const {
PIByteArray ba(_content); PIByteArray ba(_content);
switch (_type) { switch (_type) {
case PIVariant::Bool: {bool r; ba >> r; return PIString::fromNumber(r);} case PIVariant::pivBool: {bool r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::Char: {char r; ba >> r; return PIString::fromNumber(r);} case PIVariant::pivChar: {char r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::UChar: {uchar r; ba >> r; return PIString::fromNumber(r);} case PIVariant::pivUChar: {uchar r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::Short: {short r; ba >> r; return PIString::fromNumber(r);} case PIVariant::pivShort: {short r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::UShort: {ushort r; ba >> r; return PIString::fromNumber(r);} case PIVariant::pivUShort: {ushort r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::Int: {int r; ba >> r; return PIString::fromNumber(r);} case PIVariant::pivInt: {int r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::UInt: {uint r; ba >> r; return PIString::fromNumber(r);} case PIVariant::pivUInt: {uint r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::LLong: {llong r; ba >> r; return PIString::fromNumber(r);} case PIVariant::pivLLong: {llong r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::ULLong: {ullong r; ba >> r; return PIString::fromNumber(r);} case PIVariant::pivULLong: {ullong r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::Float: {float r; ba >> r; return PIString::fromNumber(r);} case PIVariant::pivFloat: {float r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::Double: {double r; ba >> r; return PIString::fromNumber(r);} case PIVariant::pivDouble: {double r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::LDouble: {ldouble r; ba >> r; return PIString::fromNumber(r);} case PIVariant::pivLDouble: {ldouble r; ba >> r; return PIString::fromNumber(r);}
case PIVariant::Complexd: {complexd r; ba >> r; return PIString::fromNumber(r.real());} case PIVariant::pivComplexd: {complexd r; ba >> r; return PIString::fromNumber(r.real());}
case PIVariant::Complexld: {complexld r; ba >> r; return PIString::fromNumber(r.real());} case PIVariant::pivComplexld: {complexld r; ba >> r; return PIString::fromNumber(r.real());}
case PIVariant::String: {PIString r; ba >> r; return r;} case PIVariant::pivString: {PIString r; ba >> r; return r;}
case PIVariant::StringList: {PIStringList r; ba >> r; if (r.isEmpty()) return PIString(); return r.front();} case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return PIString(); return r.front();}
case PIVariant::Custom: case PIVariant::pivCustom:
return getAsValue<PIString>(*this); return getAsValue<PIString>(*this);
} }
return PIString(); return PIString();
@@ -496,8 +496,8 @@ PIString PIVariant::toString() const {
* In case of other types returns \a PIStringList with one string value of variant content. */ * In case of other types returns \a PIStringList with one string value of variant content. */
PIStringList PIVariant::toStringList() const { PIStringList PIVariant::toStringList() const {
PIByteArray ba(_content); PIByteArray ba(_content);
if (_type == PIVariant::StringList) {PIStringList r; ba >> r; return r;} if (_type == PIVariant::pivStringList) {PIStringList r; ba >> r; return r;}
if (_type == PIVariant::Custom) {return getAsValue<PIStringList>(*this);} if (_type == PIVariant::pivCustom) {return getAsValue<PIStringList>(*this);}
return PIStringList(toString()); return PIStringList(toString());
} }
@@ -507,8 +507,8 @@ PIStringList PIVariant::toStringList() const {
* In case of other types returns \a PIBitArray from \a toLLong() value. */ * In case of other types returns \a PIBitArray from \a toLLong() value. */
PIBitArray PIVariant::toBitArray() const { PIBitArray PIVariant::toBitArray() const {
PIByteArray ba(_content); PIByteArray ba(_content);
if (_type == PIVariant::BitArray) {PIBitArray r; ba >> r; return r;} if (_type == PIVariant::pivBitArray) {PIBitArray r; ba >> r; return r;}
if (_type == PIVariant::Custom) {return getAsValue<PIBitArray>(*this);} if (_type == PIVariant::pivCustom) {return getAsValue<PIBitArray>(*this);}
return PIBitArray(ullong(toLLong())); return PIBitArray(ullong(toLLong()));
} }
@@ -518,7 +518,7 @@ PIBitArray PIVariant::toBitArray() const {
* In case of other types returns empty \a PIByteArray. */ * In case of other types returns empty \a PIByteArray. */
PIByteArray PIVariant::toByteArray() const { PIByteArray PIVariant::toByteArray() const {
PIByteArray ba(_content); PIByteArray ba(_content);
if (_type == PIVariant::ByteArray) {PIByteArray r; ba >> r; return r;} if (_type == PIVariant::pivByteArray) {PIByteArray r; ba >> r; return r;}
if (_type == PIVariant::Custom) {return getAsValue<PIByteArray>(*this);} if (_type == PIVariant::pivCustom) {return getAsValue<PIByteArray>(*this);}
return PIByteArray(); return PIByteArray();
} }

102
src/core/pivariant.h
View File

@@ -133,30 +133,30 @@ public:
//! Type of %PIVariant content //! Type of %PIVariant content
enum Type { enum Type {
Invalid /** Invalid type , default type of empty contructor */ = 0 , pivInvalid /** Invalid type , default type of empty contructor */ = 0 ,
Bool /** bool */ , pivBool /** bool */ ,
Char /** char */ , pivChar /** char */ ,
UChar /** uchar */ , pivUChar /** uchar */ ,
Short /** short */ , pivShort /** short */ ,
UShort /** ushort */ , pivUShort /** ushort */ ,
Int /** int */ , pivInt /** int */ ,
UInt /** uint */ , pivUInt /** uint */ ,
LLong /** llong */ , pivLLong /** llong */ ,
ULLong /** ullong */ , pivULLong /** ullong */ ,
Float /** float */ , pivFloat /** float */ ,
Double /** double */ , pivDouble /** double */ ,
LDouble /** ldouble */ , pivLDouble /** ldouble */ ,
Complexd /** complexd */ , pivComplexd /** complexd */ ,
Complexld /** complexld */ , pivComplexld /** complexld */ ,
BitArray /** PIBitArray */ , pivBitArray /** PIBitArray */ ,
ByteArray /** PIByteArray */ , pivByteArray /** PIByteArray */ ,
String /** PIString */ , pivString /** PIString */ ,
StringList /** PIStringList */ , pivStringList /** PIStringList */ ,
Time /** PITime */ , pivTime /** PITime */ ,
Date /** PIDate */ , pivDate /** PIDate */ ,
DateTime /** PIDateTime */ , pivDateTime /** PIDateTime */ ,
SystemTime /** PISystemTime */ , pivSystemTime /** PISystemTime */ ,
Custom /** Custom */ = 0xFF pivCustom /** Custom */ = 0xFF
}; };
//! Empty constructor, \a type() will be set to \a Invalid //! Empty constructor, \a type() will be set to \a Invalid
@@ -417,7 +417,7 @@ public:
//! Returns \b true if type is not Invalid //! Returns \b true if type is not Invalid
bool isValid() const {return _type != PIVariant::Invalid;} bool isValid() const {return _type != PIVariant::pivInvalid;}
/** \brief Returns new variant from custom type /** \brief Returns new variant from custom type
@@ -437,14 +437,14 @@ public:
if (!ret._info) { if (!ret._info) {
#endif #endif
PIVariant::Type t = typeFromName(type); PIVariant::Type t = typeFromName(type);
if (t == Invalid) { if (t == pivInvalid) {
piCout << "Can`t initialize PIVariant from unregistered type \"" << type << "\"!"; piCout << "Can`t initialize PIVariant from unregistered type \"" << type << "\"!";
return ret; return ret;
} }
ret._type = t; ret._type = t;
#ifdef CUSTOM_PIVARIANT #ifdef CUSTOM_PIVARIANT
} else } else
ret._type = Custom; ret._type = pivCustom;
#endif #endif
ret._content = c; ret._content = c;
return ret; return ret;
@@ -459,13 +459,13 @@ public:
private: private:
void destroy() {_content.clear();} void destroy() {_content.clear();}
template <typename T> static Type getType() {return Custom;} template <typename T> static Type getType() {return pivCustom;}
template <typename T> void initType(const T & v) { template <typename T> void initType(const T & v) {
_content.clear(); _content.clear();
_content << v; _content << v;
_type = getType<T>(); _type = getType<T>();
#ifdef CUSTOM_PIVARIANT #ifdef CUSTOM_PIVARIANT
if (_type == Custom) { if (_type == pivCustom) {
_info = __PIVariantInfoStorage__::get()->map->value(__PIVariantFunctions__<T>::typeNameHelper(), 0); _info = __PIVariantInfoStorage__::get()->map->value(__PIVariantFunctions__<T>::typeNameHelper(), 0);
if (!_info) if (!_info)
piCout << "Can`t initialize PIVariant from unregistered type!"; piCout << "Can`t initialize PIVariant from unregistered type!";
@@ -550,28 +550,28 @@ template<> inline PIVariant PIVariant::fromValue(const PIDate & v) {return PIVar
template<> inline PIVariant PIVariant::fromValue(const PIDateTime & 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);} template<> inline PIVariant PIVariant::fromValue(const PISystemTime & v) {return PIVariant(v);}
template<> inline PIVariant::Type PIVariant::getType<bool>() {return PIVariant::Bool;} template<> inline PIVariant::Type PIVariant::getType<bool>() {return PIVariant::pivBool;}
template<> inline PIVariant::Type PIVariant::getType<char>() {return PIVariant::Char;} template<> inline PIVariant::Type PIVariant::getType<char>() {return PIVariant::pivChar;}
template<> inline PIVariant::Type PIVariant::getType<uchar>() {return PIVariant::UChar;} template<> inline PIVariant::Type PIVariant::getType<uchar>() {return PIVariant::pivUChar;}
template<> inline PIVariant::Type PIVariant::getType<short>() {return PIVariant::Short;} template<> inline PIVariant::Type PIVariant::getType<short>() {return PIVariant::pivShort;}
template<> inline PIVariant::Type PIVariant::getType<ushort>() {return PIVariant::UShort;} template<> inline PIVariant::Type PIVariant::getType<ushort>() {return PIVariant::pivUShort;}
template<> inline PIVariant::Type PIVariant::getType<int>() {return PIVariant::Int;} template<> inline PIVariant::Type PIVariant::getType<int>() {return PIVariant::pivInt;}
template<> inline PIVariant::Type PIVariant::getType<uint>() {return PIVariant::UInt;} template<> inline PIVariant::Type PIVariant::getType<uint>() {return PIVariant::pivUInt;}
template<> inline PIVariant::Type PIVariant::getType<llong>() {return PIVariant::LLong;} template<> inline PIVariant::Type PIVariant::getType<llong>() {return PIVariant::pivLLong;}
template<> inline PIVariant::Type PIVariant::getType<ullong>() {return PIVariant::ULLong;} template<> inline PIVariant::Type PIVariant::getType<ullong>() {return PIVariant::pivULLong;}
template<> inline PIVariant::Type PIVariant::getType<float>() {return PIVariant::Float;} template<> inline PIVariant::Type PIVariant::getType<float>() {return PIVariant::pivFloat;}
template<> inline PIVariant::Type PIVariant::getType<double>() {return PIVariant::Double;} template<> inline PIVariant::Type PIVariant::getType<double>() {return PIVariant::pivDouble;}
template<> inline PIVariant::Type PIVariant::getType<ldouble>() {return PIVariant::LDouble;} template<> inline PIVariant::Type PIVariant::getType<ldouble>() {return PIVariant::pivLDouble;}
template<> inline PIVariant::Type PIVariant::getType<complexd>() {return PIVariant::Complexd;} template<> inline PIVariant::Type PIVariant::getType<complexd>() {return PIVariant::pivComplexd;}
template<> inline PIVariant::Type PIVariant::getType<complexld>() {return PIVariant::Complexld;} template<> inline PIVariant::Type PIVariant::getType<complexld>() {return PIVariant::pivComplexld;}
template<> inline PIVariant::Type PIVariant::getType<PIBitArray>() {return PIVariant::BitArray;} template<> inline PIVariant::Type PIVariant::getType<PIBitArray>() {return PIVariant::pivBitArray;}
template<> inline PIVariant::Type PIVariant::getType<PIByteArray>() {return PIVariant::ByteArray;} template<> inline PIVariant::Type PIVariant::getType<PIByteArray>() {return PIVariant::pivByteArray;}
template<> inline PIVariant::Type PIVariant::getType<PIString>() {return PIVariant::String;} template<> inline PIVariant::Type PIVariant::getType<PIString>() {return PIVariant::pivString;}
template<> inline PIVariant::Type PIVariant::getType<PIStringList>() {return PIVariant::StringList;} template<> inline PIVariant::Type PIVariant::getType<PIStringList>() {return PIVariant::pivStringList;}
template<> inline PIVariant::Type PIVariant::getType<PITime>() {return PIVariant::Time;} template<> inline PIVariant::Type PIVariant::getType<PITime>() {return PIVariant::pivTime;}
template<> inline PIVariant::Type PIVariant::getType<PIDate>() {return PIVariant::Date;} template<> inline PIVariant::Type PIVariant::getType<PIDate>() {return PIVariant::pivDate;}
template<> inline PIVariant::Type PIVariant::getType<PIDateTime>() {return PIVariant::DateTime;} template<> inline PIVariant::Type PIVariant::getType<PIDateTime>() {return PIVariant::pivDateTime;}
template<> inline PIVariant::Type PIVariant::getType<PISystemTime>() {return PIVariant::SystemTime;} template<> inline PIVariant::Type PIVariant::getType<PISystemTime>() {return PIVariant::pivSystemTime;}
inline PICout operator <<(PICout s, const PIVariant & v) { inline PICout operator <<(PICout s, const PIVariant & v) {
s.space(); s.setControl(0, true); s.space(); s.setControl(0, true);