git-svn-id: svn://db.shs.com.ru/pip@182 12ceb7fc-bf1f-11e4-8940-5bc7170c53b5
This commit is contained in:
@@ -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 <http://www.gnu.org/licenses/>.
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef PIVARIANT_H
|
||||
@@ -30,407 +30,432 @@
|
||||
#include "pitime.h"
|
||||
#include "pimathbase.h"
|
||||
|
||||
#define __PIVARIANT_UNION_SIZE__ 32
|
||||
|
||||
template<typename T>
|
||||
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<typename C> static PIByteArray castHelper(PIByteArray ba) {return PIByteArray();}
|
||||
template<typename C> static C castVariant(const T & v) {return C();}
|
||||
};
|
||||
|
||||
struct __PIVariantInfo__ {
|
||||
__PIVariantInfo__() {
|
||||
simple = false;
|
||||
}
|
||||
typedef PIByteArray(*castHelperFunc)(PIByteArray);
|
||||
PIMap<PIString, castHelperFunc> cast;
|
||||
PIString typeName;
|
||||
bool simple;
|
||||
};
|
||||
|
||||
class __PIVariantInfoStorage__ {
|
||||
public:
|
||||
__PIVariantInfoStorage__() {if (!map) map = new PIMap<PIString, __PIVariantInfo__ * >();}
|
||||
static __PIVariantInfoStorage__ * get() {static __PIVariantInfoStorage__ * r = new __PIVariantInfoStorage__(); return r;}
|
||||
static PIMap<PIString, __PIVariantInfo__ * > * 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 <typename T> \
|
||||
class __##classname##_PIVariantInitializer__ { \
|
||||
public: \
|
||||
__##classname##_PIVariantInitializer__(const PIString & name) { \
|
||||
if (__PIVariantInfoStorage__::get()->map->contains(name)) \
|
||||
return; \
|
||||
__PIVariantInfo__ * vi = new __PIVariantInfo__(); \
|
||||
vi->typeName = name; \
|
||||
(*(__PIVariantInfoStorage__::get()->map))[name] = vi; \
|
||||
} \
|
||||
};
|
||||
|
||||
#define INIT_VARIANT(classname) \
|
||||
__##classname##_PIVariantInitializer__< classname > __##classname##_pivariant_initializer__(#classname);
|
||||
|
||||
#define REGISTER_VARIANT(classname) \
|
||||
REGISTER_VARIANT_H(classname) \
|
||||
REGISTER_VARIANT_CPP(classname) \
|
||||
static INIT_VARIANT(classname)
|
||||
|
||||
|
||||
#define REGISTER_VARIANT_CAST_H(classname_from, classname_to) \
|
||||
template<> template<> inline \
|
||||
classname_to __PIVariantFunctions__<classname_from>::castVariant<classname_to>(const classname_from & v);
|
||||
|
||||
#define REGISTER_VARIANT_CAST_CPP(classname_from, classname_to) \
|
||||
template<> template<> inline \
|
||||
PIByteArray __PIVariantFunctions__<classname_from>::castHelper<classname_to>(PIByteArray v) { \
|
||||
classname_from f; v >> f; \
|
||||
classname_to t = __PIVariantFunctions__<classname_from>::castVariant<classname_to>(f); \
|
||||
PIByteArray ret; ret << t; \
|
||||
return ret;} \
|
||||
template <typename T, typename C> \
|
||||
class __##classname_from##_##classname_to##_PIVariantCastInitializer__ { \
|
||||
public: \
|
||||
__##classname_from##_##classname_to##_PIVariantCastInitializer__(const PIString & name, const PIString & cname) { \
|
||||
__PIVariantInfo__ * vi(__PIVariantInfoStorage__::get()->map->value(name, 0)); \
|
||||
if (!vi) { \
|
||||
piCout << "Warning! Using REGISTER_VARIANT_CAST("#classname_from", "#classname_to") before REGISTER_VARIANT("#classname_from"), ignore."; \
|
||||
return; \
|
||||
} \
|
||||
vi->cast[cname] = __PIVariantFunctions__<classname_from>::castHelper<classname_to>; \
|
||||
} \
|
||||
}; \
|
||||
static __##classname_from##_##classname_to##_PIVariantCastInitializer__< classname_from, classname_to > __##classname_from##_##classname_to##_pivariant_cast_initializer__(#classname_from, #classname_to); \
|
||||
template<> template<> \
|
||||
classname_to __PIVariantFunctions__<classname_from>::castVariant<classname_to>(const classname_from & v)
|
||||
|
||||
#define REGISTER_VARIANT_CAST(classname_from, classname_to) \
|
||||
REGISTER_VARIANT_CAST_H(classname_from, classname_to) \
|
||||
REGISTER_VARIANT_CAST_CPP(classname_from, classname_to)
|
||||
|
||||
|
||||
#define REGISTER_VARIANT_CAST_SIMPLE(classname_from, classname_to) REGISTER_VARIANT_CAST(classname_from, classname_to) {return classname_to(v);}
|
||||
#define REGISTER_VARIANT_CAST_SIMPLE_H(classname_from, classname_to) REGISTER_VARIANT_CAST_H(classname_from, classname_to)
|
||||
#define REGISTER_VARIANT_CAST_SIMPLE_CPP(classname_from, classname_to) REGISTER_VARIANT_CAST_CPP(classname_from, classname_to) {return classname_to(v);}
|
||||
#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<bool>();}
|
||||
char toChar() const {return value<char>();}
|
||||
uchar toUChar() const {return value<uchar>();}
|
||||
short toShort() const {return value<short>();}
|
||||
ushort toUShort() const {return value<ushort>();}
|
||||
int toInt() const {return value<int>();}
|
||||
uint toUInt() const {return value<uint>();}
|
||||
llong toLLong() const {return value<llong>();}
|
||||
ullong toULLong() const {return value<ullong>();}
|
||||
float toFloat() const {return value<float>();}
|
||||
double toDouble() const {return value<double>();}
|
||||
ldouble toLDouble() const {return value<ldouble>();}
|
||||
complexf toComplexf() const {return value<complexf>();}
|
||||
complexd toComplexd() const {return value<complexd>();}
|
||||
complexld toComplexld() const {return value<complexld>();}
|
||||
PIString toString() const {return value<PIString>();}
|
||||
PIStringList toStringList() const {return value<PIStringList>();}
|
||||
PIByteArray toByteArray() const {return value<PIByteArray>();}
|
||||
PISystemTime toSystemTime() const {return value<PISystemTime>();}
|
||||
PITime toTime() const {return value<PITime>();}
|
||||
PIDate toDate() const {return value<PIDate>();}
|
||||
PIDateTime toDateTime() const {return value<PIDateTime>();}
|
||||
//! Empty constructor, \a type() will be set to \a Invalid
|
||||
PIVariant();
|
||||
|
||||
template <typename T>
|
||||
static PIVariant fromValue(const T & v) {
|
||||
PIVariant ret;
|
||||
ret.initType<T>(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<Type> function. \n
|
||||
* Otherwise returns content as type T. */
|
||||
template<typename T>
|
||||
T value() const {
|
||||
if (_content.isEmpty() || !_info) return T();
|
||||
PIString cn = __PIVariantFunctions__<T>::typeNameHelper();
|
||||
//bool cs = __PIVariantFunctions__<T>::isSimpleHelper();
|
||||
PIByteArray ba;
|
||||
if (cn == _info->typeName) {
|
||||
ba = _content;
|
||||
} else {
|
||||
__PIVariantInfo__::castHelperFunc cf = _info->cast.value(cn);
|
||||
if (!cf) return T();
|
||||
ba = cf(_content);
|
||||
}
|
||||
T ret; ba >> ret;
|
||||
return ret;
|
||||
}
|
||||
private:
|
||||
template <typename T>
|
||||
void initType(const T & v) {
|
||||
_content.clear();
|
||||
_content << v;
|
||||
_info = __PIVariantInfoStorage__::get()->map->value(__PIVariantFunctions__<T>::typeNameHelper(), 0);
|
||||
if (!_info)
|
||||
piCout << "Can`t initialize PIVariant from unregistered type!";
|
||||
}
|
||||
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 <typename T>
|
||||
static PIVariant fromValue(const T & v) {PIVariant ret; ret._vcustom.resize(sizeof(T)); new((T*)(ret._vcustom.data()))T(v); ret.type_ = PIVariant::Custom; return ret;}
|
||||
|
||||
|
||||
//! Returns type from name
|
||||
static PIVariant::Type typeFromName(const PIString & tname);
|
||||
|
||||
//! Returns type name
|
||||
static PIString typeName(PIVariant::Type type);
|
||||
|
||||
private:
|
||||
void destroy() {_vcustom.clear();}
|
||||
|
||||
union {
|
||||
int _vint;
|
||||
llong _vllong;
|
||||
float _vfloat;
|
||||
double _vdouble;
|
||||
ldouble _vldouble;
|
||||
uchar _vraw[__PIVARIANT_UNION_SIZE__];
|
||||
/*complexd _vcomplexd;
|
||||
complexld _vcomplexld;
|
||||
PITime _vtime;
|
||||
PIDate _vdate;
|
||||
PIDateTime _vdatetime;
|
||||
PISystemTime _vsystime;*/
|
||||
};
|
||||
PIBitArray _vbitarray;
|
||||
PIByteArray _vbytearray;
|
||||
PIString _vstring;
|
||||
PIStringList _vstringlist;
|
||||
PIByteArray _vcustom;
|
||||
PIVariant::Type type_;
|
||||
|
||||
};
|
||||
|
||||
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
|
||||
|
||||
Reference in New Issue
Block a user