23.06.2014 - PICodeParser, PICodeInfo, PIConnection, new binary "pip_cmg"

2014-06-23 21:08:27 +04:00
parent 2e5e75c4c4
commit 15a20d40ac
56 changed files with 10315 additions and 760 deletions
--- a/pivariant.h
+++ b/pivariant.h
@@ -49,88 +49,192 @@
 class PIP_EXPORT PIVariant {
 	friend PICout operator <<(PICout s, const PIVariant & v);
 public:
+	
+	//! Type of %PIVariant content
 	enum Type {
-		Invalid = 0,
-		Bool,
-		Char,
-		UChar,
-		Short,
-		UShort,
-		Int,
-		UInt,
-		Long,
-		ULong,
-		LLong,
-		ULLong,
-		Float,
-		Double,
-		LDouble,
-		Complexd,
-		Complexld,
-		BitArray,
-		ByteArray,
-		String,
-		StringList,
-		Time,
-		Date,
-		DateTime,
-		SystemTime,
-		Custom = 0xFF
+		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
 	};
 	
+	//! Empty constructor, \a type() will be set to \a Invalid
 	PIVariant();
+	
+	//! Constructs variant from string
 	PIVariant(const char * v) {setValue(PIString(v));}
+	
+	//! 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;
@@ -148,6 +252,10 @@ public:
 	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 toValue() const {if (_vcustom.size() != sizeof(T)) return T(); return *((T*)_vcustom.data());}
 	/*
@@ -177,46 +285,89 @@ public:
 	operator const char*() const {return toString().data();}
 	operator void*() const {return (void*)(toLLong());}
 	*/
-	void operator =(const PIVariant & v);
-	void operator =(const char * v) {setValue(PIString(v));}
-	void operator =(const bool v) {setValue(v);}
-	void operator =(const char v) {setValue(v);}
-	void operator =(const uchar v) {setValue(v);}
-	void operator =(const short v) {setValue(v);}
-	void operator =(const ushort v) {setValue(v);}
-	void operator =(const int & v) {setValue(v);}
-	void operator =(const uint & v) {setValue(v);}
-	void operator =(const long & v) {setValue(v);}
-	void operator =(const ulong & v) {setValue(v);}
-	void operator =(const llong & v) {setValue(v);}
-	void operator =(const ullong & v) {setValue(v);}
-	void operator =(const float & v) {setValue(v);}
-	void operator =(const double & v) {setValue(v);}
-	void operator =(const ldouble & v) {setValue(v);}
-	void operator =(const complexd & v) {setValue(v);}
-	void operator =(const complexld & v) {setValue(v);}
-	void operator =(const PIBitArray & v) {setValue(v);}
-	void operator =(const PIByteArray & v) {setValue(v);}
-	void operator =(const PIString & v) {setValue(v);}
-	void operator =(const PIStringList & v) {setValue(v);}
-	void operator =(const PITime & v) {setValue(v);}
-	void operator =(const PIDate & v) {setValue(v);}
-	void operator =(const PIDateTime & v) {setValue(v);}
-	void operator =(const PISystemTime & v) {setValue(v);}
 	
+	//! 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: