Source: classlib/include/cvariant.h

/***************************************************************************
			cvariant.h  -  classe wrapper per tipo variant
                             -------------------
    begin                : Mon Oct 7 2002
    copyright            : (C) 2002 by Nicola De Nisco
    email                : nicola@winada.it
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef __CVARIANT_H
#define __CVARIANT_H

#include 

/**

	class Variant

	A class able to contain various data types.
	It's almost compatible with the MFC version
	of this object.

*/

class Variant
{
public:
	inline Variant() {
		VariantInit(&v);
	}
	inline Variant(short val) {
		Int16ToVariant(val, &v);
	}
	inline Variant(int val) {
		Int32ToVariant(val, &v);
	}
	inline Variant(long val) {
		Int32ToVariant(val, &v);
	}
	inline Variant(float val) {
		FloatToVariant(val, &v);
	}
	inline Variant(double val) {
		DoubleToVariant(val, &v);
	}
	inline Variant(LPCSTR val) {
		StringToVariant(val, &v);
	}
	inline Variant(LPCSTR val, int maxlen) {
		SafeStringToVariant(val, &v, maxlen);
	}

	inline virtual ~Variant() {
		VariantClear(&v);
	}

	inline short getShort() {
		return VariantToInt16(&v);
	}
	inline int getInt() {
		return VariantToInt32(&v);
	}
	inline float getFloat() {
		return VariantToFloat(&v);
	}
	inline double getDouble() {
		return VariantToDouble(&v);
	}
	inline char* getString() {
		return VariantToString(&v);
	}
	inline DATE getDate() {
		return VariantToDate(&v);
	}
	inline BOOL getBOOL() {
		return VariantToBOOL(&v);
	}

	inline short operator=(short val) {
		VariantClear(&v);
		Int16ToVariant(val, &v);
		return val;
	}
	inline int operator=(int val) {
		VariantClear(&v);
		Int32ToVariant(val, &v);
		return val;
	}
	inline long operator=(long val) {
		VariantClear(&v);
		Int32ToVariant(val, &v);
		return val;
	}
	inline float operator=(float val) {
		VariantClear(&v);
		FloatToVariant(val, &v);
		return val;
	}
	inline double operator=(double val) {
		VariantClear(&v);
		DoubleToVariant(val, &v);
		return val;
	}
	inline LPCSTR operator=(LPCSTR val) {
		VariantClear(&v);
		StringToVariant(val, &v);
		return val;
	}
	
	inline VARIANT* getVariant() {return &v;}

	inline int Send(int sock, int flags = MSG_NOSIGNAL) {
		return sendVariant(sock, &v, flags);
	}
	inline int Recv(int sock, int flags = MSG_NOSIGNAL | MSG_WAITALL) {
		return recvVariant(sock, &v, flags);
	}
	inline int Read(int handle) {
		return readVariant(handle, &v);
	}
	inline int Write(int handle) {
		return writeVariant(handle, &v);
	}

	inline int operator==(const Variant& o) const {return &o == this;}
		
protected:
	VARIANT v;
};


#endif // __CVARIANT_H