improved hungarian notation;

added doxygen comments;
cleaned code;
updated TODOs;


git-svn-id: https://svn.kvirc.de/svn/trunk/kvirc@5102 17fca916-40b9-46aa-a4ea-0a15b648b75c

5 files changed, 2096 insertions, 1025 deletions

diff --git a/src/kvirc/kernel/kvi_defaultscript.h b/src/kvirc/kernel/kvi_defaultscript.h
index 04962928e..5ea8ae3c2 100644
--- a/src/kvirc/kernel/kvi_defaultscript.h
+++ b/src/kvirc/kernel/kvi_defaultscript.h
@@ -99,16 +99,20 @@ public:
 
 	/**
 	* \brief Restores the default script
+	*
 	* If this function is suggested by KVIrc, the default script will be wiped out and then
 	* it will be reloaded. Otherwise, when the user wants to restore it, he can choose which
 	* part of the default script have to be restored
+	*
 	* This is an external helper to the real function
+	* \param bSuggest Whether the restore is suggested by KVIrc
 	* \return void
 	*/
 	void restore(bool bSuggest = false);
 
 	/**
 	* \brief Loads the configuration of the default script
+	*
 	* This is an external helper to the real function
 	* \param szConfigFile The file where to load
 	* \return void
@@ -117,6 +121,7 @@ public:
 
 	/**
 	* \brief Saves the configuration of the default script
+	*
 	* This is an external helper to the real function
 	* \param szConfigFile The file to save
 	* \return void
@@ -125,13 +130,17 @@ public:
 private:
 	/**
 	* \brief Restores the default script
+	*
 	* This is the real function
+	* \param bSuggest Whether the restore is suggested by KVIrc
 	* \return void
+	* \todo This function still misses class clearing due to a missing function in class editor
 	*/
 	void restoreInternal(bool bSuggest = false);
 
 	/**
 	* \brief Loads the configuration of the default script
+	*
 	* This is the real function
 	* \param pCfg The configuration file
 	* \return void
@@ -140,6 +149,7 @@ private:
 
 	/**
 	* \brief Saves the configuration of the default script
+	*
 	* This is the real function
 	* \param pCfg The configuration file
 	* \return void
@@ -189,6 +199,7 @@ protected:
 protected slots:
 	/**
 	* \brief Enables or disables all checkboxes
+	*
 	* Called when the user (de)selects the 'All' one
 	* \return void
 	*/
@@ -196,6 +207,7 @@ protected slots:
 
 	/**
 	* \brief Open/close the advanced widget
+	*
 	* Called when the user clicks on 'Advanced...'
 	* \return void
 	*/
@@ -203,6 +215,7 @@ protected slots:
 
 	/**
 	* \brief Accepts the dialog
+	*
 	* Called when the user clicks on 'Ok'
 	* \return void
 	*/
@@ -210,6 +223,7 @@ protected slots:
 
 	/**
 	* \brief Rejects the dialog
+	*
 	* Called when the user clicks on 'Cancel' or closes the dialog using the window
 	* decoration or pressing ESC
 	* \return void
diff --git a/src/kvirc/kvs/kvi_kvs_variant.cpp b/src/kvirc/kvs/kvi_kvs_variant.cpp
index fc5d4f52d..1e7bad192 100644
--- a/src/kvirc/kvs/kvi_kvs_variant.cpp
+++ b/src/kvirc/kvs/kvi_kvs_variant.cpp
@@ -4,7 +4,7 @@
 //   Creation date : Tue 07 Oct 2003 04:01:19 by Szymon Stefanek
 //
 //   This file is part of the KVIrc IRC client distribution
-//   Copyright (C) 2003-2008 Szymon Stefanek <pragma at kvirc dot net>
+//   Copyright (C) 2003-2010 Szymon Stefanek <pragma at kvirc dot net>
 //
 //   This program is FREE software. You can redistribute it and/or
 //   modify it under the terms of the GNU General Public License
@@ -22,8 +22,6 @@
 //
 //=============================================================================
 
-
-
 #include "kvi_kvs_variant.h"
 #include "kvi_kvs_arraycast.h"
 #include "kvi_kvs_hash.h"
@@ -31,6 +29,214 @@
 
 #include <math.h>
 
+int KviKvsVariantComparison::compareIntString(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	kvs_real_t dReal;
+
+	if(pV1->m_pData->m_u.iInt == 0)
+	{
+		if(pV2->m_pData->m_u.pString->isEmpty())
+			return KviKvsVariantComparison::Equal;
+	}
+
+	if(pV2->asReal(dReal))
+	{
+		if(((kvs_real_t)pV1->m_pData->m_u.iInt) == dReal)
+			return KviKvsVariantComparison::Equal;
+		if(((kvs_real_t)pV1->m_pData->m_u.iInt) > dReal)
+			return KviKvsVariantComparison::FirstGreater;
+		return KviKvsVariantComparison::SecondGreater;
+	}
+
+	// compare as strings instead
+	QString szString;
+	pV1->asString(szString);
+	return -1 * KviQString::cmpCI(szString,*(pV2->m_pData->m_u.pString));
+}
+
+int KviKvsVariantComparison::compareIntReal(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(((kvs_real_t)pV1->m_pData->m_u.iInt) == *(pV2->m_pData->m_u.pReal))
+		return KviKvsVariantComparison::Equal;
+	if(((kvs_real_t)pV1->m_pData->m_u.iInt) > *(pV2->m_pData->m_u.pReal))
+		return KviKvsVariantComparison::FirstGreater;
+	return KviKvsVariantComparison::SecondGreater;
+}
+
+int KviKvsVariantComparison::compareIntBool(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(pV1->m_pData->m_u.iInt == 0)
+		return pV2->m_pData->m_u.bBoolean ? KviKvsVariantComparison::SecondGreater : KviKvsVariantComparison::Equal;
+	return pV2->m_pData->m_u.bBoolean ? KviKvsVariantComparison::Equal : KviKvsVariantComparison::FirstGreater;
+}
+
+int KviKvsVariantComparison::compareIntHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(pV1->m_pData->m_u.iInt == 0)
+		return pV2->m_pData->m_u.pHash->isEmpty() ? KviKvsVariantComparison::Equal : KviKvsVariantComparison::SecondGreater;
+	return KviKvsVariantComparison::FirstGreater;
+}
+
+int KviKvsVariantComparison::compareIntArray(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(pV1->m_pData->m_u.iInt == 0)
+		return pV2->m_pData->m_u.pArray->isEmpty() ? KviKvsVariantComparison::Equal : KviKvsVariantComparison::SecondGreater;
+	return KviKvsVariantComparison::FirstGreater;
+}
+
+int KviKvsVariantComparison::compareIntHObject(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(pV1->m_pData->m_u.iInt == 0.0)
+		return (pV2->m_pData->m_u.hObject == (kvs_hobject_t)0) ? KviKvsVariantComparison::Equal : KviKvsVariantComparison::FirstGreater;
+	return KviKvsVariantComparison::SecondGreater;
+}
+
+int KviKvsVariantComparison::compareRealHObject(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(*(pV1->m_pData->m_u.pReal) == 0.0)
+		return (pV2->m_pData->m_u.hObject == (kvs_hobject_t)0) ? KviKvsVariantComparison::Equal : KviKvsVariantComparison::FirstGreater;
+	return KviKvsVariantComparison::SecondGreater;
+}
+
+int KviKvsVariantComparison::compareRealString(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	kvs_real_t dReal;
+
+	if(*(pV1->m_pData->m_u.pReal) == 0.0)
+	{
+		if(pV2->m_pData->m_u.pString->isEmpty())
+			return KviKvsVariantComparison::Equal;
+	}
+
+	if(pV2->asReal(dReal))
+	{
+		if(*(pV1->m_pData->m_u.pReal) == dReal)
+			return KviKvsVariantComparison::Equal;
+		if(*(pV1->m_pData->m_u.pReal) > dReal)
+			return KviKvsVariantComparison::FirstGreater;
+		return KviKvsVariantComparison::SecondGreater;
+	}
+
+	// compare as strings instead
+	QString szString;
+	pV1->asString(szString);
+	return -1 * KviQString::cmpCI(szString,*(pV2->m_pData->m_u.pString));
+}
+
+int KviKvsVariantComparison::compareRealBool(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(*(pV1->m_pData->m_u.pReal) == 0.0)
+		return pV2->m_pData->m_u.bBoolean ? KviKvsVariantComparison::SecondGreater : KviKvsVariantComparison::Equal;
+	return pV2->m_pData->m_u.bBoolean ? KviKvsVariantComparison::Equal : KviKvsVariantComparison::FirstGreater;
+}
+
+int KviKvsVariantComparison::compareRealHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(*(pV1->m_pData->m_u.pReal) == 0)
+		return pV2->m_pData->m_u.pHash->isEmpty() ? KviKvsVariantComparison::Equal : KviKvsVariantComparison::SecondGreater;
+	return KviKvsVariantComparison::FirstGreater;
+}
+
+int KviKvsVariantComparison::compareRealArray(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(*(pV1->m_pData->m_u.pReal) == 0)
+		return pV2->m_pData->m_u.pArray->isEmpty() ? KviKvsVariantComparison::Equal : KviKvsVariantComparison::SecondGreater;
+	return KviKvsVariantComparison::FirstGreater;
+}
+
+int KviKvsVariantComparison::compareStringHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(pV1->m_pData->m_u.pString->isEmpty())
+	{
+		return pV2->m_pData->m_u.pHash->isEmpty() ? KviKvsVariantComparison::Equal : KviKvsVariantComparison::SecondGreater;
+	}
+	return KviKvsVariantComparison::FirstGreater;
+}
+
+int KviKvsVariantComparison::compareStringArray(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(pV1->m_pData->m_u.pString->isEmpty())
+	{
+		return pV2->m_pData->m_u.pArray->isEmpty() ? KviKvsVariantComparison::Equal : KviKvsVariantComparison::SecondGreater;
+	}
+	return KviKvsVariantComparison::FirstGreater;
+}
+
+int KviKvsVariantComparison::compareStringHObject(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	kvs_real_t dReal;
+
+	if(pV2->m_pData->m_u.hObject == (kvs_hobject_t)0)
+	{
+		if(pV1->m_pData->m_u.pString->isEmpty())
+			return KviKvsVariantComparison::Equal;
+
+		if(pV1->asReal(dReal))
+		{
+			if(dReal == 0)
+				return KviKvsVariantComparison::Equal;
+		}
+	}
+
+	return KviKvsVariantComparison::FirstGreater;
+}
+
+int KviKvsVariantComparison::compareBoolString(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(pV2->isEqualToNothing())
+		return pV1->m_pData->m_u.bBoolean ? KviKvsVariantComparison::FirstGreater : KviKvsVariantComparison::Equal;
+	else
+		return pV1->m_pData->m_u.bBoolean ? KviKvsVariantComparison::Equal : KviKvsVariantComparison::FirstGreater;
+}
+
+int KviKvsVariantComparison::compareBoolHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(pV1->m_pData->m_u.bBoolean)
+		return pV2->m_pData->m_u.pHash->isEmpty() ? KviKvsVariantComparison::FirstGreater : KviKvsVariantComparison::Equal;
+	else
+		return pV2->m_pData->m_u.pHash->isEmpty() ? KviKvsVariantComparison::Equal : KviKvsVariantComparison::SecondGreater;
+}
+
+int KviKvsVariantComparison::compareBoolArray(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(pV1->m_pData->m_u.bBoolean)
+		return pV2->m_pData->m_u.pArray->isEmpty() ? KviKvsVariantComparison::FirstGreater : KviKvsVariantComparison::Equal;
+	else
+		return pV2->m_pData->m_u.pArray->isEmpty() ? KviKvsVariantComparison::Equal : KviKvsVariantComparison::SecondGreater;
+}
+
+int KviKvsVariantComparison::compareBoolHObject(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(pV1->m_pData->m_u.bBoolean)
+		return pV2->m_pData->m_u.hObject == ((kvs_hobject_t)0) ? KviKvsVariantComparison::FirstGreater : KviKvsVariantComparison::Equal;
+	else
+		return pV2->m_pData->m_u.hObject == ((kvs_hobject_t)0) ? KviKvsVariantComparison::Equal : KviKvsVariantComparison::SecondGreater;
+}
+
+int KviKvsVariantComparison::compareArrayHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(pV1->m_pData->m_u.pArray->size() > pV2->m_pData->m_u.pHash->size())
+		return KviKvsVariantComparison::FirstGreater;
+	if(pV1->m_pData->m_u.pArray->size() == pV2->m_pData->m_u.pHash->size())
+		return KviKvsVariantComparison::Equal;
+	return KviKvsVariantComparison::SecondGreater;
+}
+
+int KviKvsVariantComparison::compareHObjectHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(pV2->m_pData->m_u.pHash->isEmpty())
+		return pV1->m_pData->m_u.hObject == ((kvs_hobject_t)0) ? KviKvsVariantComparison::Equal : KviKvsVariantComparison::SecondGreater;
+	return pV1->m_pData->m_u.hObject == ((kvs_hobject_t)0) ? KviKvsVariantComparison::FirstGreater : KviKvsVariantComparison::Equal;
+}
+
+int KviKvsVariantComparison::compareHObjectArray(const KviKvsVariant * pV1, const KviKvsVariant * pV2)
+{
+	if(pV2->m_pData->m_u.pArray->isEmpty())
+		return pV1->m_pData->m_u.hObject == ((kvs_hobject_t)0) ? KviKvsVariantComparison::Equal : KviKvsVariantComparison::SecondGreater;
+	return pV1->m_pData->m_u.hObject == ((kvs_hobject_t)0) ? KviKvsVariantComparison::FirstGreater : KviKvsVariantComparison::Equal;
+}
+
+
 KviKvsVariant::KviKvsVariant()
 {
 	m_pData = 0;
@@ -42,25 +248,28 @@ KviKvsVariant::KviKvsVariant(QString * pString, bool bEscape)
 	m_pData->m_eType = KviKvsVariantData::String;
 	m_pData->m_uRefs = 1;
 	m_pData->m_u.pString = pString;
-	if(bEscape) KviQString::escapeKvs(m_pData->m_u.pString);
+	if(bEscape)
+		KviQString::escapeKvs(m_pData->m_u.pString);
 }
 
-KviKvsVariant::KviKvsVariant(const QString &szString, bool bEscape)
+KviKvsVariant::KviKvsVariant(const QString & szString, bool bEscape)
 {
 	m_pData = new KviKvsVariantData;
 	m_pData->m_eType = KviKvsVariantData::String;
 	m_pData->m_uRefs = 1;
 	m_pData->m_u.pString = new QString(szString);
-	if(bEscape) KviQString::escapeKvs(m_pData->m_u.pString);
+	if(bEscape)
+		KviQString::escapeKvs(m_pData->m_u.pString);
 }
 
-KviKvsVariant::KviKvsVariant(const char * szString, bool bEscape)
+KviKvsVariant::KviKvsVariant(const char * pcString, bool bEscape)
 {
 	m_pData = new KviKvsVariantData;
 	m_pData->m_eType = KviKvsVariantData::String;
 	m_pData->m_uRefs = 1;
-	m_pData->m_u.pString = new QString(QString::fromUtf8(szString));
-	if(bEscape) KviQString::escapeKvs(m_pData->m_u.pString);
+	m_pData->m_u.pString = new QString(QString::fromUtf8(pcString));
+	if(bEscape)
+		KviQString::escapeKvs(m_pData->m_u.pString);
 }
 
 KviKvsVariant::KviKvsVariant(KviKvsArray * pArray)
@@ -104,12 +313,12 @@ KviKvsVariant::KviKvsVariant(bool bBoolean)
 	m_pData->m_u.bBoolean = bBoolean;
 }
 
-KviKvsVariant::KviKvsVariant(kvs_int_t iInteger, bool)
+KviKvsVariant::KviKvsVariant(kvs_int_t iInt, bool)
 {
 	m_pData = new KviKvsVariantData;
 	m_pData->m_eType = KviKvsVariantData::Integer;
 	m_pData->m_uRefs = 1;
-	m_pData->m_u.iInteger = iInteger;
+	m_pData->m_u.iInt = iInt;
 }
 
 KviKvsVariant::KviKvsVariant(kvs_hobject_t hObject)
@@ -120,19 +329,28 @@ KviKvsVariant::KviKvsVariant(kvs_hobject_t hObject)
 	m_pData->m_u.hObject = hObject;
 }
 
-KviKvsVariant::KviKvsVariant(const KviKvsVariant &v)
+KviKvsVariant::KviKvsVariant(const KviKvsVariant & variant)
 {
-	m_pData = v.m_pData;
-	if(m_pData)m_pData->m_uRefs++;
+	m_pData = variant.m_pData;
+	if(m_pData)
+		m_pData->m_uRefs++;
 }
 
 #define DELETE_VARIANT_CONTENTS \
 	switch(m_pData->m_eType) \
 	{ \
-		case KviKvsVariantData::Array: delete m_pData->m_u.pArray; break; \
-		case KviKvsVariantData::Hash: delete m_pData->m_u.pHash; break; \
-		case KviKvsVariantData::String: delete m_pData->m_u.pString; break; \
-		case KviKvsVariantData::Real: delete m_pData->m_u.pReal; break; \
+		case KviKvsVariantData::Array: \
+			delete m_pData->m_u.pArray; \
+		break; \
+		case KviKvsVariantData::Hash: \
+			delete m_pData->m_u.pHash; \
+		break; \
+		case KviKvsVariantData::String: \
+			delete m_pData->m_u.pString; \
+		break; \
+		case KviKvsVariantData::Real: \
+			delete m_pData->m_u.pReal; \
+		break; \
 		default: /* make gcc happy */ break; \
 	}
 
@@ -176,7 +394,7 @@ void KviKvsVariant::setString(QString * pString)
 	m_pData->m_u.pString = pString;
 }
 
-void KviKvsVariant::setString(const QString &szString)
+void KviKvsVariant::setString(const QString & szString)
 {
 	RENEW_VARIANT_DATA
 	m_pData->m_eType = KviKvsVariantData::String;
@@ -212,11 +430,11 @@ void KviKvsVariant::setReal(kvs_real_t * pReal)
 	m_pData->m_u.pReal = pReal;
 }
 
-void KviKvsVariant::setInteger(kvs_int_t iInteger)
+void KviKvsVariant::setInteger(kvs_int_t iInt)
 {
 	RENEW_VARIANT_DATA
 	m_pData->m_eType = KviKvsVariantData::Integer;
-	m_pData->m_u.iInteger = iInteger;
+	m_pData->m_u.iInt = iInt;
 }
 
 void KviKvsVariant::setArray(KviKvsArray * pArray)
@@ -251,13 +469,22 @@ void KviKvsVariant::setNothing()
 
 bool KviKvsVariant::isEmpty() const
 {
-	if(!m_pData)return true;
+	if(!m_pData)
+		return true;
 	switch(m_pData->m_eType)
 	{
-		case KviKvsVariantData::String: return m_pData->m_u.pString->isEmpty(); break;
-		case KviKvsVariantData::Array: return m_pData->m_u.pArray->isEmpty(); break;
-		case KviKvsVariantData::Hash: return m_pData->m_u.pHash->isEmpty(); break;
-		case KviKvsVariantData::HObject: return m_pData->m_u.hObject == 0; break;
+		case KviKvsVariantData::String:
+			return m_pData->m_u.pString->isEmpty();
+		break;
+		case KviKvsVariantData::Array:
+			return m_pData->m_u.pArray->isEmpty();
+		break;
+		case KviKvsVariantData::Hash:
+			return m_pData->m_u.pHash->isEmpty();
+		break;
+		case KviKvsVariantData::HObject:
+			return m_pData->m_u.hObject == 0;
+		break;
 		default: /* make gcc happy */ break;
 	}
 	return false;
@@ -265,35 +492,52 @@ bool KviKvsVariant::isEmpty() const
 
 bool KviKvsVariant::asBoolean() const
 {
-	if(!m_pData)return false;
+	if(!m_pData)
+		return false;
 	switch(m_pData->m_eType)
 	{
-		case KviKvsVariantData::Boolean: return m_pData->m_u.bBoolean; break;
+		case KviKvsVariantData::Boolean:
+			return m_pData->m_u.bBoolean;
+		break;
 		case KviKvsVariantData::String:
 		{
-			if(m_pData->m_u.pString->isEmpty())return false;
+			if(m_pData->m_u.pString->isEmpty())
+				return false;
+			
 			// check integer or real values
 			bool bOk;
 			kvs_int_t iVal = (kvs_int_t)KviQString::toI64(*(m_pData->m_u.pString),&bOk);
-			if(bOk)return iVal;
+			if(bOk)
+				return iVal;
 			kvs_real_t dVal = m_pData->m_u.pString->toDouble(&bOk);
-			if(bOk)return (dVal != 0.0);
+			if(bOk)
+				return (dVal != 0.0);
 			// non number, non empty
 			return true;
 		}
 		break;
-		case KviKvsVariantData::Integer: return m_pData->m_u.iInteger; break;
-		case KviKvsVariantData::Real: return *(m_pData->m_u.pReal) != 0.0; break;
-		case KviKvsVariantData::Array: return !(m_pData->m_u.pArray->isEmpty()); break;
-		case KviKvsVariantData::Hash: return !(m_pData->m_u.pHash->isEmpty()); break;
-		case KviKvsVariantData::HObject: return m_pData->m_u.hObject; break;
+		case KviKvsVariantData::Integer:
+			return m_pData->m_u.iInt;
+		break;
+		case KviKvsVariantData::Real:
+			return *(m_pData->m_u.pReal) != 0.0;
+		break;
+		case KviKvsVariantData::Array:
+			return !(m_pData->m_u.pArray->isEmpty());
+		break;
+		case KviKvsVariantData::Hash:
+			return !(m_pData->m_u.pHash->isEmpty());
+		break;
+		case KviKvsVariantData::HObject:
+			return m_pData->m_u.hObject;
+		break;
 		default: /* make gcc happy */ break;
 	}
 	qDebug("WARNING: invalid variant type %d in KviKvsVariant::asBoolean()",m_pData->m_eType);
 	return false;
 }
 
-bool KviKvsVariant::asHObject(kvs_hobject_t &hObject) const
+bool KviKvsVariant::asHObject(kvs_hobject_t & hObject) const
 {
 	if(!m_pData)
 	{
@@ -308,7 +552,7 @@ bool KviKvsVariant::asHObject(kvs_hobject_t &hObject) const
 			return true;
 		break;
 		case KviKvsVariantData::Integer:
-			if(m_pData->m_u.iInteger == 0)
+			if(m_pData->m_u.iInt == 0)
 			{
 				hObject = 0;
 				return true;
@@ -334,103 +578,110 @@ bool KviKvsVariant::asHObject(kvs_hobject_t &hObject) const
 	return false;
 }
 
-bool KviKvsVariant::asNumber(KviKvsNumber &n) const
+bool KviKvsVariant::asNumber(KviKvsNumber & number) const
 {
-	if(!m_pData)return false;
+	if(!m_pData)
+		return false;
 
 	if(isInteger())
 	{
-		n.m_u.iInteger = m_pData->m_u.iInteger;
-		n.m_type = KviKvsNumber::Integer;
+		number.m_u.iInt = m_pData->m_u.iInt;
+		number.m_type = KviKvsNumber::Integer;
 		return true;
 	}
+
 	if(isReal())
 	{
-		n.m_u.dReal = *(m_pData->m_u.pReal);
-		n.m_type = KviKvsNumber::Real;
+		number.m_u.dReal = *(m_pData->m_u.pReal);
+		number.m_type = KviKvsNumber::Real;
 		return true;
 	}
-	if(asInteger(n.m_u.iInteger))
+
+	if(asInteger(number.m_u.iInt))
 	{
-		n.m_type = KviKvsNumber::Integer;
+		number.m_type = KviKvsNumber::Integer;
 		return true;
 	}
-	if(asReal(n.m_u.dReal))
+
+	if(asReal(number.m_u.dReal))
 	{
-		n.m_type = KviKvsNumber::Real;
+		number.m_type = KviKvsNumber::Real;
 		return true;
 	}
 	return false;
 }
 
-void KviKvsVariant::castToNumber(KviKvsNumber &n) const
+void KviKvsVariant::castToNumber(KviKvsNumber & number) const
 {
 	if(!m_pData)
 	{
-		n.m_u.iInteger = 0;
-		n.m_type = KviKvsNumber::Integer;
+		number.m_u.iInt = 0;
+		number.m_type = KviKvsNumber::Integer;
 		return;
 	}
 
 	if(isInteger())
 	{
-		n.m_u.iInteger = m_pData->m_u.iInteger;
-		n.m_type = KviKvsNumber::Integer;
+		number.m_u.iInt = m_pData->m_u.iInt;
+		number.m_type = KviKvsNumber::Integer;
 		return;
 	}
+
 	if(isReal())
 	{
-		n.m_u.dReal = *(m_pData->m_u.pReal);
-		n.m_type = KviKvsNumber::Real;
+		number.m_u.dReal = *(m_pData->m_u.pReal);
+		number.m_type = KviKvsNumber::Real;
 		return;
 	}
-	if(asInteger(n.m_u.iInteger))
+
+	if(asInteger(number.m_u.iInt))
 	{
-		n.m_type = KviKvsNumber::Integer;
+		number.m_type = KviKvsNumber::Integer;
 		return;
 	}
-	if(asReal(n.m_u.dReal))
+
+	if(asReal(number.m_u.dReal))
 	{
-		n.m_type = KviKvsNumber::Real;
+		number.m_type = KviKvsNumber::Real;
 		return;
 	}
-	castToInteger(n.m_u.iInteger);
-	n.m_type = KviKvsNumber::Integer;
+	castToInteger(number.m_u.iInt);
+	number.m_type = KviKvsNumber::Integer;
 }
 
-void KviKvsVariant::castToArray(KviKvsArrayCast *c) const
+void KviKvsVariant::castToArray(KviKvsArrayCast * pCast) const
 {
 	if(!m_pData)
 	{
-		c->set(new KviKvsArray(),true);
+		pCast->set(new KviKvsArray(),true);
 		return;
 	}
 
 	switch(m_pData->m_eType)
 	{
 		case KviKvsVariantData::Array:
-			c->set(m_pData->m_u.pArray,false);
+			pCast->set(m_pData->m_u.pArray,false);
 		break;
 		case KviKvsVariantData::Hash:
 		{
 			KviPointerHashTableIterator<QString,KviKvsVariant> it(*(m_pData->m_u.pHash->dict()));
-			KviKvsArray * a = new KviKvsArray();
+			KviKvsArray * pArray = new KviKvsArray();
 			kvs_int_t idx = 0;
-			while(KviKvsVariant * v = it.current())
+			while(KviKvsVariant * pVariant = it.current())
 			{
-				a->set(idx,new KviKvsVariant(*v));
+				pArray->set(idx,new KviKvsVariant(*pVariant));
 				++it;
 				idx++;
 			}
-			c->set(a,true);
+			pCast->set(pArray,true);
 		}
 		break;
 		default:
 		{
 			// other scalars
-			KviKvsArray * a = new KviKvsArray();
-			a->set(0,new KviKvsVariant(*this));
-			c->set(a,true);
+			KviKvsArray * pArray = new KviKvsArray();
+			pArray->set(0,new KviKvsVariant(*this));
+			pCast->set(pArray,true);
 		}
 		break;
 	}
@@ -452,35 +703,36 @@ void KviKvsVariant::convertToArray()
 		case KviKvsVariantData::Hash:
 		{
 			KviPointerHashTableIterator<QString,KviKvsVariant> it(*(m_pData->m_u.pHash->dict()));
-			KviKvsArray * a = new KviKvsArray();
+			KviKvsArray * pArray = new KviKvsArray();
 			kvs_int_t idx = 0;
-			while(KviKvsVariant * v = it.current())
+			while(KviKvsVariant * pVariant = it.current())
 			{
-				a->set(idx,new KviKvsVariant(*v));
+				pArray->set(idx,new KviKvsVariant(*pVariant));
 				++it;
 				idx++;
 			}
-			setArray(a);
+			setArray(pArray);
 		}
 		break;
 		default:
 		{
 			// other scalars
-			KviKvsArray * a = new KviKvsArray();
-			a->set(0,new KviKvsVariant(*this));
-			setArray(a);
+			KviKvsArray * pArray = new KviKvsArray();
+			pArray->set(0,new KviKvsVariant(*this));
+			setArray(pArray);
 		}
 		break;
 	}
 }
 
-bool KviKvsVariant::asInteger(kvs_int_t &iVal) const
+bool KviKvsVariant::asInteger(kvs_int_t & iVal) const
 {
-	if(!m_pData)return false;
+	if(!m_pData)
+		return false;
 	switch(m_pData->m_eType)
 	{
 		case KviKvsVariantData::Integer:
-			iVal = m_pData->m_u.iInteger;
+			iVal = m_pData->m_u.iInt;
 			return true;
 		break;
 		case KviKvsVariantData::String:
@@ -509,7 +761,7 @@ bool KviKvsVariant::asInteger(kvs_int_t &iVal) const
 	return false;
 }
 
-void KviKvsVariant::castToInteger(kvs_int_t &iVal) const
+void KviKvsVariant::castToInteger(kvs_int_t & iVal) const
 {
 	if(!m_pData)
 	{
@@ -519,7 +771,7 @@ void KviKvsVariant::castToInteger(kvs_int_t &iVal) const
 	switch(m_pData->m_eType)
 	{
 		case KviKvsVariantData::Integer:
-			iVal = m_pData->m_u.iInteger;
+			iVal = m_pData->m_u.iInt;
 		break;
 		case KviKvsVariantData::Boolean:
 			iVal = m_pData->m_u.bBoolean ? 1 : 0;
@@ -531,7 +783,8 @@ void KviKvsVariant::castToInteger(kvs_int_t &iVal) const
 		{
 			bool bOk;
 			iVal = (kvs_int_t)KviQString::toI64(*(m_pData->m_u.pString),&bOk);
-			if(bOk)return;
+			if(bOk)
+				return;
 			iVal = m_pData->m_u.pString->length();
 		}
 		break;
@@ -553,11 +806,12 @@ void KviKvsVariant::castToInteger(kvs_int_t &iVal) const
 
 bool KviKvsVariant::asReal(kvs_real_t & dVal) const
 {
-	if(!m_pData)return false;
+	if(!m_pData)
+		return false;
 	switch(m_pData->m_eType)
 	{
 		case KviKvsVariantData::Integer:
-			dVal = m_pData->m_u.iInteger;
+			dVal = m_pData->m_u.iInt;
 			return true;
 		break;
 		case KviKvsVariantData::String:
@@ -580,7 +834,7 @@ bool KviKvsVariant::asReal(kvs_real_t & dVal) const
 	return false;
 }
 
-void KviKvsVariant::asString(QString &szBuffer) const
+void KviKvsVariant::asString(QString & szBuffer) const
 {
 	if(!m_pData)
 	{
@@ -589,12 +843,23 @@ void KviKvsVariant::asString(QString &szBuffer) const
 	}
 	switch(m_pData->m_eType)
 	{
-		case KviKvsVariantData::String: szBuffer = *(m_pData->m_u.pString); break;
-		case KviKvsVariantData::Array: szBuffer = QString(); m_pData->m_u.pArray->appendAsString(szBuffer); break;
-		case KviKvsVariantData::Hash: szBuffer = QString(); m_pData->m_u.pHash->appendAsString(szBuffer); break;
-		case KviKvsVariantData::Integer:  szBuffer.setNum(m_pData->m_u.iInteger); break;
-		case KviKvsVariantData::Real: szBuffer.setNum(*(m_pData->m_u.pReal)); break;
-		case KviKvsVariantData::Boolean: szBuffer.setNum(m_pData->m_u.bBoolean ? 1 : 0); break;
+		case KviKvsVariantData::String:
+			szBuffer = *(m_pData->m_u.pString);
+		break;
+		case KviKvsVariantData::Array:
+			szBuffer = QString(); m_pData->m_u.pArray->appendAsString(szBuffer);
+		break;
+		case KviKvsVariantData::Hash:
+			szBuffer = QString(); m_pData->m_u.pHash->appendAsString(szBuffer);
+		break;
+		case KviKvsVariantData::Integer:
+			szBuffer.setNum(m_pData->m_u.iInt);
+		break;
+		case KviKvsVariantData::Real:
+			szBuffer.setNum(*(m_pData->m_u.pReal));
+		break;
+		case KviKvsVariantData::Boolean:
+			szBuffer.setNum(m_pData->m_u.bBoolean ? 1 : 0); break;
 		case KviKvsVariantData::HObject:
 			if(m_pData->m_u.hObject)
 				KviQString::sprintf(szBuffer,"object[%lx]",m_pData->m_u.hObject);
@@ -605,72 +870,102 @@ void KviKvsVariant::asString(QString &szBuffer) const
 	}
 }
 
-void KviKvsVariant::appendAsString(QString &szBuffer) const
+void KviKvsVariant::appendAsString(QString & szBuffer) const
 {
-	if(!m_pData)return;
+	if(!m_pData)
+		return;
 	switch(m_pData->m_eType)
 	{
-		case KviKvsVariantData::String: szBuffer.append(*(m_pData->m_u.pString)); break;
-		case KviKvsVariantData::Array: m_pData->m_u.pArray->appendAsString(szBuffer); break;
-		case KviKvsVariantData::Hash: m_pData->m_u.pHash->appendAsString(szBuffer); break;
-		case KviKvsVariantData::Integer:  KviQString::appendNumber(szBuffer,m_pData->m_u.iInteger); break;
-		case KviKvsVariantData::Real: KviQString::appendNumber(szBuffer,*(m_pData->m_u.pReal)); break;
-		case KviKvsVariantData::Boolean: KviQString::appendNumber(szBuffer,m_pData->m_u.bBoolean ? 1 : 0); break;
-		case KviKvsVariantData::HObject: szBuffer.append(m_pData->m_u.hObject ? "object" : "null-object"); break;
+		case KviKvsVariantData::String:
+			szBuffer.append(*(m_pData->m_u.pString));
+		break;
+		case KviKvsVariantData::Array:
+			m_pData->m_u.pArray->appendAsString(szBuffer);
+		break;
+		case KviKvsVariantData::Hash:
+			m_pData->m_u.pHash->appendAsString(szBuffer);
+		break;
+		case KviKvsVariantData::Integer:
+			KviQString::appendNumber(szBuffer,m_pData->m_u.iInt);
+		break;
+		case KviKvsVariantData::Real:
+			KviQString::appendNumber(szBuffer,*(m_pData->m_u.pReal));
+		break;
+		case KviKvsVariantData::Boolean:
+			KviQString::appendNumber(szBuffer,m_pData->m_u.bBoolean ? 1 : 0);
+		break;
+		case KviKvsVariantData::HObject:
+			szBuffer.append(m_pData->m_u.hObject ? "object" : "null-object");
+		break;
 		default: /* make gcc happy */ break;
 	}
 }
 
-void KviKvsVariant::dump(const char * prefix) const
+void KviKvsVariant::dump(const char * pcPrefix) const
 {
 	if(!m_pData)
 	{
-		qDebug("%s Nothing [this=0x%lx]",prefix,(long unsigned int) this);
+		qDebug("%s Nothing [this=0x%lx]",pcPrefix,(long unsigned int)this);
 		return;
 	}
 	switch(m_pData->m_eType)
 	{
-		case KviKvsVariantData::String: qDebug("%s String(%s) [this=0x%lx]",prefix,m_pData->m_u.pString->toUtf8().data(),(long unsigned int)this); break;
-		case KviKvsVariantData::Array: qDebug("%s Array(ptr=0x%lx) [this=0x%lx]",prefix,(long unsigned int)m_pData->m_u.pArray,(long unsigned int)this); break;
-		case KviKvsVariantData::Hash: qDebug("%s Hash(ptr=0x%lx,dict=0x%lx) [this=0x%lx]",prefix,(long unsigned int)m_pData->m_u.pHash,(long unsigned int)m_pData->m_u.pHash->dict(),(long unsigned int)this); break;
-		case KviKvsVariantData::Integer:  qDebug("%s Integer(%d) [this=0x%lx]",prefix,(int) m_pData->m_u.iInteger,(long unsigned int)this); break;
-		case KviKvsVariantData::Real: qDebug("%s Real(%f) [this=0x%lx]",prefix,*(m_pData->m_u.pReal),(long unsigned int)this); break;
-		case KviKvsVariantData::Boolean: qDebug("%s Boolean(%s) [this=0x%lx]",prefix,m_pData->m_u.bBoolean ? "true" : "false",(long unsigned int)this); break;
-		case KviKvsVariantData::HObject: qDebug("%s HObject(%lx) [this=0x%lx]",prefix,(long unsigned int)m_pData->m_u.hObject,(long unsigned int)this); break;
+		case KviKvsVariantData::String:
+			qDebug("%s String(%s) [this=0x%lx]",pcPrefix,m_pData->m_u.pString->toUtf8().data(),(long unsigned int)this);
+		break;
+		case KviKvsVariantData::Array:
+			qDebug("%s Array(ptr=0x%lx) [this=0x%lx]",pcPrefix,(long unsigned int)m_pData->m_u.pArray,(long unsigned int)this);
+		break;
+		case KviKvsVariantData::Hash:
+			qDebug("%s Hash(ptr=0x%lx,dict=0x%lx) [this=0x%lx]",pcPrefix,(long unsigned int)m_pData->m_u.pHash,(long unsigned int)m_pData->m_u.pHash->dict(),(long unsigned int)this);
+		break;
+		case KviKvsVariantData::Integer:
+			qDebug("%s Integer(%d) [this=0x%lx]",pcPrefix,(int) m_pData->m_u.iInt,(long unsigned int)this);
+		break;
+		case KviKvsVariantData::Real:
+			qDebug("%s Real(%f) [this=0x%lx]",pcPrefix,*(m_pData->m_u.pReal),(long unsigned int)this);
+		break;
+		case KviKvsVariantData::Boolean:
+			qDebug("%s Boolean(%s) [this=0x%lx]",pcPrefix,m_pData->m_u.bBoolean ? "true" : "false",(long unsigned int)this);
+		break;
+		case KviKvsVariantData::HObject:
+			qDebug("%s HObject(%lx) [this=0x%lx]",pcPrefix,(long unsigned int)m_pData->m_u.hObject,(long unsigned int)this);
+		break;
 		default: /* make gcc happy */ break;
 	}
 }
 
-void KviKvsVariant::copyFrom(const KviKvsVariant * v)
+void KviKvsVariant::copyFrom(const KviKvsVariant * pVariant)
 {
 	DETACH_CONTENTS
-	m_pData = v->m_pData;
-	if(m_pData)m_pData->m_uRefs++;
+	m_pData = pVariant->m_pData;
+	if(m_pData)
+		m_pData->m_uRefs++;
 }
 
-void KviKvsVariant::copyFrom(const KviKvsVariant &v)
+void KviKvsVariant::copyFrom(const KviKvsVariant & variant)
 {
 	DETACH_CONTENTS
-	m_pData = v.m_pData;
-	if(m_pData)m_pData->m_uRefs++;
-
+	m_pData = variant.m_pData;
+	if(m_pData)
+		m_pData->m_uRefs++;
 }
 
-void KviKvsVariant::takeFrom(KviKvsVariant * v)
+void KviKvsVariant::takeFrom(KviKvsVariant * pVariant)
 {
 	DETACH_CONTENTS
-	m_pData = v->m_pData;
-	v->m_pData = 0;
+	m_pData = pVariant->m_pData;
+	pVariant->m_pData = 0;
 }
 
-void KviKvsVariant::takeFrom(KviKvsVariant &v)
+void KviKvsVariant::takeFrom(KviKvsVariant & variant)
 {
 	DETACH_CONTENTS
-	m_pData = v.m_pData;
-	v.m_pData = 0;
+	m_pData = variant.m_pData;
+	variant.m_pData = 0;
 }
 
-void KviKvsVariant::getTypeName(QString &szBuffer) const
+void KviKvsVariant::getTypeName(QString & szBuffer) const
 {
 	if(!m_pData)
 	{
@@ -679,39 +974,57 @@ void KviKvsVariant::getTypeName(QString &szBuffer) const
 	}
 	switch(m_pData->m_eType)
 	{
-		case KviKvsVariantData::String: szBuffer = "string"; break;
-		case KviKvsVariantData::Hash: szBuffer = "hash"; break;
-		case KviKvsVariantData::Array: szBuffer = "array"; break;
-		case KviKvsVariantData::Real: szBuffer = "real"; break;
-		case KviKvsVariantData::Integer: szBuffer = "integer"; break;
-		case KviKvsVariantData::Boolean: szBuffer = "boolean"; break;
-		case KviKvsVariantData::HObject: szBuffer = "hobject"; break;
-		default: szBuffer = "internal_error"; break;
+		case KviKvsVariantData::String:
+			szBuffer = "string";
+		break;
+		case KviKvsVariantData::Hash:
+			szBuffer = "hash";
+		break;
+		case KviKvsVariantData::Array:
+			szBuffer = "array";
+		break;
+		case KviKvsVariantData::Real:
+			szBuffer = "real"; 
+		break;
+		case KviKvsVariantData::Integer:
+			szBuffer = "integer";
+		break;
+		case KviKvsVariantData::Boolean:
+			szBuffer = "boolean";
+		break;
+		case KviKvsVariantData::HObject:
+			szBuffer = "hobject";
+		break;
+		default:
+			szBuffer = "internal_error";
+		break;
 	}
 }
 
 bool KviKvsVariant::isEqualToNothing() const
 {
-	if(!m_pData)return true;
+	if(!m_pData)
+		return true;
 	switch(m_pData->m_eType)
 	{
 		case KviKvsVariantData::HObject:
 			return (m_pData->m_u.hObject == (kvs_hobject_t)0);
 		break;
 		case KviKvsVariantData::Integer:
-			return (m_pData->m_u.iInteger == 0);
+			return (m_pData->m_u.iInt == 0);
 		break;
 		case KviKvsVariantData::Real:
 			return (*(m_pData->m_u.pReal) == 0.0);
 		break;
 		case KviKvsVariantData::String:
-			{
-				if(m_pData->m_u.pString->isEmpty())return true;
-				kvs_real_t dReal;
-				if(asReal(dReal))
-					return dReal == 0.0;
-				return false;
-			}
+		{
+			if(m_pData->m_u.pString->isEmpty())
+				return true;
+			kvs_real_t dReal;
+			if(asReal(dReal))
+				return dReal == 0.0;
+			return false;
+		}
 		break;
 		case KviKvsVariantData::Boolean:
 			return !m_pData->m_u.bBoolean;
@@ -729,225 +1042,277 @@ bool KviKvsVariant::isEqualToNothing() const
 	return false;
 }
 
-
 #define CMP_THISGREATER -1
 #define CMP_EQUAL 0
 #define CMP_OTHERGREATER 1
 
-class KviKvsVariantComparison
+int KviKvsVariant::compare(const KviKvsVariant * pOther, bool bPreferNumeric) const
 {
-public:
-	static inline int compare_integer_string(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(v1->m_pData->m_u.iInteger == 0)
-		{
-			if(v2->m_pData->m_u.pString->isEmpty())return CMP_EQUAL;
-		}
-		kvs_real_t dReal;
-		if(v2->asReal(dReal))
-		{
-			if(((kvs_real_t)v1->m_pData->m_u.iInteger) == dReal)return CMP_EQUAL;
-			if(((kvs_real_t)v1->m_pData->m_u.iInteger) > dReal)return CMP_THISGREATER;
-			return CMP_OTHERGREATER;
-		}
-		// compare as strings instead
-		QString szString;
-		v1->asString(szString);
-		return -1 * KviQString::cmpCI(szString,*(v2->m_pData->m_u.pString));
-	}
-
-	static inline int compare_integer_real(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(((kvs_real_t)v1->m_pData->m_u.iInteger) == *(v2->m_pData->m_u.pReal))return CMP_EQUAL;
-		if(((kvs_real_t)v1->m_pData->m_u.iInteger) > *(v2->m_pData->m_u.pReal))return CMP_THISGREATER;
-		return CMP_OTHERGREATER;
-	}
-
-	static inline int compare_integer_boolean(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(v1->m_pData->m_u.iInteger == 0)
-			return v2->m_pData->m_u.bBoolean ? CMP_OTHERGREATER : CMP_EQUAL;
-		return v2->m_pData->m_u.bBoolean ? CMP_EQUAL : CMP_THISGREATER;
-	}
-
-	static inline int compare_integer_hash(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(v1->m_pData->m_u.iInteger == 0)
-			return v2->m_pData->m_u.pHash->isEmpty() ? CMP_EQUAL : CMP_OTHERGREATER;
-		return CMP_THISGREATER;
-	}
-
-	static inline int compare_integer_array(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(v1->m_pData->m_u.iInteger == 0)
-			return v2->m_pData->m_u.pArray->isEmpty() ? CMP_EQUAL : CMP_OTHERGREATER;
-		return CMP_THISGREATER;
-	}
-
-	static inline int compare_integer_hobject(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(v1->m_pData->m_u.iInteger == 0.0)
-			return (v2->m_pData->m_u.hObject == (kvs_hobject_t)0) ? CMP_EQUAL : CMP_THISGREATER;
-		return CMP_OTHERGREATER;
-	}
-
-	static inline int compare_real_hobject(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(*(v1->m_pData->m_u.pReal) == 0.0)
-			return (v2->m_pData->m_u.hObject == (kvs_hobject_t)0) ? CMP_EQUAL : CMP_THISGREATER;
-		return CMP_OTHERGREATER;
-	}
-
-	static inline int compare_real_string(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(*(v1->m_pData->m_u.pReal) == 0.0)
-		{
-			if(v2->m_pData->m_u.pString->isEmpty())return CMP_EQUAL;
-		}
-		kvs_real_t dReal;
-		if(v2->asReal(dReal))
-		{
-			if(*(v1->m_pData->m_u.pReal) == dReal)return CMP_EQUAL;
-			if(*(v1->m_pData->m_u.pReal) > dReal)return CMP_THISGREATER;
-			return CMP_OTHERGREATER;
-		}
-		// compare as strings instead
-		QString szString;
-		v1->asString(szString);
-		return -1 * KviQString::cmpCI(szString,*(v2->m_pData->m_u.pString));
-	}
-
-	static inline int compare_real_boolean(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(*(v1->m_pData->m_u.pReal) == 0.0)
-			return v2->m_pData->m_u.bBoolean ? CMP_OTHERGREATER : CMP_EQUAL;
-		return v2->m_pData->m_u.bBoolean ? CMP_EQUAL : CMP_THISGREATER;
-	}
-
-	static inline int compare_real_hash(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(*(v1->m_pData->m_u.pReal) == 0)
-			return v2->m_pData->m_u.pHash->isEmpty() ? CMP_EQUAL : CMP_OTHERGREATER;
-		return CMP_THISGREATER;
-	}
-
-	static inline int compare_real_array(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(*(v1->m_pData->m_u.pReal) == 0)
-			return v2->m_pData->m_u.pArray->isEmpty() ? CMP_EQUAL : CMP_OTHERGREATER;
-		return CMP_THISGREATER;
-	}
-
-	static inline int compare_string_hash(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(v1->m_pData->m_u.pString->isEmpty())
-		{
-			return v2->m_pData->m_u.pHash->isEmpty() ? CMP_EQUAL : CMP_OTHERGREATER;
-		}
-		return CMP_THISGREATER;
-	}
-
-	static inline int compare_string_array(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(v1->m_pData->m_u.pString->isEmpty())
-		{
-			return v2->m_pData->m_u.pArray->isEmpty() ? CMP_EQUAL : CMP_OTHERGREATER;
-		}
-		return CMP_THISGREATER;
-	}
+	if(!pOther)
+		return isEqualToNothing() ? CMP_EQUAL : CMP_THISGREATER;
+	if(!pOther->m_pData)
+		return isEqualToNothing() ? CMP_EQUAL : CMP_THISGREATER;
+	if(!m_pData)
+		return pOther->isEqualToNothing() ? CMP_EQUAL : CMP_OTHERGREATER;
 
-	static inline int compare_string_hobject(const KviKvsVariant * v1,const KviKvsVariant * v2)
+	switch(m_pData->m_eType)
 	{
-		if(v2->m_pData->m_u.hObject == (kvs_hobject_t)0)
-		{
-			if(v1->m_pData->m_u.pString->isEmpty())
-				return CMP_EQUAL;
-			kvs_real_t dReal;
-			if(v1->asReal(dReal))
+		case KviKvsVariantData::HObject:
+			switch(pOther->m_pData->m_eType)
 			{
-				if(dReal == 0)return CMP_EQUAL;
+				case KviKvsVariantData::HObject:
+					if(m_pData->m_u.hObject == pOther->m_pData->m_u.hObject)
+						return CMP_EQUAL;
+					if(m_pData->m_u.hObject == ((kvs_hobject_t)0))
+						return CMP_OTHERGREATER;
+					return CMP_THISGREATER;
+				break;
+				case KviKvsVariantData::Integer:
+					return -1 * KviKvsVariantComparison::compareIntHObject(pOther,this);
+				break;
+				case KviKvsVariantData::Real:
+					return -1 * KviKvsVariantComparison::compareRealHObject(pOther,this);
+				break;
+				case KviKvsVariantData::String:
+					return -1 * KviKvsVariantComparison::compareStringHObject(pOther,this);
+				break;
+				case KviKvsVariantData::Boolean:
+					return -1 * KviKvsVariantComparison::compareBoolHObject(pOther,this);
+				break;
+				case KviKvsVariantData::Hash:
+					return KviKvsVariantComparison::compareHObjectHash(this,pOther);
+				break;
+				case KviKvsVariantData::Array:
+					return KviKvsVariantComparison::compareHObjectArray(this,pOther);
+				break;
+				default: // just make gcc happy
+				break;
 			}
-		}
-
-		return CMP_THISGREATER;
-	}
-
-	static inline int compare_boolean_string(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(v2->isEqualToNothing())
-		{
-			return v1->m_pData->m_u.bBoolean ? CMP_THISGREATER : CMP_EQUAL;
-		} else {
-			return v1->m_pData->m_u.bBoolean ? CMP_EQUAL : CMP_THISGREATER;
-		}
-	}
-
-	static inline int compare_boolean_hash(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(v1->m_pData->m_u.bBoolean)
-			return v2->m_pData->m_u.pHash->isEmpty() ? CMP_THISGREATER : CMP_EQUAL;
-		else
-			return v2->m_pData->m_u.pHash->isEmpty() ? CMP_EQUAL : CMP_OTHERGREATER;
-	}
-
-	static inline int compare_boolean_array(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(v1->m_pData->m_u.bBoolean)
-			return v2->m_pData->m_u.pArray->isEmpty() ? CMP_THISGREATER : CMP_EQUAL;
-		else
-			return v2->m_pData->m_u.pArray->isEmpty() ? CMP_EQUAL : CMP_OTHERGREATER;
-	}
-
-	static inline int compare_boolean_hobject(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(v1->m_pData->m_u.bBoolean)
-			return v2->m_pData->m_u.hObject == ((kvs_hobject_t)0) ? CMP_THISGREATER : CMP_EQUAL;
-		else
-			return v2->m_pData->m_u.hObject == ((kvs_hobject_t)0) ? CMP_EQUAL : CMP_OTHERGREATER;
-	}
-
-	static inline int compare_array_hash(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(v1->m_pData->m_u.pArray->size() > v2->m_pData->m_u.pHash->size())return CMP_THISGREATER;
-		if(v1->m_pData->m_u.pArray->size() == v2->m_pData->m_u.pHash->size())return CMP_EQUAL;
-		return CMP_OTHERGREATER;
-	}
-
-	static inline int compare_hobject_hash(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(v2->m_pData->m_u.pHash->isEmpty())
-			return v1->m_pData->m_u.hObject == ((kvs_hobject_t)0) ? CMP_EQUAL : CMP_OTHERGREATER;
-		return v1->m_pData->m_u.hObject == ((kvs_hobject_t)0) ? CMP_THISGREATER : CMP_EQUAL;
-	}
-
-	static inline int compare_hobject_array(const KviKvsVariant * v1,const KviKvsVariant * v2)
-	{
-		if(v2->m_pData->m_u.pArray->isEmpty())
-			return v1->m_pData->m_u.hObject == ((kvs_hobject_t)0) ? CMP_EQUAL : CMP_OTHERGREATER;
-		return v1->m_pData->m_u.hObject == ((kvs_hobject_t)0) ? CMP_THISGREATER : CMP_EQUAL;
+		break;
+		case KviKvsVariantData::Integer:
+			switch(pOther->m_pData->m_eType)
+			{
+				case KviKvsVariantData::HObject:
+					return KviKvsVariantComparison::compareIntHObject(this,pOther);
+				break;
+				case KviKvsVariantData::Integer:
+					if(m_pData->m_u.iInt == pOther->m_pData->m_u.iInt)
+						return CMP_EQUAL;
+					if(m_pData->m_u.iInt > pOther->m_pData->m_u.iInt)
+						return CMP_THISGREATER;
+					return CMP_OTHERGREATER;
+				break;
+				case KviKvsVariantData::Real:
+					return KviKvsVariantComparison::compareIntReal(this,pOther);
+				break;
+				case KviKvsVariantData::String:
+					return KviKvsVariantComparison::compareIntString(this,pOther);
+				break;
+				case KviKvsVariantData::Boolean:
+					return KviKvsVariantComparison::compareIntBool(this,pOther);
+				break;
+				case KviKvsVariantData::Hash:
+					return KviKvsVariantComparison::compareIntHash(this,pOther);
+				break;
+				case KviKvsVariantData::Array:
+					return KviKvsVariantComparison::compareIntArray(this,pOther);
+				break;
+				default: // just make gcc happy
+				break;
+			}
+		break;
+		case KviKvsVariantData::Real:
+			switch(pOther->m_pData->m_eType)
+			{
+				case KviKvsVariantData::HObject:
+					return KviKvsVariantComparison::compareRealHObject(this,pOther);
+				break;
+				case KviKvsVariantData::Integer:
+					return -1 * KviKvsVariantComparison::compareIntReal(pOther,this);
+				break;
+				case KviKvsVariantData::Real:
+					if(*(m_pData->m_u.pReal) == *(pOther->m_pData->m_u.pReal))
+						return CMP_EQUAL;
+					if(*(m_pData->m_u.pReal) > *(pOther->m_pData->m_u.pReal))
+						return CMP_THISGREATER;
+					return CMP_OTHERGREATER;
+				break;
+				case KviKvsVariantData::String:
+					return KviKvsVariantComparison::compareRealString(this,pOther);
+				break;
+				case KviKvsVariantData::Boolean:
+					return KviKvsVariantComparison::compareRealBool(this,pOther);
+				break;
+				case KviKvsVariantData::Hash:
+					return KviKvsVariantComparison::compareRealHash(this,pOther);
+				break;
+				case KviKvsVariantData::Array:
+					return KviKvsVariantComparison::compareRealArray(this,pOther);
+				break;
+				default: // just make gcc happy
+				break;
+			}
+		break;
+		case KviKvsVariantData::String:
+			switch(pOther->m_pData->m_eType)
+			{
+				case KviKvsVariantData::String:
+					if(bPreferNumeric)
+					{
+						// prefer numeric comparison
+						double dReal1;
+						double dReal2;
+						if(asReal(dReal1))
+						{
+							if(pOther->asReal(dReal2))
+							{
+								if(dReal1 == dReal2)
+									return CMP_EQUAL;
+								if(dReal1 > dReal2)
+									return CMP_THISGREATER;
+								return CMP_OTHERGREATER;
+							}
+						}
+					}
+					return -1 * KviQString::cmpCI(*(m_pData->m_u.pString),*(pOther->m_pData->m_u.pString));
+				case KviKvsVariantData::Real:
+					return -1 * KviKvsVariantComparison::compareRealString(pOther,this);
+				case KviKvsVariantData::Integer:
+					return -1 * KviKvsVariantComparison::compareIntString(pOther,this);
+				case KviKvsVariantData::Boolean:
+					return -1 * KviKvsVariantComparison::compareBoolString(pOther,this);
+				break;
+				case KviKvsVariantData::Hash:
+					return KviKvsVariantComparison::compareStringHash(this,pOther);
+				break;
+				case KviKvsVariantData::Array:
+					return KviKvsVariantComparison::compareStringArray(this,pOther);
+				break;
+				case KviKvsVariantData::HObject:
+					return KviKvsVariantComparison::compareStringHObject(this,pOther);
+				break;
+				default:
+				break;
+			}
+		break;
+		case KviKvsVariantData::Hash:
+			switch(pOther->m_pData->m_eType)
+			{
+				case KviKvsVariantData::String:
+					return -1 * KviKvsVariantComparison::compareStringHash(pOther,this);
+				case KviKvsVariantData::Real:
+					return -1 * KviKvsVariantComparison::compareRealHash(pOther,this);
+				break;
+				case KviKvsVariantData::Integer:
+					return -1 * KviKvsVariantComparison::compareIntHash(pOther,this);
+				break;
+				case KviKvsVariantData::Boolean:
+					return -1 * KviKvsVariantComparison::compareBoolHash(pOther,this);
+				break;
+				case KviKvsVariantData::Hash:
+					if(m_pData->m_u.pHash->size() > pOther->m_pData->m_u.pHash->size())
+						return CMP_THISGREATER;
+					if(m_pData->m_u.pHash->size() == pOther->m_pData->m_u.pHash->size())
+						return CMP_EQUAL;
+					return CMP_OTHERGREATER;
+				break;
+				case KviKvsVariantData::Array:
+					return -1 * KviKvsVariantComparison::compareArrayHash(pOther,this);
+				break;
+				case KviKvsVariantData::HObject:
+					return -1 * KviKvsVariantComparison::compareHObjectHash(pOther,this);
+				break;
+				default:
+				break;
+			}
+		break;
+		case KviKvsVariantData::Array:
+			switch(pOther->m_pData->m_eType)
+			{
+				case KviKvsVariantData::String:
+					return -1 * KviKvsVariantComparison::compareStringArray(pOther,this);
+				case KviKvsVariantData::Real:
+					return -1 * KviKvsVariantComparison::compareRealArray(pOther,this);
+				case KviKvsVariantData::Integer:
+					return -1 * KviKvsVariantComparison::compareIntArray(pOther,this);
+				case KviKvsVariantData::Boolean:
+					return -1 * KviKvsVariantComparison::compareBoolArray(pOther,this);
+				break;
+				case KviKvsVariantData::Hash:
+					return KviKvsVariantComparison::compareArrayHash(this,pOther);
+				break;
+				case KviKvsVariantData::Array:
+					if(m_pData->m_u.pArray->size() > pOther->m_pData->m_u.pArray->size())
+						return CMP_THISGREATER;
+					if(m_pData->m_u.pArray->size() == pOther->m_pData->m_u.pArray->size())
+						return CMP_EQUAL;
+					return CMP_OTHERGREATER;
+				break;
+				case KviKvsVariantData::HObject:
+					return -1 * KviKvsVariantComparison::compareHObjectArray(pOther,this);
+				break;
+				default:
+				break;
+			}
+		break;
+		case KviKvsVariantData::Boolean:
+			switch(pOther->m_pData->m_eType)
+			{
+				case KviKvsVariantData::String:
+					return KviKvsVariantComparison::compareBoolString(this,pOther);
+				break;
+				case KviKvsVariantData::Real:
+					return -1 * KviKvsVariantComparison::compareRealBool(pOther,this);
+				break;
+				case KviKvsVariantData::Integer:
+					return -1 * KviKvsVariantComparison::compareIntBool(pOther,this);
+				break;
+				case KviKvsVariantData::Boolean:
+					if(m_pData->m_u.bBoolean == pOther->m_pData->m_u.bBoolean)
+						return CMP_EQUAL;
+					if(m_pData->m_u.bBoolean)
+						return CMP_THISGREATER;
+					return CMP_OTHERGREATER;
+				break;
+				case KviKvsVariantData::Hash:
+					return KviKvsVariantComparison::compareBoolHash(this,pOther);
+				break;
+				case KviKvsVariantData::Array:
+					return KviKvsVariantComparison::compareBoolArray(this,pOther);
+				break;
+				case KviKvsVariantData::HObject:
+					return KviKvsVariantComparison::compareBoolHObject(this,pOther);
+				break;
+				default:
+				break;
+			}
+		break;
+		default: // should never happen anyway
+		break;
 	}
 
-};
+	return CMP_THISGREATER; // should never happen
+}
 
-void KviKvsVariant::serializeString(QString& buffer)
+void KviKvsVariant::serializeString(QString & szBuffer)
 {
-	buffer.replace('\\',"\\\\");
-	buffer.replace('\n',"\\n");
-	buffer.replace('\r',"\\r");
-	buffer.replace('\b',"\\b");
-	buffer.replace('\t',"\\t");
-	buffer.replace('\f',"\\f");
-	buffer.replace('/',"\\/");
-	buffer.replace('"',"\\\"");
-	buffer.prepend('"');
-	buffer.append('"');
+	szBuffer.replace('\\',"\\\\");
+	szBuffer.replace('\n',"\\n");
+	szBuffer.replace('\r',"\\r");
+	szBuffer.replace('\b',"\\b");
+	szBuffer.replace('\t',"\\t");
+	szBuffer.replace('\f',"\\f");
+	szBuffer.replace('/',"\\/");
+	szBuffer.replace('"',"\\\"");
+	szBuffer.prepend('"');
+	szBuffer.append('"');
 }
 
-void KviKvsVariant::serialize(QString& result)
+void KviKvsVariant::serialize(QString & szResult)
 {
 	if(!m_pData)
 	{
-		result = "null";
+		szResult = "null";
 		return;
 	}
 
@@ -957,265 +1322,350 @@ void KviKvsVariant::serialize(QString& result)
 			//can't serialize objects yet
 		break;
 		case KviKvsVariantData::Integer:
-			result.setNum(m_pData->m_u.iInteger);
+			szResult.setNum(m_pData->m_u.iInt);
 		break;
 		case KviKvsVariantData::Real:
-			result.setNum(*(m_pData->m_u.pReal));
+			szResult.setNum(*(m_pData->m_u.pReal));
 		break;
 		case KviKvsVariantData::String:
-			result = *(m_pData->m_u.pString);
-			serializeString(result);
+			szResult = *(m_pData->m_u.pString);
+			serializeString(szResult);
 		break;
 		case KviKvsVariantData::Boolean:
-			result = m_pData->m_u.bBoolean ? "true" : "false";
+			szResult = m_pData->m_u.bBoolean ? "true" : "false";
 		break;
 		case KviKvsVariantData::Hash:
-			m_pData->m_u.pHash->serialize(result);
+			m_pData->m_u.pHash->serialize(szResult);
 		break;
 		case KviKvsVariantData::Array:
-			m_pData->m_u.pArray->serialize(result);
+			m_pData->m_u.pArray->serialize(szResult);
 		break;
 		case KviKvsVariantData::Nothing:
-			result = "null";
+			szResult = "null";
 		break;
 		default: // just make gcc happy
 		break;
 	}
 }
 
-KviKvsVariant* KviKvsVariant::unserializeTrue(const QChar** aux)
+KviKvsVariant * KviKvsVariant::unserialize(const QString & szBuffer)
+{
+	KviKvsVariant * pResult = 0;
+
+	const QChar * pAux = (const QChar *)szBuffer.constData();
+
+	pResult = unserialize(&pAux);
+
+	if(pAux->unicode())
+	{
+		//strange extra characters?
+		if(pResult)
+			delete pResult;
+		pResult = 0;
+	}
+
+	return pResult;
+}
+
+KviKvsVariant * KviKvsVariant::unserialize(const QChar ** ppAux)
 {
-	if(KviQString::equalCIN(QString("true"),*aux,4))
+	KviKvsVariant * pResult = 0;
+
+	while((*ppAux)->isSpace())
+		(*ppAux)++;
+
+	switch((*ppAux)->unicode())
 	{
-		(*aux)+=4;
-		return new KviKvsVariant(true);
+		case 't':
+			//true
+			pResult = unserializeBool(ppAux,true);
+		break;
+		case 'f':
+			//false
+			pResult = unserializeBool(ppAux,false);
+		break;
+		case 'n':
+			//null
+			pResult = unserializeNull(ppAux);
+		break;
+		case '[':
+			//array
+			pResult = unserializeArray(ppAux);
+		break;
+		case '{':
+			//hash
+			pResult = unserializeHash(ppAux);
+		break;
+		case '"':
+			//string
+			pResult = unserializeString(ppAux);
+		break;
+		case '0':
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':
+		case '-':
+			//real or integer
+			pResult = unserializeNumber(ppAux);
+		break;
+		default:
+			//incorrect value
+			return 0;
 	}
-	return 0;
+
+	while((*ppAux)->isSpace())
+		(*ppAux)++;
+
+	return pResult;
 }
 
-KviKvsVariant* KviKvsVariant::unserializeFalse(const QChar** aux)
+KviKvsVariant * KviKvsVariant::unserializeBool(const QChar ** ppAux, bool bBool)
 {
-	if(KviQString::equalCIN(QString("false"),*aux,5))
+	bool bOk = false;
+
+	if(bBool)
 	{
-		(*aux)+=5;
-		return new KviKvsVariant(false);
+		if(KviQString::equalCIN(QString("true"),*ppAux,4))
+		{
+			(*ppAux) += 4;
+			bOk = true;
+		}
+	} else {
+		if(KviQString::equalCIN(QString("false"),*ppAux,5))
+		{
+			(*ppAux) += 5;
+			bOk = true;
+		}
 	}
+
+	if(bOk)
+		return new KviKvsVariant(bBool);
 	return 0;
 }
 
-KviKvsVariant* KviKvsVariant::unserializeNull(const QChar** aux)
+KviKvsVariant * KviKvsVariant::unserializeNull(const QChar ** ppAux)
 {
-	if(KviQString::equalCIN(QString("null"),*aux,4))
+	if(KviQString::equalCIN(QString("null"),*ppAux,4))
 	{
-		(*aux)+=4;
+		(*ppAux) += 4;
 		return new KviKvsVariant();
 	}
 	return 0;
 }
 
-KviKvsVariant* KviKvsVariant::unserializeRealOrInteger(const QChar** aux)
+KviKvsVariant * KviKvsVariant::unserializeNumber(const QChar ** ppAux)
 {
-	QString data;
-	if((*aux)->unicode() == '-')
+	QString szData;
+
+	if((*ppAux)->unicode() == '-')
 	{
-		data.append('-');
-		(*aux)++;
+		szData.append('-');
+		(*ppAux)++;
 	}
-	if(!(*aux)->isDigit())
+
+	if(!(*ppAux)->isDigit())
 	{
 		return 0;
 	}
-	while((*aux)->isDigit())
+
+	while((*ppAux)->isDigit())
 	{
-		data.append(**aux);
-		(*aux)++;
+		szData.append(**ppAux);
+		(*ppAux)++;
 	}
-	if((*aux)->unicode()=='.')
+
+	if((*ppAux)->unicode() == '.')
 	{
-		return unserializeReal(aux,data);
+		return unserializeReal(ppAux,szData);
 	}
-	return unserializeInteger(aux,data);
+
+	return unserializeInteger(ppAux,szData);
 }
 
-KviKvsVariant* KviKvsVariant::unserializeReal(const QChar** aux,QString& data)
+KviKvsVariant * KviKvsVariant::unserializeReal(const QChar ** ppAux, QString & szData)
 {
-	QString exponent;
-	(*aux)++; //skip .
-	data.append('.');
-	while((*aux)->isDigit())
+	QString szExponent;
+	(*ppAux)++; //skip .
+	szData.append('.');
+	while((*ppAux)->isDigit())
 	{
-		data.append(**aux);
-		(*aux)++;
+		szData.append(**ppAux);
+		(*ppAux)++;
 	}
 
-	if((*aux)->unicode() == 'e' || (*aux)->unicode() == 'E')
+	if((*ppAux)->unicode() == 'e' || (*ppAux)->unicode() == 'E')
 	{
-		(*aux)++;
-		if((*aux)->unicode() == '-')
+		(*ppAux)++;
+		if((*ppAux)->unicode() == '-')
 		{
-			exponent.append('-');
-			(*aux)++;
+			szExponent.append('-');
+			(*ppAux)++;
 		} else {
-			if((*aux)->unicode() == '+')
+			if((*ppAux)->unicode() == '+')
 			{
-				exponent.append('+');
-				(*aux)++;
+				szExponent.append('+');
+				(*ppAux)++;
 			}
 		}
 
-		while((*aux)->isDigit())
+		while((*ppAux)->isDigit())
 		{
-			exponent.append(**aux);
-			(*aux)++;
+			szExponent.append(**ppAux);
+			(*ppAux)++;
 		}
 	}
 
-	float value = data.toFloat();
-	if(!exponent.isNull())
+	float fValue = szData.toFloat();
+	if(!szExponent.isNull())
 	{
-		value*=pow(10.0,exponent.toInt());
+		fValue *= pow(10.0,szExponent.toInt());
 	}
-	return new KviKvsVariant(value);
+	return new KviKvsVariant(fValue);
 }
 
-KviKvsVariant* KviKvsVariant::unserializeInteger(const QChar** aux,QString& data)
+KviKvsVariant * KviKvsVariant::unserializeInteger(const QChar ** ppAux, QString & szData)
 {
+	QString szExponent;
 
-	QString exponent;
-
-	if((*aux)->unicode() == 'e' || (*aux)->unicode() == 'E')
+	if((*ppAux)->unicode() == 'e' || (*ppAux)->unicode() == 'E')
 	{
-		(*aux)++;
-		if((*aux)->unicode() == '-')
+		(*ppAux)++;
+		if((*ppAux)->unicode() == '-')
 		{
-			exponent.append('-');
-			(*aux)++;
+			szExponent.append('-');
+			(*ppAux)++;
 		} else {
-			if((*aux)->unicode() == '+')
+			if((*ppAux)->unicode() == '+')
 			{
-				exponent.append('+');
-				(*aux)++;
+				szExponent.append('+');
+				(*ppAux)++;
 			}
 		}
 
-		while((*aux)->isDigit())
+		while((*ppAux)->isDigit())
 		{
-			exponent.append(**aux);
-			(*aux)++;
+			szExponent.append(**ppAux);
+			(*ppAux)++;
 		}
 	}
 
-	kvs_int_t value = data.toInt();
-	if(!exponent.isNull())
+	kvs_int_t iValue = szData.toInt();
+	if(!szExponent.isNull())
 	{
-		value*= (kvs_int_t) pow(10.0,exponent.toInt());
+		iValue *= (kvs_int_t) pow(10.0,szExponent.toInt());
 	}
-	return new KviKvsVariant(value);
+	return new KviKvsVariant(iValue);
 }
 
-KviKvsVariant* KviKvsVariant::unserializeString(const QChar** aux)
+KviKvsVariant * KviKvsVariant::unserializeString(const QChar ** ppAux)
 {
-	QString buffer;
-	unserializeString(aux,buffer);
-	return new KviKvsVariant(buffer);
+	QString szBuffer;
+	unserializeString(ppAux,szBuffer);
+	return new KviKvsVariant(szBuffer);
 }
 
-void KviKvsVariant::unserializeString(const QChar** aux,QString& data)
+void KviKvsVariant::unserializeString(const QChar ** ppAux, QString & szData)
 {
-	data="";
-	QString hex; //temp var
+	szData = "";
+	QString szHex; //temp var
 	//skip leading "
-	(*aux)++;
-	while((*aux)->unicode())
+	(*ppAux)++;
+	while((*ppAux)->unicode())
 	{
-		switch((*aux)->unicode())
+		switch((*ppAux)->unicode())
 		{
-		case '"':
-			//EOF
-			(*aux)++;
-			return;
+			case '"':
+				//EOF
+				(*ppAux)++;
+				return;
 			break;
-		case '\\':
-			//Special
-			(*aux)++;
-			switch((*aux)->unicode())
-			{
-			case 't':
-				data.append('\t');
-				break;
-			case '\"':
-				data.append('\"');
-				break;
-			case '/':
-				data.append('/');
-				break;
-			case 'b':
-				data.append('\b');
-				break;
-			case 'f':
-				data.append('\f');
-				break;
-			case 'n':
-				data.append('\n');
-				break;
-			case 'r':
-				data.append('\r');
-				break;
-			case 'u':
-				//4 hexadecmical digits pending...
-				hex="";
-				(*aux)++;
-				for(int k=0;k<4 && (*aux)->unicode(); k++)
+			case '\\':
+				//Special
+				(*ppAux)++;
+				switch((*ppAux)->unicode())
 				{
-					if((*aux)->isDigit() ||
-						((*aux)->unicode() >='A' && (*aux)->unicode() <='F')|| //ABCDEF
-						((*aux)->unicode() >='a' && (*aux)->unicode() <='f')) //abcdef
-					{
-						hex.append(**aux);
-						(*aux)++;
-					} else {
-						break;
-					}
+					case 't':
+						szData.append('\t');
+					break;
+					case '\"':
+						szData.append('\"');
+					break;
+					case '/':
+						szData.append('/');
+					break;
+					case 'b':
+						szData.append('\b');
+					break;
+					case 'f':
+						szData.append('\f');
+					break;
+					case 'n':
+						szData.append('\n');
+					break;
+					case 'r':
+						szData.append('\r');
+					break;
+					case 'u':
+						//4 hexadecmical digits pending...
+						szHex = "";
+						(*ppAux)++;
+						for(int i=0; i<4 && (*ppAux)->unicode(); i++)
+						{
+							if((*ppAux)->isDigit() ||
+								((*ppAux)->unicode() >='A' && (*ppAux)->unicode() <='F')|| //ABCDEF
+								((*ppAux)->unicode() >='a' && (*ppAux)->unicode() <='f')) //abcdef
+							{
+								szHex.append(**ppAux);
+								(*ppAux)++;
+							} else {
+								break;
+							}
+						}
+						(*ppAux)--;
+						szData.append(QChar(szHex.toUInt(0,16)));
+					break;
+					default:
+						//Fallback; incorrect escape
+						(*ppAux)--;
+						szData.append('\\');
 				}
-				(*aux)--;
-				data.append(QChar(hex.toUInt(0,16)));
-				break;
-			default:
-				//Fallback; incorrect escape
-				(*aux)--;
-				data.append('\\');
-			}
-			(*aux)++;
+				(*ppAux)++;
 			break;
-		default:
-			data.append(**aux);
-			(*aux)++;
+			default:
+				szData.append(**ppAux);
+				(*ppAux)++;
 			break;
 		}
 	}
 }
 
-KviKvsVariant* KviKvsVariant::unserializeHash(const QChar** aux)
+KviKvsVariant * KviKvsVariant::unserializeHash(const QChar ** ppAux)
 {
-	KviKvsHash* pHash = new KviKvsHash();
+	KviKvsHash * pHash = new KviKvsHash();
 	QString szKey;
-	KviKvsVariant* pElement = 0;
+	KviKvsVariant * pElement = 0;
 	//skip leading '{'
-	(*aux)++;
+	(*ppAux)++;
 	int i=0;
 	while(1)
 	{
 		//skip leading space
-		while((*aux)->isSpace())
-				(*aux)++;
+		while((*ppAux)->isSpace())
+			(*ppAux)++;
 		//waiting for starting of string
-		if((*aux)->unicode()!='\"')
+		if((*ppAux)->unicode() != '\"')
 		{
 			//strange characters
 			delete pHash;
 			return 0;
 		}
-		unserializeString(aux,szKey);
+		unserializeString(ppAux,szKey);
 		if(szKey.isEmpty())
 		{
 			//Strange element name
@@ -1224,40 +1674,39 @@ KviKvsVariant* KviKvsVariant::unserializeHash(const QChar** aux)
 		}
 
 		//skip leading space before ':'
-		while((*aux)->isSpace())
-				(*aux)++;
+		while((*ppAux)->isSpace())
+			(*ppAux)++;
 		//waiting for name-value delimeter
-		if((*aux)->unicode()!=':')
+		if((*ppAux)->unicode() != ':')
 		{
 			//strange characters
 			delete pHash;
 			return 0;
 		}
-		(*aux)++;
-
+		(*ppAux)++;
 
 		//getting element
-		pElement = unserialize(aux);
+		pElement = unserialize(ppAux);
 		if(pElement)
 		{
 			pHash->set(szKey,pElement);
 			i++;
-			while((*aux)->isSpace())
-				(*aux)++;
-			switch((*aux)->unicode())
+			while((*ppAux)->isSpace())
+				(*ppAux)++;
+			switch((*ppAux)->unicode())
 			{
-			case ',':
-				//goto next
-				(*aux)++;
+				case ',':
+					//goto next
+					(*ppAux)++;
 				break;
-			case '}':
-				//EOF array
-				(*aux)++;
-				return new KviKvsVariant(pHash);
+				case '}':
+					//EOF array
+					(*ppAux)++;
+					return new KviKvsVariant(pHash);
 				break;
-			default:
-				delete pHash;
-				return 0;
+				default:
+					delete pHash;
+					return 0;
 				break;
 			}
 		} else {
@@ -1269,35 +1718,35 @@ KviKvsVariant* KviKvsVariant::unserializeHash(const QChar** aux)
 	return 0;
 }
 
-KviKvsVariant* KviKvsVariant::unserializeArray(const QChar** aux)
+KviKvsVariant * KviKvsVariant::unserializeArray(const QChar ** ppAux)
 {
-	KviKvsArray* pArray = new KviKvsArray();
-	KviKvsVariant* pElement = 0;
-	(*aux)++;
+	KviKvsArray * pArray = new KviKvsArray();
+	KviKvsVariant * pElement = 0;
+	(*ppAux)++;
 	int i=0;
 	while(1)
 	{
-		pElement = unserialize(aux);
+		pElement = unserialize(ppAux);
 		if(pElement)
 		{
 			pArray->set(i,pElement);
 			i++;
-			while((*aux)->isSpace())
-				(*aux)++;
-			switch((*aux)->unicode())
+			while((*ppAux)->isSpace())
+				(*ppAux)++;
+			switch((*ppAux)->unicode())
 			{
-			case ',':
-				//goto next
-				(*aux)++;
+				case ',':
+					//goto next
+					(*ppAux)++;
 				break;
-			case ']':
-				//EOF array
-				(*aux)++;
-				return new KviKvsVariant(pArray);
+				case ']':
+					//EOF array
+					(*ppAux)++;
+					return new KviKvsVariant(pArray);
 				break;
-			default:
-				delete pArray;
-				return 0;
+				default:
+					delete pArray;
+					return 0;
 				break;
 			}
 		} else {
@@ -1308,317 +1757,3 @@ KviKvsVariant* KviKvsVariant::unserializeArray(const QChar** aux)
 	}
 	return 0;
 }
-
-KviKvsVariant* KviKvsVariant::unserialize(const QChar** aux)
-{
-	KviKvsVariant* pResult = 0;
-
-	while((*aux)->isSpace())
-		(*aux)++;
-
-	switch((*aux)->unicode())
-	{
-	case 't':
-		//true
-		pResult = unserializeTrue(aux);
-		break;
-	case 'f':
-		//false
-		pResult = unserializeFalse(aux);
-		break;
-	case 'n':
-		//null
-		pResult = unserializeNull(aux);
-		break;
-	case '[':
-		//array
-		pResult = unserializeArray(aux);
-		break;
-	case '{':
-		//hash
-		pResult = unserializeHash(aux);
-		break;
-	case '"':
-		//string
-		pResult = unserializeString(aux);
-		break;
-	case '1':
-	case '2':
-	case '3':
-	case '4':
-	case '5':
-	case '6':
-	case '7':
-	case '8':
-	case '9':
-	case '0':
-	case '-':
-		//real or integer
-		pResult = unserializeRealOrInteger(aux);
-		break;
-	default:
-		//incorrect value
-		return 0;
-	}
-
-	while((*aux)->isSpace())
-		(*aux)++;
-
-	return pResult;
-}
-
-KviKvsVariant* KviKvsVariant::unserialize(const QString& data)
-{
-	KviKvsVariant* pResult = 0;
-
-	const QChar * aux = (const QChar *)data.constData();
-
-	pResult = unserialize(&aux);
-
-	if(aux->unicode())
-	{
-		//strange extra characters?
-		if(pResult) delete pResult;
-		pResult = 0;
-	}
-
-	return pResult;
-}
-
-int KviKvsVariant::compare(const KviKvsVariant * pOther,bool bPreferNumeric) const
-{
-	// returns -1 if this variant is greater than pOther
-	// 0 if they are considered to be equal
-	// 1 if the other variant is greater
-
-	if(!pOther)
-		return isEqualToNothing() ? CMP_EQUAL : CMP_THISGREATER;
-	if(!pOther->m_pData)
-		return isEqualToNothing() ? CMP_EQUAL : CMP_THISGREATER;
-	if(!m_pData)
-		return pOther->isEqualToNothing() ? CMP_EQUAL : CMP_OTHERGREATER;
-
-	switch(m_pData->m_eType)
-	{
-		case KviKvsVariantData::HObject:
-			switch(pOther->m_pData->m_eType)
-			{
-				case KviKvsVariantData::HObject:
-					if(m_pData->m_u.hObject == pOther->m_pData->m_u.hObject)return CMP_EQUAL;
-					if(m_pData->m_u.hObject == ((kvs_hobject_t)0))return CMP_OTHERGREATER;
-					return CMP_THISGREATER;
-				break;
-				case KviKvsVariantData::Integer:
-					return -1 * KviKvsVariantComparison::compare_integer_hobject(pOther,this);
-				break;
-				case KviKvsVariantData::Real:
-					return -1 * KviKvsVariantComparison::compare_real_hobject(pOther,this);
-				break;
-				case KviKvsVariantData::String:
-					return -1 * KviKvsVariantComparison::compare_string_hobject(pOther,this);
-				break;
-				case KviKvsVariantData::Boolean:
-					return -1 * KviKvsVariantComparison::compare_boolean_hobject(pOther,this);
-				break;
-				case KviKvsVariantData::Hash:
-					return KviKvsVariantComparison::compare_hobject_hash(this,pOther);
-				break;
-				case KviKvsVariantData::Array:
-					return KviKvsVariantComparison::compare_hobject_array(this,pOther);
-				break;
-				default: // just make gcc happy
-				break;
-			}
-		break;
-		case KviKvsVariantData::Integer:
-			switch(pOther->m_pData->m_eType)
-			{
-				case KviKvsVariantData::HObject:
-					return KviKvsVariantComparison::compare_integer_hobject(this,pOther);
-				break;
-				case KviKvsVariantData::Integer:
-					if(m_pData->m_u.iInteger == pOther->m_pData->m_u.iInteger)return CMP_EQUAL;
-					if(m_pData->m_u.iInteger > pOther->m_pData->m_u.iInteger)return CMP_THISGREATER;
-					return CMP_OTHERGREATER;
-				break;
-				case KviKvsVariantData::Real:
-					return KviKvsVariantComparison::compare_integer_real(this,pOther);
-				break;
-				case KviKvsVariantData::String:
-					return KviKvsVariantComparison::compare_integer_string(this,pOther);
-				break;
-				case KviKvsVariantData::Boolean:
-					return KviKvsVariantComparison::compare_integer_boolean(this,pOther);
-				break;
-				case KviKvsVariantData::Hash:
-					return KviKvsVariantComparison::compare_integer_hash(this,pOther);
-				break;
-				case KviKvsVariantData::Array:
-					return KviKvsVariantComparison::compare_integer_array(this,pOther);
-				break;
-				default: // just make gcc happy
-				break;
-			}
-		break;
-		case KviKvsVariantData::Real:
-			switch(pOther->m_pData->m_eType)
-			{
-				case KviKvsVariantData::HObject:
-					return KviKvsVariantComparison::compare_real_hobject(this,pOther);
-				break;
-				case KviKvsVariantData::Integer:
-					return -1 * KviKvsVariantComparison::compare_integer_real(pOther,this);
-				break;
-				case KviKvsVariantData::Real:
-					if(*(m_pData->m_u.pReal) == *(pOther->m_pData->m_u.pReal))return CMP_EQUAL;
-					if(*(m_pData->m_u.pReal) > *(pOther->m_pData->m_u.pReal))return CMP_THISGREATER;
-					return CMP_OTHERGREATER;
-				break;
-				case KviKvsVariantData::String:
-					return KviKvsVariantComparison::compare_real_string(this,pOther);
-				break;
-				case KviKvsVariantData::Boolean:
-					return KviKvsVariantComparison::compare_real_boolean(this,pOther);
-				break;
-				case KviKvsVariantData::Hash:
-					return KviKvsVariantComparison::compare_real_hash(this,pOther);
-				break;
-				case KviKvsVariantData::Array:
-					return KviKvsVariantComparison::compare_real_array(this,pOther);
-				break;
-				default: // just make gcc happy
-				break;
-			}
-		break;
-		case KviKvsVariantData::String:
-			switch(pOther->m_pData->m_eType)
-			{
-				case KviKvsVariantData::String:
-					if(bPreferNumeric)
-					{
-						// prefer numeric comparison
-						double dReal1;
-						double dReal2;
-						if(asReal(dReal1))
-						{
-							if(pOther->asReal(dReal2))
-							{
-								if(dReal1 == dReal2)return CMP_EQUAL;
-								if(dReal1 > dReal2)return CMP_THISGREATER;
-								return CMP_OTHERGREATER;
-							}
-						}
-					}
-					return -1 * KviQString::cmpCI(*(m_pData->m_u.pString),*(pOther->m_pData->m_u.pString));
-				case KviKvsVariantData::Real:
-					return -1 * KviKvsVariantComparison::compare_real_string(pOther,this);
-				case KviKvsVariantData::Integer:
-					return -1 * KviKvsVariantComparison::compare_integer_string(pOther,this);
-				case KviKvsVariantData::Boolean:
-					return -1 * KviKvsVariantComparison::compare_boolean_string(pOther,this);
-				break;
-				case KviKvsVariantData::Hash:
-					return KviKvsVariantComparison::compare_string_hash(this,pOther);
-				break;
-				case KviKvsVariantData::Array:
-					return KviKvsVariantComparison::compare_string_array(this,pOther);
-				break;
-				case KviKvsVariantData::HObject:
-					return KviKvsVariantComparison::compare_string_hobject(this,pOther);
-				break;
-				default:
-				break;
-			}
-		break;
-		case KviKvsVariantData::Hash:
-			switch(pOther->m_pData->m_eType)
-			{
-				case KviKvsVariantData::String:
-					return -1 * KviKvsVariantComparison::compare_string_hash(pOther,this);
-				case KviKvsVariantData::Real:
-					return -1 * KviKvsVariantComparison::compare_real_hash(pOther,this);
-				break;
-				case KviKvsVariantData::Integer:
-					return -1 * KviKvsVariantComparison::compare_integer_hash(pOther,this);
-				break;
-				case KviKvsVariantData::Boolean:
-					return -1 * KviKvsVariantComparison::compare_boolean_hash(pOther,this);
-				break;
-				case KviKvsVariantData::Hash:
-					if(m_pData->m_u.pHash->size() > pOther->m_pData->m_u.pHash->size())return CMP_THISGREATER;
-					if(m_pData->m_u.pHash->size() == pOther->m_pData->m_u.pHash->size())return CMP_EQUAL;
-					return CMP_OTHERGREATER;
-				break;
-				case KviKvsVariantData::Array:
-					return -1 * KviKvsVariantComparison::compare_array_hash(pOther,this);
-				break;
-				case KviKvsVariantData::HObject:
-					return -1 * KviKvsVariantComparison::compare_hobject_hash(pOther,this);
-				break;
-				default:
-				break;
-			}
-		break;
-		case KviKvsVariantData::Array:
-			switch(pOther->m_pData->m_eType)
-			{
-				case KviKvsVariantData::String:
-					return -1 * KviKvsVariantComparison::compare_string_array(pOther,this);
-				case KviKvsVariantData::Real:
-					return -1 * KviKvsVariantComparison::compare_real_array(pOther,this);
-				case KviKvsVariantData::Integer:
-					return -1 * KviKvsVariantComparison::compare_integer_array(pOther,this);
-				case KviKvsVariantData::Boolean:
-					return -1 * KviKvsVariantComparison::compare_boolean_array(pOther,this);
-				break;
-				case KviKvsVariantData::Hash:
-					return KviKvsVariantComparison::compare_array_hash(this,pOther);
-				break;
-				case KviKvsVariantData::Array:
-					if(m_pData->m_u.pArray->size() > pOther->m_pData->m_u.pArray->size())return CMP_THISGREATER;
-					if(m_pData->m_u.pArray->size() == pOther->m_pData->m_u.pArray->size())return CMP_EQUAL;
-					return CMP_OTHERGREATER;
-				break;
-				case KviKvsVariantData::HObject:
-					return -1 * KviKvsVariantComparison::compare_hobject_array(pOther,this);
-				break;
-				default:
-				break;
-			}
-		break;
-		case KviKvsVariantData::Boolean:
-			switch(pOther->m_pData->m_eType)
-			{
-				case KviKvsVariantData::String:
-					return KviKvsVariantComparison::compare_boolean_string(this,pOther);
-				break;
-				case KviKvsVariantData::Real:
-					return -1 * KviKvsVariantComparison::compare_real_boolean(pOther,this);
-				break;
-				case KviKvsVariantData::Integer:
-					return -1 * KviKvsVariantComparison::compare_integer_boolean(pOther,this);
-				break;
-				case KviKvsVariantData::Boolean:
-					if(m_pData->m_u.bBoolean == pOther->m_pData->m_u.bBoolean)return CMP_EQUAL;
-					if(m_pData->m_u.bBoolean)return CMP_THISGREATER;
-					return CMP_OTHERGREATER;
-				break;
-				case KviKvsVariantData::Hash:
-					return KviKvsVariantComparison::compare_boolean_hash(this,pOther);
-				break;
-				case KviKvsVariantData::Array:
-					return KviKvsVariantComparison::compare_boolean_array(this,pOther);
-				break;
-				case KviKvsVariantData::HObject:
-					return KviKvsVariantComparison::compare_boolean_hobject(this,pOther);
-				break;
-				default:
-				break;
-			}
-		break;
-		default: // should never happen anyway
-		break;
-	}
-
-	return CMP_THISGREATER; // should never happen
-}
\ No newline at end of file
diff --git a/src/kvirc/kvs/kvi_kvs_variant.h b/src/kvirc/kvs/kvi_kvs_variant.h
index e82851266..47bf5b7d7 100644
--- a/src/kvirc/kvs/kvi_kvs_variant.h
+++ b/src/kvirc/kvs/kvi_kvs_variant.h
@@ -6,7 +6,7 @@
 //   Creation date : Tue 07 Oct 2003 04:01:19 by Szymon Stefanek
 //
 //   This file is part of the KVIrc IRC client distribution
-//   Copyright (C) 2003-2008 Szymon Stefanek <pragma at kvirc dot net>
+//   Copyright (C) 2003-2010 Szymon Stefanek <pragma at kvirc dot net>
 //
 //   This program is FREE software. You can redistribute it and/or
 //   modify it under the terms of the GNU General Public License
@@ -24,184 +24,851 @@
 //
 //=============================================================================
 
+/**
+* \file kvi_kvs_variant.h
+* \author Szymon Stefanek
+* \brief Handling of variant data
+*/
+
 #include "kvi_settings.h"
 #include "kvi_qstring.h"
 #include "kvi_heapobject.h"
 #include "kvi_kvs_types.h"
 
-
 class KviKvsVariant;
 class KviKvsArrayCast;
 
+// pre-declare.. the real declarations are included below
+class KviKvsHash;
+class KviKvsArray;
+
+/**
+* \class KviKvsNumber
+* \brief A class which maps every number
+*/
 class KVIRC_API KviKvsNumber
 {
 	friend class KviKvsVariant;
 public:
-	enum DataType { Real, Integer };
+	/**
+	* \enum Type
+	* \brief Describes the type of number
+	*/
+	enum Type {
+		Real,     /**< The number is an integer */
+		Integer   /**< The number is a double floating point */
+	};
 protected:
-	union {
-		kvs_int_t     iInteger;
+	/**
+	* \union DataType
+	* \brief This union holds an integer or a double floating point number
+	*/
+	union DataType {
+		kvs_int_t     iInt;
 		kvs_real_t    dReal;
-	} m_u;
-	DataType m_type;
+	};
+protected:
+	Type     m_type;
+	DataType m_u;
 public:
-	DataType type() const { return m_type; };
+	/**
+	* \brief Returns the type of the number
+	* \return Type
+	*/
+	Type type() const { return m_type; };
+
+	/**
+	* \brief Returns true if the number is a double floating point
+	* \return bool
+	*/
 	bool isReal() const { return m_type == Real; };
+
+	/**
+	* \brief Returns true if the number is an integer
+	* \return bool
+	*/
 	bool isInteger() const { return m_type == Integer; };
+
+	/**
+	* \brief Return the real number if the number itself is a double floating point
+	* \return kvs_real_t
+	*/
 	kvs_real_t real() const { return m_u.dReal; };
-	kvs_int_t integer() const { return m_u.iInteger; };
-};
 
-// pre-declare.. the real declarations are included below
-class KviKvsHash;
-class KviKvsArray;
+	/**
+	* \brief Return the integer number if the number itself is an integer
+	* \return kvs_int_t
+	*/
+	kvs_int_t integer() const { return m_u.iInt; };
+};
 
+/**
+* \class KviKvsVariantData
+* \brief The class which holds the type of the variant data
+*/
 class KviKvsVariantData
 {
 public:
+	/**
+	* \enum Type
+	* \brief Holds the type of the variant data
+	*/
 	enum Type {
-		Nothing = 0,  // m_pData not initialized
-		String  = 1,  // QString          (scalar)
-		Integer = 2,  // long int         (scalar)
-		Real    = 4,  // double           (scalar)
-		Array   = 8,  // KviKvsArray
-		Hash    = 16, // KviKvsHash
-		Boolean = 32, // bool             (scalar)
-		HObject = 64  // object, shallow! (scalar)
+		Nothing = 0,    /**< Data not initialized      */
+		String  = 1,    /**< QString          (scalar) */
+		Integer = 2,    /**< long int         (scalar) */
+		Real    = 4,    /**< double           (scalar) */
+		Array   = 8,    /**< KviKvsArray               */
+		Hash    = 16,   /**< KviKvsHash                */
+		Boolean = 32,   /**< bool             (scalar) */
+		HObject = 64    /**< object, shallow! (scalar) */
 	};
 public:
-	unsigned int m_uRefs;
-	Type m_eType;
-	union {
-		kvs_int_t       iInteger;
+	/**
+	* \union DataType
+	* \brief Holds the value of the variant data
+	*/
+	union DataType {
+		kvs_int_t       iInt;
 		kvs_real_t    * pReal;
 		QString       * pString;
 		KviKvsArray   * pArray;
 		KviKvsHash    * pHash;
 		bool            bBoolean;
 		kvs_hobject_t   hObject;
-	} m_u;
+	};
+public:
+	unsigned int m_uRefs;
+	Type         m_eType;
+	DataType     m_u;
 };
 
-// This class must not have virtual funcitons nor destructor
-// Otherwise it will happily crash on windows when it is
-// allocated in modules and destroyed anywhere else around...
+/**
+* \class KviKvsVariantComparison
+* \brief A class for comparison between two variant data
+*/
+class KviKvsVariantComparison
+{
+public:
+	/**
+	* \enum Result
+	* \brief Holds the result of the comparison
+	*/
+	enum Result {
+		FirstGreater  = -1,   /**< the first variant is greater than the second */
+		Equal         =  0,   /**< the two variants are equal */
+		SecondGreater =  1    /**< the second variant is greater than the first */
+	};
+public:
+	/**
+	* \brief Compares an integer and a string variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareIntString(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares an integer and a double floating point variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareIntReal(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares an integer and a boolean variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareIntBool(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares an integer and a hash variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareIntHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares an integer and an array variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareIntArray(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares an integer and an object handle variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareIntHObject(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares a double floating point and an object handle variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareRealHObject(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares a double floating point and a string variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareRealString(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares a double floating point and a boolean variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareRealBool(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares a double floating point and a hash variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareRealHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares a double floating point and an array variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareRealArray(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares a string and a hash variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareStringHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares a string and an array variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareStringArray(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares a string and an object handle variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareStringHObject(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares a boolean and a string variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareBoolString(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares a boolean and a hash variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareBoolHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares a boolean and an array variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareBoolArray(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares a boolean and an object handle variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareBoolHObject(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares an array and a hash variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareArrayHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares an object handle and a hash variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareHObjectHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+
+	/**
+	* \brief Compares an object handle and an array variant
+	* \param pV1 The first variant to compare
+	* \param pV2 The second variant to compare
+	* \return int
+	*/
+	static inline int compareHObjectArray(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
+};
+
+/**
+* \class KviKvsVariant
+* \brief This class holds the variant data
+* 
+* A variant data is a data which can assume different data types. This is very useful when you
+* don't know in advance which data type you have to manage.
+* \warning This class must NOT have virtual functions nor destructor otherwise it will happily
+* crash on windows when it is allocated in modules and destroyed anywhere else around...
+*/
 class KVIRC_API KviKvsVariant : public KviHeapObject
 {
 	friend class KviKvsVariantComparison;
 public:
+	/**
+	* \brief Constructs the variant data
+	* \return KviKvsVariant
+	*/
 	KviKvsVariant();
-	KviKvsVariant(kvs_int_t iInteger, bool bEscape=false);
+
+	/**
+	* \brief Constructs the variant data
+	* 
+	* This is a carbon copy
+	* \param variant The variant data to use as a copy
+	* \return KviKvsVariant
+	*/
+	KviKvsVariant(const KviKvsVariant & variant);
+
+	/**
+	* \brief Constructs the variant data
+	* \param szString The string data to use as variant data
+	* \param bEscape Whether to escape the data in KVS
+	* \return KviKvsVariant
+	*/
+	KviKvsVariant(const QString & szString, bool bEscape = false);
+
+	/**
+	* \brief Constructs the variant data
+	* \param pcString The string data to use as variant data
+	* \param bEscape Whether to escape the data in KVS
+	* \warning Without this constructor gcc chooses the conversion (const char *)->(void *)
+	* instead of (const char *)->(QString) and obviously calls the wrong constructor
+	* \return KviKvsVariant
+	*/
+	KviKvsVariant(const char * pcString, bool bEscape=false);
+
+	/**
+	* \brief Constructs the variant data
+	* \param pszString The string data to use as variant data
+	* \param bEscape Whether to escape the data in KVS
+	* \return KviKvsVariant
+	*/
+	KviKvsVariant(QString * pszString, bool bEscape = false);
+
+	/**
+	* \brief Constructs the variant data
+	* \param iInteger The integer data to use as variant data
+	* \param bEscape Whether to escape the data in KVS
+	* \return KviKvsVariant
+	*/
+	KviKvsVariant(kvs_int_t iInteger, bool bEscape = false);
+
+	/**
+	* \brief Constructs the variant data
+	* \param dReal The double floating point data to use as variant data
+	* \return KviKvsVariant
+	*/
 	KviKvsVariant(kvs_real_t dReal);
+
+	/**
+	* \brief Constructs the variant data
+	* \param pReal The double floating point data to use as variant data
+	* \return KviKvsVariant
+	*/
 	KviKvsVariant(kvs_real_t * pReal);
+
+	/**
+	* \brief Constructs the variant data
+	* \param bBoolean The boolean data to use as variant data
+	* \return KviKvsVariant
+	*/
 	KviKvsVariant(bool bBoolean);
-	KviKvsVariant(const QString &szString, bool bEscape=false);
-	KviKvsVariant(const char * szString, bool bEscape=false); // without this gcc chooses the conversion (const char *)->(void *) instead of (const char *)->(QString) and obviously calls the wrong constructor
-	KviKvsVariant(QString * pString, bool bEscape=false);
+
+	/**
+	* \brief Constructs the variant data
+	* \param pArray The array data to use as variant data
+	* \return KviKvsVariant
+	*/
 	KviKvsVariant(KviKvsArray * pArray);
+
+	/**
+	* \brief Constructs the variant data
+	* \param pHash The hash data to use as variant data
+	* \return KviKvsVariant
+	*/
 	KviKvsVariant(KviKvsHash * pHash);
+
+	/**
+	* \brief Constructs the variant data
+	* \param hObject The hObject data to use as variant data
+	* \return KviKvsVariant
+	*/
 	KviKvsVariant(kvs_hobject_t hObject);
-	KviKvsVariant(const KviKvsVariant &v);
+
+	/**
+	* \brief Destroys the variant data
+	*/
 	~KviKvsVariant();
 protected:
 	KviKvsVariantData * m_pData;
 public:
+	/**
+	* \brief Returns the type of the variant data
+	* \return KviKvsVariantData::Type
+	*/
 	KviKvsVariantData::Type type(){ return m_pData ? m_pData->m_eType : KviKvsVariantData::Nothing; };
 
+	/**
+	* \brief Sets the variant data as double floating point
+	* \param dReal The value to set
+	* \return void
+	*/
 	void setReal(kvs_real_t dReal);
+
+	/**
+	* \brief Sets the variant data as double floating point
+	* \param pReal The value to set
+	* \return void
+	*/
 	void setReal(kvs_real_t * pReal);
+
+	/**
+	* \brief Sets the variant data as integer
+	* \param iInteger The value to set
+	* \return void
+	*/
 	void setInteger(kvs_int_t iInteger);
-	void setString(const QString &szString);
-	void setString(QString * pString);
+
+	/**
+	* \brief Sets the variant data as string
+	* \param szString The value to set
+	* \return void
+	*/
+	void setString(const QString & szString);
+
+	/**
+	* \brief Sets the variant data as string
+	* \param pszString The value to set
+	* \return void
+	*/
+	void setString(QString * pszString);
+
+	/**
+	* \brief Sets the variant data as array
+	* \param pArray The value to set
+	* \return void
+	*/
 	void setArray(KviKvsArray * pArray);
+
+	/**
+	* \brief Sets the variant data as hash
+	* \param pHash The value to set
+	* \return void
+	*/
 	void setHash(KviKvsHash * pHash);
+
+	/**
+	* \brief Sets the variant data as boolean
+	* \param bBoolean The value to set
+	* \return void
+	*/
 	void setBoolean(bool bBoolean);
+
+	/**
+	* \brief Sets the variant data as hObject
+	* \param hObject The value to set
+	* \return void
+	*/
 	void setHObject(kvs_hobject_t hObject);
+
+	/**
+	* \brief Clears the variant data
+	* \return void
+	*/
 	void setNothing();
-	//void unset(){ setNothing(); };
 
-	void getTypeName(QString &szBuffer) const;
+	/**
+	* \brief Gets the type from a variant and returns its name
+	* \param szBuffer The buffer to save the type name
+	* \return void
+	*/
+	void getTypeName(QString & szBuffer) const;
 
+	/**
+	* \brief Returns true if the variant is empty
+	* \return bool
+	*/
 	bool isNothing() const { return !m_pData; };
+
+	/**
+	* \brief Returns true if the variant is an integer
+	* \return bool
+	*/
 	bool isInteger() const { return m_pData ? (m_pData->m_eType == KviKvsVariantData::Integer) : false; };
+
+	/**
+	* \brief Returns true if the variant is a double floating point
+	* \return bool
+	*/
 	bool isReal() const { return m_pData ? (m_pData->m_eType == KviKvsVariantData::Real) : false; };
+
+	/**
+	* \brief Returns true if the variant is numeric
+	* \return bool
+	*/
 	bool isNumeric() const { return m_pData ? (m_pData->m_eType & (KviKvsVariantData::Integer | KviKvsVariantData::Real)) : false; };
+
+	/**
+	* \brief Returns true if the variant is a string
+	* \return bool
+	*/
 	bool isString() const { return m_pData ? (m_pData->m_eType == KviKvsVariantData::String) : false; };
+
+	/**
+	* \brief Returns true if the variant is a scalar
+	* \return bool
+	*/
 	bool isScalar() const { return m_pData ? (m_pData->m_eType & (KviKvsVariantData::String | KviKvsVariantData::Integer | KviKvsVariantData::Real)) : false; };
+
+	/**
+	* \brief Returns true if the variant is an array
+	* \return bool
+	*/
 	bool isArray() const { return m_pData ? (m_pData->m_eType == KviKvsVariantData::Array) : false; };
+
+	/**
+	* \brief Returns true if the variant is an hash
+	* \return bool
+	*/
 	bool isHash() const { return m_pData ? (m_pData->m_eType == KviKvsVariantData::Hash) : false; };
+
+	/**
+	* \brief Returns true if the variant is boolean
+	* \return bool
+	*/
 	bool isBoolean() const { return m_pData ? (m_pData->m_eType == KviKvsVariantData::Boolean) : false; };
+
+	/**
+	* \brief Returns true if the variant is a hObject
+	* \return bool
+	*/
 	bool isHObject() const { return m_pData ? (m_pData->m_eType == KviKvsVariantData::HObject) : false; };
 
+	/**
+	* \brief Returns true if the variant is empty
+	* \return bool
+	*/
 	bool isEmpty() const;
 
-	// returns true if this variant is nothing, false, null, 0 or an empty string
+	/**
+	* \brief Returns true if the variant is nothing, false, null, 0 or an empty string
+	* \return bool
+	*/
 	bool isEqualToNothing() const;
 
-	// evaluates Integer, Real and String rappresenting an Integer
-	bool asInteger(kvs_int_t &iVal) const;
-	// evaluates Real, Integer and String rappresenting a Real
-	bool asReal(kvs_real_t &dVal) const;
-	// evaluates Real, Integer and String rappresenting a Real or integer
-	bool asNumber(KviKvsNumber &n) const;
-	// always evaluates to a boolean value
+	/**
+	* \brief Eevaluates Integer, Real and String rappresenting an Integer
+	* \param iVal The integer buffer to save
+	* \return bool
+	*/
+	bool asInteger(kvs_int_t & iVal) const;
+
+	/**
+	* \brief Eevaluates Integer, Real and String rappresenting a Real
+	* \param dVal The double floating point buffer to save
+	* \return bool
+	*/
+	bool asReal(kvs_real_t & dVal) const;
+
+	/**
+	* \brief Eevaluates Integer, Real and String rappresenting a Real or Integer
+	* \param n The number buffer to save
+	* \return bool
+	*/
+	bool asNumber(KviKvsNumber & n) const;
+
+	/**
+	* \brief Always evaluates to a boolean value
+	* \return bool
+	*/
 	bool asBoolean() const;
-	// evaluates to an object handle
-	bool asHObject(kvs_hobject_t &hObject) const;
-	// evaluates anything to a string
-	void asString(QString &szBuffer) const;
-	void appendAsString(QString &szBuffer) const;
 
-	// always evaluates to some number...
-	void castToNumber(KviKvsNumber &n) const;
-	// always evaluates to an integer
-	void castToInteger(kvs_int_t &iVal) const;
-	// always evaluates to an array
-	void castToArray(KviKvsArrayCast *c) const;
-	// converts this variant to an array
+	/**
+	* \brief Evaluates to an object handle
+	* \param hObject The hObject buffer to save
+	* \return bool
+	*/
+	bool asHObject(kvs_hobject_t & hObject) const;
+
+	/**
+	* \brief Evaluates anything to a string
+	* \param szBuffer The string buffer to save
+	* \return bool
+	*/
+	void asString(QString & szBuffer) const;
+
+	/**
+	* \brief Appends the variant data to a representative string
+	* \param szBuffer The string buffer to save
+	* \return void
+	*/
+	void appendAsString(QString & szBuffer) const;
+
+	/**
+	* \brief Casts the variant data to a number
+	* 
+	* Always evaluates to some number
+	* \param number The string buffer to save
+	* \return void
+	*/
+	void castToNumber(KviKvsNumber & number) const;
+
+	/**
+	* \brief Casts the variant data to an integer
+	* 
+	* Always evaluates to an integer
+	* \param iVal The integer buffer to save
+	* \return void
+	*/
+	void castToInteger(kvs_int_t & iVal) const;
+
+	/**
+	* \brief Casts the variant data to an array
+	* 
+	* Always evaluates to an array
+	* \param pCast The array buffer to save
+	* \return void
+	*/
+	void castToArray(KviKvsArrayCast * pCast) const;
+
+	/**
+	* \brief Converts this variant to an array
+	* \return void
+	*/
 	void convertToArray();
 
-	kvs_int_t integer() const { return m_pData ? m_pData->m_u.iInteger : 0; };
+	/**
+	* \brief Returns the integer contained in the variant data
+	* \return kvs_int_t
+	*/
+	kvs_int_t integer() const { return m_pData ? m_pData->m_u.iInt : 0; };
+
+	/**
+	* \brief Returns the double floating point contained in the variant data
+	* \return kvs_real_t
+	*/
 	kvs_real_t real() const { return m_pData ? *(m_pData->m_u.pReal) : 0.0; };
+
+	/**
+	* \brief Returns the string contained in the variant data
+	* \return const QString &
+	*/
 	const QString & string() const { return m_pData ? *(m_pData->m_u.pString) : KviQString::Empty; };
+
+	/**
+	* \brief Returns the boolean contained in the variant data
+	* \return bool
+	*/
+	bool boolean() const { return m_pData ? m_pData->m_u.bBoolean : false; };
+
+	/**
+	* \brief Returns the array contained in the variant data
+	* \return KviKvsArray
+	*/
 	KviKvsArray * array() const { return m_pData ? m_pData->m_u.pArray : 0; };
+
+	/**
+	* \brief Returns the hash contained in the variant data
+	* \return KviKvsHash
+	*/
 	KviKvsHash * hash() const { return m_pData ? m_pData->m_u.pHash : 0; };
-	bool boolean() const { return m_pData ? m_pData->m_u.bBoolean : false; };
+
+	/**
+	* \brief Returns the object handle contained in the variant data
+	* \return kvs_hobject_t
+	*/
 	kvs_hobject_t hobject() const { return m_pData ? m_pData->m_u.hObject : (kvs_hobject_t)0; };
 
-	void copyFrom(const KviKvsVariant * v);
-	void copyFrom(const KviKvsVariant & v);
-	void takeFrom(KviKvsVariant * v);
-	void takeFrom(KviKvsVariant &v);
+	/**
+	* \brief Copies a variant from another
+	* \param pVariant The variant to copy from
+	* \return void
+	*/
+	void copyFrom(const KviKvsVariant * pVariant);
+
+	/**
+	* \brief Copies a variant from another
+	* \param variant The variant to copy from
+	* \return void
+	*/
+	void copyFrom(const KviKvsVariant & variant);
 
-	void dump(const char * prefix) const;
+	/**
+	* \brief Copies a variant from another and destroys the second one
+	* \param pVariant The variant to take from
+	* \return void
+	*/
+	void takeFrom(KviKvsVariant * pVariant);
 
-	// returns -1 if this variant is greater than the other, 0 if are equal, 1 if the other is greater
-	// if bPreferNumeric is true then when comparing strings a conversion to a numeric format
-	// is first attempted.
-	int compare(const KviKvsVariant * pOther,bool bPreferNumeric = false) const;
+	/**
+	* \brief Copies a variant from another and destroys the second one
+	* \param variant The variant to take from
+	* \return void
+	*/
+	void takeFrom(KviKvsVariant & variant);
 
-	void operator = (const KviKvsVariant &v){ copyFrom(v); };
+	/**
+	* \brief Dumps the variant data
+	* \param pcPrefix The prefix of the data
+	* \return void
+	*/
+	void dump(const char * pcPrefix) const;
 
-	//JSON serialization
-	void serialize(QString& result);
-	static void serializeString(QString& buffer);
-	static KviKvsVariant* unserialize(const QString& buffer);
+	/**
+	* \brief Compares two variants
+	* 
+	* Returns -1 if this variant is greater than the other, 0 if they are equal, 1 if the
+	* other is greater.
+	* If bPreferNumeric is true then a conversion to a numeric format is first attempted
+	* \param pOther The second variant to compare
+	* \param bPreferNumeric Whether to cast to a numeric format
+	* \return int
+	*/
+	int compare(const KviKvsVariant * pOther, bool bPreferNumeric = false) const;
+
+	// JSON serialization
+	/**
+	* \brief Serializes the variant data using the JSON format
+	* \param szResult The buffer to store the serialization
+	* \return void
+	*/
+	void serialize(QString & szResult);
+
+	/**
+	* \brief Replaces escapes chars and serialize the string in the given buffer
+	* \param szBuffer The buffer to store the serialization
+	* \return void
+	*/
+	static void serializeString(QString & szBuffer);
+
+	/**
+	* \brief Unserializes the variant data using the JSON format
+	* \param szBuffer The buffer where is stored the serialization
+	* \return KviKvsVariant *
+	*/
+	static KviKvsVariant * unserialize(const QString & szBuffer);
+
+	/**
+	* \brief Allows to create a variant using a carbon copy method
+	* \param variant The variant to copy from
+	* \return void
+	*/
+	void operator = (const KviKvsVariant & variant){ copyFrom(variant); };
 private:
-	static KviKvsVariant* unserialize(const QChar** aux);
-	static KviKvsVariant* unserializeTrue(const QChar** aux);
-	static KviKvsVariant* unserializeFalse(const QChar** aux);
-	static KviKvsVariant* unserializeNull(const QChar** aux);
-	static KviKvsVariant* unserializeArray(const QChar** aux);
-	static KviKvsVariant* unserializeHash(const QChar** aux);
-	static void unserializeString(const QChar** aux,QString& buffer);
-	static KviKvsVariant* unserializeString(const QChar** aux);
-	static KviKvsVariant* unserializeRealOrInteger(const QChar** aux);
-	static KviKvsVariant* unserializeReal(const QChar** aux,QString& data);
-	static KviKvsVariant* unserializeInteger(const QChar** aux,QString& data);
+	/**
+	* \brief Unserializes the variant data using the JSON format
+	* \param ppAux The pointer where the serialization is located
+	* \return KviKvsVariant *
+	*/
+	static KviKvsVariant * unserialize(const QChar ** ppAux);
+
+	/**
+	* \brief Unserializes a boolean into a variant data using the JSON format
+	* \param ppAux The pointer where the serialization is located
+	* \param bBool Whether the variant is true or false
+	* \return KviKvsVariant *
+	*/
+	static KviKvsVariant * unserializeBool(const QChar ** ppAux, bool bBool);
+
+	/**
+	* \brief Unserializes null into a variant data using the JSON format
+	* \param ppAux The pointer where the serialization is located
+	* \return KviKvsVariant *
+	*/
+	static KviKvsVariant * unserializeNull(const QChar ** ppAux);
+
+	/**
+	* \brief Unserializes an array into a variant data using the JSON format
+	* \param ppAux The pointer where the serialization is located
+	* \return KviKvsVariant *
+	*/
+	static KviKvsVariant * unserializeArray(const QChar ** ppAux);
+
+	/**
+	* \brief Unserializes a hash into a variant data using the JSON format
+	* \param ppAux The pointer where the serialization is located
+	* \return KviKvsVariant *
+	*/
+	static KviKvsVariant * unserializeHash(const QChar ** ppAux);
+
+	/**
+	* \brief Unserializes a string into a variant data using the JSON format
+	* \param ppAux The pointer where the serialization is located
+	* \param szBuffer The buffer to store the unserialization
+	* \return void
+	*/
+	static void unserializeString(const QChar ** ppAux, QString & szBuffer);
+
+	/**
+	* \brief Unserializes a string into a variant data using the JSON format
+	* \param ppAux The pointer where the serialization is located
+	* \return KviKvsVariant *
+	*/
+	static KviKvsVariant * unserializeString(const QChar ** ppAux);
+
+	/**
+	* \brief Unserializes a number into a variant data using the JSON format
+	* \param ppAux The pointer where the serialization is located
+	* \return KviKvsVariant *
+	*/
+	static KviKvsVariant * unserializeNumber(const QChar ** ppAux);
+
+	/**
+	* \brief Unserializes a double floating point into a variant data using the JSON format
+	* \param ppAux The pointer where the serialization is located
+	* \param szData The buffer where the serialization is stored
+	* \return KviKvsVariant *
+	*/
+	static KviKvsVariant * unserializeReal(const QChar ** ppAux, QString & szData);
+
+	/**
+	* \brief Unserializes an integer into a variant data using the JSON format
+	* \param ppAux The pointer where the serialization is located
+	* \param szData The buffer where the serialization is stored
+	* \return KviKvsVariant *
+	*/
+	static KviKvsVariant * unserializeInteger(const QChar ** ppAux, QString & szData);
 };
 
 #include "kvi_kvs_array.h"
 #include "kvi_kvs_hash.h"
 
-#endif //!_KVI_KVS_VARIANT_H_
+#endif // _KVI_KVS_VARIANT_H_
diff --git a/src/kvirc/kvs/kvi_kvs_variantlist.cpp b/src/kvirc/kvs/kvi_kvs_variantlist.cpp
index 0671923bb..ee2db9ca0 100644
--- a/src/kvirc/kvs/kvi_kvs_variantlist.cpp
+++ b/src/kvirc/kvs/kvi_kvs_variantlist.cpp
@@ -22,8 +22,6 @@
 //
 //=============================================================================
 
-
-
 #include "kvi_kvs_variantlist.h"
 
 KviKvsVariantList::KviKvsVariantList()
@@ -32,131 +30,144 @@ KviKvsVariantList::KviKvsVariantList()
 	m_pList->setAutoDelete(true);
 }
 
-KviKvsVariantList::KviKvsVariantList(KviKvsVariant * v1)
+KviKvsVariantList::KviKvsVariantList(KviKvsVariant * pV1)
+{
+	m_pList = new KviPointerList<KviKvsVariant>();
+	m_pList->setAutoDelete(true);
+	m_pList->append(pV1);
+}
+
+KviKvsVariantList::KviKvsVariantList(KviKvsVariant * pV1, KviKvsVariant * pV2)
 {
 	m_pList = new KviPointerList<KviKvsVariant>();
 	m_pList->setAutoDelete(true);
-	m_pList->append(v1);
+	m_pList->append(pV1);
+	m_pList->append(pV2);
 }
 
-KviKvsVariantList::KviKvsVariantList(KviKvsVariant * v1,KviKvsVariant * v2)
+KviKvsVariantList::KviKvsVariantList(KviKvsVariant * pV1, KviKvsVariant * pV2, KviKvsVariant * pV3)
 {
 	m_pList = new KviPointerList<KviKvsVariant>();
 	m_pList->setAutoDelete(true);
-	m_pList->append(v1);
-	m_pList->append(v2);
+	m_pList->append(pV1);
+	m_pList->append(pV2);
+	m_pList->append(pV3);
 }
 
-KviKvsVariantList::KviKvsVariantList(KviKvsVariant * v1,KviKvsVariant * v2,KviKvsVariant * v3)
+KviKvsVariantList::KviKvsVariantList(KviKvsVariant * pV1, KviKvsVariant * pV2, KviKvsVariant * pV3, KviKvsVariant * pV4)
 {
 	m_pList = new KviPointerList<KviKvsVariant>();
 	m_pList->setAutoDelete(true);
-	m_pList->append(v1);
-	m_pList->append(v2);
-	m_pList->append(v3);
+	m_pList->append(pV1);
+	m_pList->append(pV2);
+	m_pList->append(pV3);
+	m_pList->append(pV4);
 }
 
-KviKvsVariantList::KviKvsVariantList(KviKvsVariant * v1,KviKvsVariant * v2,KviKvsVariant * v3,KviKvsVariant * v4)
+KviKvsVariantList::KviKvsVariantList(KviKvsVariant * pV1, KviKvsVariant * pV2, KviKvsVariant * pV3, KviKvsVariant * pV4, KviKvsVariant * pV5)
 {
 	m_pList = new KviPointerList<KviKvsVariant>();
 	m_pList->setAutoDelete(true);
-	m_pList->append(v1);
-	m_pList->append(v2);
-	m_pList->append(v3);
-	m_pList->append(v4);
+	m_pList->append(pV1);
+	m_pList->append(pV2);
+	m_pList->append(pV3);
+	m_pList->append(pV4);
+	m_pList->append(pV5);
 }
 
-KviKvsVariantList::KviKvsVariantList(KviKvsVariant * v1,KviKvsVariant * v2,KviKvsVariant * v3,KviKvsVariant * v4,KviKvsVariant * v5)
+KviKvsVariantList::KviKvsVariantList(KviKvsVariant * pV1, KviKvsVariant * pV2, KviKvsVariant * pV3, KviKvsVariant * pV4, KviKvsVariant * pV5, KviKvsVariant * pV6)
 {
 	m_pList = new KviPointerList<KviKvsVariant>();
 	m_pList->setAutoDelete(true);
-	m_pList->append(v1);
-	m_pList->append(v2);
-	m_pList->append(v3);
-	m_pList->append(v4);
-	m_pList->append(v5);
+	m_pList->append(pV1);
+	m_pList->append(pV2);
+	m_pList->append(pV3);
+	m_pList->append(pV4);
+	m_pList->append(pV5);
+	m_pList->append(pV6);
 }
 
-KviKvsVariantList::KviKvsVariantList(KviKvsVariant * v1,KviKvsVariant * v2,KviKvsVariant * v3,KviKvsVariant * v4,KviKvsVariant * v5,KviKvsVariant * v6)
+KviKvsVariantList::KviKvsVariantList(KviKvsVariant * pV1, KviKvsVariant * pV2, KviKvsVariant * pV3, KviKvsVariant * pV4, KviKvsVariant * pV5, KviKvsVariant * pV6, KviKvsVariant * pV7)
 {
 	m_pList = new KviPointerList<KviKvsVariant>();
 	m_pList->setAutoDelete(true);
-	m_pList->append(v1);
-	m_pList->append(v2);
-	m_pList->append(v3);
-	m_pList->append(v4);
-	m_pList->append(v5);
-	m_pList->append(v6);
+	m_pList->append(pV1);
+	m_pList->append(pV2);
+	m_pList->append(pV3);
+	m_pList->append(pV4);
+	m_pList->append(pV5);
+	m_pList->append(pV6);
+	m_pList->append(pV7);
 }
 
-KviKvsVariantList::KviKvsVariantList(KviKvsVariant * v1,KviKvsVariant * v2,KviKvsVariant * v3,KviKvsVariant * v4,KviKvsVariant * v5,KviKvsVariant * v6,KviKvsVariant * v7)
+KviKvsVariantList::KviKvsVariantList(QString * pS1)
 {
 	m_pList = new KviPointerList<KviKvsVariant>();
 	m_pList->setAutoDelete(true);
-	m_pList->append(v1);
-	m_pList->append(v2);
-	m_pList->append(v3);
-	m_pList->append(v4);
-	m_pList->append(v5);
-	m_pList->append(v6);
-	m_pList->append(v7);
+	m_pList->append(new KviKvsVariant(pS1));
 }
 
-KviKvsVariantList::KviKvsVariantList(QString * s1)
+KviKvsVariantList::KviKvsVariantList(QString * pS1, QString * pS2)
 {
 	m_pList = new KviPointerList<KviKvsVariant>();
 	m_pList->setAutoDelete(true);
-	m_pList->append(new KviKvsVariant(s1));
+	m_pList->append(new KviKvsVariant(pS1));
+	m_pList->append(new KviKvsVariant(pS2));
 }
 
-KviKvsVariantList::KviKvsVariantList(QString * s1,QString * s2)
+KviKvsVariantList::KviKvsVariantList(QString * pS1, QString * pS2, QString * pS3)
 {
 	m_pList = new KviPointerList<KviKvsVariant>();
 	m_pList->setAutoDelete(true);
-	m_pList->append(new KviKvsVariant(s1));
-	m_pList->append(new KviKvsVariant(s2));
+	m_pList->append(new KviKvsVariant(pS1));
+	m_pList->append(new KviKvsVariant(pS2));
+	m_pList->append(new KviKvsVariant(pS3));
 }
 
-KviKvsVariantList::KviKvsVariantList(QString * s1,QString * s2,QString * s3)
+KviKvsVariantList::KviKvsVariantList(QString * pS1, QString * pS2, QString * pS3, QString * pS4)
 {
 	m_pList = new KviPointerList<KviKvsVariant>();
 	m_pList->setAutoDelete(true);
-	m_pList->append(new KviKvsVariant(s1));
-	m_pList->append(new KviKvsVariant(s2));
-	m_pList->append(new KviKvsVariant(s3));
+	m_pList->append(new KviKvsVariant(pS1));
+	m_pList->append(new KviKvsVariant(pS2));
+	m_pList->append(new KviKvsVariant(pS3));
+	m_pList->append(new KviKvsVariant(pS4));
 }
 
-KviKvsVariantList::KviKvsVariantList(QString * s1,QString * s2,QString * s3,QString * s4)
+KviKvsVariantList::KviKvsVariantList(QString * pS1, QString * pS2, QString * pS3, QString * pS4, QString * pS5)
 {
 	m_pList = new KviPointerList<KviKvsVariant>();
 	m_pList->setAutoDelete(true);
-	m_pList->append(new KviKvsVariant(s1));
-	m_pList->append(new KviKvsVariant(s2));
-	m_pList->append(new KviKvsVariant(s3));
-	m_pList->append(new KviKvsVariant(s4));
+	m_pList->append(new KviKvsVariant(pS1));
+	m_pList->append(new KviKvsVariant(pS2));
+	m_pList->append(new KviKvsVariant(pS3));
+	m_pList->append(new KviKvsVariant(pS4));
+	m_pList->append(new KviKvsVariant(pS5));
 }
 
-KviKvsVariantList::KviKvsVariantList(QString * s1,QString * s2,QString * s3,QString * s4,QString * s5)
+KviKvsVariantList::KviKvsVariantList(QString * pS1, QString * pS2, QString * pS3, QString * pS4, QString * pS5, QString * pS6)
 {
 	m_pList = new KviPointerList<KviKvsVariant>();
 	m_pList->setAutoDelete(true);
-	m_pList->append(new KviKvsVariant(s1));
-	m_pList->append(new KviKvsVariant(s2));
-	m_pList->append(new KviKvsVariant(s3));
-	m_pList->append(new KviKvsVariant(s4));
-	m_pList->append(new KviKvsVariant(s5));
+	m_pList->append(new KviKvsVariant(pS1));
+	m_pList->append(new KviKvsVariant(pS2));
+	m_pList->append(new KviKvsVariant(pS3));
+	m_pList->append(new KviKvsVariant(pS4));
+	m_pList->append(new KviKvsVariant(pS5));
+	m_pList->append(new KviKvsVariant(pS6));
 }
 
-KviKvsVariantList::KviKvsVariantList(QString * s1,QString * s2,QString * s3,QString * s4,QString * s5,QString * s6)
+KviKvsVariantList::KviKvsVariantList(QString * pS1, QString * pS2, QString * pS3, QString * pS4, QString * pS5, QString * pS6, QString * pS7)
 {
 	m_pList = new KviPointerList<KviKvsVariant>();
 	m_pList->setAutoDelete(true);
-	m_pList->append(new KviKvsVariant(s1));
-	m_pList->append(new KviKvsVariant(s2));
-	m_pList->append(new KviKvsVariant(s3));
-	m_pList->append(new KviKvsVariant(s4));
-	m_pList->append(new KviKvsVariant(s5));
-	m_pList->append(new KviKvsVariant(s6));
+	m_pList->append(new KviKvsVariant(pS1));
+	m_pList->append(new KviKvsVariant(pS2));
+	m_pList->append(new KviKvsVariant(pS3));
+	m_pList->append(new KviKvsVariant(pS4));
+	m_pList->append(new KviKvsVariant(pS5));
+	m_pList->append(new KviKvsVariant(pS6));
+	m_pList->append(new KviKvsVariant(pS7));
 }
 
 KviKvsVariantList::~KviKvsVariantList()
@@ -170,30 +181,34 @@ void KviKvsVariantList::setAutoDelete(bool bAutoDelete)
 	m_pList->setAutoDelete(bAutoDelete);
 }
 
-void KviKvsVariantList::allAsString(QString &szBuffer)
+void KviKvsVariantList::allAsString(QString & szBuffer)
 {
 	szBuffer = QString();
 	bool bFirst = true;
-	for(KviKvsVariant * v = first();v;v = next())
+	for(KviKvsVariant * v = first(); v; v = next())
 	{
-		if(bFirst)bFirst = false;
-		else szBuffer.append(' ');
+		if(bFirst)
+			bFirst = false;
+		else
+			szBuffer.append(' ');
 		v->appendAsString(szBuffer);
 	}
 }
 
-bool KviKvsVariantList::firstAsString(QString &szBuffer)
+bool KviKvsVariantList::firstAsString(QString & szBuffer)
 {
 	KviKvsVariant * v = first();
-	if(!v)return false;
+	if(!v)
+		return false;
 	v->asString(szBuffer);
 	return true;
 }
 
-bool KviKvsVariantList::nextAsString(QString &szBuffer)
+bool KviKvsVariantList::nextAsString(QString & szBuffer)
 {
 	KviKvsVariant * v = next();
-	if(!v)return false;
+	if(!v)
+		return false;
 	v->asString(szBuffer);
 	return true;
 }
diff --git a/src/kvirc/kvs/kvi_kvs_variantlist.h b/src/kvirc/kvs/kvi_kvs_variantlist.h
index 26510c513..16df64a3d 100644
--- a/src/kvirc/kvs/kvi_kvs_variantlist.h
+++ b/src/kvirc/kvs/kvi_kvs_variantlist.h
@@ -6,7 +6,7 @@
 //   Creation date : Sat 11 Oct 2003 02:20:51 by Szymon Stefanek
 //
 //   This file is part of the KVIrc IRC client distribution
-//   Copyright (C) 2003-2008 Szymon Stefanek <pragma at kvirc dot net>
+//   Copyright (C) 2003-2010 Szymon Stefanek <pragma at kvirc dot net>
 //
 //   This program is FREE software. You can redistribute it and/or
 //   modify it under the terms of the GNU General Public License
@@ -24,58 +24,298 @@
 //
 //=============================================================================
 
+/**
+* \file kvi_kvs_variantlist.h
+* \author Szymon Stefanek
+* \brief Parser class to handle variant variables lists
+*/
+
 #include "kvi_settings.h"
 #include "kvi_pointerlist.h"
 #include "kvi_kvs_variant.h"
 
-
-
+/**
+* \class KviKvsVariantList
+* \brief Class to handle variant variables lists
+*/
 class KVIRC_API KviKvsVariantList
 {
 public:
+	/**
+	* \brief Constructs the KviKvsVariantList object
+	* \return KviKvsVariantList
+	*/
 	KviKvsVariantList();
-	KviKvsVariantList(KviKvsVariant * v1);
-	KviKvsVariantList(KviKvsVariant * v1,KviKvsVariant * v2);
-	KviKvsVariantList(KviKvsVariant * v1,KviKvsVariant * v2,KviKvsVariant * v3);
-	KviKvsVariantList(KviKvsVariant * v1,KviKvsVariant * v2,KviKvsVariant * v3,KviKvsVariant * v4);
-	KviKvsVariantList(KviKvsVariant * v1,KviKvsVariant * v2,KviKvsVariant * v3,KviKvsVariant * v4,KviKvsVariant * v5);
-	KviKvsVariantList(KviKvsVariant * v1,KviKvsVariant * v2,KviKvsVariant * v3,KviKvsVariant * v4,KviKvsVariant * v5,KviKvsVariant * v6);
-	KviKvsVariantList(KviKvsVariant * v1,KviKvsVariant * v2,KviKvsVariant * v3,KviKvsVariant * v4,KviKvsVariant * v5,KviKvsVariant * v6,KviKvsVariant * v7);
-	KviKvsVariantList(QString * s1);
-	KviKvsVariantList(QString * s1,QString * s2);
-	KviKvsVariantList(QString * s1,QString * s2,QString * s3);
-	KviKvsVariantList(QString * s1,QString * s2,QString * s3,QString * s4);
-	KviKvsVariantList(QString * s1,QString * s2,QString * s3,QString * s4,QString * s5);
-	KviKvsVariantList(QString * s1,QString * s2,QString * s3,QString * s4,QString * s5,QString * s6);
+
+	/**
+	* \brief Constructs the KviKvsVariantList object
+	* \param pV1 The first element's list
+	* \return KviKvsVariantList
+	*/
+	KviKvsVariantList(KviKvsVariant * pV1);
+
+	/**
+	* \brief Constructs the KviKvsVariantList object
+	* \param pV1 The first element's list
+	* \param pV2 The second element's list
+	* \return KviKvsVariantList
+	*/
+	KviKvsVariantList(KviKvsVariant * pV1, KviKvsVariant * pV2);
+
+	/**
+	* \brief Constructs the KviKvsVariantList object
+	* \param pV1 The first element's list
+	* \param pV2 The second element's list
+	* \param pV3 The third element's list
+	* \return KviKvsVariantList
+	*/
+	KviKvsVariantList(KviKvsVariant * pV1, KviKvsVariant * pV2, KviKvsVariant * pV3);
+
+	/**
+	* \brief Constructs the KviKvsVariantList object
+	* \param pV1 The first element's list
+	* \param pV2 The second element's list
+	* \param pV3 The third element's list
+	* \param pV4 The fourth element's list
+	* \return KviKvsVariantList
+	*/
+	KviKvsVariantList(KviKvsVariant * pV1, KviKvsVariant * pV2, KviKvsVariant * pV3, KviKvsVariant * pV4);
+
+	/**
+	* \brief Constructs the KviKvsVariantList object
+	* \param pV1 The first element's list
+	* \param pV2 The second element's list
+	* \param pV3 The third element's list
+	* \param pV4 The fourth element's list
+	* \param pV5 The fifth element's list
+	* \return KviKvsVariantList
+	*/
+	KviKvsVariantList(KviKvsVariant * pV1, KviKvsVariant * pV2, KviKvsVariant * pV3, KviKvsVariant * pV4, KviKvsVariant * pV5);
+
+	/**
+	* \brief Constructs the KviKvsVariantList object
+	* \param pV1 The first element's list
+	* \param pV2 The second element's list
+	* \param pV3 The third element's list
+	* \param pV4 The fourth element's list
+	* \param pV5 The fifth element's list
+	* \param pV6 The sixth element's list
+	* \return KviKvsVariantList
+	*/
+	KviKvsVariantList(KviKvsVariant * pV1, KviKvsVariant * pV2, KviKvsVariant * pV3, KviKvsVariant * pV4, KviKvsVariant * pV5, KviKvsVariant * pV6);
+
+	/**
+	* \brief Constructs the KviKvsVariantList object
+	* \param pV1 The first element's list
+	* \param pV2 The second element's list
+	* \param pV3 The third element's list
+	* \param pV4 The fourth element's list
+	* \param pV5 The fifth element's list
+	* \param pV6 The sixth element's list
+	* \param pV7 The seventh element's list
+	* \return KviKvsVariantList
+	*/
+	KviKvsVariantList(KviKvsVariant * pV1, KviKvsVariant * pV2, KviKvsVariant * pV3, KviKvsVariant * pV4, KviKvsVariant * pV5, KviKvsVariant * pV6, KviKvsVariant * pV7);
+
+	/**
+	* \brief Constructs the KviKvsVariantList object
+	* \param pS1 The first element's list
+	* \return KviKvsVariantList
+	*/
+	KviKvsVariantList(QString * pS1);
+
+	/**
+	* \brief Constructs the KviKvsVariantList object
+	* \param pS1 The first element's list
+	* \param pS2 The second element's list
+	* \return KviKvsVariantList
+	*/
+	KviKvsVariantList(QString * pS1, QString * pS2);
+
+	/**
+	* \brief Constructs the KviKvsVariantList object
+	* \param pS1 The first element's list
+	* \param pS2 The second element's list
+	* \param pS3 The third element's list
+	* \return KviKvsVariantList
+	*/
+	KviKvsVariantList(QString * pS1, QString * pS2, QString * pS3);
+
+	/**
+	* \brief Constructs the KviKvsVariantList object
+	* \param pS1 The first element's list
+	* \param pS2 The second element's list
+	* \param pS3 The third element's list
+	* \param pS4 The fourth element's list
+	* \return KviKvsVariantList
+	*/
+	KviKvsVariantList(QString * pS1, QString * pS2, QString * pS3, QString * pS4);
+
+	/**
+	* \brief Constructs the KviKvsVariantList object
+	* \param pS1 The first element's list
+	* \param pS2 The second element's list
+	* \param pS3 The third element's list
+	* \param pS4 The fourth element's list
+	* \param pS5 The fifth element's list
+	* \return KviKvsVariantList
+	*/
+	KviKvsVariantList(QString * pS1, QString * pS2, QString * pS3, QString * pS4, QString * pS5);
+
+	/**
+	* \brief Constructs the KviKvsVariantList object
+	* \param pS1 The first element's list
+	* \param pS2 The second element's list
+	* \param pS3 The third element's list
+	* \param pS4 The fourth element's list
+	* \param pS5 The fifth element's list
+	* \param pS6 The sixth element's list
+	* \return KviKvsVariantList
+	*/
+	KviKvsVariantList(QString * pS1, QString * pS2, QString * pS3, QString * pS4, QString * pS5, QString * pS6);
+
+	/**
+	* \brief Constructs the KviKvsVariantList object
+	* \param pS1 The first element's list
+	* \param pS2 The second element's list
+	* \param pS3 The third element's list
+	* \param pS4 The fourth element's list
+	* \param pS5 The fifth element's list
+	* \param pS6 The sixth element's list
+	* \param pS7 The seventh element's list
+	* \return KviKvsVariantList
+	*/
+	KviKvsVariantList(QString * pS1, QString * pS2, QString * pS3, QString * pS4, QString * pS5, QString * pS6, QString * pS7);
+
+	/**
+	* \brief Destroys the KviKvsVariantList object
+	*/
 	~KviKvsVariantList();
 protected:
 	KviPointerList<KviKvsVariant> * m_pList;
 public:
+	/**
+	* \brief Returns the first element of the list
+	* \return KviKvsVariant *
+	*/
 	KviKvsVariant * first(){ return m_pList->first(); };
+
+	/**
+	* \brief Returns the next element of the list
+	* \return KviKvsVariant *
+	*/
 	KviKvsVariant * next(){ return m_pList->next(); };
+
+	/**
+	* \brief Returns the element of the list at the given index
+	* \param iIdx The index of the list we want to extract
+	* \return KviKvsVariant *
+	*/
 	KviKvsVariant * at(int iIdx){ return m_pList->at(iIdx); };
+
+	/**
+	* \brief Returns the size of the list
+	* \return unsigned int
+	*/
 	unsigned int count(){ return m_pList->count(); };
 
+	/**
+	* \brief Clears the list
+	* \return void
+	*/
 	void clear(){ m_pList->clear(); };
 
-	void append(const QString &szParam, bool bEscape=false){ m_pList->append(new KviKvsVariant(szParam, bEscape)); };
-	void append(kvs_int_t iInteger){ m_pList->append(new KviKvsVariant(iInteger)); };
+	/**
+	* \brief Appends an element to the list
+	* \param pItem The element to append
+	* \return void
+	*/
+	void append(KviKvsVariant * pItem){ m_pList->append(pItem); };
+
+	/**
+	* \brief Prepends an element to the list
+	* \param pItem The element to prepend
+	* \return void
+	*/
+	void prepend(KviKvsVariant * pItem){ m_pList->prepend(pItem); };
+
+	/**
+	* \brief Appends an element to the list
+	* \param szParam The string element to append
+	* \param bEscape Whether the string has to be escaped for KVS
+	* \return void
+	*/
+	void append(const QString & szParam, bool bEscape = false){ m_pList->append(new KviKvsVariant(szParam,bEscape)); };
+
+	/**
+	* \brief Appends an element to the list
+	* \param iInt The integer element to append
+	* \return void
+	*/
+	void append(kvs_int_t iInt){ m_pList->append(new KviKvsVariant(iInt)); };
+
+	/**
+	* \brief Appends an element to the list
+	* \param dReal The real element to append
+	* \return void
+	*/
 	void append(kvs_real_t dReal){ m_pList->append(new KviKvsVariant(dReal)); };
+
+	/**
+	* \brief Appends an element to the list
+	* \param bBoolean The boolean element to append
+	* \return void
+	*/
 	void append(bool bBoolean){ m_pList->append(new KviKvsVariant(bBoolean)); };
+
+	/**
+	* \brief Appends an element to the list
+	* \param hObject The hObject element to append
+	* \return void
+	*/
 	void append(kvs_hobject_t hObject){ m_pList->append(new KviKvsVariant(hObject)); };
+
+	/**
+	* \brief Appends an element to the list
+	* \param pArray The array element to append
+	* \return void
+	*/
 	void append(KviKvsArray * pArray){ m_pList->append(new KviKvsVariant(pArray)); };
-	void append(KviKvsHash * pHash){ m_pList->append(new KviKvsVariant(pHash)); };
 
-	void append(KviKvsVariant * v){ m_pList->append(v); };
-	void prepend(KviKvsVariant * v){ m_pList->prepend(v); };
+	/**
+	* \brief Appends an element to the list
+	* \param pHash The hash element to append
+	* \return void
+	*/
+	void append(KviKvsHash * pHash){ m_pList->append(new KviKvsVariant(pHash)); };
 
+	/**
+	* \brief Sets the auto delete flag on the list
+	* \param bAutoDelete Whether the list has to auto delete itself
+	* \return void
+	*/
 	void setAutoDelete(bool bAutoDelete); // this is TRUE by default
 
-	void allAsString(QString &szBuffer);
-	// returns true if there was a first parameter at all
-	bool firstAsString(QString &szBuffer);
-	// returns true if there was a next parameter at all
-	bool nextAsString(QString &szBuffer);
+	/**
+	* \brief Appends all elements in a single string delimited by spaces
+	* \param szBuffer The buffer where to store the string
+	* \return void
+	*/
+	void allAsString(QString & szBuffer);
+
+	/**
+	* \brief Returns true if there was a first parameter at all
+	* \param szBuffer The buffer where to store the string
+	* \return bool
+	*/
+	bool firstAsString(QString & szBuffer);
+
+	/**
+	* \brief Returns true if there was a next parameter at all
+	* \param szBuffer The buffer where to store the string
+	* \return bool
+	*/
+	bool nextAsString(QString & szBuffer);
 };
 
-#endif //!_KVI_KVS_VARIANTLIST_H_
+#endif // _KVI_KVS_VARIANTLIST_H_