Restoring authorship annotation for <orivej@yandex-team.ru>. Commit 1 of 2.

1 files changed, 2212 insertions, 2212 deletions

diff --git a/contrib/libs/poco/Foundation/include/Poco/Dynamic/Var.h b/contrib/libs/poco/Foundation/include/Poco/Dynamic/Var.h
index bd06afe54b..674041c87b 100644
--- a/contrib/libs/poco/Foundation/include/Poco/Dynamic/Var.h
+++ b/contrib/libs/poco/Foundation/include/Poco/Dynamic/Var.h
@@ -1,2228 +1,2228 @@
-//
-// Var.h
-//
-// Library: Foundation
-// Package: Dynamic
-// Module:  Var
-//
-// Definition of the Var class.
-//
-// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
-// and Contributors.
-//
-// SPDX-License-Identifier:	BSL-1.0
-//
-
-
-#ifndef Foundation_Var_INCLUDED
-#define Foundation_Var_INCLUDED
-
-
-#include "Poco/Foundation.h"
-#include "Poco/Format.h"
-#include "Poco/SharedPtr.h"
-#include "Poco/Dynamic/VarHolder.h"
-#include "Poco/Dynamic/VarIterator.h"
-#include <typeinfo>
-
-
-namespace Poco {
-namespace Dynamic {
-
-
-template <typename T>
-class Struct;
-
-
-class Foundation_API Var
-	/// Var allows to store data of different types and to convert between these types transparently.
-	/// Var puts forth the best effort to provide intuitive and reasonable conversion semantics and prevent 
-	/// unexpected data loss, particularly when performing narrowing or signedness conversions of numeric data types.
-	///
-	/// An attempt to convert or extract from a non-initialized ("empty") Var variable shall result
-	/// in an exception being thrown.
-	///
-	/// Loss of signedness is not allowed for numeric values. This means that if an attempt is made to convert 
-	/// the internal value which is a negative signed integer to an unsigned integer type storage, a RangeException is thrown. 
-	/// Overflow is not allowed, so if the internal value is a larger number than the target numeric type size can accommodate, 
-	/// a RangeException is thrown.
-	///
-	/// Precision loss, such as in conversion from floating-point types to integers or from double to float on platforms
-	/// where they differ in size (provided internal actual value fits in float min/max range), is allowed.
+// 
+// Var.h 
+// 
+// Library: Foundation 
+// Package: Dynamic 
+// Module:  Var 
+// 
+// Definition of the Var class. 
+// 
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH. 
+// and Contributors. 
+// 
+// SPDX-License-Identifier:	BSL-1.0 
+// 
+ 
+ 
+#ifndef Foundation_Var_INCLUDED 
+#define Foundation_Var_INCLUDED 
+ 
+ 
+#include "Poco/Foundation.h" 
+#include "Poco/Format.h" 
+#include "Poco/SharedPtr.h" 
+#include "Poco/Dynamic/VarHolder.h" 
+#include "Poco/Dynamic/VarIterator.h" 
+#include <typeinfo> 
+ 
+ 
+namespace Poco { 
+namespace Dynamic { 
+ 
+ 
+template <typename T> 
+class Struct; 
+ 
+ 
+class Foundation_API Var 
+	/// Var allows to store data of different types and to convert between these types transparently. 
+	/// Var puts forth the best effort to provide intuitive and reasonable conversion semantics and prevent  
+	/// unexpected data loss, particularly when performing narrowing or signedness conversions of numeric data types. 
 	/// 
-	/// String truncation is allowed -- it is possible to convert between string and character when string length is 
-	/// greater than 1. An empty string gets converted to the char '\0', a non-empty string is truncated to the first character. 
-	///
-	/// Boolean conversion is performed as follows:
-	///
-	/// A string value "false" (not case sensitive), "0" or "" (empty string) can be converted to a boolean value false,
-	/// any other string not being false by the above criteria evaluates to true (e.g: "hi" -> true).
-	/// Integer 0 values are false, everything else is true.
-	/// Floating point values equal to the minimal FP representation on a given platform are false, everything else is true.
-	///
-	/// Arithmetic operations with POD types as well as between Var's are supported, subject to following
-	/// limitations:
+	/// An attempt to convert or extract from a non-initialized ("empty") Var variable shall result 
+	/// in an exception being thrown. 
 	/// 
-	/// 	- for std::string and const char* values, only '+' and '+=' operations are supported
+	/// Loss of signedness is not allowed for numeric values. This means that if an attempt is made to convert  
+	/// the internal value which is a negative signed integer to an unsigned integer type storage, a RangeException is thrown.  
+	/// Overflow is not allowed, so if the internal value is a larger number than the target numeric type size can accommodate,  
+	/// a RangeException is thrown. 
 	/// 
-	/// 	- for integral and floating point numeric values, following operations are supported:
-	/// 	  '+', '+=', '-', '-=', '*', '*=' , '/' and '/=' 
-	///
-	/// 	- for integral values, following operations are supported:
-	///		  prefix and postfix increment (++) and decrement (--)
+	/// Precision loss, such as in conversion from floating-point types to integers or from double to float on platforms 
+	/// where they differ in size (provided internal actual value fits in float min/max range), is allowed. 
+	///  
+	/// String truncation is allowed -- it is possible to convert between string and character when string length is  
+	/// greater than 1. An empty string gets converted to the char '\0', a non-empty string is truncated to the first character.  
 	/// 
-	/// 	- for all other types, InvalidArgumentException is thrown upon attempt of an arithmetic operation
+	/// Boolean conversion is performed as follows: 
 	/// 
-	/// A Var can be created from and converted to a value of any type for which a specialization of 
-	/// VarHolderImpl is available. For supported types, see VarHolder documentation.
-{
-public:
-	typedef SharedPtr<Var>             Ptr;
-	typedef Poco::Dynamic::VarIterator Iterator;
-	typedef const VarIterator          ConstIterator;
-
-	Var();
-		/// Creates an empty Var.
-
-	template <typename T> 
-	Var(const T& val)
-		/// Creates the Var from the given value.
-#ifdef POCO_NO_SOO
-		: _pHolder(new VarHolderImpl<T>(val))
-	{
-	}
-#else
-	{
-		construct(val);
-	}
-#endif
-
-	Var(const char* pVal);
-		// Convenience constructor for const char* which gets mapped to a std::string internally, i.e. pVal is deep-copied.
-
-	Var(const Var& other);
-		/// Copy constructor.
-
-	~Var();
-		/// Destroys the Var.
-
-	void swap(Var& other);
-		/// Swaps the content of the this Var with the other Var.
-
-	ConstIterator begin() const;
-		/// Returns the const Var iterator.
-
-	ConstIterator end() const;
-		/// Returns the const Var iterator.
-
-	Iterator begin();
-		/// Returns the Var iterator.
-
-	Iterator end();
-		/// Returns the Var iterator.
-
-	template <typename T> 
-	void convert(T& val) const
-		/// Invoke this method to perform a safe conversion.
-		///
-		/// Example usage:
-		///     Var any("42");
-		///     int i;
-		///     any.convert(i);
-		///
-		/// Throws a RangeException if the value does not fit
-		/// into the result variable.
-		/// Throws a NotImplementedException if conversion is
-		/// not available for the given type.
-		/// Throws InvalidAccessException if Var is empty.
-	{
-		VarHolder* pHolder = content();
-
-		if (!pHolder)
-			throw InvalidAccessException("Can not convert empty value.");
-
-		pHolder->convert(val);
-	}
-	
-	template <typename T> 
-	T convert() const
-		/// Invoke this method to perform a safe conversion.
-		///
-		/// Example usage:
-		///     Var any("42");
-		///     int i = any.convert<int>();
-		///
-		/// Throws a RangeException if the value does not fit
-		/// into the result variable.
-		/// Throws a NotImplementedException if conversion is
-		/// not available for the given type.
-		/// Throws InvalidAccessException if Var is empty.
-	{
-		VarHolder* pHolder = content();
-
-		if (!pHolder)
-			throw InvalidAccessException("Can not convert empty value.");
-
-		if (typeid(T) == pHolder->type()) return extract<T>();
-
-		T result;
-		pHolder->convert(result);
-		return result;
-	}
-	
-	template <typename T>
-	operator T () const
-		/// Safe conversion operator for implicit type
-		/// conversions. If the requested type T is same as the 
-		/// type being held, the operation performed is direct 
-		/// extraction, otherwise it is the conversion of the value
-		/// from type currently held to the one requested.
-		///
-		/// Throws a RangeException if the value does not fit
-		/// into the result variable.
-		/// Throws a NotImplementedException if conversion is
-		/// not available for the given type.
-		/// Throws InvalidAccessException if Var is empty.
-	{
-		VarHolder* pHolder = content();
-
-		if (!pHolder)
-				throw InvalidAccessException("Can not convert empty value.");
-
-		if (typeid(T) == pHolder->type())
-			return extract<T>();
-		else
-		{
-			T result;
-			pHolder->convert(result);
-			return result;
-		}
-	}
-
-	template <typename T>
-	const T& extract() const
-		/// Returns a const reference to the actual value.
-		///
-		/// Must be instantiated with the exact type of
-		/// the stored value, otherwise a BadCastException
-		/// is thrown.
-		/// Throws InvalidAccessException if Var is empty.
-	{
-		VarHolder* pHolder = content();
-
-		if (pHolder && pHolder->type() == typeid(T))
-		{
-			VarHolderImpl<T>* pHolderImpl = static_cast<VarHolderImpl<T>*>(pHolder);
-			return pHolderImpl->value();
-		}
-		else if (!pHolder)
-			throw InvalidAccessException("Can not extract empty value.");
-		else
-			throw BadCastException(format("Can not convert %s to %s.",
-				std::string(pHolder->type().name()),
-				std::string(typeid(T).name())));
-	}
-
-	template <typename T> 
-	Var& operator = (const T& other)
-		/// Assignment operator for assigning POD to Var
-	{
-#ifdef POCO_NO_SOO
-		Var tmp(other);
-		swap(tmp);
-#else
-		construct(other);
-#endif
-		return *this;
-	}
-
-	bool operator ! () const;
-		/// Logical NOT operator.
-
-	Var& operator = (const Var& other);
-		/// Assignment operator specialization for Var
-
-	template <typename T>
-	const Var operator + (const T& other) const
-		/// Addition operator for adding POD to Var
-	{
-		return convert<T>() + other;
-	}
-
-	const Var operator + (const Var& other) const;
-		/// Addition operator specialization for Var
-
-	const Var operator + (const char* other) const;
-		/// Addition operator specialization for adding const char* to Var
-
-	Var& operator ++ ();
-		/// Pre-increment operator
-
-	const Var operator ++ (int);
-		/// Post-increment operator
-
-	Var& operator -- ();
-		/// Pre-decrement operator
-
-	const Var operator -- (int);
-		/// Post-decrement operator
-
-	template <typename T> 
-	Var& operator += (const T& other)
-		/// Addition assignment operator for addition/assignment of POD to Var.
-	{
-		return *this = convert<T>() + other;
-	}
-
-	Var& operator += (const Var& other);
-		/// Addition assignment operator overload for Var
-
-	Var& operator += (const char* other);
-		/// Addition assignment operator overload for const char*
-
-	template <typename T> 
-	const Var operator - (const T& other) const
-		/// Subtraction operator for subtracting POD from Var
-	{
-		return convert<T>() - other;
-	}
-
-	const Var operator - (const Var& other) const;
-		/// Subtraction operator overload for Var
-
+	/// A string value "false" (not case sensitive), "0" or "" (empty string) can be converted to a boolean value false, 
+	/// any other string not being false by the above criteria evaluates to true (e.g: "hi" -> true). 
+	/// Integer 0 values are false, everything else is true. 
+	/// Floating point values equal to the minimal FP representation on a given platform are false, everything else is true. 
+	/// 
+	/// Arithmetic operations with POD types as well as between Var's are supported, subject to following 
+	/// limitations: 
+	///  
+	/// 	- for std::string and const char* values, only '+' and '+=' operations are supported 
+	///  
+	/// 	- for integral and floating point numeric values, following operations are supported: 
+	/// 	  '+', '+=', '-', '-=', '*', '*=' , '/' and '/='  
+	/// 
+	/// 	- for integral values, following operations are supported: 
+	///		  prefix and postfix increment (++) and decrement (--) 
+	///  
+	/// 	- for all other types, InvalidArgumentException is thrown upon attempt of an arithmetic operation 
+	///  
+	/// A Var can be created from and converted to a value of any type for which a specialization of  
+	/// VarHolderImpl is available. For supported types, see VarHolder documentation. 
+{ 
+public: 
+	typedef SharedPtr<Var>             Ptr; 
+	typedef Poco::Dynamic::VarIterator Iterator; 
+	typedef const VarIterator          ConstIterator; 
+ 
+	Var(); 
+		/// Creates an empty Var. 
+ 
+	template <typename T>  
+	Var(const T& val) 
+		/// Creates the Var from the given value. 
+#ifdef POCO_NO_SOO 
+		: _pHolder(new VarHolderImpl<T>(val)) 
+	{ 
+	} 
+#else 
+	{ 
+		construct(val); 
+	} 
+#endif 
+ 
+	Var(const char* pVal); 
+		// Convenience constructor for const char* which gets mapped to a std::string internally, i.e. pVal is deep-copied. 
+ 
+	Var(const Var& other); 
+		/// Copy constructor. 
+ 
+	~Var(); 
+		/// Destroys the Var. 
+ 
+	void swap(Var& other); 
+		/// Swaps the content of the this Var with the other Var. 
+ 
+	ConstIterator begin() const; 
+		/// Returns the const Var iterator. 
+ 
+	ConstIterator end() const; 
+		/// Returns the const Var iterator. 
+ 
+	Iterator begin(); 
+		/// Returns the Var iterator. 
+ 
+	Iterator end(); 
+		/// Returns the Var iterator. 
+ 
+	template <typename T>  
+	void convert(T& val) const 
+		/// Invoke this method to perform a safe conversion. 
+		/// 
+		/// Example usage: 
+		///     Var any("42"); 
+		///     int i; 
+		///     any.convert(i); 
+		/// 
+		/// Throws a RangeException if the value does not fit 
+		/// into the result variable. 
+		/// Throws a NotImplementedException if conversion is 
+		/// not available for the given type. 
+		/// Throws InvalidAccessException if Var is empty. 
+	{ 
+		VarHolder* pHolder = content(); 
+ 
+		if (!pHolder) 
+			throw InvalidAccessException("Can not convert empty value."); 
+ 
+		pHolder->convert(val); 
+	} 
+	 
+	template <typename T>  
+	T convert() const 
+		/// Invoke this method to perform a safe conversion. 
+		/// 
+		/// Example usage: 
+		///     Var any("42"); 
+		///     int i = any.convert<int>(); 
+		/// 
+		/// Throws a RangeException if the value does not fit 
+		/// into the result variable. 
+		/// Throws a NotImplementedException if conversion is 
+		/// not available for the given type. 
+		/// Throws InvalidAccessException if Var is empty. 
+	{ 
+		VarHolder* pHolder = content(); 
+ 
+		if (!pHolder) 
+			throw InvalidAccessException("Can not convert empty value."); 
+ 
+		if (typeid(T) == pHolder->type()) return extract<T>(); 
+ 
+		T result; 
+		pHolder->convert(result); 
+		return result; 
+	} 
+	 
 	template <typename T> 
-	Var& operator -= (const T& other)
-		/// Subtraction assignment operator
-	{
-		return *this = convert<T>() - other;
-	}
-
-	Var& operator -= (const Var& other);
-		/// Subtraction assignment operator overload for Var
-
+	operator T () const 
+		/// Safe conversion operator for implicit type 
+		/// conversions. If the requested type T is same as the  
+		/// type being held, the operation performed is direct  
+		/// extraction, otherwise it is the conversion of the value 
+		/// from type currently held to the one requested. 
+		/// 
+		/// Throws a RangeException if the value does not fit 
+		/// into the result variable. 
+		/// Throws a NotImplementedException if conversion is 
+		/// not available for the given type. 
+		/// Throws InvalidAccessException if Var is empty. 
+	{ 
+		VarHolder* pHolder = content(); 
+ 
+		if (!pHolder) 
+				throw InvalidAccessException("Can not convert empty value."); 
+ 
+		if (typeid(T) == pHolder->type()) 
+			return extract<T>(); 
+		else 
+		{ 
+			T result; 
+			pHolder->convert(result); 
+			return result; 
+		} 
+	} 
+ 
 	template <typename T> 
-	const Var operator * (const T& other) const
-		/// Multiplication operator for multiplying Var with POD
-	{
-		return convert<T>() * other;
-	}
-
-	const Var operator * (const Var& other) const;
-		/// Multiplication operator overload for Var
-
+	const T& extract() const 
+		/// Returns a const reference to the actual value. 
+		/// 
+		/// Must be instantiated with the exact type of 
+		/// the stored value, otherwise a BadCastException 
+		/// is thrown. 
+		/// Throws InvalidAccessException if Var is empty. 
+	{ 
+		VarHolder* pHolder = content(); 
+ 
+		if (pHolder && pHolder->type() == typeid(T)) 
+		{ 
+			VarHolderImpl<T>* pHolderImpl = static_cast<VarHolderImpl<T>*>(pHolder); 
+			return pHolderImpl->value(); 
+		} 
+		else if (!pHolder) 
+			throw InvalidAccessException("Can not extract empty value."); 
+		else 
+			throw BadCastException(format("Can not convert %s to %s.", 
+				std::string(pHolder->type().name()), 
+				std::string(typeid(T).name()))); 
+	} 
+ 
+	template <typename T>  
+	Var& operator = (const T& other) 
+		/// Assignment operator for assigning POD to Var 
+	{ 
+#ifdef POCO_NO_SOO 
+		Var tmp(other); 
+		swap(tmp); 
+#else 
+		construct(other); 
+#endif 
+		return *this; 
+	} 
+ 
+	bool operator ! () const; 
+		/// Logical NOT operator. 
+ 
+	Var& operator = (const Var& other); 
+		/// Assignment operator specialization for Var 
+ 
 	template <typename T> 
-	Var& operator *= (const T& other)
-		/// Multiplication assignment operator
-	{
-		return *this = convert<T>() * other;
-	}
-
-	Var& operator *= (const Var& other);
-		/// Multiplication assignment operator overload for Var
-
+	const Var operator + (const T& other) const 
+		/// Addition operator for adding POD to Var 
+	{ 
+		return convert<T>() + other; 
+	} 
+ 
+	const Var operator + (const Var& other) const; 
+		/// Addition operator specialization for Var 
+ 
+	const Var operator + (const char* other) const; 
+		/// Addition operator specialization for adding const char* to Var 
+ 
+	Var& operator ++ (); 
+		/// Pre-increment operator 
+ 
+	const Var operator ++ (int); 
+		/// Post-increment operator 
+ 
+	Var& operator -- (); 
+		/// Pre-decrement operator 
+ 
+	const Var operator -- (int); 
+		/// Post-decrement operator 
+ 
+	template <typename T>  
+	Var& operator += (const T& other) 
+		/// Addition assignment operator for addition/assignment of POD to Var. 
+	{ 
+		return *this = convert<T>() + other; 
+	} 
+ 
+	Var& operator += (const Var& other); 
+		/// Addition assignment operator overload for Var 
+ 
+	Var& operator += (const char* other); 
+		/// Addition assignment operator overload for const char* 
+ 
+	template <typename T>  
+	const Var operator - (const T& other) const 
+		/// Subtraction operator for subtracting POD from Var 
+	{ 
+		return convert<T>() - other; 
+	} 
+ 
+	const Var operator - (const Var& other) const; 
+		/// Subtraction operator overload for Var 
+ 
+	template <typename T>  
+	Var& operator -= (const T& other) 
+		/// Subtraction assignment operator 
+	{ 
+		return *this = convert<T>() - other; 
+	} 
+ 
+	Var& operator -= (const Var& other); 
+		/// Subtraction assignment operator overload for Var 
+ 
+	template <typename T>  
+	const Var operator * (const T& other) const 
+		/// Multiplication operator for multiplying Var with POD 
+	{ 
+		return convert<T>() * other; 
+	} 
+ 
+	const Var operator * (const Var& other) const; 
+		/// Multiplication operator overload for Var 
+ 
+	template <typename T>  
+	Var& operator *= (const T& other) 
+		/// Multiplication assignment operator 
+	{ 
+		return *this = convert<T>() * other; 
+	} 
+ 
+	Var& operator *= (const Var& other); 
+		/// Multiplication assignment operator overload for Var 
+ 
+	template <typename T>  
+	const Var operator / (const T& other) const 
+		/// Division operator for dividing Var with POD 
+	{ 
+		return convert<T>() / other; 
+	} 
+ 
+	const Var operator / (const Var& other) const; 
+		/// Division operator overload for Var 
+ 
+	template <typename T>  
+	Var& operator /= (const T& other) 
+		/// Division assignment operator 
+	{ 
+		return *this = convert<T>() / other; 
+	} 
+ 
+	Var& operator /= (const Var& other); 
+		/// Division assignment operator specialization for Var 
+ 
+	template <typename T>  
+	bool operator == (const T& other) const 
+		/// Equality operator 
+	{ 
+		if (isEmpty()) return false; 
+		return convert<T>() == other; 
+	} 
+ 
+	bool operator == (const char* other) const; 
+		/// Equality operator overload for const char* 
+ 
+	bool operator == (const Var& other) const; 
+		/// Equality operator overload for Var 
+ 
+	template <typename T>  
+	bool operator != (const T& other) const 
+		/// Inequality operator 
+	{ 
+		if (isEmpty()) return true; 
+		return convert<T>() != other; 
+	} 
+ 
+	bool operator != (const Var& other) const; 
+		/// Inequality operator overload for Var 
+ 
+	bool operator != (const char* other) const; 
+		/// Inequality operator overload for const char* 
+ 
+	template <typename T>  
+	bool operator < (const T& other) const 
+		/// Less than operator 
+	{ 
+		if (isEmpty()) return false; 
+		return convert<T>() < other; 
+	} 
+ 
+	bool operator < (const Var& other) const; 
+		/// Less than operator overload for Var 
+ 
+	template <typename T>  
+	bool operator <= (const T& other) const 
+		/// Less than or equal operator 
+	{ 
+		if (isEmpty()) return false; 
+		return convert<T>() <= other; 
+	} 
+ 
+	bool operator <= (const Var& other) const; 
+		/// Less than or equal operator overload for Var 
+ 
+	template <typename T>  
+	bool operator > (const T& other) const 
+		/// Greater than operator 
+	{ 
+		if (isEmpty()) return false; 
+		return convert<T>() > other; 
+	} 
+ 
+	bool operator > (const Var& other) const; 
+		/// Greater than operator overload for Var 
+ 
+	template <typename T>  
+	bool operator >= (const T& other) const 
+		/// Greater than or equal operator 
+	{ 
+		if (isEmpty()) return false; 
+		return convert<T>() >= other; 
+	} 
+ 
+	bool operator >= (const Var& other) const; 
+		/// Greater than or equal operator overload for Var 
+ 
 	template <typename T> 
-	const Var operator / (const T& other) const
-		/// Division operator for dividing Var with POD
-	{
-		return convert<T>() / other;
-	}
-
-	const Var operator / (const Var& other) const;
-		/// Division operator overload for Var
-
+	bool operator || (const T& other) const 
+		/// Logical OR operator 
+	{ 
+		if (isEmpty()) return false; 
+		return convert<bool>() || other; 
+	} 
+ 
+	bool operator || (const Var& other) const; 
+		/// Logical OR operator operator overload for Var 
+ 
 	template <typename T> 
-	Var& operator /= (const T& other)
-		/// Division assignment operator
-	{
-		return *this = convert<T>() / other;
-	}
-
-	Var& operator /= (const Var& other);
-		/// Division assignment operator specialization for Var
-
+	bool operator && (const T& other) const 
+		/// Logical AND operator. 
+	{ 
+		if (isEmpty()) return false; 
+		return convert<bool>() && other; 
+	} 
+ 
+	bool operator && (const Var& other) const; 
+		/// Logical AND operator operator overload for Var. 
+ 
+	bool isArray() const; 
+		/// Returns true if Var is an array. 
+ 
+	bool isVector() const; 
+		/// Returns true if Var represents a vector. 
+ 
+	bool isList() const; 
+		/// Returns true if Var represents a list. 
+ 
+	bool isDeque() const; 
+		/// Returns true if Var represents a deque. 
+ 
+	bool isStruct() const; 
+		/// Returns true if Var represents a struct. 
+ 
+	char& at(std::size_t n); 
+		/// Returns character at position n. This function only works with 
+		/// Var containing a std::string. 
+ 
+ 
 	template <typename T> 
-	bool operator == (const T& other) const
-		/// Equality operator
-	{
-		if (isEmpty()) return false;
-		return convert<T>() == other;
-	}
-
-	bool operator == (const char* other) const;
-		/// Equality operator overload for const char*
-
-	bool operator == (const Var& other) const;
-		/// Equality operator overload for Var
-
+	Var& operator [] (const T& n) 
+	{ 
+		return getAt(n); 
+	} 
+ 
 	template <typename T> 
-	bool operator != (const T& other) const
-		/// Inequality operator
-	{
-		if (isEmpty()) return true;
-		return convert<T>() != other;
-	}
-
-	bool operator != (const Var& other) const;
-		/// Inequality operator overload for Var
-
-	bool operator != (const char* other) const;
-		/// Inequality operator overload for const char*
-
+	const Var& operator [] (const T& n) const 
+	{ 
+		return const_cast<Var*>(this)->getAt(n); 
+	} 
+ 
+	Var& operator [] (const std::string& name); 
+		/// Index operator by name, only use on Vars where isStruct 
+		/// returns true! In all other cases InvalidAccessException is thrown. 
+ 
+	const Var& operator [] (const std::string& name) const; 
+		/// Index operator by name, only use on Vars where isStruct 
+		/// returns true! In all other cases InvalidAccessException is thrown. 
+ 
+	const std::type_info& type() const; 
+		/// Returns the type information of the stored content. 
+ 
+	//@ deprecated 
+	void empty(); 
+		/// Empties Var. 
+		/// This function is deprecated and will be removed. 
+		/// Please use clear(). 
+ 
+	void clear(); 
+		/// Empties Var. 
+ 
+	bool isEmpty() const; 
+		/// Returns true if empty. 
+ 
+	bool isInteger() const; 
+		/// Returns true if stored value is integer. 
+ 
+	bool isSigned() const; 
+		/// Returns true if stored value is signed. 
+ 
+	bool isNumeric() const; 
+		/// Returns true if stored value is numeric. 
+		/// Returns false for numeric strings (e.g. "123" is string, not number) 
+ 
+	bool isBoolean() const; 
+		/// Returns true if stored value is boolean. 
+		/// Returns false for boolean strings (e.g. "true" is string, not number) 
+ 
+	bool isString() const; 
+		/// Returns true if stored value is std::string. 
+ 
+	bool isDate() const; 
+		/// Returns true if stored value represents a date. 
+ 
+	bool isTime() const; 
+		/// Returns true if stored value represents time or date/time. 
+ 
+	bool isDateTime() const; 
+		/// Returns true if stored value represents a date/time. 
+ 
+	std::size_t size() const; 
+		/// Returns the size of this Var. 
+		/// This function returns 0 when Var is empty, 1 for POD or the size (i.e. length) 
+		/// for held container. 
+ 
+	std::string toString() const 
+		/// Returns the stored value as string. 
+	{ 
+		VarHolder* pHolder = content(); 
+ 
+		if (!pHolder) 
+				throw InvalidAccessException("Can not convert empty value."); 
+ 
+		if (typeid(std::string) == pHolder->type()) 
+			return extract<std::string>(); 
+		else 
+		{ 
+			std::string result; 
+			pHolder->convert(result); 
+			return result; 
+		} 
+	} 
+ 
+	static Var parse(const std::string& val); 
+		/// Parses the string which must be in JSON format 
+ 
+	static std::string toString(const Var& var); 
+		/// Converts the Var to a string in JSON format. Note that toString(const Var&) will return 
+		/// a different result than Var::convert<std::string>() and Var::toString()! 
+	 
+private: 
+	Var& getAt(std::size_t n); 
+	Var& getAt(const std::string& n); 
+ 
+	static Var parse(const std::string& val, std::string::size_type& offset); 
+		/// Parses the string which must be in JSON format 
+ 
+	static Var parseObject(const std::string& val, std::string::size_type& pos); 
+	static Var parseArray(const std::string& val, std::string::size_type& pos); 
+	static std::string parseString(const std::string& val, std::string::size_type& pos); 
+	static std::string parseJSONString(const std::string& val, std::string::size_type& pos); 
+	static void skipWhiteSpace(const std::string& val, std::string::size_type& pos); 
+ 
 	template <typename T> 
-	bool operator < (const T& other) const
-		/// Less than operator
-	{
-		if (isEmpty()) return false;
-		return convert<T>() < other;
-	}
-
-	bool operator < (const Var& other) const;
-		/// Less than operator overload for Var
-
+	T add(const Var& other) const 
+	{ 
+		return convert<T>() + other.convert<T>(); 
+	} 
+ 
 	template <typename T> 
-	bool operator <= (const T& other) const
-		/// Less than or equal operator
-	{
-		if (isEmpty()) return false;
-		return convert<T>() <= other;
-	}
-
-	bool operator <= (const Var& other) const;
-		/// Less than or equal operator overload for Var
-
+	T subtract(const Var& other) const 
+	{ 
+		return convert<T>() - other.convert<T>(); 
+	} 
+	 
 	template <typename T> 
-	bool operator > (const T& other) const
-		/// Greater than operator
-	{
-		if (isEmpty()) return false;
-		return convert<T>() > other;
-	}
-
-	bool operator > (const Var& other) const;
-		/// Greater than operator overload for Var
-
+	T multiply(const Var& other) const 
+	{ 
+		return convert<T>() * other.convert<T>(); 
+	} 
+ 
 	template <typename T> 
-	bool operator >= (const T& other) const
-		/// Greater than or equal operator
-	{
-		if (isEmpty()) return false;
-		return convert<T>() >= other;
-	}
-
-	bool operator >= (const Var& other) const;
-		/// Greater than or equal operator overload for Var
-
-	template <typename T>
-	bool operator || (const T& other) const
-		/// Logical OR operator
-	{
-		if (isEmpty()) return false;
-		return convert<bool>() || other;
-	}
-
-	bool operator || (const Var& other) const;
-		/// Logical OR operator operator overload for Var
-
-	template <typename T>
-	bool operator && (const T& other) const
-		/// Logical AND operator.
-	{
-		if (isEmpty()) return false;
-		return convert<bool>() && other;
-	}
-
-	bool operator && (const Var& other) const;
-		/// Logical AND operator operator overload for Var.
-
-	bool isArray() const;
-		/// Returns true if Var is an array.
-
-	bool isVector() const;
-		/// Returns true if Var represents a vector.
-
-	bool isList() const;
-		/// Returns true if Var represents a list.
-
-	bool isDeque() const;
-		/// Returns true if Var represents a deque.
-
-	bool isStruct() const;
-		/// Returns true if Var represents a struct.
-
-	char& at(std::size_t n);
-		/// Returns character at position n. This function only works with
-		/// Var containing a std::string.
-
-
-	template <typename T>
-	Var& operator [] (const T& n)
-	{
-		return getAt(n);
-	}
-
-	template <typename T>
-	const Var& operator [] (const T& n) const
-	{
-		return const_cast<Var*>(this)->getAt(n);
-	}
-
-	Var& operator [] (const std::string& name);
-		/// Index operator by name, only use on Vars where isStruct
-		/// returns true! In all other cases InvalidAccessException is thrown.
-
-	const Var& operator [] (const std::string& name) const;
-		/// Index operator by name, only use on Vars where isStruct
-		/// returns true! In all other cases InvalidAccessException is thrown.
-
-	const std::type_info& type() const;
-		/// Returns the type information of the stored content.
-
-	//@ deprecated
-	void empty();
-		/// Empties Var.
-		/// This function is deprecated and will be removed.
-		/// Please use clear().
-
-	void clear();
-		/// Empties Var.
-
-	bool isEmpty() const;
-		/// Returns true if empty.
-
-	bool isInteger() const;
-		/// Returns true if stored value is integer.
-
-	bool isSigned() const;
-		/// Returns true if stored value is signed.
-
-	bool isNumeric() const;
-		/// Returns true if stored value is numeric.
-		/// Returns false for numeric strings (e.g. "123" is string, not number)
-
-	bool isBoolean() const;
-		/// Returns true if stored value is boolean.
-		/// Returns false for boolean strings (e.g. "true" is string, not number)
-
-	bool isString() const;
-		/// Returns true if stored value is std::string.
-
-	bool isDate() const;
-		/// Returns true if stored value represents a date.
-
-	bool isTime() const;
-		/// Returns true if stored value represents time or date/time.
-
-	bool isDateTime() const;
-		/// Returns true if stored value represents a date/time.
-
-	std::size_t size() const;
-		/// Returns the size of this Var.
-		/// This function returns 0 when Var is empty, 1 for POD or the size (i.e. length)
-		/// for held container.
-
-	std::string toString() const
-		/// Returns the stored value as string.
-	{
-		VarHolder* pHolder = content();
-
-		if (!pHolder)
-				throw InvalidAccessException("Can not convert empty value.");
-
-		if (typeid(std::string) == pHolder->type())
-			return extract<std::string>();
-		else
-		{
-			std::string result;
-			pHolder->convert(result);
-			return result;
-		}
-	}
-
-	static Var parse(const std::string& val);
-		/// Parses the string which must be in JSON format
-
-	static std::string toString(const Var& var);
-		/// Converts the Var to a string in JSON format. Note that toString(const Var&) will return
-		/// a different result than Var::convert<std::string>() and Var::toString()!
-	
-private:
-	Var& getAt(std::size_t n);
-	Var& getAt(const std::string& n);
-
-	static Var parse(const std::string& val, std::string::size_type& offset);
-		/// Parses the string which must be in JSON format
-
-	static Var parseObject(const std::string& val, std::string::size_type& pos);
-	static Var parseArray(const std::string& val, std::string::size_type& pos);
-	static std::string parseString(const std::string& val, std::string::size_type& pos);
-	static std::string parseJSONString(const std::string& val, std::string::size_type& pos);
-	static void skipWhiteSpace(const std::string& val, std::string::size_type& pos);
-
-	template <typename T>
-	T add(const Var& other) const
-	{
-		return convert<T>() + other.convert<T>();
-	}
-
-	template <typename T>
-	T subtract(const Var& other) const
-	{
-		return convert<T>() - other.convert<T>();
-	}
-	
-	template <typename T>
-	T multiply(const Var& other) const
-	{
-		return convert<T>() * other.convert<T>();
-	}
-
-	template <typename T>
-	T divide(const Var& other) const
-	{
-		return convert<T>() / other.convert<T>();
-	}
-
-	template <typename T, typename E>
-	VarHolderImpl<T>* holderImpl(const std::string errorMessage = "") const
-	{
-		VarHolder* pHolder = content();
-
-		if (pHolder && pHolder->type() == typeid(T))
-			return static_cast<VarHolderImpl<T>*>(pHolder);
-		else if (!pHolder)
-			throw InvalidAccessException("Can not access empty value.");
-		else
-			throw E(errorMessage);
-	}
-
-	Var& structIndexOperator(VarHolderImpl<Struct<int> >* pStr, int n) const;
-
-#ifdef POCO_NO_SOO
-
-	VarHolder* content() const
-	{
-		return _pHolder;
-	}
-
-	void destruct()
-	{
-		if (!isEmpty()) delete content();
-	}
-
-	VarHolder* _pHolder;
-
-#else
-
-	VarHolder* content() const
-	{
-		return _placeholder.content();
-	}
-
-	template<typename ValueType>
-	void construct(const ValueType& value)
-	{
-		if (sizeof(VarHolderImpl<ValueType>) <= Placeholder<ValueType>::Size::value)
-		{
-			new (reinterpret_cast<VarHolder*>(_placeholder.holder)) VarHolderImpl<ValueType>(value);
-			_placeholder.setLocal(true);
-		}
-		else
-		{
-			_placeholder.pHolder = new VarHolderImpl<ValueType>(value);
-			_placeholder.setLocal(false);
-		}
-	}
-
-	void construct(const char* value)
-	{
-		std::string val(value);
-		if (sizeof(VarHolderImpl<std::string>) <= Placeholder<std::string>::Size::value)
-		{
-			new (reinterpret_cast<VarHolder*>(_placeholder.holder)) VarHolderImpl<std::string>(val);
-			_placeholder.setLocal(true);
-		}
-		else
-		{
-			_placeholder.pHolder = new VarHolderImpl<std::string>(val);
-			_placeholder.setLocal(false);
-		}
-	}
-
-	void construct(const Var& other)
-	{
-		if (!other.isEmpty())
-			other.content()->clone(&_placeholder);
-		else
-			_placeholder.erase();
-	}
-
-	void destruct()
-	{
-		if (!isEmpty())
-		{
-			if (_placeholder.isLocal())
-				content()->~VarHolder();
-			else
-				delete content();
-		}
-	}
-
-	Placeholder<VarHolder> _placeholder;
-
-#endif // POCO_NO_SOO
-};
-
-
-///
-/// inlines
-///
-
-
-///
-/// Var members
-///
-
-inline void Var::swap(Var& other)
-{
-#ifdef POCO_NO_SOO
-
-	std::swap(_pHolder, other._pHolder);
-
-#else
-
-	if (this == &other) return;
-
-	if (!_placeholder.isLocal() && !other._placeholder.isLocal())
-	{
-		std::swap(_placeholder.pHolder, other._placeholder.pHolder);
-	}
-	else
-	{
-		Var tmp(*this);
-		try
-		{
-			if (_placeholder.isLocal()) destruct();
-			construct(other);
-			other = tmp;
-		}
-		catch (...)
-		{
-			construct(tmp);
-			throw;
-		}
-	}
-
-#endif
-}
-
-
-inline const std::type_info& Var::type() const
-{
-	VarHolder* pHolder = content();
-	return pHolder ? pHolder->type() : typeid(void);
-}
-
-
-inline Var::ConstIterator Var::begin() const
-{
-	if (isEmpty()) return ConstIterator(const_cast<Var*>(this), true);
-
-	return ConstIterator(const_cast<Var*>(this), false);
-}
-
-inline Var::ConstIterator Var::end() const
-{
-	return ConstIterator(const_cast<Var*>(this), true);
-}
-
-inline Var::Iterator Var::begin()
-{
-	if (isEmpty()) return Iterator(const_cast<Var*>(this), true);
-
-	return Iterator(const_cast<Var*>(this), false);
-}
-
-inline Var::Iterator Var::end()
-{
-	return Iterator(this, true);
-}
-
-
-inline Var& Var::operator [] (const std::string& name)
-{
-	return getAt(name);
-}
-
-
-inline const Var& Var::operator [] (const std::string& name) const
-{
-	return const_cast<Var*>(this)->getAt(name);
-}
-
-
-inline const Var Var::operator + (const char* other) const
-{
-	return convert<std::string>() + other;
-}
-
-
-inline Var& Var::operator += (const char*other)
-{
-	return *this = convert<std::string>() + other;
-}
-
-
-inline bool Var::operator ! () const
-{
-	return !convert<bool>();
-}
-
-
-inline bool Var::isEmpty() const
-{
-	return 0 == content();
-}
-
-
-inline bool Var::isArray() const
-{
-	if (isEmpty() || 
-		isString()) return false;
-
-	VarHolder* pHolder = content();
-	return pHolder ? pHolder->isArray() : false;
-}
-
-
-inline bool Var::isVector() const
-{
-	VarHolder* pHolder = content();
-	return pHolder ? pHolder->isVector() : false;
-}
-
-
-inline bool Var::isList() const
-{
-	VarHolder* pHolder = content();
-	return pHolder ? pHolder->isList() : false;
-}
-
-
-inline bool Var::isDeque() const
-{
-	VarHolder* pHolder = content();
-	return pHolder ? pHolder->isDeque() : false;
-}
-
-
-inline bool Var::isStruct() const
-{
-	VarHolder* pHolder = content();
-	return pHolder ? pHolder->isStruct() : false;
-}
-
-
-inline bool Var::isInteger() const
-{
-	VarHolder* pHolder = content();
-	return pHolder ? pHolder->isInteger() : false;
-}
-
-
-inline bool Var::isSigned() const
-{
-	VarHolder* pHolder = content();
-	return pHolder ? pHolder->isSigned() : false;
-}
-
-
-inline bool Var::isNumeric() const
-{
-	VarHolder* pHolder = content();
-	return pHolder ? pHolder->isNumeric() : false;
-}
-
-
-inline bool Var::isBoolean() const
-{
-	VarHolder* pHolder = content();
-	return pHolder ? pHolder->isBoolean() : false;
-}
-
-
-inline bool Var::isString() const
-{
-	VarHolder* pHolder = content();
-	return pHolder ? pHolder->isString() : false;
-}
-
-
-inline bool Var::isDate() const
-{
-	VarHolder* pHolder = content();
-	return pHolder ? pHolder->isDate() : false;
-}
-
-
-inline bool Var::isTime() const
-{
-	VarHolder* pHolder = content();
-	return pHolder ? pHolder->isTime() : false;
-}
-
-
-inline bool Var::isDateTime() const
-{
-	VarHolder* pHolder = content();
-	return pHolder ? pHolder->isDateTime() : false;
-}
-
-
-inline std::size_t Var::size() const
-{
-	VarHolder* pHolder = content();
-	return pHolder ? pHolder->size() : 0;
-}
-
-
-///
-/// Var non-member functions
-///
-
-inline const Var operator + (const char* other, const Var& da)
-	/// Addition operator for adding Var to const char*
-{
-	std::string tmp = other;
-	return tmp + da.convert<std::string>();
-}
-
-
-inline char operator + (const char& other, const Var& da)
-	/// Addition operator for adding Var to char
-{
-	return other + da.convert<char>();
-}
-
-
-inline char operator - (const char& other, const Var& da)
-	/// Subtraction operator for subtracting Var from char
-{
-	return other - da.convert<char>();
-}
-
-
-inline char operator * (const char& other, const Var& da)
-	/// Multiplication operator for multiplying Var with char
-{
-	return other * da.convert<char>();
-}
-
-
-inline char operator / (const char& other, const Var& da)
-	/// Division operator for dividing Var with char
-{
-	return other / da.convert<char>();
-}
-
-
-inline char operator += (char& other, const Var& da)
-	/// Addition assignment operator for adding Var to char
-{
-	return other += da.convert<char>();
-}
-
-
-inline char operator -= (char& other, const Var& da)
-	/// Subtraction assignment operator for subtracting Var from char
-{
-	return other -= da.convert<char>();
-}
-
-
-inline char operator *= (char& other, const Var& da)
-	/// Multiplication assignment operator for multiplying Var with char
-{
-	return other *= da.convert<char>();
-}
-
-
-inline char operator /= (char& other, const Var& da)
-	/// Division assignment operator for dividing Var with char
-{
-	return other /= da.convert<char>();
-}
-
-
-inline bool operator == (const char& other, const Var& da)
-	/// Equality operator for comparing Var with char
-{
-	if (da.isEmpty()) return false;
-	return other == da.convert<char>();
-}
-
-
-inline bool operator != (const char& other, const Var& da)
-	/// Inequality operator for comparing Var with char
-{
-	if (da.isEmpty()) return true;
-	return other != da.convert<char>();
-}
-
-
-inline bool operator < (const char& other, const Var& da)
-	/// Less than operator for comparing Var with char
-{
-	if (da.isEmpty()) return false;
-	return other < da.convert<char>();
-}
-
-
-inline bool operator <= (const char& other, const Var& da)
-	/// Less than or equal operator for comparing Var with char
-{
-	if (da.isEmpty()) return false;
-	return other <= da.convert<char>();
-}
-
-
-inline bool operator > (const char& other, const Var& da)
-	/// Greater than operator for comparing Var with char
-{
-	if (da.isEmpty())return false;
-	return other > da.convert<char>();
-}
-
-
-inline bool operator >= (const char& other, const Var& da)
-	/// Greater than or equal operator for comparing Var with char
-{
-	if (da.isEmpty())return false;
-	return other >= da.convert<char>();
-}
-
-
-inline Poco::Int8 operator + (const Poco::Int8& other, const Var& da)
-	/// Addition operator for adding Var to Poco::Int8
-{
-	return other + da.convert<Poco::Int8>();
-}
-
-
-inline Poco::Int8 operator - (const Poco::Int8& other, const Var& da)
-	/// Subtraction operator for subtracting Var from Poco::Int8
-{
-	return other - da.convert<Poco::Int8>();
-}
-
-
-inline Poco::Int8 operator * (const Poco::Int8& other, const Var& da)
-	/// Multiplication operator for multiplying Var with Poco::Int8
-{
-	return other * da.convert<Poco::Int8>();
-}
-
-
-inline Poco::Int8 operator / (const Poco::Int8& other, const Var& da)
-	/// Division operator for dividing Var with Poco::Int8
-{
-	return other / da.convert<Poco::Int8>();
-}
-
-
-inline Poco::Int8 operator += (Poco::Int8& other, const Var& da)
-	/// Addition assignment operator for adding Var to Poco::Int8
-{
-	return other += da.convert<Poco::Int8>();
-}
-
-
-inline Poco::Int8 operator -= (Poco::Int8& other, const Var& da)
-	/// Subtraction assignment operator for subtracting Var from Poco::Int8
-{
-	return other -= da.convert<Poco::Int8>();
-}
-
-
-inline Poco::Int8 operator *= (Poco::Int8& other, const Var& da)
-	/// Multiplication assignment operator for multiplying Var with Poco::Int8
-{
-	return other *= da.convert<Poco::Int8>();
-}
-
-
-inline Poco::Int8 operator /= (Poco::Int8& other, const Var& da)
-	/// Division assignment operator for dividing Var with Poco::Int8
-{
-	return other /= da.convert<Poco::Int8>();
-}
-
-
-inline bool operator == (const Poco::Int8& other, const Var& da)
-	/// Equality operator for comparing Var with Poco::Int8
-{
-	if (da.isEmpty()) return false;
-	return other == da.convert<Poco::Int8>();
-}
-
-
-inline bool operator != (const Poco::Int8& other, const Var& da)
-	/// Inequality operator for comparing Var with Poco::Int8
-{
-	if (da.isEmpty()) return true;
-	return other != da.convert<Poco::Int8>();
-}
-
-
-inline bool operator < (const Poco::Int8& other, const Var& da)
-	/// Less than operator for comparing Var with Poco::Int8
-{
-	if (da.isEmpty()) return false;
-	return other < da.convert<Poco::Int8>();
-}
-
-
-inline bool operator <= (const Poco::Int8& other, const Var& da)
-	/// Less than or equal operator for comparing Var with Poco::Int8
-{
-	if (da.isEmpty()) return false;
-	return other <= da.convert<Poco::Int8>();
-}
-
-
-inline bool operator > (const Poco::Int8& other, const Var& da)
-	/// Greater than operator for comparing Var with Poco::Int8
-{
-	if (da.isEmpty()) return false;
-	return other > da.convert<Poco::Int8>();
-}
-
-
-inline bool operator >= (const Poco::Int8& other, const Var& da)
-	/// Greater than or equal operator for comparing Var with Poco::Int8
-{
-	if (da.isEmpty()) return false;
-	return other >= da.convert<Poco::Int8>();
-}
-
-
-inline Poco::UInt8 operator + (const Poco::UInt8& other, const Var& da)
-	/// Addition operator for adding Var to Poco::UInt8
-{
-	return other + da.convert<Poco::UInt8>();
-}
-
-
-inline Poco::UInt8 operator - (const Poco::UInt8& other, const Var& da)
-	/// Subtraction operator for subtracting Var from Poco::UInt8
-{
-	return other - da.convert<Poco::UInt8>();
-}
-
-
-inline Poco::UInt8 operator * (const Poco::UInt8& other, const Var& da)
-	/// Multiplication operator for multiplying Var with Poco::UInt8
-{
-	return other * da.convert<Poco::UInt8>();
-}
-
-
-inline Poco::UInt8 operator / (const Poco::UInt8& other, const Var& da)
-	/// Division operator for dividing Var with Poco::UInt8
-{
-	return other / da.convert<Poco::UInt8>();
-}
-
-
-inline Poco::UInt8 operator += (Poco::UInt8& other, const Var& da)
-	/// Addition assignment operator for adding Var to Poco::UInt8
-{
-	return other += da.convert<Poco::UInt8>();
-}
-
-
-inline Poco::UInt8 operator -= (Poco::UInt8& other, const Var& da)
-	/// Subtraction assignment operator for subtracting Var from Poco::UInt8
-{
-	return other -= da.convert<Poco::UInt8>();
-}
-
-
-inline Poco::UInt8 operator *= (Poco::UInt8& other, const Var& da)
-	/// Multiplication assignment operator for multiplying Var with Poco::UInt8
-{
-	return other *= da.convert<Poco::UInt8>();
-}
-
-
-inline Poco::UInt8 operator /= (Poco::UInt8& other, const Var& da)
-	/// Division assignment operator for dividing Var with Poco::UInt8
-{
-	return other /= da.convert<Poco::UInt8>();
-}
-
-
-inline bool operator == (const Poco::UInt8& other, const Var& da)
-	/// Equality operator for comparing Var with Poco::UInt8
-{
-	if (da.isEmpty()) return false;
-	return other == da.convert<Poco::UInt8>();
-}
-
-
-inline bool operator != (const Poco::UInt8& other, const Var& da)
-	/// Inequality operator for comparing Var with Poco::UInt8
-{
-	if (da.isEmpty()) return true;
-	return other != da.convert<Poco::UInt8>();
-}
-
-
-inline bool operator < (const Poco::UInt8& other, const Var& da)
-	/// Less than operator for comparing Var with Poco::UInt8
-{
-	if (da.isEmpty()) return false;
-	return other < da.convert<Poco::UInt8>();
-}
-
-
-inline bool operator <= (const Poco::UInt8& other, const Var& da)
-	/// Less than or equal operator for comparing Var with Poco::UInt8
-{
-	if (da.isEmpty()) return false;
-	return other <= da.convert<Poco::UInt8>();
-}
-
-
-inline bool operator > (const Poco::UInt8& other, const Var& da)
-	/// Greater than operator for comparing Var with Poco::UInt8
-{
-	if (da.isEmpty()) return false;
-	return other > da.convert<Poco::UInt8>();
-}
-
-
-inline bool operator >= (const Poco::UInt8& other, const Var& da)
-	/// Greater than or equal operator for comparing Var with Poco::UInt8
-{
-	if (da.isEmpty()) return false;
-	return other >= da.convert<Poco::UInt8>();
-}
-
-
-inline Poco::Int16 operator + (const Poco::Int16& other, const Var& da)
-	/// Addition operator for adding Var to Poco::Int16
-{
-	return other + da.convert<Poco::Int16>();
-}
-
-
-inline Poco::Int16 operator - (const Poco::Int16& other, const Var& da)
-	/// Subtraction operator for subtracting Var from Poco::Int16
-{
-	return other - da.convert<Poco::Int16>();
-}
-
-
-inline Poco::Int16 operator * (const Poco::Int16& other, const Var& da)
-	/// Multiplication operator for multiplying Var with Poco::Int16
-{
-	return other * da.convert<Poco::Int16>();
-}
-
-
-inline Poco::Int16 operator / (const Poco::Int16& other, const Var& da)
-	/// Division operator for dividing Var with Poco::Int16
-{
-	return other / da.convert<Poco::Int16>();
-}
-
-
-inline Poco::Int16 operator += (Poco::Int16& other, const Var& da)
-	/// Addition assignment operator for adding Var to Poco::Int16
-{
-	return other += da.convert<Poco::Int16>();
-}
-
-
-inline Poco::Int16 operator -= (Poco::Int16& other, const Var& da)
-	/// Subtraction assignment operator for subtracting Var from Poco::Int16
-{
-	return other -= da.convert<Poco::Int16>();
-}
-
-
-inline Poco::Int16 operator *= (Poco::Int16& other, const Var& da)
-	/// Multiplication assignment operator for multiplying Var with Poco::Int16
-{
-	return other *= da.convert<Poco::Int16>();
-}
-
-
-inline Poco::Int16 operator /= (Poco::Int16& other, const Var& da)
-	/// Division assignment operator for dividing Var with Poco::Int16
-{
-	return other /= da.convert<Poco::Int16>();
-}
-
-
-inline bool operator == (const Poco::Int16& other, const Var& da)
-	/// Equality operator for comparing Var with Poco::Int16
-{
-	if (da.isEmpty()) return false;
-	return other == da.convert<Poco::Int16>();
-}
-
-
-inline bool operator != (const Poco::Int16& other, const Var& da)
-	/// Inequality operator for comparing Var with Poco::Int16
-{
-	if (da.isEmpty()) return true;
-	return other != da.convert<Poco::Int16>();
-}
-
-
-inline bool operator < (const Poco::Int16& other, const Var& da)
-	/// Less than operator for comparing Var with Poco::Int16
-{
-	if (da.isEmpty()) return false;
-	return other < da.convert<Poco::Int16>();
-}
-
-
-inline bool operator <= (const Poco::Int16& other, const Var& da)
-	/// Less than or equal operator for comparing Var with Poco::Int16
-{
-	if (da.isEmpty()) return false;
-	return other <= da.convert<Poco::Int16>();
-}
-
-
-inline bool operator > (const Poco::Int16& other, const Var& da)
-	/// Greater than operator for comparing Var with Poco::Int16
-{
-	if (da.isEmpty()) return false;
-	return other > da.convert<Poco::Int16>();
-}
-
-
-inline bool operator >= (const Poco::Int16& other, const Var& da)
-	/// Greater than or equal operator for comparing Var with Poco::Int16
-{
-	if (da.isEmpty()) return false;
-	return other >= da.convert<Poco::Int16>();
-}
-
-
-inline Poco::UInt16 operator + (const Poco::UInt16& other, const Var& da)
-	/// Addition operator for adding Var to Poco::UInt16
-{
-	return other + da.convert<Poco::UInt16>();
-}
-
-
-inline Poco::UInt16 operator - (const Poco::UInt16& other, const Var& da)
-	/// Subtraction operator for subtracting Var from Poco::UInt16
-{
-	return other - da.convert<Poco::UInt16>();
-}
-
-
-inline Poco::UInt16 operator * (const Poco::UInt16& other, const Var& da)
-	/// Multiplication operator for multiplying Var with Poco::UInt16
-{
-	return other * da.convert<Poco::UInt16>();
-}
-
-
-inline Poco::UInt16 operator / (const Poco::UInt16& other, const Var& da)
-	/// Division operator for dividing Var with Poco::UInt16
-{
-	return other / da.convert<Poco::UInt16>();
-}
-
-
-inline Poco::UInt16 operator += (Poco::UInt16& other, const Var& da)
-	/// Addition assignment operator for adding Var to Poco::UInt16
-{
-	return other += da.convert<Poco::UInt16>();
-}
-
-
-inline Poco::UInt16 operator -= (Poco::UInt16& other, const Var& da)
-	/// Subtraction assignment operator for subtracting Var from Poco::UInt16
-{
-	return other -= da.convert<Poco::UInt16>();
-}
-
-
-inline Poco::UInt16 operator *= (Poco::UInt16& other, const Var& da)
-	/// Multiplication assignment operator for multiplying Var with Poco::UInt16
-{
-	return other *= da.convert<Poco::UInt16>();
-}
-
-
-inline Poco::UInt16 operator /= (Poco::UInt16& other, const Var& da)
-	/// Division assignment operator for dividing Var with Poco::UInt16
-{
-	return other /= da.convert<Poco::UInt16>();
-}
-
-
-inline bool operator == (const Poco::UInt16& other, const Var& da)
-	/// Equality operator for comparing Var with Poco::UInt16
-{
-	if (da.isEmpty()) return false;
-	return other == da.convert<Poco::UInt16>();
-}
-
-
-inline bool operator != (const Poco::UInt16& other, const Var& da)
-	/// Inequality operator for comparing Var with Poco::UInt16
-{
-	if (da.isEmpty()) return true;
-	return other != da.convert<Poco::UInt16>();
-}
-
-
-inline bool operator < (const Poco::UInt16& other, const Var& da)
-	/// Less than operator for comparing Var with Poco::UInt16
-{
-	if (da.isEmpty()) return false;
-	return other < da.convert<Poco::UInt16>();
-}
-
-
-inline bool operator <= (const Poco::UInt16& other, const Var& da)
-	/// Less than or equal operator for comparing Var with Poco::UInt16
-{
-	if (da.isEmpty()) return false;
-	return other <= da.convert<Poco::UInt16>();
-}
-
-
-inline bool operator > (const Poco::UInt16& other, const Var& da)
-	/// Greater than operator for comparing Var with Poco::UInt16
-{
-	if (da.isEmpty()) return false;
-	return other > da.convert<Poco::UInt16>();
-}
-
-
-inline bool operator >= (const Poco::UInt16& other, const Var& da)
-	/// Greater than or equal operator for comparing Var with Poco::UInt16
-{
-	if (da.isEmpty()) return false;
-	return other >= da.convert<Poco::UInt16>();
-}
-
-
-inline Poco::Int32 operator + (const Poco::Int32& other, const Var& da)
-	/// Addition operator for adding Var to Poco::Int32
-{
-	return other + da.convert<Poco::Int32>();
-}
-
-
-inline Poco::Int32 operator - (const Poco::Int32& other, const Var& da)
-	/// Subtraction operator for subtracting Var from Poco::Int32
-{
-	return other - da.convert<Poco::Int32>();
-}
-
-
-inline Poco::Int32 operator * (const Poco::Int32& other, const Var& da)
-	/// Multiplication operator for multiplying Var with Poco::Int32
-{
-	return other * da.convert<Poco::Int32>();
-}
-
-
-inline Poco::Int32 operator / (const Poco::Int32& other, const Var& da)
-	/// Division operator for dividing Var with Poco::Int32
-{
-	return other / da.convert<Poco::Int32>();
-}
-
-
-inline Poco::Int32 operator += (Poco::Int32& other, const Var& da)
-	/// Addition assignment operator for adding Var to Poco::Int32
-{
-	return other += da.convert<Poco::Int32>();
-}
-
-
-inline Poco::Int32 operator -= (Poco::Int32& other, const Var& da)
-	/// Subtraction assignment operator for subtracting Var from Poco::Int32
-{
-	return other -= da.convert<Poco::Int32>();
-}
-
-
-inline Poco::Int32 operator *= (Poco::Int32& other, const Var& da)
-	/// Multiplication assignment operator for multiplying Var with Poco::Int32
-{
-	return other *= da.convert<Poco::Int32>();
-}
-
-
-inline Poco::Int32 operator /= (Poco::Int32& other, const Var& da)
-	/// Division assignment operator for dividing Var with Poco::Int32
-{
-	return other /= da.convert<Poco::Int32>();
-}
-
-
-inline bool operator == (const Poco::Int32& other, const Var& da)
-	/// Equality operator for comparing Var with Poco::Int32
-{
-	if (da.isEmpty()) return false;
-	return other == da.convert<Poco::Int32>();
-}
-
-
-inline bool operator != (const Poco::Int32& other, const Var& da)
-	/// Inequality operator for comparing Var with Poco::Int32
-{
-	if (da.isEmpty()) return true;
-	return other != da.convert<Poco::Int32>();
-}
-
-
-inline bool operator < (const Poco::Int32& other, const Var& da)
-	/// Less than operator for comparing Var with Poco::Int32
-{
-	if (da.isEmpty()) return false;
-	return other < da.convert<Poco::Int32>();
-}
-
-
-inline bool operator <= (const Poco::Int32& other, const Var& da)
-	/// Less than or equal operator for comparing Var with Poco::Int32
-{
-	if (da.isEmpty()) return false;
-	return other <= da.convert<Poco::Int32>();
-}
-
-
-inline bool operator > (const Poco::Int32& other, const Var& da)
-	/// Greater than operator for comparing Var with Poco::Int32
-{
-	if (da.isEmpty()) return false;
-	return other > da.convert<Poco::Int32>();
-}
-
-
-inline bool operator >= (const Poco::Int32& other, const Var& da)
-	/// Greater than or equal operator for comparing Var with Poco::Int32
-{
-	if (da.isEmpty()) return false;
-	return other >= da.convert<Poco::Int32>();
-}
-
-
-inline Poco::UInt32 operator + (const Poco::UInt32& other, const Var& da)
-	/// Addition operator for adding Var to Poco::UInt32
-{
-	return other + da.convert<Poco::UInt32>();
-}
-
-
-inline Poco::UInt32 operator - (const Poco::UInt32& other, const Var& da)
-	/// Subtraction operator for subtracting Var from Poco::UInt32
-{
-	return other - da.convert<Poco::UInt32>();
-}
-
-
-inline Poco::UInt32 operator * (const Poco::UInt32& other, const Var& da)
-	/// Multiplication operator for multiplying Var with Poco::UInt32
-{
-	return other * da.convert<Poco::UInt32>();
-}
-
-
-inline Poco::UInt32 operator / (const Poco::UInt32& other, const Var& da)
-	/// Division operator for dividing Var with Poco::UInt32
-{
-	return other / da.convert<Poco::UInt32>();
-}
-
-
-inline Poco::UInt32 operator += (Poco::UInt32& other, const Var& da)
-	/// Addition assignment operator for adding Var to Poco::UInt32
-{
-	return other += da.convert<Poco::UInt32>();
-}
-
-
-inline Poco::UInt32 operator -= (Poco::UInt32& other, const Var& da)
-	/// Subtraction assignment operator for subtracting Var from Poco::UInt32
-{
-	return other -= da.convert<Poco::UInt32>();
-}
-
-
-inline Poco::UInt32 operator *= (Poco::UInt32& other, const Var& da)
-	/// Multiplication assignment operator for multiplying Var with Poco::UInt32
-{
-	return other *= da.convert<Poco::UInt32>();
-}
-
-
-inline Poco::UInt32 operator /= (Poco::UInt32& other, const Var& da)
-	/// Division assignment operator for dividing Var with Poco::UInt32
-{
-	return other /= da.convert<Poco::UInt32>();
-}
-
-
-inline bool operator == (const Poco::UInt32& other, const Var& da)
-	/// Equality operator for comparing Var with Poco::UInt32
-{
-	if (da.isEmpty()) return false;
-	return other == da.convert<Poco::UInt32>();
-}
-
-
-inline bool operator != (const Poco::UInt32& other, const Var& da)
-	/// Inequality operator for comparing Var with Poco::UInt32
-{
-	if (da.isEmpty()) return true;
-	return other != da.convert<Poco::UInt32>();
-}
-
-
-inline bool operator < (const Poco::UInt32& other, const Var& da)
-	/// Less than operator for comparing Var with Poco::UInt32
-{
-	if (da.isEmpty()) return false;
-	return other < da.convert<Poco::UInt32>();
-}
-
-
-inline bool operator <= (const Poco::UInt32& other, const Var& da)
-	/// Less than or equal operator for comparing Var with Poco::UInt32
-{
-	if (da.isEmpty()) return false;
-	return other <= da.convert<Poco::UInt32>();
-}
-
-
-inline bool operator > (const Poco::UInt32& other, const Var& da)
-	/// Greater than operator for comparing Var with Poco::UInt32
-{
-	if (da.isEmpty()) return false;
-	return other > da.convert<Poco::UInt32>();
-}
-
-
-inline bool operator >= (const Poco::UInt32& other, const Var& da)
-	/// Greater than or equal operator for comparing Var with Poco::UInt32
-{
-	if (da.isEmpty()) return false;
-	return other >= da.convert<Poco::UInt32>();
-}
-
-
-inline Poco::Int64 operator + (const Poco::Int64& other, const Var& da)
-	/// Addition operator for adding Var to Poco::Int64
-{
-	return other + da.convert<Poco::Int64>();
-}
-
-
-inline Poco::Int64 operator - (const Poco::Int64& other, const Var& da)
-	/// Subtraction operator for subtracting Var from Poco::Int64
-{
-	return other - da.convert<Poco::Int64>();
-}
-
-
-inline Poco::Int64 operator * (const Poco::Int64& other, const Var& da)
-	/// Multiplication operator for multiplying Var with Poco::Int64
-{
-	return other * da.convert<Poco::Int64>();
-}
-
-
-inline Poco::Int64 operator / (const Poco::Int64& other, const Var& da)
-	/// Division operator for dividing Var with Poco::Int64
-{
-	return other / da.convert<Poco::Int64>();
-}
-
-
-inline Poco::Int64 operator += (Poco::Int64& other, const Var& da)
-	/// Addition assignment operator for adding Var to Poco::Int64
-{
-	return other += da.convert<Poco::Int64>();
-}
-
-
-inline Poco::Int64 operator -= (Poco::Int64& other, const Var& da)
-	/// Subtraction assignment operator for subtracting Var from Poco::Int64
-{
-	return other -= da.convert<Poco::Int64>();
-}
-
-
-inline Poco::Int64 operator *= (Poco::Int64& other, const Var& da)
-	/// Multiplication assignment operator for multiplying Var with Poco::Int64
-{
-	return other *= da.convert<Poco::Int64>();
-}
-
-
-inline Poco::Int64 operator /= (Poco::Int64& other, const Var& da)
-	/// Division assignment operator for dividing Var with Poco::Int64
-{
-	return other /= da.convert<Poco::Int64>();
-}
-
-
-inline bool operator == (const Poco::Int64& other, const Var& da)
-	/// Equality operator for comparing Var with Poco::Int64
-{
-	if (da.isEmpty()) return false;
-	return other == da.convert<Poco::Int64>();
-}
-
-
-inline bool operator != (const Poco::Int64& other, const Var& da)
-	/// Inequality operator for comparing Var with Poco::Int64
-{
-	if (da.isEmpty()) return true;
-	return other != da.convert<Poco::Int64>();
-}
-
-
-inline bool operator < (const Poco::Int64& other, const Var& da)
-	/// Less than operator for comparing Var with Poco::Int64
-{
-	if (da.isEmpty()) return false;
-	return other < da.convert<Poco::Int64>();
-}
-
-
-inline bool operator <= (const Poco::Int64& other, const Var& da)
-	/// Less than or equal operator for comparing Var with Poco::Int64
-{
-	if (da.isEmpty()) return false;
-	return other <= da.convert<Poco::Int64>();
-}
-
-
-inline bool operator > (const Poco::Int64& other, const Var& da)
-	/// Greater than operator for comparing Var with Poco::Int64
-{
-	if (da.isEmpty()) return false;
-	return other > da.convert<Poco::Int64>();
-}
-
-
-inline bool operator >= (const Poco::Int64& other, const Var& da)
-	/// Greater than or equal operator for comparing Var with Poco::Int64
-{
-	if (da.isEmpty()) return false;
-	return other >= da.convert<Poco::Int64>();
-}
-
-
-inline Poco::UInt64 operator + (const Poco::UInt64& other, const Var& da)
-	/// Addition operator for adding Var to Poco::UInt64
-{
-	return other + da.convert<Poco::UInt64>();
-}
-
-
-inline Poco::UInt64 operator - (const Poco::UInt64& other, const Var& da)
-	/// Subtraction operator for subtracting Var from Poco::UInt64
-{
-	return other - da.convert<Poco::UInt64>();
-}
-
-
-inline Poco::UInt64 operator * (const Poco::UInt64& other, const Var& da)
-	/// Multiplication operator for multiplying Var with Poco::UInt64
-{
-	return other * da.convert<Poco::UInt64>();
-}
-
-
-inline Poco::UInt64 operator / (const Poco::UInt64& other, const Var& da)
-	/// Division operator for dividing Var with Poco::UInt64
-{
-	return other / da.convert<Poco::UInt64>();
-}
-
-
-inline Poco::UInt64 operator += (Poco::UInt64& other, const Var& da)
-	/// Addition assignment operator for adding Var to Poco::UInt64
-{
-	return other += da.convert<Poco::UInt64>();
-}
-
-
-inline Poco::UInt64 operator -= (Poco::UInt64& other, const Var& da)
-	/// Subtraction assignment operator for subtracting Var from Poco::UInt64
-{
-	return other -= da.convert<Poco::UInt64>();
-}
-
-
-inline Poco::UInt64 operator *= (Poco::UInt64& other, const Var& da)
-	/// Multiplication assignment operator for multiplying Var with Poco::UInt64
-{
-	return other *= da.convert<Poco::UInt64>();
-}
-
-
-inline Poco::UInt64 operator /= (Poco::UInt64& other, const Var& da)
-	/// Division assignment operator for dividing Var with Poco::UInt64
-{
-	return other /= da.convert<Poco::UInt64>();
-}
-
-
-inline bool operator == (const Poco::UInt64& other, const Var& da)
-	/// Equality operator for comparing Var with Poco::UInt64
-{
-	if (da.isEmpty()) return false;
-	return other == da.convert<Poco::UInt64>();
-}
-
-
-inline bool operator != (const Poco::UInt64& other, const Var& da)
-	/// Inequality operator for comparing Var with Poco::UInt64
-{
-	if (da.isEmpty()) return true;
-	return other != da.convert<Poco::UInt64>();
-}
-
-
-inline bool operator < (const Poco::UInt64& other, const Var& da)
-	/// Less than operator for comparing Var with Poco::UInt64
-{
-	if (da.isEmpty()) return false;
-	return other < da.convert<Poco::UInt64>();
-}
-
-
-inline bool operator <= (const Poco::UInt64& other, const Var& da)
-	/// Less than or equal operator for comparing Var with Poco::UInt64
-{
-	if (da.isEmpty()) return false;
-	return other <= da.convert<Poco::UInt64>();
-}
-
-
-inline bool operator > (const Poco::UInt64& other, const Var& da)
-	/// Greater than operator for comparing Var with Poco::UInt64
-{
-	if (da.isEmpty()) return false;
-	return other > da.convert<Poco::UInt64>();
-}
-
-
-inline bool operator >= (const Poco::UInt64& other, const Var& da)
-	/// Greater than or equal operator for comparing Var with Poco::UInt64
-{
-	if (da.isEmpty()) return false;
-	return other >= da.convert<Poco::UInt64>();
-}
-
-
-inline float operator + (const float& other, const Var& da)
-	/// Addition operator for adding Var to float
-{
-	return other + da.convert<float>();
-}
-
-
-inline float operator - (const float& other, const Var& da)
-	/// Subtraction operator for subtracting Var from float
-{
-	return other - da.convert<float>();
-}
-
-
-inline float operator * (const float& other, const Var& da)
-	/// Multiplication operator for multiplying Var with float
-{
-	return other * da.convert<float>();
-}
-
-
-inline float operator / (const float& other, const Var& da)
-	/// Division operator for dividing Var with float
-{
-	return other / da.convert<float>();
-}
-
-
-inline float operator += (float& other, const Var& da)
-	/// Addition assignment operator for adding Var to float
-{
-	return other += da.convert<float>();
-}
-
-
-inline float operator -= (float& other, const Var& da)
-	/// Subtraction assignment operator for subtracting Var from float
-{
-	return other -= da.convert<float>();
-}
-
-
-inline float operator *= (float& other, const Var& da)
-	/// Multiplication assignment operator for multiplying Var with float
-{
-	return other *= da.convert<float>();
-}
-
-
-inline float operator /= (float& other, const Var& da)
-	/// Division assignment operator for dividing Var with float
-{
-	return other /= da.convert<float>();
-}
-
-
-inline bool operator == (const float& other, const Var& da)
-	/// Equality operator for comparing Var with float
-{
-	if (da.isEmpty()) return false;
-	return other == da.convert<float>();
-}
-
-
-inline bool operator != (const float& other, const Var& da)
-	/// Inequality operator for comparing Var with float
-{
-	if (da.isEmpty()) return true;
-	return other != da.convert<float>();
-}
-
-
-inline bool operator < (const float& other, const Var& da)
-	/// Less than operator for comparing Var with float
-{
-	if (da.isEmpty()) return false;
-	return other < da.convert<float>();
-}
-
-
-inline bool operator <= (const float& other, const Var& da)
-	/// Less than or equal operator for comparing Var with float
-{
-	if (da.isEmpty()) return false;
-	return other <= da.convert<float>();
-}
-
-
-inline bool operator > (const float& other, const Var& da)
-	/// Greater than operator for comparing Var with float
-{
-	if (da.isEmpty()) return false;
-	return other > da.convert<float>();
-}
-
-
-inline bool operator >= (const float& other, const Var& da)
-	/// Greater than or equal operator for comparing Var with float
-{
-	if (da.isEmpty()) return false;
-	return other >= da.convert<float>();
-}
-
-
-inline double operator + (const double& other, const Var& da)
-	/// Addition operator for adding Var to double
-{
-	return other + da.convert<double>();
-}
-
-
-inline double operator - (const double& other, const Var& da)
-	/// Subtraction operator for subtracting Var from double
-{
-	return other - da.convert<double>();
-}
-
-
-inline double operator * (const double& other, const Var& da)
-	/// Multiplication operator for multiplying Var with double
-{
-	return other * da.convert<double>();
-}
-
-
-inline double operator / (const double& other, const Var& da)
-	/// Division operator for dividing Var with double
-{
-	return other / da.convert<double>();
-}
-
-
-inline double operator += (double& other, const Var& da)
-	/// Addition assignment operator for adding Var to double
-{
-	return other += da.convert<double>();
-}
-
-
-inline double operator -= (double& other, const Var& da)
-	/// Subtraction assignment operator for subtracting Var from double
-{
-	return other -= da.convert<double>();
-}
-
-
-inline double operator *= (double& other, const Var& da)
-	/// Multiplication assignment operator for multiplying Var with double
-{
-	return other *= da.convert<double>();
-}
-
-
-inline double operator /= (double& other, const Var& da)
-	/// Division assignment operator for dividing Var with double
-{
-	return other /= da.convert<double>();
-}
-
-
-inline bool operator == (const double& other, const Var& da)
-	/// Equality operator for comparing Var with double
-{
-	if (da.isEmpty()) return false;
-	return other == da.convert<double>();
-}
-
-
-inline bool operator != (const double& other, const Var& da)
-	/// Inequality operator for comparing Var with double
-{
-	if (da.isEmpty()) return true;
-	return other != da.convert<double>();
-}
-
-
-inline bool operator < (const double& other, const Var& da)
-	/// Less than operator for comparing Var with double
-{
-	if (da.isEmpty()) return false;
-	return other < da.convert<double>();
-}
-
-
-inline bool operator <= (const double& other, const Var& da)
-	/// Less than or equal operator for comparing Var with double
-{
-	if (da.isEmpty()) return false;
-	return other <= da.convert<double>();
-}
-
-
-inline bool operator > (const double& other, const Var& da)
-	/// Greater than operator for comparing Var with double
-{
-	if (da.isEmpty()) return false;
-	return other > da.convert<double>();
-}
-
-
-inline bool operator >= (const double& other, const Var& da)
-	/// Greater than or equal operator for comparing Var with double
-{
-	if (da.isEmpty()) return false;
-	return other >= da.convert<double>();
-}
-
-
-inline bool operator == (const bool& other, const Var& da)
-	/// Equality operator for comparing Var with bool
-{
-	if (da.isEmpty()) return false;
-	return other == da.convert<bool>();
-}
-
-
-inline bool operator != (const bool& other, const Var& da)
-	/// Inequality operator for comparing Var with bool
-{
-	if (da.isEmpty()) return true;
-	return other != da.convert<bool>();
-}
-
-
-inline bool operator == (const std::string& other, const Var& da)
-	/// Equality operator for comparing Var with std::string
-{
-	if (da.isEmpty()) return false;
-	return other == da.convert<std::string>();
-}
-
-
-inline bool operator != (const std::string& other, const Var& da)
-	/// Inequality operator for comparing Var with std::string
-{
-	if (da.isEmpty()) return true;
-	return other != da.convert<std::string>();
-}
-
-
-inline bool operator == (const UTF16String& other, const Var& da)
-	/// Equality operator for comparing Var with UTF16String
-{
-	if (da.isEmpty()) return false;
-	return other == da.convert<UTF16String>();
-}
-
-
-inline bool operator != (const UTF16String& other, const Var& da)
-	/// Inequality operator for comparing Var with UTF16String
-{
-	if (da.isEmpty()) return true;
-	return other != da.convert<UTF16String>();
-}
-
-
-inline bool operator == (const char* other, const Var& da)
-	/// Equality operator for comparing Var with const char*
-{
-	if (da.isEmpty()) return false;
-	return da.convert<std::string>() == other;
-}
-
-
-inline bool operator != (const char* other, const Var& da)
-	/// Inequality operator for comparing Var with const char*
-{
-	if (da.isEmpty()) return true;
-	return da.convert<std::string>() != other;
-}
-
-
-#ifndef POCO_LONG_IS_64_BIT
-
-
-inline long operator + (const long& other, const Var& da)
-	/// Addition operator for adding Var to long
-{
-	return other + da.convert<long>();
-}
-
-
-inline long operator - (const long& other, const Var& da)
-	/// Subtraction operator for subtracting Var from long
-{
-	return other - da.convert<long>();
-}
-
-
-inline long operator * (const long& other, const Var& da)
-	/// Multiplication operator for multiplying Var with long
-{
-	return other * da.convert<long>();
-}
-
-
-inline long operator / (const long& other, const Var& da)
-	/// Division operator for dividing Var with long
-{
-	return other / da.convert<long>();
-}
-
-
-inline long operator += (long& other, const Var& da)
-	/// Addition assignment operator for adding Var to long
-{
-	return other += da.convert<long>();
-}
-
-
-inline long operator -= (long& other, const Var& da)
-	/// Subtraction assignment operator for subtracting Var from long
-{
-	return other -= da.convert<long>();
-}
-
-
-inline long operator *= (long& other, const Var& da)
-	/// Multiplication assignment operator for multiplying Var with long
-{
-	return other *= da.convert<long>();
-}
-
-
-inline long operator /= (long& other, const Var& da)
-	/// Division assignment operator for dividing Var with long
-{
-	return other /= da.convert<long>();
-}
-
-
-inline bool operator == (const long& other, const Var& da)
-	/// Equality operator for comparing Var with long
-{
-	if (da.isEmpty()) return false;
-	return other == da.convert<long>();
-}
-
-
-inline bool operator != (const long& other, const Var& da)
-	/// Inequality operator for comparing Var with long
-{
-	if (da.isEmpty()) return true;
-	return other != da.convert<long>();
-}
-
-
-inline bool operator < (const long& other, const Var& da)
-	/// Less than operator for comparing Var with long
-{
-	if (da.isEmpty()) return false;
-	return other < da.convert<long>();
-}
-
-
-inline bool operator <= (const long& other, const Var& da)
-	/// Less than or equal operator for comparing Var with long
-{
-	if (da.isEmpty()) return false;
-	return other <= da.convert<long>();
-}
-
-
-inline bool operator > (const long& other, const Var& da)
-	/// Greater than operator for comparing Var with long
-{
-	if (da.isEmpty()) return false;
-	return other > da.convert<long>();
-}
-
-
-inline bool operator >= (const long& other, const Var& da)
-	/// Greater than or equal operator for comparing Var with long
-{
-	if (da.isEmpty()) return false;
-	return other >= da.convert<long>();
-}
-
-
-#endif // POCO_LONG_IS_64_BIT
-
-
-} // namespace Dynamic
-
-
-//@ deprecated
-typedef Dynamic::Var DynamicAny;
-
-
-} // namespace Poco
-
-
-#endif // Foundation_Var_INCLUDED
+	T divide(const Var& other) const 
+	{ 
+		return convert<T>() / other.convert<T>(); 
+	} 
+ 
+	template <typename T, typename E> 
+	VarHolderImpl<T>* holderImpl(const std::string errorMessage = "") const 
+	{ 
+		VarHolder* pHolder = content(); 
+ 
+		if (pHolder && pHolder->type() == typeid(T)) 
+			return static_cast<VarHolderImpl<T>*>(pHolder); 
+		else if (!pHolder) 
+			throw InvalidAccessException("Can not access empty value."); 
+		else 
+			throw E(errorMessage); 
+	} 
+ 
+	Var& structIndexOperator(VarHolderImpl<Struct<int> >* pStr, int n) const; 
+ 
+#ifdef POCO_NO_SOO 
+ 
+	VarHolder* content() const 
+	{ 
+		return _pHolder; 
+	} 
+ 
+	void destruct() 
+	{ 
+		if (!isEmpty()) delete content(); 
+	} 
+ 
+	VarHolder* _pHolder; 
+ 
+#else 
+ 
+	VarHolder* content() const 
+	{ 
+		return _placeholder.content(); 
+	} 
+ 
+	template<typename ValueType> 
+	void construct(const ValueType& value) 
+	{ 
+		if (sizeof(VarHolderImpl<ValueType>) <= Placeholder<ValueType>::Size::value) 
+		{ 
+			new (reinterpret_cast<VarHolder*>(_placeholder.holder)) VarHolderImpl<ValueType>(value); 
+			_placeholder.setLocal(true); 
+		} 
+		else 
+		{ 
+			_placeholder.pHolder = new VarHolderImpl<ValueType>(value); 
+			_placeholder.setLocal(false); 
+		} 
+	} 
+ 
+	void construct(const char* value) 
+	{ 
+		std::string val(value); 
+		if (sizeof(VarHolderImpl<std::string>) <= Placeholder<std::string>::Size::value) 
+		{ 
+			new (reinterpret_cast<VarHolder*>(_placeholder.holder)) VarHolderImpl<std::string>(val); 
+			_placeholder.setLocal(true); 
+		} 
+		else 
+		{ 
+			_placeholder.pHolder = new VarHolderImpl<std::string>(val); 
+			_placeholder.setLocal(false); 
+		} 
+	} 
+ 
+	void construct(const Var& other) 
+	{ 
+		if (!other.isEmpty()) 
+			other.content()->clone(&_placeholder); 
+		else 
+			_placeholder.erase(); 
+	} 
+ 
+	void destruct() 
+	{ 
+		if (!isEmpty()) 
+		{ 
+			if (_placeholder.isLocal()) 
+				content()->~VarHolder(); 
+			else 
+				delete content(); 
+		} 
+	} 
+ 
+	Placeholder<VarHolder> _placeholder; 
+ 
+#endif // POCO_NO_SOO 
+}; 
+ 
+ 
+/// 
+/// inlines 
+/// 
+ 
+ 
+/// 
+/// Var members 
+/// 
+ 
+inline void Var::swap(Var& other) 
+{ 
+#ifdef POCO_NO_SOO 
+ 
+	std::swap(_pHolder, other._pHolder); 
+ 
+#else 
+ 
+	if (this == &other) return; 
+ 
+	if (!_placeholder.isLocal() && !other._placeholder.isLocal()) 
+	{ 
+		std::swap(_placeholder.pHolder, other._placeholder.pHolder); 
+	} 
+	else 
+	{ 
+		Var tmp(*this); 
+		try 
+		{ 
+			if (_placeholder.isLocal()) destruct(); 
+			construct(other); 
+			other = tmp; 
+		} 
+		catch (...) 
+		{ 
+			construct(tmp); 
+			throw; 
+		} 
+	} 
+ 
+#endif 
+} 
+ 
+ 
+inline const std::type_info& Var::type() const 
+{ 
+	VarHolder* pHolder = content(); 
+	return pHolder ? pHolder->type() : typeid(void); 
+} 
+ 
+ 
+inline Var::ConstIterator Var::begin() const 
+{ 
+	if (isEmpty()) return ConstIterator(const_cast<Var*>(this), true); 
+ 
+	return ConstIterator(const_cast<Var*>(this), false); 
+} 
+ 
+inline Var::ConstIterator Var::end() const 
+{ 
+	return ConstIterator(const_cast<Var*>(this), true); 
+} 
+ 
+inline Var::Iterator Var::begin() 
+{ 
+	if (isEmpty()) return Iterator(const_cast<Var*>(this), true); 
+ 
+	return Iterator(const_cast<Var*>(this), false); 
+} 
+ 
+inline Var::Iterator Var::end() 
+{ 
+	return Iterator(this, true); 
+} 
+ 
+ 
+inline Var& Var::operator [] (const std::string& name) 
+{ 
+	return getAt(name); 
+} 
+ 
+ 
+inline const Var& Var::operator [] (const std::string& name) const 
+{ 
+	return const_cast<Var*>(this)->getAt(name); 
+} 
+ 
+ 
+inline const Var Var::operator + (const char* other) const 
+{ 
+	return convert<std::string>() + other; 
+} 
+ 
+ 
+inline Var& Var::operator += (const char*other) 
+{ 
+	return *this = convert<std::string>() + other; 
+} 
+ 
+ 
+inline bool Var::operator ! () const 
+{ 
+	return !convert<bool>(); 
+} 
+ 
+ 
+inline bool Var::isEmpty() const 
+{ 
+	return 0 == content(); 
+} 
+ 
+ 
+inline bool Var::isArray() const 
+{ 
+	if (isEmpty() ||  
+		isString()) return false; 
+ 
+	VarHolder* pHolder = content(); 
+	return pHolder ? pHolder->isArray() : false; 
+} 
+ 
+ 
+inline bool Var::isVector() const 
+{ 
+	VarHolder* pHolder = content(); 
+	return pHolder ? pHolder->isVector() : false; 
+} 
+ 
+ 
+inline bool Var::isList() const 
+{ 
+	VarHolder* pHolder = content(); 
+	return pHolder ? pHolder->isList() : false; 
+} 
+ 
+ 
+inline bool Var::isDeque() const 
+{ 
+	VarHolder* pHolder = content(); 
+	return pHolder ? pHolder->isDeque() : false; 
+} 
+ 
+ 
+inline bool Var::isStruct() const 
+{ 
+	VarHolder* pHolder = content(); 
+	return pHolder ? pHolder->isStruct() : false; 
+} 
+ 
+ 
+inline bool Var::isInteger() const 
+{ 
+	VarHolder* pHolder = content(); 
+	return pHolder ? pHolder->isInteger() : false; 
+} 
+ 
+ 
+inline bool Var::isSigned() const 
+{ 
+	VarHolder* pHolder = content(); 
+	return pHolder ? pHolder->isSigned() : false; 
+} 
+ 
+ 
+inline bool Var::isNumeric() const 
+{ 
+	VarHolder* pHolder = content(); 
+	return pHolder ? pHolder->isNumeric() : false; 
+} 
+ 
+ 
+inline bool Var::isBoolean() const 
+{ 
+	VarHolder* pHolder = content(); 
+	return pHolder ? pHolder->isBoolean() : false; 
+} 
+ 
+ 
+inline bool Var::isString() const 
+{ 
+	VarHolder* pHolder = content(); 
+	return pHolder ? pHolder->isString() : false; 
+} 
+ 
+ 
+inline bool Var::isDate() const 
+{ 
+	VarHolder* pHolder = content(); 
+	return pHolder ? pHolder->isDate() : false; 
+} 
+ 
+ 
+inline bool Var::isTime() const 
+{ 
+	VarHolder* pHolder = content(); 
+	return pHolder ? pHolder->isTime() : false; 
+} 
+ 
+ 
+inline bool Var::isDateTime() const 
+{ 
+	VarHolder* pHolder = content(); 
+	return pHolder ? pHolder->isDateTime() : false; 
+} 
+ 
+ 
+inline std::size_t Var::size() const 
+{ 
+	VarHolder* pHolder = content(); 
+	return pHolder ? pHolder->size() : 0; 
+} 
+ 
+ 
+/// 
+/// Var non-member functions 
+/// 
+ 
+inline const Var operator + (const char* other, const Var& da) 
+	/// Addition operator for adding Var to const char* 
+{ 
+	std::string tmp = other; 
+	return tmp + da.convert<std::string>(); 
+} 
+ 
+ 
+inline char operator + (const char& other, const Var& da) 
+	/// Addition operator for adding Var to char 
+{ 
+	return other + da.convert<char>(); 
+} 
+ 
+ 
+inline char operator - (const char& other, const Var& da) 
+	/// Subtraction operator for subtracting Var from char 
+{ 
+	return other - da.convert<char>(); 
+} 
+ 
+ 
+inline char operator * (const char& other, const Var& da) 
+	/// Multiplication operator for multiplying Var with char 
+{ 
+	return other * da.convert<char>(); 
+} 
+ 
+ 
+inline char operator / (const char& other, const Var& da) 
+	/// Division operator for dividing Var with char 
+{ 
+	return other / da.convert<char>(); 
+} 
+ 
+ 
+inline char operator += (char& other, const Var& da) 
+	/// Addition assignment operator for adding Var to char 
+{ 
+	return other += da.convert<char>(); 
+} 
+ 
+ 
+inline char operator -= (char& other, const Var& da) 
+	/// Subtraction assignment operator for subtracting Var from char 
+{ 
+	return other -= da.convert<char>(); 
+} 
+ 
+ 
+inline char operator *= (char& other, const Var& da) 
+	/// Multiplication assignment operator for multiplying Var with char 
+{ 
+	return other *= da.convert<char>(); 
+} 
+ 
+ 
+inline char operator /= (char& other, const Var& da) 
+	/// Division assignment operator for dividing Var with char 
+{ 
+	return other /= da.convert<char>(); 
+} 
+ 
+ 
+inline bool operator == (const char& other, const Var& da) 
+	/// Equality operator for comparing Var with char 
+{ 
+	if (da.isEmpty()) return false; 
+	return other == da.convert<char>(); 
+} 
+ 
+ 
+inline bool operator != (const char& other, const Var& da) 
+	/// Inequality operator for comparing Var with char 
+{ 
+	if (da.isEmpty()) return true; 
+	return other != da.convert<char>(); 
+} 
+ 
+ 
+inline bool operator < (const char& other, const Var& da) 
+	/// Less than operator for comparing Var with char 
+{ 
+	if (da.isEmpty()) return false; 
+	return other < da.convert<char>(); 
+} 
+ 
+ 
+inline bool operator <= (const char& other, const Var& da) 
+	/// Less than or equal operator for comparing Var with char 
+{ 
+	if (da.isEmpty()) return false; 
+	return other <= da.convert<char>(); 
+} 
+ 
+ 
+inline bool operator > (const char& other, const Var& da) 
+	/// Greater than operator for comparing Var with char 
+{ 
+	if (da.isEmpty())return false; 
+	return other > da.convert<char>(); 
+} 
+ 
+ 
+inline bool operator >= (const char& other, const Var& da) 
+	/// Greater than or equal operator for comparing Var with char 
+{ 
+	if (da.isEmpty())return false; 
+	return other >= da.convert<char>(); 
+} 
+ 
+ 
+inline Poco::Int8 operator + (const Poco::Int8& other, const Var& da) 
+	/// Addition operator for adding Var to Poco::Int8 
+{ 
+	return other + da.convert<Poco::Int8>(); 
+} 
+ 
+ 
+inline Poco::Int8 operator - (const Poco::Int8& other, const Var& da) 
+	/// Subtraction operator for subtracting Var from Poco::Int8 
+{ 
+	return other - da.convert<Poco::Int8>(); 
+} 
+ 
+ 
+inline Poco::Int8 operator * (const Poco::Int8& other, const Var& da) 
+	/// Multiplication operator for multiplying Var with Poco::Int8 
+{ 
+	return other * da.convert<Poco::Int8>(); 
+} 
+ 
+ 
+inline Poco::Int8 operator / (const Poco::Int8& other, const Var& da) 
+	/// Division operator for dividing Var with Poco::Int8 
+{ 
+	return other / da.convert<Poco::Int8>(); 
+} 
+ 
+ 
+inline Poco::Int8 operator += (Poco::Int8& other, const Var& da) 
+	/// Addition assignment operator for adding Var to Poco::Int8 
+{ 
+	return other += da.convert<Poco::Int8>(); 
+} 
+ 
+ 
+inline Poco::Int8 operator -= (Poco::Int8& other, const Var& da) 
+	/// Subtraction assignment operator for subtracting Var from Poco::Int8 
+{ 
+	return other -= da.convert<Poco::Int8>(); 
+} 
+ 
+ 
+inline Poco::Int8 operator *= (Poco::Int8& other, const Var& da) 
+	/// Multiplication assignment operator for multiplying Var with Poco::Int8 
+{ 
+	return other *= da.convert<Poco::Int8>(); 
+} 
+ 
+ 
+inline Poco::Int8 operator /= (Poco::Int8& other, const Var& da) 
+	/// Division assignment operator for dividing Var with Poco::Int8 
+{ 
+	return other /= da.convert<Poco::Int8>(); 
+} 
+ 
+ 
+inline bool operator == (const Poco::Int8& other, const Var& da) 
+	/// Equality operator for comparing Var with Poco::Int8 
+{ 
+	if (da.isEmpty()) return false; 
+	return other == da.convert<Poco::Int8>(); 
+} 
+ 
+ 
+inline bool operator != (const Poco::Int8& other, const Var& da) 
+	/// Inequality operator for comparing Var with Poco::Int8 
+{ 
+	if (da.isEmpty()) return true; 
+	return other != da.convert<Poco::Int8>(); 
+} 
+ 
+ 
+inline bool operator < (const Poco::Int8& other, const Var& da) 
+	/// Less than operator for comparing Var with Poco::Int8 
+{ 
+	if (da.isEmpty()) return false; 
+	return other < da.convert<Poco::Int8>(); 
+} 
+ 
+ 
+inline bool operator <= (const Poco::Int8& other, const Var& da) 
+	/// Less than or equal operator for comparing Var with Poco::Int8 
+{ 
+	if (da.isEmpty()) return false; 
+	return other <= da.convert<Poco::Int8>(); 
+} 
+ 
+ 
+inline bool operator > (const Poco::Int8& other, const Var& da) 
+	/// Greater than operator for comparing Var with Poco::Int8 
+{ 
+	if (da.isEmpty()) return false; 
+	return other > da.convert<Poco::Int8>(); 
+} 
+ 
+ 
+inline bool operator >= (const Poco::Int8& other, const Var& da) 
+	/// Greater than or equal operator for comparing Var with Poco::Int8 
+{ 
+	if (da.isEmpty()) return false; 
+	return other >= da.convert<Poco::Int8>(); 
+} 
+ 
+ 
+inline Poco::UInt8 operator + (const Poco::UInt8& other, const Var& da) 
+	/// Addition operator for adding Var to Poco::UInt8 
+{ 
+	return other + da.convert<Poco::UInt8>(); 
+} 
+ 
+ 
+inline Poco::UInt8 operator - (const Poco::UInt8& other, const Var& da) 
+	/// Subtraction operator for subtracting Var from Poco::UInt8 
+{ 
+	return other - da.convert<Poco::UInt8>(); 
+} 
+ 
+ 
+inline Poco::UInt8 operator * (const Poco::UInt8& other, const Var& da) 
+	/// Multiplication operator for multiplying Var with Poco::UInt8 
+{ 
+	return other * da.convert<Poco::UInt8>(); 
+} 
+ 
+ 
+inline Poco::UInt8 operator / (const Poco::UInt8& other, const Var& da) 
+	/// Division operator for dividing Var with Poco::UInt8 
+{ 
+	return other / da.convert<Poco::UInt8>(); 
+} 
+ 
+ 
+inline Poco::UInt8 operator += (Poco::UInt8& other, const Var& da) 
+	/// Addition assignment operator for adding Var to Poco::UInt8 
+{ 
+	return other += da.convert<Poco::UInt8>(); 
+} 
+ 
+ 
+inline Poco::UInt8 operator -= (Poco::UInt8& other, const Var& da) 
+	/// Subtraction assignment operator for subtracting Var from Poco::UInt8 
+{ 
+	return other -= da.convert<Poco::UInt8>(); 
+} 
+ 
+ 
+inline Poco::UInt8 operator *= (Poco::UInt8& other, const Var& da) 
+	/// Multiplication assignment operator for multiplying Var with Poco::UInt8 
+{ 
+	return other *= da.convert<Poco::UInt8>(); 
+} 
+ 
+ 
+inline Poco::UInt8 operator /= (Poco::UInt8& other, const Var& da) 
+	/// Division assignment operator for dividing Var with Poco::UInt8 
+{ 
+	return other /= da.convert<Poco::UInt8>(); 
+} 
+ 
+ 
+inline bool operator == (const Poco::UInt8& other, const Var& da) 
+	/// Equality operator for comparing Var with Poco::UInt8 
+{ 
+	if (da.isEmpty()) return false; 
+	return other == da.convert<Poco::UInt8>(); 
+} 
+ 
+ 
+inline bool operator != (const Poco::UInt8& other, const Var& da) 
+	/// Inequality operator for comparing Var with Poco::UInt8 
+{ 
+	if (da.isEmpty()) return true; 
+	return other != da.convert<Poco::UInt8>(); 
+} 
+ 
+ 
+inline bool operator < (const Poco::UInt8& other, const Var& da) 
+	/// Less than operator for comparing Var with Poco::UInt8 
+{ 
+	if (da.isEmpty()) return false; 
+	return other < da.convert<Poco::UInt8>(); 
+} 
+ 
+ 
+inline bool operator <= (const Poco::UInt8& other, const Var& da) 
+	/// Less than or equal operator for comparing Var with Poco::UInt8 
+{ 
+	if (da.isEmpty()) return false; 
+	return other <= da.convert<Poco::UInt8>(); 
+} 
+ 
+ 
+inline bool operator > (const Poco::UInt8& other, const Var& da) 
+	/// Greater than operator for comparing Var with Poco::UInt8 
+{ 
+	if (da.isEmpty()) return false; 
+	return other > da.convert<Poco::UInt8>(); 
+} 
+ 
+ 
+inline bool operator >= (const Poco::UInt8& other, const Var& da) 
+	/// Greater than or equal operator for comparing Var with Poco::UInt8 
+{ 
+	if (da.isEmpty()) return false; 
+	return other >= da.convert<Poco::UInt8>(); 
+} 
+ 
+ 
+inline Poco::Int16 operator + (const Poco::Int16& other, const Var& da) 
+	/// Addition operator for adding Var to Poco::Int16 
+{ 
+	return other + da.convert<Poco::Int16>(); 
+} 
+ 
+ 
+inline Poco::Int16 operator - (const Poco::Int16& other, const Var& da) 
+	/// Subtraction operator for subtracting Var from Poco::Int16 
+{ 
+	return other - da.convert<Poco::Int16>(); 
+} 
+ 
+ 
+inline Poco::Int16 operator * (const Poco::Int16& other, const Var& da) 
+	/// Multiplication operator for multiplying Var with Poco::Int16 
+{ 
+	return other * da.convert<Poco::Int16>(); 
+} 
+ 
+ 
+inline Poco::Int16 operator / (const Poco::Int16& other, const Var& da) 
+	/// Division operator for dividing Var with Poco::Int16 
+{ 
+	return other / da.convert<Poco::Int16>(); 
+} 
+ 
+ 
+inline Poco::Int16 operator += (Poco::Int16& other, const Var& da) 
+	/// Addition assignment operator for adding Var to Poco::Int16 
+{ 
+	return other += da.convert<Poco::Int16>(); 
+} 
+ 
+ 
+inline Poco::Int16 operator -= (Poco::Int16& other, const Var& da) 
+	/// Subtraction assignment operator for subtracting Var from Poco::Int16 
+{ 
+	return other -= da.convert<Poco::Int16>(); 
+} 
+ 
+ 
+inline Poco::Int16 operator *= (Poco::Int16& other, const Var& da) 
+	/// Multiplication assignment operator for multiplying Var with Poco::Int16 
+{ 
+	return other *= da.convert<Poco::Int16>(); 
+} 
+ 
+ 
+inline Poco::Int16 operator /= (Poco::Int16& other, const Var& da) 
+	/// Division assignment operator for dividing Var with Poco::Int16 
+{ 
+	return other /= da.convert<Poco::Int16>(); 
+} 
+ 
+ 
+inline bool operator == (const Poco::Int16& other, const Var& da) 
+	/// Equality operator for comparing Var with Poco::Int16 
+{ 
+	if (da.isEmpty()) return false; 
+	return other == da.convert<Poco::Int16>(); 
+} 
+ 
+ 
+inline bool operator != (const Poco::Int16& other, const Var& da) 
+	/// Inequality operator for comparing Var with Poco::Int16 
+{ 
+	if (da.isEmpty()) return true; 
+	return other != da.convert<Poco::Int16>(); 
+} 
+ 
+ 
+inline bool operator < (const Poco::Int16& other, const Var& da) 
+	/// Less than operator for comparing Var with Poco::Int16 
+{ 
+	if (da.isEmpty()) return false; 
+	return other < da.convert<Poco::Int16>(); 
+} 
+ 
+ 
+inline bool operator <= (const Poco::Int16& other, const Var& da) 
+	/// Less than or equal operator for comparing Var with Poco::Int16 
+{ 
+	if (da.isEmpty()) return false; 
+	return other <= da.convert<Poco::Int16>(); 
+} 
+ 
+ 
+inline bool operator > (const Poco::Int16& other, const Var& da) 
+	/// Greater than operator for comparing Var with Poco::Int16 
+{ 
+	if (da.isEmpty()) return false; 
+	return other > da.convert<Poco::Int16>(); 
+} 
+ 
+ 
+inline bool operator >= (const Poco::Int16& other, const Var& da) 
+	/// Greater than or equal operator for comparing Var with Poco::Int16 
+{ 
+	if (da.isEmpty()) return false; 
+	return other >= da.convert<Poco::Int16>(); 
+} 
+ 
+ 
+inline Poco::UInt16 operator + (const Poco::UInt16& other, const Var& da) 
+	/// Addition operator for adding Var to Poco::UInt16 
+{ 
+	return other + da.convert<Poco::UInt16>(); 
+} 
+ 
+ 
+inline Poco::UInt16 operator - (const Poco::UInt16& other, const Var& da) 
+	/// Subtraction operator for subtracting Var from Poco::UInt16 
+{ 
+	return other - da.convert<Poco::UInt16>(); 
+} 
+ 
+ 
+inline Poco::UInt16 operator * (const Poco::UInt16& other, const Var& da) 
+	/// Multiplication operator for multiplying Var with Poco::UInt16 
+{ 
+	return other * da.convert<Poco::UInt16>(); 
+} 
+ 
+ 
+inline Poco::UInt16 operator / (const Poco::UInt16& other, const Var& da) 
+	/// Division operator for dividing Var with Poco::UInt16 
+{ 
+	return other / da.convert<Poco::UInt16>(); 
+} 
+ 
+ 
+inline Poco::UInt16 operator += (Poco::UInt16& other, const Var& da) 
+	/// Addition assignment operator for adding Var to Poco::UInt16 
+{ 
+	return other += da.convert<Poco::UInt16>(); 
+} 
+ 
+ 
+inline Poco::UInt16 operator -= (Poco::UInt16& other, const Var& da) 
+	/// Subtraction assignment operator for subtracting Var from Poco::UInt16 
+{ 
+	return other -= da.convert<Poco::UInt16>(); 
+} 
+ 
+ 
+inline Poco::UInt16 operator *= (Poco::UInt16& other, const Var& da) 
+	/// Multiplication assignment operator for multiplying Var with Poco::UInt16 
+{ 
+	return other *= da.convert<Poco::UInt16>(); 
+} 
+ 
+ 
+inline Poco::UInt16 operator /= (Poco::UInt16& other, const Var& da) 
+	/// Division assignment operator for dividing Var with Poco::UInt16 
+{ 
+	return other /= da.convert<Poco::UInt16>(); 
+} 
+ 
+ 
+inline bool operator == (const Poco::UInt16& other, const Var& da) 
+	/// Equality operator for comparing Var with Poco::UInt16 
+{ 
+	if (da.isEmpty()) return false; 
+	return other == da.convert<Poco::UInt16>(); 
+} 
+ 
+ 
+inline bool operator != (const Poco::UInt16& other, const Var& da) 
+	/// Inequality operator for comparing Var with Poco::UInt16 
+{ 
+	if (da.isEmpty()) return true; 
+	return other != da.convert<Poco::UInt16>(); 
+} 
+ 
+ 
+inline bool operator < (const Poco::UInt16& other, const Var& da) 
+	/// Less than operator for comparing Var with Poco::UInt16 
+{ 
+	if (da.isEmpty()) return false; 
+	return other < da.convert<Poco::UInt16>(); 
+} 
+ 
+ 
+inline bool operator <= (const Poco::UInt16& other, const Var& da) 
+	/// Less than or equal operator for comparing Var with Poco::UInt16 
+{ 
+	if (da.isEmpty()) return false; 
+	return other <= da.convert<Poco::UInt16>(); 
+} 
+ 
+ 
+inline bool operator > (const Poco::UInt16& other, const Var& da) 
+	/// Greater than operator for comparing Var with Poco::UInt16 
+{ 
+	if (da.isEmpty()) return false; 
+	return other > da.convert<Poco::UInt16>(); 
+} 
+ 
+ 
+inline bool operator >= (const Poco::UInt16& other, const Var& da) 
+	/// Greater than or equal operator for comparing Var with Poco::UInt16 
+{ 
+	if (da.isEmpty()) return false; 
+	return other >= da.convert<Poco::UInt16>(); 
+} 
+ 
+ 
+inline Poco::Int32 operator + (const Poco::Int32& other, const Var& da) 
+	/// Addition operator for adding Var to Poco::Int32 
+{ 
+	return other + da.convert<Poco::Int32>(); 
+} 
+ 
+ 
+inline Poco::Int32 operator - (const Poco::Int32& other, const Var& da) 
+	/// Subtraction operator for subtracting Var from Poco::Int32 
+{ 
+	return other - da.convert<Poco::Int32>(); 
+} 
+ 
+ 
+inline Poco::Int32 operator * (const Poco::Int32& other, const Var& da) 
+	/// Multiplication operator for multiplying Var with Poco::Int32 
+{ 
+	return other * da.convert<Poco::Int32>(); 
+} 
+ 
+ 
+inline Poco::Int32 operator / (const Poco::Int32& other, const Var& da) 
+	/// Division operator for dividing Var with Poco::Int32 
+{ 
+	return other / da.convert<Poco::Int32>(); 
+} 
+ 
+ 
+inline Poco::Int32 operator += (Poco::Int32& other, const Var& da) 
+	/// Addition assignment operator for adding Var to Poco::Int32 
+{ 
+	return other += da.convert<Poco::Int32>(); 
+} 
+ 
+ 
+inline Poco::Int32 operator -= (Poco::Int32& other, const Var& da) 
+	/// Subtraction assignment operator for subtracting Var from Poco::Int32 
+{ 
+	return other -= da.convert<Poco::Int32>(); 
+} 
+ 
+ 
+inline Poco::Int32 operator *= (Poco::Int32& other, const Var& da) 
+	/// Multiplication assignment operator for multiplying Var with Poco::Int32 
+{ 
+	return other *= da.convert<Poco::Int32>(); 
+} 
+ 
+ 
+inline Poco::Int32 operator /= (Poco::Int32& other, const Var& da) 
+	/// Division assignment operator for dividing Var with Poco::Int32 
+{ 
+	return other /= da.convert<Poco::Int32>(); 
+} 
+ 
+ 
+inline bool operator == (const Poco::Int32& other, const Var& da) 
+	/// Equality operator for comparing Var with Poco::Int32 
+{ 
+	if (da.isEmpty()) return false; 
+	return other == da.convert<Poco::Int32>(); 
+} 
+ 
+ 
+inline bool operator != (const Poco::Int32& other, const Var& da) 
+	/// Inequality operator for comparing Var with Poco::Int32 
+{ 
+	if (da.isEmpty()) return true; 
+	return other != da.convert<Poco::Int32>(); 
+} 
+ 
+ 
+inline bool operator < (const Poco::Int32& other, const Var& da) 
+	/// Less than operator for comparing Var with Poco::Int32 
+{ 
+	if (da.isEmpty()) return false; 
+	return other < da.convert<Poco::Int32>(); 
+} 
+ 
+ 
+inline bool operator <= (const Poco::Int32& other, const Var& da) 
+	/// Less than or equal operator for comparing Var with Poco::Int32 
+{ 
+	if (da.isEmpty()) return false; 
+	return other <= da.convert<Poco::Int32>(); 
+} 
+ 
+ 
+inline bool operator > (const Poco::Int32& other, const Var& da) 
+	/// Greater than operator for comparing Var with Poco::Int32 
+{ 
+	if (da.isEmpty()) return false; 
+	return other > da.convert<Poco::Int32>(); 
+} 
+ 
+ 
+inline bool operator >= (const Poco::Int32& other, const Var& da) 
+	/// Greater than or equal operator for comparing Var with Poco::Int32 
+{ 
+	if (da.isEmpty()) return false; 
+	return other >= da.convert<Poco::Int32>(); 
+} 
+ 
+ 
+inline Poco::UInt32 operator + (const Poco::UInt32& other, const Var& da) 
+	/// Addition operator for adding Var to Poco::UInt32 
+{ 
+	return other + da.convert<Poco::UInt32>(); 
+} 
+ 
+ 
+inline Poco::UInt32 operator - (const Poco::UInt32& other, const Var& da) 
+	/// Subtraction operator for subtracting Var from Poco::UInt32 
+{ 
+	return other - da.convert<Poco::UInt32>(); 
+} 
+ 
+ 
+inline Poco::UInt32 operator * (const Poco::UInt32& other, const Var& da) 
+	/// Multiplication operator for multiplying Var with Poco::UInt32 
+{ 
+	return other * da.convert<Poco::UInt32>(); 
+} 
+ 
+ 
+inline Poco::UInt32 operator / (const Poco::UInt32& other, const Var& da) 
+	/// Division operator for dividing Var with Poco::UInt32 
+{ 
+	return other / da.convert<Poco::UInt32>(); 
+} 
+ 
+ 
+inline Poco::UInt32 operator += (Poco::UInt32& other, const Var& da) 
+	/// Addition assignment operator for adding Var to Poco::UInt32 
+{ 
+	return other += da.convert<Poco::UInt32>(); 
+} 
+ 
+ 
+inline Poco::UInt32 operator -= (Poco::UInt32& other, const Var& da) 
+	/// Subtraction assignment operator for subtracting Var from Poco::UInt32 
+{ 
+	return other -= da.convert<Poco::UInt32>(); 
+} 
+ 
+ 
+inline Poco::UInt32 operator *= (Poco::UInt32& other, const Var& da) 
+	/// Multiplication assignment operator for multiplying Var with Poco::UInt32 
+{ 
+	return other *= da.convert<Poco::UInt32>(); 
+} 
+ 
+ 
+inline Poco::UInt32 operator /= (Poco::UInt32& other, const Var& da) 
+	/// Division assignment operator for dividing Var with Poco::UInt32 
+{ 
+	return other /= da.convert<Poco::UInt32>(); 
+} 
+ 
+ 
+inline bool operator == (const Poco::UInt32& other, const Var& da) 
+	/// Equality operator for comparing Var with Poco::UInt32 
+{ 
+	if (da.isEmpty()) return false; 
+	return other == da.convert<Poco::UInt32>(); 
+} 
+ 
+ 
+inline bool operator != (const Poco::UInt32& other, const Var& da) 
+	/// Inequality operator for comparing Var with Poco::UInt32 
+{ 
+	if (da.isEmpty()) return true; 
+	return other != da.convert<Poco::UInt32>(); 
+} 
+ 
+ 
+inline bool operator < (const Poco::UInt32& other, const Var& da) 
+	/// Less than operator for comparing Var with Poco::UInt32 
+{ 
+	if (da.isEmpty()) return false; 
+	return other < da.convert<Poco::UInt32>(); 
+} 
+ 
+ 
+inline bool operator <= (const Poco::UInt32& other, const Var& da) 
+	/// Less than or equal operator for comparing Var with Poco::UInt32 
+{ 
+	if (da.isEmpty()) return false; 
+	return other <= da.convert<Poco::UInt32>(); 
+} 
+ 
+ 
+inline bool operator > (const Poco::UInt32& other, const Var& da) 
+	/// Greater than operator for comparing Var with Poco::UInt32 
+{ 
+	if (da.isEmpty()) return false; 
+	return other > da.convert<Poco::UInt32>(); 
+} 
+ 
+ 
+inline bool operator >= (const Poco::UInt32& other, const Var& da) 
+	/// Greater than or equal operator for comparing Var with Poco::UInt32 
+{ 
+	if (da.isEmpty()) return false; 
+	return other >= da.convert<Poco::UInt32>(); 
+} 
+ 
+ 
+inline Poco::Int64 operator + (const Poco::Int64& other, const Var& da) 
+	/// Addition operator for adding Var to Poco::Int64 
+{ 
+	return other + da.convert<Poco::Int64>(); 
+} 
+ 
+ 
+inline Poco::Int64 operator - (const Poco::Int64& other, const Var& da) 
+	/// Subtraction operator for subtracting Var from Poco::Int64 
+{ 
+	return other - da.convert<Poco::Int64>(); 
+} 
+ 
+ 
+inline Poco::Int64 operator * (const Poco::Int64& other, const Var& da) 
+	/// Multiplication operator for multiplying Var with Poco::Int64 
+{ 
+	return other * da.convert<Poco::Int64>(); 
+} 
+ 
+ 
+inline Poco::Int64 operator / (const Poco::Int64& other, const Var& da) 
+	/// Division operator for dividing Var with Poco::Int64 
+{ 
+	return other / da.convert<Poco::Int64>(); 
+} 
+ 
+ 
+inline Poco::Int64 operator += (Poco::Int64& other, const Var& da) 
+	/// Addition assignment operator for adding Var to Poco::Int64 
+{ 
+	return other += da.convert<Poco::Int64>(); 
+} 
+ 
+ 
+inline Poco::Int64 operator -= (Poco::Int64& other, const Var& da) 
+	/// Subtraction assignment operator for subtracting Var from Poco::Int64 
+{ 
+	return other -= da.convert<Poco::Int64>(); 
+} 
+ 
+ 
+inline Poco::Int64 operator *= (Poco::Int64& other, const Var& da) 
+	/// Multiplication assignment operator for multiplying Var with Poco::Int64 
+{ 
+	return other *= da.convert<Poco::Int64>(); 
+} 
+ 
+ 
+inline Poco::Int64 operator /= (Poco::Int64& other, const Var& da) 
+	/// Division assignment operator for dividing Var with Poco::Int64 
+{ 
+	return other /= da.convert<Poco::Int64>(); 
+} 
+ 
+ 
+inline bool operator == (const Poco::Int64& other, const Var& da) 
+	/// Equality operator for comparing Var with Poco::Int64 
+{ 
+	if (da.isEmpty()) return false; 
+	return other == da.convert<Poco::Int64>(); 
+} 
+ 
+ 
+inline bool operator != (const Poco::Int64& other, const Var& da) 
+	/// Inequality operator for comparing Var with Poco::Int64 
+{ 
+	if (da.isEmpty()) return true; 
+	return other != da.convert<Poco::Int64>(); 
+} 
+ 
+ 
+inline bool operator < (const Poco::Int64& other, const Var& da) 
+	/// Less than operator for comparing Var with Poco::Int64 
+{ 
+	if (da.isEmpty()) return false; 
+	return other < da.convert<Poco::Int64>(); 
+} 
+ 
+ 
+inline bool operator <= (const Poco::Int64& other, const Var& da) 
+	/// Less than or equal operator for comparing Var with Poco::Int64 
+{ 
+	if (da.isEmpty()) return false; 
+	return other <= da.convert<Poco::Int64>(); 
+} 
+ 
+ 
+inline bool operator > (const Poco::Int64& other, const Var& da) 
+	/// Greater than operator for comparing Var with Poco::Int64 
+{ 
+	if (da.isEmpty()) return false; 
+	return other > da.convert<Poco::Int64>(); 
+} 
+ 
+ 
+inline bool operator >= (const Poco::Int64& other, const Var& da) 
+	/// Greater than or equal operator for comparing Var with Poco::Int64 
+{ 
+	if (da.isEmpty()) return false; 
+	return other >= da.convert<Poco::Int64>(); 
+} 
+ 
+ 
+inline Poco::UInt64 operator + (const Poco::UInt64& other, const Var& da) 
+	/// Addition operator for adding Var to Poco::UInt64 
+{ 
+	return other + da.convert<Poco::UInt64>(); 
+} 
+ 
+ 
+inline Poco::UInt64 operator - (const Poco::UInt64& other, const Var& da) 
+	/// Subtraction operator for subtracting Var from Poco::UInt64 
+{ 
+	return other - da.convert<Poco::UInt64>(); 
+} 
+ 
+ 
+inline Poco::UInt64 operator * (const Poco::UInt64& other, const Var& da) 
+	/// Multiplication operator for multiplying Var with Poco::UInt64 
+{ 
+	return other * da.convert<Poco::UInt64>(); 
+} 
+ 
+ 
+inline Poco::UInt64 operator / (const Poco::UInt64& other, const Var& da) 
+	/// Division operator for dividing Var with Poco::UInt64 
+{ 
+	return other / da.convert<Poco::UInt64>(); 
+} 
+ 
+ 
+inline Poco::UInt64 operator += (Poco::UInt64& other, const Var& da) 
+	/// Addition assignment operator for adding Var to Poco::UInt64 
+{ 
+	return other += da.convert<Poco::UInt64>(); 
+} 
+ 
+ 
+inline Poco::UInt64 operator -= (Poco::UInt64& other, const Var& da) 
+	/// Subtraction assignment operator for subtracting Var from Poco::UInt64 
+{ 
+	return other -= da.convert<Poco::UInt64>(); 
+} 
+ 
+ 
+inline Poco::UInt64 operator *= (Poco::UInt64& other, const Var& da) 
+	/// Multiplication assignment operator for multiplying Var with Poco::UInt64 
+{ 
+	return other *= da.convert<Poco::UInt64>(); 
+} 
+ 
+ 
+inline Poco::UInt64 operator /= (Poco::UInt64& other, const Var& da) 
+	/// Division assignment operator for dividing Var with Poco::UInt64 
+{ 
+	return other /= da.convert<Poco::UInt64>(); 
+} 
+ 
+ 
+inline bool operator == (const Poco::UInt64& other, const Var& da) 
+	/// Equality operator for comparing Var with Poco::UInt64 
+{ 
+	if (da.isEmpty()) return false; 
+	return other == da.convert<Poco::UInt64>(); 
+} 
+ 
+ 
+inline bool operator != (const Poco::UInt64& other, const Var& da) 
+	/// Inequality operator for comparing Var with Poco::UInt64 
+{ 
+	if (da.isEmpty()) return true; 
+	return other != da.convert<Poco::UInt64>(); 
+} 
+ 
+ 
+inline bool operator < (const Poco::UInt64& other, const Var& da) 
+	/// Less than operator for comparing Var with Poco::UInt64 
+{ 
+	if (da.isEmpty()) return false; 
+	return other < da.convert<Poco::UInt64>(); 
+} 
+ 
+ 
+inline bool operator <= (const Poco::UInt64& other, const Var& da) 
+	/// Less than or equal operator for comparing Var with Poco::UInt64 
+{ 
+	if (da.isEmpty()) return false; 
+	return other <= da.convert<Poco::UInt64>(); 
+} 
+ 
+ 
+inline bool operator > (const Poco::UInt64& other, const Var& da) 
+	/// Greater than operator for comparing Var with Poco::UInt64 
+{ 
+	if (da.isEmpty()) return false; 
+	return other > da.convert<Poco::UInt64>(); 
+} 
+ 
+ 
+inline bool operator >= (const Poco::UInt64& other, const Var& da) 
+	/// Greater than or equal operator for comparing Var with Poco::UInt64 
+{ 
+	if (da.isEmpty()) return false; 
+	return other >= da.convert<Poco::UInt64>(); 
+} 
+ 
+ 
+inline float operator + (const float& other, const Var& da) 
+	/// Addition operator for adding Var to float 
+{ 
+	return other + da.convert<float>(); 
+} 
+ 
+ 
+inline float operator - (const float& other, const Var& da) 
+	/// Subtraction operator for subtracting Var from float 
+{ 
+	return other - da.convert<float>(); 
+} 
+ 
+ 
+inline float operator * (const float& other, const Var& da) 
+	/// Multiplication operator for multiplying Var with float 
+{ 
+	return other * da.convert<float>(); 
+} 
+ 
+ 
+inline float operator / (const float& other, const Var& da) 
+	/// Division operator for dividing Var with float 
+{ 
+	return other / da.convert<float>(); 
+} 
+ 
+ 
+inline float operator += (float& other, const Var& da) 
+	/// Addition assignment operator for adding Var to float 
+{ 
+	return other += da.convert<float>(); 
+} 
+ 
+ 
+inline float operator -= (float& other, const Var& da) 
+	/// Subtraction assignment operator for subtracting Var from float 
+{ 
+	return other -= da.convert<float>(); 
+} 
+ 
+ 
+inline float operator *= (float& other, const Var& da) 
+	/// Multiplication assignment operator for multiplying Var with float 
+{ 
+	return other *= da.convert<float>(); 
+} 
+ 
+ 
+inline float operator /= (float& other, const Var& da) 
+	/// Division assignment operator for dividing Var with float 
+{ 
+	return other /= da.convert<float>(); 
+} 
+ 
+ 
+inline bool operator == (const float& other, const Var& da) 
+	/// Equality operator for comparing Var with float 
+{ 
+	if (da.isEmpty()) return false; 
+	return other == da.convert<float>(); 
+} 
+ 
+ 
+inline bool operator != (const float& other, const Var& da) 
+	/// Inequality operator for comparing Var with float 
+{ 
+	if (da.isEmpty()) return true; 
+	return other != da.convert<float>(); 
+} 
+ 
+ 
+inline bool operator < (const float& other, const Var& da) 
+	/// Less than operator for comparing Var with float 
+{ 
+	if (da.isEmpty()) return false; 
+	return other < da.convert<float>(); 
+} 
+ 
+ 
+inline bool operator <= (const float& other, const Var& da) 
+	/// Less than or equal operator for comparing Var with float 
+{ 
+	if (da.isEmpty()) return false; 
+	return other <= da.convert<float>(); 
+} 
+ 
+ 
+inline bool operator > (const float& other, const Var& da) 
+	/// Greater than operator for comparing Var with float 
+{ 
+	if (da.isEmpty()) return false; 
+	return other > da.convert<float>(); 
+} 
+ 
+ 
+inline bool operator >= (const float& other, const Var& da) 
+	/// Greater than or equal operator for comparing Var with float 
+{ 
+	if (da.isEmpty()) return false; 
+	return other >= da.convert<float>(); 
+} 
+ 
+ 
+inline double operator + (const double& other, const Var& da) 
+	/// Addition operator for adding Var to double 
+{ 
+	return other + da.convert<double>(); 
+} 
+ 
+ 
+inline double operator - (const double& other, const Var& da) 
+	/// Subtraction operator for subtracting Var from double 
+{ 
+	return other - da.convert<double>(); 
+} 
+ 
+ 
+inline double operator * (const double& other, const Var& da) 
+	/// Multiplication operator for multiplying Var with double 
+{ 
+	return other * da.convert<double>(); 
+} 
+ 
+ 
+inline double operator / (const double& other, const Var& da) 
+	/// Division operator for dividing Var with double 
+{ 
+	return other / da.convert<double>(); 
+} 
+ 
+ 
+inline double operator += (double& other, const Var& da) 
+	/// Addition assignment operator for adding Var to double 
+{ 
+	return other += da.convert<double>(); 
+} 
+ 
+ 
+inline double operator -= (double& other, const Var& da) 
+	/// Subtraction assignment operator for subtracting Var from double 
+{ 
+	return other -= da.convert<double>(); 
+} 
+ 
+ 
+inline double operator *= (double& other, const Var& da) 
+	/// Multiplication assignment operator for multiplying Var with double 
+{ 
+	return other *= da.convert<double>(); 
+} 
+ 
+ 
+inline double operator /= (double& other, const Var& da) 
+	/// Division assignment operator for dividing Var with double 
+{ 
+	return other /= da.convert<double>(); 
+} 
+ 
+ 
+inline bool operator == (const double& other, const Var& da) 
+	/// Equality operator for comparing Var with double 
+{ 
+	if (da.isEmpty()) return false; 
+	return other == da.convert<double>(); 
+} 
+ 
+ 
+inline bool operator != (const double& other, const Var& da) 
+	/// Inequality operator for comparing Var with double 
+{ 
+	if (da.isEmpty()) return true; 
+	return other != da.convert<double>(); 
+} 
+ 
+ 
+inline bool operator < (const double& other, const Var& da) 
+	/// Less than operator for comparing Var with double 
+{ 
+	if (da.isEmpty()) return false; 
+	return other < da.convert<double>(); 
+} 
+ 
+ 
+inline bool operator <= (const double& other, const Var& da) 
+	/// Less than or equal operator for comparing Var with double 
+{ 
+	if (da.isEmpty()) return false; 
+	return other <= da.convert<double>(); 
+} 
+ 
+ 
+inline bool operator > (const double& other, const Var& da) 
+	/// Greater than operator for comparing Var with double 
+{ 
+	if (da.isEmpty()) return false; 
+	return other > da.convert<double>(); 
+} 
+ 
+ 
+inline bool operator >= (const double& other, const Var& da) 
+	/// Greater than or equal operator for comparing Var with double 
+{ 
+	if (da.isEmpty()) return false; 
+	return other >= da.convert<double>(); 
+} 
+ 
+ 
+inline bool operator == (const bool& other, const Var& da) 
+	/// Equality operator for comparing Var with bool 
+{ 
+	if (da.isEmpty()) return false; 
+	return other == da.convert<bool>(); 
+} 
+ 
+ 
+inline bool operator != (const bool& other, const Var& da) 
+	/// Inequality operator for comparing Var with bool 
+{ 
+	if (da.isEmpty()) return true; 
+	return other != da.convert<bool>(); 
+} 
+ 
+ 
+inline bool operator == (const std::string& other, const Var& da) 
+	/// Equality operator for comparing Var with std::string 
+{ 
+	if (da.isEmpty()) return false; 
+	return other == da.convert<std::string>(); 
+} 
+ 
+ 
+inline bool operator != (const std::string& other, const Var& da) 
+	/// Inequality operator for comparing Var with std::string 
+{ 
+	if (da.isEmpty()) return true; 
+	return other != da.convert<std::string>(); 
+} 
+ 
+ 
+inline bool operator == (const UTF16String& other, const Var& da) 
+	/// Equality operator for comparing Var with UTF16String 
+{ 
+	if (da.isEmpty()) return false; 
+	return other == da.convert<UTF16String>(); 
+} 
+ 
+ 
+inline bool operator != (const UTF16String& other, const Var& da) 
+	/// Inequality operator for comparing Var with UTF16String 
+{ 
+	if (da.isEmpty()) return true; 
+	return other != da.convert<UTF16String>(); 
+} 
+ 
+ 
+inline bool operator == (const char* other, const Var& da) 
+	/// Equality operator for comparing Var with const char* 
+{ 
+	if (da.isEmpty()) return false; 
+	return da.convert<std::string>() == other; 
+} 
+ 
+ 
+inline bool operator != (const char* other, const Var& da) 
+	/// Inequality operator for comparing Var with const char* 
+{ 
+	if (da.isEmpty()) return true; 
+	return da.convert<std::string>() != other; 
+} 
+ 
+ 
+#ifndef POCO_LONG_IS_64_BIT 
+ 
+ 
+inline long operator + (const long& other, const Var& da) 
+	/// Addition operator for adding Var to long 
+{ 
+	return other + da.convert<long>(); 
+} 
+ 
+ 
+inline long operator - (const long& other, const Var& da) 
+	/// Subtraction operator for subtracting Var from long 
+{ 
+	return other - da.convert<long>(); 
+} 
+ 
+ 
+inline long operator * (const long& other, const Var& da) 
+	/// Multiplication operator for multiplying Var with long 
+{ 
+	return other * da.convert<long>(); 
+} 
+ 
+ 
+inline long operator / (const long& other, const Var& da) 
+	/// Division operator for dividing Var with long 
+{ 
+	return other / da.convert<long>(); 
+} 
+ 
+ 
+inline long operator += (long& other, const Var& da) 
+	/// Addition assignment operator for adding Var to long 
+{ 
+	return other += da.convert<long>(); 
+} 
+ 
+ 
+inline long operator -= (long& other, const Var& da) 
+	/// Subtraction assignment operator for subtracting Var from long 
+{ 
+	return other -= da.convert<long>(); 
+} 
+ 
+ 
+inline long operator *= (long& other, const Var& da) 
+	/// Multiplication assignment operator for multiplying Var with long 
+{ 
+	return other *= da.convert<long>(); 
+} 
+ 
+ 
+inline long operator /= (long& other, const Var& da) 
+	/// Division assignment operator for dividing Var with long 
+{ 
+	return other /= da.convert<long>(); 
+} 
+ 
+ 
+inline bool operator == (const long& other, const Var& da) 
+	/// Equality operator for comparing Var with long 
+{ 
+	if (da.isEmpty()) return false; 
+	return other == da.convert<long>(); 
+} 
+ 
+ 
+inline bool operator != (const long& other, const Var& da) 
+	/// Inequality operator for comparing Var with long 
+{ 
+	if (da.isEmpty()) return true; 
+	return other != da.convert<long>(); 
+} 
+ 
+ 
+inline bool operator < (const long& other, const Var& da) 
+	/// Less than operator for comparing Var with long 
+{ 
+	if (da.isEmpty()) return false; 
+	return other < da.convert<long>(); 
+} 
+ 
+ 
+inline bool operator <= (const long& other, const Var& da) 
+	/// Less than or equal operator for comparing Var with long 
+{ 
+	if (da.isEmpty()) return false; 
+	return other <= da.convert<long>(); 
+} 
+ 
+ 
+inline bool operator > (const long& other, const Var& da) 
+	/// Greater than operator for comparing Var with long 
+{ 
+	if (da.isEmpty()) return false; 
+	return other > da.convert<long>(); 
+} 
+ 
+ 
+inline bool operator >= (const long& other, const Var& da) 
+	/// Greater than or equal operator for comparing Var with long 
+{ 
+	if (da.isEmpty()) return false; 
+	return other >= da.convert<long>(); 
+} 
+ 
+ 
+#endif // POCO_LONG_IS_64_BIT 
+ 
+ 
+} // namespace Dynamic 
+ 
+ 
+//@ deprecated 
+typedef Dynamic::Var DynamicAny; 
+ 
+ 
+} // namespace Poco 
+ 
+ 
+#endif // Foundation_Var_INCLUDED