pip/pivariant.cpp

/*
    PIP - Platform Independent Primitives
    Variant type
    Copyright (C) 2013  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 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 <http://www.gnu.org/licenses/>.
*/

#include "pivariant.h"


PIVariant::PIVariant() {
	type_ = PIVariant::Invalid;
	memset(_vraw, 0, __PIVARIANT_UNION_SIZE__);
}


void 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;
}

/*
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<double>") return PIVariant::Complexd;
	if (s == "complexld" || s == "complex<ldouble>" || s == "complex<longdouble>") return PIVariant::Complexld;
	if (s == "pibitarray" || s == "bitarray") return PIVariant::BitArray;
	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;
	if (s == "pistring" || s == "string") return PIVariant::String;
	if (s == "pistringlist" || s == "vector<string>" || s == "vector<pistring>" || s == "pivector<string>" || s == "pivector<pistring>") 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";
	default: break;
	}
	return "Invalid";
}


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;
}


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 false; return _vstringlist.front().toInt();
	default: break;
	}
	return 0;
}


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 false; return _vstringlist.front().toLLong();
	default: break;
	}
	return 0L;
}


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 false; return _vstringlist.front().toFloat();
	default: break;
	}
	return 0.f;
}


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 false; return _vstringlist.front().toDouble();
	default: break;
	}
	return 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 false; return _vstringlist.front().toLDouble();
	default: break;
	}
	return 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 false; return _vstringlist.front().toDouble();
	default: break;
	}
	return complexd_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 false; return _vstringlist.front().toLDouble();
	default: break;
	}
	return complexld_0;
}


PITime PIVariant::toTime() const {
	if (type_ == PIVariant::Time) return _vtime;
	if (type_ == PIVariant::DateTime) return _vtime;
	return PITime();
}


PIDate PIVariant::toDate() const {
	if (type_ == PIVariant::Date) return _vdate;
	if (type_ == PIVariant::DateTime) return *((PIDate*)(&(_vdatetime.day)));
	return PIDate();
}


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();
}


PISystemTime PIVariant::toSystemTime() const {
	if (type_ == PIVariant::SystemTime) return _vsystime;
	return PISystemTime::fromSeconds(toDouble());
}


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 PIString::fromNumber(_vbytearray.size()) + " bytes";
	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 "";
}


PIStringList PIVariant::toStringList() const {
	if (type_ == PIVariant::StringList) return _vstringlist;
	return PIStringList(toString());
}


PIBitArray PIVariant::toBitArray() const {
	if (type_ == PIVariant::BitArray) return _vbitarray;
	return PIBitArray(ullong(toLLong()));
}


PIByteArray PIVariant::toByteArray() const {
	if (type_ == PIVariant::ByteArray) return _vbytearray;
	return PIByteArray();
}