diff --git a/src/core/pivariant.cpp b/src/core/pivariant.cpp
index 0c5414e0..3ad4acd2 100755
--- a/src/core/pivariant.cpp
+++ b/src/core/pivariant.cpp
@@ -54,7 +54,7 @@ PIMap<PIString, __PIVariantInfo__ * > * __PIVariantInfoStorage__::map = 0;
 
 
 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) {
 	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::Int;
-	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::UInt;
-	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 == "bool" || s == "boolean") return PIVariant::pivBool;
+	if (s == "char" || s == "sbyte") return PIVariant::pivChar;
+	if (s == "short" || s == "shortint" || s == "signedshort" || s == "signedshortint" || s == "sword") return PIVariant::pivShort;
+	if (s == "int" || s == "signed" || s == "signedint") return PIVariant::pivInt;
+	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::pivLLong;
+	if (s == "uchar" || s == "byte") return PIVariant::pivUChar;
+	if (s == "ushort" || s == "unsignedshort" || s == "unsignedshortint" || s == "word") return PIVariant::pivUShort;
+	if (s == "uint" || s == "unsigned" || s == "unsignedint") return PIVariant::pivUInt;
+	if (s == "ulong" || s == "unsignedlong" || s == "unsignedlongint" || s == "dword") return PIVariant::pivUInt;
+	if (s == "ullong" || s == "unsignedlonglong" || s == "unsignedlonglongint" || s == "qword") return PIVariant::pivULLong;
+	if (s == "float") return PIVariant::pivFloat;
+	if (s == "double" || s == "real") return PIVariant::pivDouble;
+	if (s == "ldouble" || s == "longdouble") return PIVariant::pivLDouble;
+	if (s == "complexd" || s == "complex<double>") return PIVariant::pivComplexd;
+	if (s == "complexld" || s == "complex<ldouble>" || s == "complex<longdouble>") return PIVariant::pivComplexld;
+	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>" ||
-		s == "vector<char>" || s == "pivector<char>") return PIVariant::ByteArray;
-	if (s == "pistring" || s == "string") return PIVariant::String;
-	if (s == "pistringlist" || s == "stringlist" || 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;
+		s == "vector<char>" || s == "pivector<char>") return PIVariant::pivByteArray;
+	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::pivStringList;
+	if (s == "pitime" || s == "time") return PIVariant::pivTime;
+	if (s == "pidate" || s == "date") return PIVariant::pivDate;
+	if (s == "pidatetime" || s == "datetime") return PIVariant::pivDateTime;
+	if (s == "pisystemtime" || s == "systemtime") return PIVariant::pivSystemTime;
+	return PIVariant::pivInvalid;
 }
 
 
 PIString PIVariant::typeName() const {
 #ifdef CUSTOM_PIVARIANT
-	if ((_type == Custom) && _info)
+	if ((_type == pivCustom) && _info)
 		return _info->typeName;
 #endif
 	return typeName(_type);
@@ -115,29 +115,29 @@ PIString PIVariant::typeName() const {
 
 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::LLong: return "LLong";
-	case PIVariant::ULLong: return "ULLong";
-	case PIVariant::Float: return "Float";
-	case PIVariant::Double: return "Double";
-	case PIVariant::LDouble: return "LDouble";
-	case PIVariant::Complexd: return "Complexd";
-	case PIVariant::Complexld: return "Complexld";
-	case PIVariant::BitArray: return "BitArray";
-	case PIVariant::ByteArray: return "ByteArray";
-	case PIVariant::String: return "String";
-	case PIVariant::StringList: return "StringList";
-	case PIVariant::Time: return "Time";
-	case PIVariant::Date: return "Date";
-	case PIVariant::DateTime: return "DateTime";
-	case PIVariant::SystemTime: return "SystemTime";
-	case PIVariant::Custom: return "Custom";
+	case PIVariant::pivBool: return "Bool";
+	case PIVariant::pivChar: return "Char";
+	case PIVariant::pivUChar: return "UChar";
+	case PIVariant::pivShort: return "Short";
+	case PIVariant::pivUShort: return "UShort";
+	case PIVariant::pivInt: return "Int";
+	case PIVariant::pivUInt: return "UInt";
+	case PIVariant::pivLLong: return "LLong";
+	case PIVariant::pivULLong: return "ULLong";
+	case PIVariant::pivFloat: return "Float";
+	case PIVariant::pivDouble: return "Double";
+	case PIVariant::pivLDouble: return "LDouble";
+	case PIVariant::pivComplexd: return "Complexd";
+	case PIVariant::pivComplexld: return "Complexld";
+	case PIVariant::pivBitArray: return "BitArray";
+	case PIVariant::pivByteArray: return "ByteArray";
+	case PIVariant::pivString: return "String";
+	case PIVariant::pivStringList: return "StringList";
+	case PIVariant::pivTime: return "Time";
+	case PIVariant::pivDate: return "Date";
+	case PIVariant::pivDateTime: return "DateTime";
+	case PIVariant::pivSystemTime: return "SystemTime";
+	case PIVariant::pivCustom: return "Custom";
 	default: break;
 	}
 	return "Invalid";
@@ -153,23 +153,23 @@ PIString PIVariant::typeName(PIVariant::Type type) {
 bool PIVariant::toBool() const {
 	PIByteArray ba(_content);
 	switch (_type) {
-	case PIVariant::Bool: {bool r; ba >> r; return r;}
-	case PIVariant::Char: {char r; ba >> r; return r != 0;}
-	case PIVariant::UChar: {uchar r; ba >> r; return r != 0;}
-	case PIVariant::Short: {short r; ba >> r; return r != 0;}
-	case PIVariant::UShort: {ushort r; ba >> r; return r != 0;}
-	case PIVariant::Int: {int r; ba >> r; return r != 0;}
-	case PIVariant::UInt: {uint r; ba >> r; return r != 0;}
-	case PIVariant::LLong: {llong r; ba >> r; return r != 0;}
-	case PIVariant::ULLong: {ullong r; ba >> r; return r != 0;}
-	case PIVariant::Float: {float r; ba >> r; return r > 0.f;}
-	case PIVariant::Double: {double r; ba >> r; return r > 0.;}
-	case PIVariant::LDouble: {ldouble r; ba >> r; return r > 0.;}
-	case PIVariant::Complexd: {complexd r; ba >> r; return r.real() != 0;}
-	case PIVariant::Complexld: {complexld r; ba >> r; return r.real() != 0;}
-	case PIVariant::String: {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::Custom:
+	case PIVariant::pivBool: {bool r; ba >> r; return r;}
+	case PIVariant::pivChar: {char r; ba >> r; return r != 0;}
+	case PIVariant::pivUChar: {uchar r; ba >> r; return r != 0;}
+	case PIVariant::pivShort: {short r; ba >> r; return r != 0;}
+	case PIVariant::pivUShort: {ushort r; ba >> r; return r != 0;}
+	case PIVariant::pivInt: {int r; ba >> r; return r != 0;}
+	case PIVariant::pivUInt: {uint r; ba >> r; return r != 0;}
+	case PIVariant::pivLLong: {llong r; ba >> r; return r != 0;}
+	case PIVariant::pivULLong: {ullong r; ba >> r; return r != 0;}
+	case PIVariant::pivFloat: {float r; ba >> r; return r > 0.f;}
+	case PIVariant::pivDouble: {double r; ba >> r; return r > 0.;}
+	case PIVariant::pivLDouble: {ldouble r; ba >> r; return r > 0.;}
+	case PIVariant::pivComplexd: {complexd r; ba >> r; return r.real() != 0;}
+	case PIVariant::pivComplexld: {complexld r; ba >> r; return r.real() != 0;}
+	case PIVariant::pivString: {PIString r; ba >> r; return r.toBool();}
+	case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return false; return r.front().toBool();}
+	case PIVariant::pivCustom:
 		return getAsValue<bool>(*this);
 	default: break;
 	}
@@ -187,23 +187,23 @@ bool PIVariant::toBool() const {
 int PIVariant::toInt() const {
 	PIByteArray ba(_content);
 	switch (_type) {
-	case PIVariant::Bool: {bool r; ba >> r; return r;}
-	case PIVariant::Char: {char r; ba >> r; return r;}
-	case PIVariant::UChar: {uchar r; ba >> r; return r;}
-	case PIVariant::Short: {short r; ba >> r; return r;}
-	case PIVariant::UShort: {ushort r; ba >> r; return r;}
-	case PIVariant::Int: {int r; ba >> r; return r;}
-	case PIVariant::UInt: {uint r; ba >> r; return r;}
-	case PIVariant::LLong: {llong r; ba >> r; return r;}
-	case PIVariant::ULLong: {ullong r; ba >> r; return r;}
-	case PIVariant::Float: {float r; ba >> r; return r;}
-	case PIVariant::Double: {double r; ba >> r; return r;}
-	case PIVariant::LDouble: {ldouble r; ba >> r; return r;}
-	case PIVariant::Complexd: {complexd r; ba >> r; return r.real();}
-	case PIVariant::Complexld: {complexld r; ba >> r; return r.real();}
-	case PIVariant::String: {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::Custom:
+	case PIVariant::pivBool: {bool r; ba >> r; return r;}
+	case PIVariant::pivChar: {char r; ba >> r; return r;}
+	case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
+	case PIVariant::pivShort: {short r; ba >> r; return r;}
+	case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
+	case PIVariant::pivInt: {int r; ba >> r; return r;}
+	case PIVariant::pivUInt: {uint r; ba >> r; return r;}
+	case PIVariant::pivLLong: {llong r; ba >> r; return r;}
+	case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
+	case PIVariant::pivFloat: {float r; ba >> r; return r;}
+	case PIVariant::pivDouble: {double r; ba >> r; return r;}
+	case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
+	case PIVariant::pivComplexd: {complexd r; ba >> r; return r.real();}
+	case PIVariant::pivComplexld: {complexld r; ba >> r; return r.real();}
+	case PIVariant::pivString: {PIString r; ba >> r; return r.toInt();}
+	case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0; return r.front().toInt();}
+	case PIVariant::pivCustom:
 		return getAsValue<int>(*this);
 	default: break;
 	}
@@ -220,23 +220,23 @@ int PIVariant::toInt() const {
 llong PIVariant::toLLong() const {
 	PIByteArray ba(_content);
 	switch (_type) {
-	case PIVariant::Bool: {bool r; ba >> r; return r;}
-	case PIVariant::Char: {char r; ba >> r; return r;}
-	case PIVariant::UChar: {uchar r; ba >> r; return r;}
-	case PIVariant::Short: {short r; ba >> r; return r;}
-	case PIVariant::UShort: {ushort r; ba >> r; return r;}
-	case PIVariant::Int: {int r; ba >> r; return r;}
-	case PIVariant::UInt: {uint r; ba >> r; return r;}
-	case PIVariant::LLong: {llong r; ba >> r; return r;}
-	case PIVariant::ULLong: {ullong r; ba >> r; return r;}
-	case PIVariant::Float: {float r; ba >> r; return r;}
-	case PIVariant::Double: {double r; ba >> r; return r;}
-	case PIVariant::LDouble: {ldouble r; ba >> r; return r;}
-	case PIVariant::Complexd: {complexd r; ba >> r; return r.real();}
-	case PIVariant::Complexld: {complexld r; ba >> r; return r.real();}
-	case PIVariant::String: {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::Custom:
+	case PIVariant::pivBool: {bool r; ba >> r; return r;}
+	case PIVariant::pivChar: {char r; ba >> r; return r;}
+	case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
+	case PIVariant::pivShort: {short r; ba >> r; return r;}
+	case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
+	case PIVariant::pivInt: {int r; ba >> r; return r;}
+	case PIVariant::pivUInt: {uint r; ba >> r; return r;}
+	case PIVariant::pivLLong: {llong r; ba >> r; return r;}
+	case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
+	case PIVariant::pivFloat: {float r; ba >> r; return r;}
+	case PIVariant::pivDouble: {double r; ba >> r; return r;}
+	case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
+	case PIVariant::pivComplexd: {complexd r; ba >> r; return r.real();}
+	case PIVariant::pivComplexld: {complexld r; ba >> r; return r.real();}
+	case PIVariant::pivString: {PIString r; ba >> r; return r.toLLong();}
+	case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0L; return r.front().toLLong();}
+	case PIVariant::pivCustom:
 		return getAsValue<llong>(*this);
 	}
 	return 0L;
@@ -252,23 +252,23 @@ llong PIVariant::toLLong() const {
 float PIVariant::toFloat() const {
 	PIByteArray ba(_content);
 	switch (_type) {
-	case PIVariant::Bool: {bool r; ba >> r; return r;}
-	case PIVariant::Char: {char r; ba >> r; return r;}
-	case PIVariant::UChar: {uchar r; ba >> r; return r;}
-	case PIVariant::Short: {short r; ba >> r; return r;}
-	case PIVariant::UShort: {ushort r; ba >> r; return r;}
-	case PIVariant::Int: {int r; ba >> r; return r;}
-	case PIVariant::UInt: {uint r; ba >> r; return r;}
-	case PIVariant::LLong: {llong r; ba >> r; return r;}
-	case PIVariant::ULLong: {ullong r; ba >> r; return r;}
-	case PIVariant::Float: {float r; ba >> r; return r;}
-	case PIVariant::Double: {double r; ba >> r; return r;}
-	case PIVariant::LDouble: {ldouble r; ba >> r; return r;}
-	case PIVariant::Complexd: {complexd r; ba >> r; return r.real();}
-	case PIVariant::Complexld: {complexld r; ba >> r; return r.real();}
-	case PIVariant::String: {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::Custom:
+	case PIVariant::pivBool: {bool r; ba >> r; return r;}
+	case PIVariant::pivChar: {char r; ba >> r; return r;}
+	case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
+	case PIVariant::pivShort: {short r; ba >> r; return r;}
+	case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
+	case PIVariant::pivInt: {int r; ba >> r; return r;}
+	case PIVariant::pivUInt: {uint r; ba >> r; return r;}
+	case PIVariant::pivLLong: {llong r; ba >> r; return r;}
+	case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
+	case PIVariant::pivFloat: {float r; ba >> r; return r;}
+	case PIVariant::pivDouble: {double r; ba >> r; return r;}
+	case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
+	case PIVariant::pivComplexd: {complexd r; ba >> r; return r.real();}
+	case PIVariant::pivComplexld: {complexld r; ba >> r; return r.real();}
+	case PIVariant::pivString: {PIString r; ba >> r; return r.toFloat();}
+	case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0.f; return r.front().toFloat();}
+	case PIVariant::pivCustom:
 		return getAsValue<float>(*this);
 	}
 	return 0.f;
@@ -284,23 +284,23 @@ float PIVariant::toFloat() const {
 double PIVariant::toDouble() const {
 	PIByteArray ba(_content);
 	switch (_type) {
-	case PIVariant::Bool: {bool r; ba >> r; return r;}
-	case PIVariant::Char: {char r; ba >> r; return r;}
-	case PIVariant::UChar: {uchar r; ba >> r; return r;}
-	case PIVariant::Short: {short r; ba >> r; return r;}
-	case PIVariant::UShort: {ushort r; ba >> r; return r;}
-	case PIVariant::Int: {int r; ba >> r; return r;}
-	case PIVariant::UInt: {uint r; ba >> r; return r;}
-	case PIVariant::LLong: {llong r; ba >> r; return r;}
-	case PIVariant::ULLong: {ullong r; ba >> r; return r;}
-	case PIVariant::Float: {float r; ba >> r; return r;}
-	case PIVariant::Double: {double r; ba >> r; return r;}
-	case PIVariant::LDouble: {ldouble r; ba >> r; return r;}
-	case PIVariant::Complexd: {complexd r; ba >> r; return r.real();}
-	case PIVariant::Complexld: {complexld r; ba >> r; return r.real();}
-	case PIVariant::String: {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::Custom:
+	case PIVariant::pivBool: {bool r; ba >> r; return r;}
+	case PIVariant::pivChar: {char r; ba >> r; return r;}
+	case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
+	case PIVariant::pivShort: {short r; ba >> r; return r;}
+	case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
+	case PIVariant::pivInt: {int r; ba >> r; return r;}
+	case PIVariant::pivUInt: {uint r; ba >> r; return r;}
+	case PIVariant::pivLLong: {llong r; ba >> r; return r;}
+	case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
+	case PIVariant::pivFloat: {float r; ba >> r; return r;}
+	case PIVariant::pivDouble: {double r; ba >> r; return r;}
+	case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
+	case PIVariant::pivComplexd: {complexd r; ba >> r; return r.real();}
+	case PIVariant::pivComplexld: {complexld r; ba >> r; return r.real();}
+	case PIVariant::pivString: {PIString r; ba >> r; return r.toDouble();}
+	case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0.; return r.front().toDouble();}
+	case PIVariant::pivCustom:
 		return getAsValue<double>(*this);
 	}
 	return 0.;
@@ -316,23 +316,23 @@ double PIVariant::toDouble() const {
 ldouble PIVariant::toLDouble() const {
 	PIByteArray ba(_content);
 	switch (_type) {
-	case PIVariant::Bool: {bool r; ba >> r; return r;}
-	case PIVariant::Char: {char r; ba >> r; return r;}
-	case PIVariant::UChar: {uchar r; ba >> r; return r;}
-	case PIVariant::Short: {short r; ba >> r; return r;}
-	case PIVariant::UShort: {ushort r; ba >> r; return r;}
-	case PIVariant::Int: {int r; ba >> r; return r;}
-	case PIVariant::UInt: {uint r; ba >> r; return r;}
-	case PIVariant::LLong: {llong r; ba >> r; return r;}
-	case PIVariant::ULLong: {ullong r; ba >> r; return r;}
-	case PIVariant::Float: {float r; ba >> r; return r;}
-	case PIVariant::Double: {double r; ba >> r; return r;}
-	case PIVariant::LDouble: {ldouble r; ba >> r; return r;}
-	case PIVariant::Complexd: {complexd r; ba >> r; return r.real();}
-	case PIVariant::Complexld: {complexld r; ba >> r; return r.real();}
-	case PIVariant::String: {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::Custom:
+	case PIVariant::pivBool: {bool r; ba >> r; return r;}
+	case PIVariant::pivChar: {char r; ba >> r; return r;}
+	case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
+	case PIVariant::pivShort: {short r; ba >> r; return r;}
+	case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
+	case PIVariant::pivInt: {int r; ba >> r; return r;}
+	case PIVariant::pivUInt: {uint r; ba >> r; return r;}
+	case PIVariant::pivLLong: {llong r; ba >> r; return r;}
+	case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
+	case PIVariant::pivFloat: {float r; ba >> r; return r;}
+	case PIVariant::pivDouble: {double r; ba >> r; return r;}
+	case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
+	case PIVariant::pivComplexd: {complexd r; ba >> r; return r.real();}
+	case PIVariant::pivComplexld: {complexld r; ba >> r; return r.real();}
+	case PIVariant::pivString: {PIString r; ba >> r; return r.toLDouble();}
+	case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return 0.; return r.front().toLDouble();}
+	case PIVariant::pivCustom:
 		return getAsValue<float>(*this);
 	}
 	return 0.;
@@ -348,23 +348,23 @@ ldouble PIVariant::toLDouble() const {
 complexd PIVariant::toComplexd() const {
 	PIByteArray ba(_content);
 	switch (_type) {
-	case PIVariant::Bool: {bool r; ba >> r; return r;}
-	case PIVariant::Char: {char r; ba >> r; return r;}
-	case PIVariant::UChar: {uchar r; ba >> r; return r;}
-	case PIVariant::Short: {short r; ba >> r; return r;}
-	case PIVariant::UShort: {ushort r; ba >> r; return r;}
-	case PIVariant::Int: {int r; ba >> r; return r;}
-	case PIVariant::UInt: {uint r; ba >> r; return r;}
-	case PIVariant::LLong: {llong r; ba >> r; return r;}
-	case PIVariant::ULLong: {ullong r; ba >> r; return r;}
-	case PIVariant::Float: {float r; ba >> r; return r;}
-	case PIVariant::Double: {double r; ba >> r; return r;}
-	case PIVariant::LDouble: {ldouble r; ba >> r; return r;}
-	case PIVariant::Complexd: {complexd r; ba >> r; return r.real();}
-	case PIVariant::Complexld: {complexld r; ba >> r; return r.real();}
-	case PIVariant::String: {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::Custom:
+	case PIVariant::pivBool: {bool r; ba >> r; return r;}
+	case PIVariant::pivChar: {char r; ba >> r; return r;}
+	case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
+	case PIVariant::pivShort: {short r; ba >> r; return r;}
+	case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
+	case PIVariant::pivInt: {int r; ba >> r; return r;}
+	case PIVariant::pivUInt: {uint r; ba >> r; return r;}
+	case PIVariant::pivLLong: {llong r; ba >> r; return r;}
+	case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
+	case PIVariant::pivFloat: {float r; ba >> r; return r;}
+	case PIVariant::pivDouble: {double r; ba >> r; return r;}
+	case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
+	case PIVariant::pivComplexd: {complexd r; ba >> r; return r.real();}
+	case PIVariant::pivComplexld: {complexld r; ba >> r; return r.real();}
+	case PIVariant::pivString: {PIString r; ba >> r; return r.toDouble();}
+	case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return complexd_0; return r.front().toDouble();}
+	case PIVariant::pivCustom:
 		return getAsValue<complexd>(*this);
 	}
 	return complexd_0;
@@ -380,23 +380,23 @@ complexd PIVariant::toComplexd() const {
 complexld PIVariant::toComplexld() const {
 	PIByteArray ba(_content);
 	switch (_type) {
-	case PIVariant::Bool: {bool r; ba >> r; return r;}
-	case PIVariant::Char: {char r; ba >> r; return r;}
-	case PIVariant::UChar: {uchar r; ba >> r; return r;}
-	case PIVariant::Short: {short r; ba >> r; return r;}
-	case PIVariant::UShort: {ushort r; ba >> r; return r;}
-	case PIVariant::Int: {int r; ba >> r; return r;}
-	case PIVariant::UInt: {uint r; ba >> r; return r;}
-	case PIVariant::LLong: {llong r; ba >> r; return r;}
-	case PIVariant::ULLong: {ullong r; ba >> r; return r;}
-	case PIVariant::Float: {float r; ba >> r; return r;}
-	case PIVariant::Double: {double r; ba >> r; return r;}
-	case PIVariant::LDouble: {ldouble r; ba >> r; return r;}
-	case PIVariant::Complexd: {complexd r; ba >> r; return r.real();}
-	case PIVariant::Complexld: {complexld r; ba >> r; return r.real();}
-	case PIVariant::String: {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::Custom:
+	case PIVariant::pivBool: {bool r; ba >> r; return r;}
+	case PIVariant::pivChar: {char r; ba >> r; return r;}
+	case PIVariant::pivUChar: {uchar r; ba >> r; return r;}
+	case PIVariant::pivShort: {short r; ba >> r; return r;}
+	case PIVariant::pivUShort: {ushort r; ba >> r; return r;}
+	case PIVariant::pivInt: {int r; ba >> r; return r;}
+	case PIVariant::pivUInt: {uint r; ba >> r; return r;}
+	case PIVariant::pivLLong: {llong r; ba >> r; return r;}
+	case PIVariant::pivULLong: {ullong r; ba >> r; return r;}
+	case PIVariant::pivFloat: {float r; ba >> r; return r;}
+	case PIVariant::pivDouble: {double r; ba >> r; return r;}
+	case PIVariant::pivLDouble: {ldouble r; ba >> r; return r;}
+	case PIVariant::pivComplexd: {complexd r; ba >> r; return r.real();}
+	case PIVariant::pivComplexld: {complexld r; ba >> r; return r.real();}
+	case PIVariant::pivString: {PIString r; ba >> r; return r.toLDouble();}
+	case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return complexld_0; return r.front().toLDouble();}
+	case PIVariant::pivCustom:
 		return getAsValue<complexld>(*this);
 	}
 	return complexld_0;
@@ -409,9 +409,9 @@ complexld PIVariant::toComplexld() const {
  * In case of other types returns \a PITime(). */
 PITime PIVariant::toTime() const {
 	PIByteArray ba(_content);
-	if (_type == PIVariant::Time) {PITime r; ba >> r; return r;}
-	if (_type == PIVariant::DateTime) {PIDateTime r; ba >> r; return r.time();}
-	if (_type == PIVariant::Custom) {return getAsValue<PITime>(*this);}
+	if (_type == PIVariant::pivTime) {PITime r; ba >> r; return r;}
+	if (_type == PIVariant::pivDateTime) {PIDateTime r; ba >> r; return r.time();}
+	if (_type == PIVariant::pivCustom) {return getAsValue<PITime>(*this);}
 	return PITime();
 }
 
@@ -422,9 +422,9 @@ PITime PIVariant::toTime() const {
  * In case of other types returns \a PIDate(). */
 PIDate PIVariant::toDate() const {
 	PIByteArray ba(_content);
-	if (_type == PIVariant::Date) {PIDate r; ba >> r; return r;}
-	if (_type == PIVariant::DateTime) {PIDateTime r; ba >> r; return r.date();}
-	if (_type == PIVariant::Custom) {return getAsValue<PIDate>(*this);}
+	if (_type == PIVariant::pivDate) {PIDate r; ba >> r; return r;}
+	if (_type == PIVariant::pivDateTime) {PIDateTime r; ba >> r; return r.date();}
+	if (_type == PIVariant::pivCustom) {return getAsValue<PIDate>(*this);}
 	return PIDate();
 }
 
@@ -436,10 +436,10 @@ PIDate PIVariant::toDate() const {
  * In case of other types returns \a PIDateTime(). */
 PIDateTime PIVariant::toDateTime() const {
 	PIByteArray ba(_content);
-	if (_type == PIVariant::Time) {PITime r; ba >> r; return PIDateTime(r);}
-	if (_type == PIVariant::Date) {PIDate r; ba >> r; return PIDateTime(r);}
-	if (_type == PIVariant::DateTime) {PIDateTime r; ba >> r; return r;}
-	if (_type == PIVariant::Custom) {return getAsValue<PIDateTime>(*this);}
+	if (_type == PIVariant::pivTime) {PITime r; ba >> r; return PIDateTime(r);}
+	if (_type == PIVariant::pivDate) {PIDate r; ba >> r; return PIDateTime(r);}
+	if (_type == PIVariant::pivDateTime) {PIDateTime r; ba >> r; return r;}
+	if (_type == PIVariant::pivCustom) {return getAsValue<PIDateTime>(*this);}
 	return PIDateTime();
 }
 
@@ -450,8 +450,8 @@ PIDateTime PIVariant::toDateTime() const {
  * double value of variant content. */
 PISystemTime PIVariant::toSystemTime() const {
 	PIByteArray ba(_content);
-	if (_type == PIVariant::SystemTime) {PISystemTime r; ba >> r; return r;}
-	if (_type == PIVariant::Custom) {return getAsValue<PISystemTime>(*this);}
+	if (_type == PIVariant::pivSystemTime) {PISystemTime r; ba >> r; return r;}
+	if (_type == PIVariant::pivCustom) {return getAsValue<PISystemTime>(*this);}
 	return PISystemTime::fromSeconds(toDouble());
 }
 
@@ -468,23 +468,23 @@ PISystemTime PIVariant::toSystemTime() const {
 PIString PIVariant::toString() const {
 	PIByteArray ba(_content);
 	switch (_type) {
-	case PIVariant::Bool: {bool r; ba >> r; return PIString::fromNumber(r);}
-	case PIVariant::Char: {char r; ba >> r; return PIString::fromNumber(r);}
-	case PIVariant::UChar: {uchar r; ba >> r; return PIString::fromNumber(r);}
-	case PIVariant::Short: {short r; ba >> r; return PIString::fromNumber(r);}
-	case PIVariant::UShort: {ushort r; ba >> r; return PIString::fromNumber(r);}
-	case PIVariant::Int: {int r; ba >> r; return PIString::fromNumber(r);}
-	case PIVariant::UInt: {uint r; ba >> r; return PIString::fromNumber(r);}
-	case PIVariant::LLong: {llong r; ba >> r; return PIString::fromNumber(r);}
-	case PIVariant::ULLong: {ullong r; ba >> r; return PIString::fromNumber(r);}
-	case PIVariant::Float: {float r; ba >> r; return PIString::fromNumber(r);}
-	case PIVariant::Double: {double r; ba >> r; return PIString::fromNumber(r);}
-	case PIVariant::LDouble: {ldouble r; ba >> r; return PIString::fromNumber(r);}
-	case PIVariant::Complexd: {complexd r; ba >> r; return PIString::fromNumber(r.real());}
-	case PIVariant::Complexld: {complexld r; ba >> r; return PIString::fromNumber(r.real());}
-	case PIVariant::String: {PIString r; ba >> r; return r;}
-	case PIVariant::StringList: {PIStringList r; ba >> r; if (r.isEmpty()) return PIString(); return r.front();}
-	case PIVariant::Custom:
+	case PIVariant::pivBool: {bool r; ba >> r; return PIString::fromNumber(r);}
+	case PIVariant::pivChar: {char r; ba >> r; return PIString::fromNumber(r);}
+	case PIVariant::pivUChar: {uchar r; ba >> r; return PIString::fromNumber(r);}
+	case PIVariant::pivShort: {short r; ba >> r; return PIString::fromNumber(r);}
+	case PIVariant::pivUShort: {ushort r; ba >> r; return PIString::fromNumber(r);}
+	case PIVariant::pivInt: {int r; ba >> r; return PIString::fromNumber(r);}
+	case PIVariant::pivUInt: {uint r; ba >> r; return PIString::fromNumber(r);}
+	case PIVariant::pivLLong: {llong r; ba >> r; return PIString::fromNumber(r);}
+	case PIVariant::pivULLong: {ullong r; ba >> r; return PIString::fromNumber(r);}
+	case PIVariant::pivFloat: {float r; ba >> r; return PIString::fromNumber(r);}
+	case PIVariant::pivDouble: {double r; ba >> r; return PIString::fromNumber(r);}
+	case PIVariant::pivLDouble: {ldouble r; ba >> r; return PIString::fromNumber(r);}
+	case PIVariant::pivComplexd: {complexd r; ba >> r; return PIString::fromNumber(r.real());}
+	case PIVariant::pivComplexld: {complexld r; ba >> r; return PIString::fromNumber(r.real());}
+	case PIVariant::pivString: {PIString r; ba >> r; return r;}
+	case PIVariant::pivStringList: {PIStringList r; ba >> r; if (r.isEmpty()) return PIString(); return r.front();}
+	case PIVariant::pivCustom:
 		return getAsValue<PIString>(*this);
 	}
 	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. */
 PIStringList PIVariant::toStringList() const {
 	PIByteArray ba(_content);
-	if (_type == PIVariant::StringList) {PIStringList r; ba >> r; return r;}
-	if (_type == PIVariant::Custom) {return getAsValue<PIStringList>(*this);}
+	if (_type == PIVariant::pivStringList) {PIStringList r; ba >> r; return r;}
+	if (_type == PIVariant::pivCustom) {return getAsValue<PIStringList>(*this);}
 	return PIStringList(toString());
 }
 
@@ -507,8 +507,8 @@ PIStringList PIVariant::toStringList() const {
  * In case of other types returns \a PIBitArray from \a toLLong() value. */
 PIBitArray PIVariant::toBitArray() const {
 	PIByteArray ba(_content);
-	if (_type == PIVariant::BitArray) {PIBitArray r; ba >> r; return r;}
-	if (_type == PIVariant::Custom) {return getAsValue<PIBitArray>(*this);}
+	if (_type == PIVariant::pivBitArray) {PIBitArray r; ba >> r; return r;}
+	if (_type == PIVariant::pivCustom) {return getAsValue<PIBitArray>(*this);}
 	return PIBitArray(ullong(toLLong()));
 }
 
@@ -518,7 +518,7 @@ PIBitArray PIVariant::toBitArray() const {
  * In case of other types returns empty \a PIByteArray. */
 PIByteArray PIVariant::toByteArray() const {
 	PIByteArray ba(_content);
-	if (_type == PIVariant::ByteArray) {PIByteArray r; ba >> r; return r;}
-	if (_type == PIVariant::Custom) {return getAsValue<PIByteArray>(*this);}
+	if (_type == PIVariant::pivByteArray) {PIByteArray r; ba >> r; return r;}
+	if (_type == PIVariant::pivCustom) {return getAsValue<PIByteArray>(*this);}
 	return PIByteArray();
 }
diff --git a/src/core/pivariant.h b/src/core/pivariant.h
index 50800190..fb4eb995 100755
--- a/src/core/pivariant.h
+++ b/src/core/pivariant.h
@@ -133,30 +133,30 @@ public:
 
 	//! 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 */ ,
-		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
+		pivInvalid /** Invalid type , default type of empty contructor */ = 0 ,
+		pivBool /** bool */ ,
+		pivChar /** char */ ,
+		pivUChar /** uchar */ ,
+		pivShort /** short */ ,
+		pivUShort /** ushort */ ,
+		pivInt /** int */ ,
+		pivUInt /** uint */ ,
+		pivLLong /** llong */ ,
+		pivULLong /** ullong */ ,
+		pivFloat /** float */ ,
+		pivDouble /** double */ ,
+		pivLDouble /** ldouble */ ,
+		pivComplexd /** complexd */ ,
+		pivComplexld /** complexld */ ,
+		pivBitArray /** PIBitArray */ ,
+		pivByteArray /** PIByteArray */ ,
+		pivString /** PIString */ ,
+		pivStringList /** PIStringList */ ,
+		pivTime /** PITime */ ,
+		pivDate /** PIDate */ ,
+		pivDateTime /** PIDateTime */ ,
+		pivSystemTime /** PISystemTime */ ,
+		pivCustom /** Custom */ = 0xFF
 	};
 
 	//! Empty constructor, \a type() will be set to \a Invalid
@@ -417,7 +417,7 @@ public:
 
 
 	//! 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
@@ -437,14 +437,14 @@ public:
 		if (!ret._info) {
 #endif
 			PIVariant::Type t = typeFromName(type);
-			if (t == Invalid) {
+			if (t == pivInvalid) {
 				piCout << "Can`t initialize PIVariant from unregistered type \"" << type << "\"!";
 				return ret;
 			}
 			ret._type = t;
 #ifdef CUSTOM_PIVARIANT
 		} else
-			ret._type = Custom;
+			ret._type = pivCustom;
 #endif
 		ret._content = c;
 		return ret;
@@ -459,13 +459,13 @@ public:
 
 private:
 	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) {
 		_content.clear();
 		_content << v;
 		_type = getType<T>();
 #ifdef CUSTOM_PIVARIANT
-		if (_type == Custom) {
+		if (_type == pivCustom) {
 			_info = __PIVariantInfoStorage__::get()->map->value(__PIVariantFunctions__<T>::typeNameHelper(), 0);
 			if (!_info)
 				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 PISystemTime & v) {return PIVariant(v);}
 
-template<> inline PIVariant::Type PIVariant::getType<bool>() {return PIVariant::Bool;}
-template<> inline PIVariant::Type PIVariant::getType<char>() {return PIVariant::Char;}
-template<> inline PIVariant::Type PIVariant::getType<uchar>() {return PIVariant::UChar;}
-template<> inline PIVariant::Type PIVariant::getType<short>() {return PIVariant::Short;}
-template<> inline PIVariant::Type PIVariant::getType<ushort>() {return PIVariant::UShort;}
-template<> inline PIVariant::Type PIVariant::getType<int>() {return PIVariant::Int;}
-template<> inline PIVariant::Type PIVariant::getType<uint>() {return PIVariant::UInt;}
-template<> inline PIVariant::Type PIVariant::getType<llong>() {return PIVariant::LLong;}
-template<> inline PIVariant::Type PIVariant::getType<ullong>() {return PIVariant::ULLong;}
-template<> inline PIVariant::Type PIVariant::getType<float>() {return PIVariant::Float;}
-template<> inline PIVariant::Type PIVariant::getType<double>() {return PIVariant::Double;}
-template<> inline PIVariant::Type PIVariant::getType<ldouble>() {return PIVariant::LDouble;}
-template<> inline PIVariant::Type PIVariant::getType<complexd>() {return PIVariant::Complexd;}
-template<> inline PIVariant::Type PIVariant::getType<complexld>() {return PIVariant::Complexld;}
-template<> inline PIVariant::Type PIVariant::getType<PIBitArray>() {return PIVariant::BitArray;}
-template<> inline PIVariant::Type PIVariant::getType<PIByteArray>() {return PIVariant::ByteArray;}
-template<> inline PIVariant::Type PIVariant::getType<PIString>() {return PIVariant::String;}
-template<> inline PIVariant::Type PIVariant::getType<PIStringList>() {return PIVariant::StringList;}
-template<> inline PIVariant::Type PIVariant::getType<PITime>() {return PIVariant::Time;}
-template<> inline PIVariant::Type PIVariant::getType<PIDate>() {return PIVariant::Date;}
-template<> inline PIVariant::Type PIVariant::getType<PIDateTime>() {return PIVariant::DateTime;}
-template<> inline PIVariant::Type PIVariant::getType<PISystemTime>() {return PIVariant::SystemTime;}
+template<> inline PIVariant::Type PIVariant::getType<bool>() {return PIVariant::pivBool;}
+template<> inline PIVariant::Type PIVariant::getType<char>() {return PIVariant::pivChar;}
+template<> inline PIVariant::Type PIVariant::getType<uchar>() {return PIVariant::pivUChar;}
+template<> inline PIVariant::Type PIVariant::getType<short>() {return PIVariant::pivShort;}
+template<> inline PIVariant::Type PIVariant::getType<ushort>() {return PIVariant::pivUShort;}
+template<> inline PIVariant::Type PIVariant::getType<int>() {return PIVariant::pivInt;}
+template<> inline PIVariant::Type PIVariant::getType<uint>() {return PIVariant::pivUInt;}
+template<> inline PIVariant::Type PIVariant::getType<llong>() {return PIVariant::pivLLong;}
+template<> inline PIVariant::Type PIVariant::getType<ullong>() {return PIVariant::pivULLong;}
+template<> inline PIVariant::Type PIVariant::getType<float>() {return PIVariant::pivFloat;}
+template<> inline PIVariant::Type PIVariant::getType<double>() {return PIVariant::pivDouble;}
+template<> inline PIVariant::Type PIVariant::getType<ldouble>() {return PIVariant::pivLDouble;}
+template<> inline PIVariant::Type PIVariant::getType<complexd>() {return PIVariant::pivComplexd;}
+template<> inline PIVariant::Type PIVariant::getType<complexld>() {return PIVariant::pivComplexld;}
+template<> inline PIVariant::Type PIVariant::getType<PIBitArray>() {return PIVariant::pivBitArray;}
+template<> inline PIVariant::Type PIVariant::getType<PIByteArray>() {return PIVariant::pivByteArray;}
+template<> inline PIVariant::Type PIVariant::getType<PIString>() {return PIVariant::pivString;}
+template<> inline PIVariant::Type PIVariant::getType<PIStringList>() {return PIVariant::pivStringList;}
+template<> inline PIVariant::Type PIVariant::getType<PITime>() {return PIVariant::pivTime;}
+template<> inline PIVariant::Type PIVariant::getType<PIDate>() {return PIVariant::pivDate;}
+template<> inline PIVariant::Type PIVariant::getType<PIDateTime>() {return PIVariant::pivDateTime;}
+template<> inline PIVariant::Type PIVariant::getType<PISystemTime>() {return PIVariant::pivSystemTime;}
 
 inline PICout operator <<(PICout s, const PIVariant & v) {
 	s.space(); s.setControl(0, true);