#ifndef _COM_VARIANT_HPP_
#define _COM_VARIANT_HPP_
#ifndef _COM_OLE2_HPP_
#include <com/ole2.hpp>
#endif
#ifndef _COM_OBJIDL_HPP_
#include <com/objidl.hpp>
#endif
#ifndef _COM_RESULT_HPP_
#include <com/result.hpp>
#endif
#ifndef _COM_BSTRING_HPP_
#include <com/bstring.hpp>
#endif

class SafeArray;

typedef enum VariantType{VTEmpty=VT_EMPTY,VTUint=VT_UINT,VTInt=VT_INT,VTInt1=VT_I1,VTInt2=VT_I2,VTInt4=VT_I4,VTInt8=VT_I8,VTReal4=VT_R4,VTReal8=VT_R8,
                         VTCcy=VT_CY,VTBStr=VT_BSTR,VTError=VT_ERROR,VTBool=VT_BOOL,VTVariant=VT_VARIANT,VTUChar=VT_UI1,VTArray=VT_ARRAY,
												 VTDispatch=VT_DISPATCH,VTUnknown=VT_UNKNOWN,VTNull=VT_NULL,VTDate=VT_DATE,VTDecimal=VT_DECIMAL,VTUShort=VT_UI2,
	                       VTUInt4=VT_UI4,VTUInt8=VT_UI8,VTVoid=VT_VOID,VTHResult=VT_HRESULT,VTPtr=VT_PTR,VTSafeArray=VT_SAFEARRAY,VTCArray=VT_CARRAY,
	                       VTUserDefined=VT_USERDEFINED,VTLPSTR=VT_LPSTR,VTLPWSTR=VT_LPWSTR,VTFileTime=VT_FILETIME,VTBlob=VT_BLOB,VTStream=VT_STREAM,
	                       VTStorage=VT_STORAGE,VTClipboardFormat=VT_CF,VTClassID=VT_CLSID,VTVector=VT_VECTOR,VTByRef=VT_BYREF};

class Variant : private tagVARIANT
{
public:
  enum Disposition{Assume,Delete};
  Variant(void);
	virtual ~Variant();
	Variant &operator=(const Variant &someVariant);
  bool changeType(VariantType varType);
  bool changeType(Variant &someVariant,VariantType varType);
	bool setData(BString &string);
	bool getData(BString &string);
	bool getData(SafeArray &safeArray);
	bool getData(VariantType variantType,void *pData);
	bool setData(const long &data);
	bool setData(SafeArray &safeArray);
	VariantType getType(void)const;
  tagVARIANT &getVARIANT(void);
	const ComResult &getLastResult(void)const;
	Disposition disposition(void)const;
	void disposition(Disposition disposition);
	bool clear(void);
private:
  void init(void);  

	ComResult mLastResult;
	Disposition mDisposition;
};

inline
Variant &Variant::operator=(const Variant &someVariant)
{
  mLastResult=::VariantCopyInd(&getVARIANT(),&((Variant&)someVariant).getVARIANT());
  return *this;
}

inline
tagVARIANT &Variant::getVARIANT(void)
{
  return *this;
}

inline
void Variant::init(void)
{
  ::VariantInit(&getVARIANT());
}

inline
bool Variant::changeType(VariantType varType)
{
  mLastResult=::VariantChangeType(&getVARIANT(),&getVARIANT(),0,varType);
	return mLastResult.success();
}

inline
bool Variant::changeType(Variant &someVariant,VariantType varType)
{
  mLastResult=::VariantChangeType(&someVariant.getVARIANT(),&getVARIANT(),0,varType);
	return mLastResult.success();
}

inline
bool Variant::setData(BString &string)
{
  if(tagVARIANT::vt!=VTBStr)return false;
	tagVARIANT::bstrVal=(wchar_t*)string.str();
	return true;
}

inline
bool Variant::setData(const long &data)
{
  if(tagVARIANT::vt!=VTInt4&&!changeType(VTInt4))return false;
	tagVARIANT::lVal=data;
	return true;
}

inline
bool Variant::getData(BString &string)
{
  if(tagVARIANT::vt!=VTBStr||!tagVARIANT::bstrVal)return false;
	string=tagVARIANT::bstrVal;
	return true;
}

inline
VariantType Variant::getType(void)const
{
  return VariantType(tagVARIANT::vt);
}

inline
bool Variant::clear(void)
{
  if(Assume==disposition())return true;
  mLastResult=::VariantClear(&getVARIANT());
  return mLastResult.success();
}

inline
const ComResult &Variant::getLastResult(void)const
{
  return mLastResult;
}

inline
Variant::Disposition Variant::disposition(void)const
{
  return mDisposition;
}

inline
void Variant::disposition(Disposition disposition)
{
  mDisposition=disposition;
}
#endif