variantdata.h

来自「这是VCF框架的代码」· C头文件 代码 · 共 840 行 · 第 1/2 页

#ifndef _VCF_VARIANTDATA_H__
#define _VCF_VARIANTDATA_H__
//VariantData.h

/*
Copyright 2000-2004 The VCF Project.
Please see License.txt in the top level directory
where you installed the VCF.
*/


#if _MSC_VER > 1000
#   pragma once
#endif



namespace VCF {


/**
\class VariantData VariantData.h "vcf/FoundationKit/VariantData.h"
VariantData represents an unknown type of variable - similiar to
Visual Basic's Variant object.
VariantData objects can store int, long, double, bool String, or Object*.
VariantData overrides conversion operators and provides operator equals overloads
to handle the conversion from one type to another. Setting the value of a VariantData
automatically sets the type. For example:
\code
	VariantData val;
	int i = 123;
	val = i; //automatically sets the VariantData::type to equal pdInt
\endcode
To convert from one type to another is equally simple:
\code
	VariantData val;
	int i;
	double d;
	val = 234.8546; //val is 234.8546 and is set to the correct type
	d = val; //val is converted to a double and d is assigned the value 234.8546
	val = 123; //val is now assigned an int (or whatever the compiler assumes 123 is )
	i = val;	//i is now equal to 123
\endcode
Strings are a special case, since the compiler will not allow a union to be made with them,
thus the reason for the StringVal member outside of the union.
VariantData objects can also have their data render as a string and can be assigned strings
and convert then to the correct data value.
*
*@version 1.0
*@author Jim Crafton
*/
class FOUNDATIONKIT_API VariantData  {
public:

	enum {
		DefaultPropertyValLength = 50
	};

	/**
	creates an empty, undefined object
	*/
	VariantData(){
		ObjVal = NULL;
		this->type = pdUndefined;
	};

	/**
	creates a VariantData initialized by an int value
	*/
	VariantData( const int& val ) {
		IntVal = val;
		type = pdInt;
	};

	/**
	creates a VariantData initialized by an unsigned int value
	*/
	VariantData( const unsigned int& val ) {
		UIntVal = val;
		type = pdUInt;
	};

	/**
	creates a VariantData initialized by a long value
	*/
	VariantData( const long& val ) {
		LongVal = val;
		type = pdLong;
	};

	/**
	creates a VariantData initialized by an unsigned long value
	*/
	VariantData( const unsigned long& val ) {
		ULongVal = val;
		type = pdULong;
	};

	/**
	creates a VariantData initialized by a float value
	*/
	VariantData( const float& val ) {
		FloatVal = val;
		type = pdFloat;
	};

	/**
	creates a VariantData initialized by a double value
	*/
	VariantData( const double& val ) {
		DblVal = val;
		type = pdDouble;
	};

	/**
	creates a VariantData initialized by a char value
	*/
	VariantData( const char& val ) {
		CharVal = val;
		type = pdChar;
	};

	/**
	creates a VariantData initialized by a bool value
	*/
	VariantData( const bool& val ) {
		BoolVal = val;
		type = pdBool;
	};

	/**
	creates a VariantData initialized by a short value
	*/
	VariantData( const short& val ) {
		ShortVal = val;
		type = pdShort;
	};

	/**
	creates a VariantData initialized by a short value
	*/
	VariantData( const ushort& val ) {
		UShortVal = val;
		type = pdUShort;
	};


	/**
	creates a VariantData initialized by a String value
	*/
	VariantData( const String& val ) {
		StringVal = val;
		type = pdString;
	};

	VariantData( const char* val ) {
		StringVal = val;
		type = pdString;
	};

	VariantData( const WideChar* val ) {
		StringVal = val;
		type = pdString;
	};

	/**
	creates a VariantData initialized by a Enum value
	*/
	VariantData( const Enum& val ) {
		EnumVal.set( const_cast<Enum*>(&val) );
		type = pdEnum;
	};

	/**
	creates a VariantData initialized by a Enum value
	*/
	VariantData( Enum& val ) {
		EnumVal.set( &val );
		type = pdEnum;
	};

	/**
	creates a VariantData initialized by a Enum* value
	*/
	VariantData( Enum* val ) {
		EnumVal.set( val );
		type = pdEnum;
	};

	/**
	creates a VariantData initialized by a Object* value
	*/
	VariantData( Object* val ) {
		ObjVal = val;
		type = pdObject;
	}

	/**
	creates a VariantData initialized by a Object& value
	*/
	VariantData( Object& val ) {
		ObjVal = &val;
		type = pdObject;
	}

	/**
	creates a VariantData initialized by a const Object& value
	*/
	VariantData( const Object& val ){
		ObjVal = const_cast<Object*>(&val);
		type = pdObject;
	}

	/**
	creates a VariantData initialized by a Interface* value
	*/
	VariantData( Interface* val ){
		InterfaceVal = val;
		type = pdInterface;
	}

#ifdef VCF_VARIANT64
	/**
	creates a Variant initialized by a long64 value
	*/
	VariantData( const VCF::long64& val ) {
		Long64Val = val;
		type = pdLong64;
	};

	/**
	creates a Variant initialized by a ulong64 value
	*/
	VariantData( const VCF::ulong64& val ) {
		ULong64Val = val;
		type  = pdULong64;
	};

	/**
	creates a Variant initialized by a DateTime value
	*/
	VariantData( const DateTime& val ) {
		Long64Val = ( val.operator long64() ).data_; // (ulong64::u64_t) (VCF::ulong64&) val;
		type  = pdDateTime;
	};

	/**
	creates a Variant initialized by a DateTimeSpan value
	*/
	VariantData( const DateTimeSpan& val ) {
		Long64Val = ( val.operator long64() ).data_; // (ulong64::u64_t) (VCF::ulong64&) val;
		type  = pdDateTimeSpan;
	};

	///**
	//creates a Variant initialized by a Color value
	//*/
	//VariantData( const Color& val ) {
	//	Long64Val = ( val.operator long64() ).data_; // (ulong64::u64_t) (VCF::ulong64&) val;
	//	type  = pdDateTimeSpan;
	//};

#endif // VCF_VARIANT64

	/**
	copy constructor
	*/
	VariantData( const VariantData& value ){
		this->type = value.type;
		this->setValue( value );
	};

	/**
	destructor
	*/
	virtual ~VariantData(){};

public:


	/**
	comparison operator
	*/
	bool operator == ( const VariantData& v ) const {
		return (	type == v.type &&
		          ( ( type == pdString && StringVal == v.StringVal ) ||
		            ( type != pdString && ObjVal == v.ObjVal ) )
		          );
	}

	/**
	comparison operator
	*/
	bool operator != ( const VariantData& v ) const {
		return ( !operator==( v ) );
	}

	/**
	*
	conversion operators
	*
	*/



	/**
	converts the VariantData to an int
	*/
	operator int () const {
		return IntVal;
	};

	/**
	converts the VariantData to an long
	*/
	operator long () const {
		return LongVal;
	};

	/**
	converts the VariantData to an short
	*/
	operator short () const {
		return ShortVal;
	};

	/**
	converts the VariantData to an unsigned short
	*/
	operator ushort () const {
		return UShortVal;
	};

	/**
	converts the VariantData to an unsigned int
	*/
	operator unsigned int () const {
		return UIntVal;
	};

	/**
	converts the VariantData to an unsigned long
	*/
	operator unsigned long () const {
		return ULongVal;
	};

	/**
	converts the VariantData to an float
	*/
	operator float () const {
		return FloatVal;
	};

	/**
	converts the VariantData to an char
	*/
	operator char () const {
		return CharVal;
	};

	/**
	converts the VariantData to an double
	*/
	operator double () const {
		return DblVal;
	};

	/**
	converts the VariantData to an Interface pointer
	*/
	operator Interface* () const {
		return InterfaceVal;
	}

	/**
	converts the VariantData to an Object pointer
	*/
	operator Object* () const {
		return ObjVal;
	};

	/**
	converts the VariantData to an Object reference
	*/
	operator Object& () const {
		return *ObjVal;
	};

	/**
	converts the VariantData to an String
	*/
	operator String () const {
		return StringVal;
	};

	/**
	converts the VariantData to a bool
	*/
	operator bool () const {
		return BoolVal;
	};

	/**
	converts the VariantData to an Enum pointer
	*/
	operator Enum* () const {
		return EnumVal.getEnum();
	};

	/**
	converts the VariantData to an Enum reference
	*/
	operator Enum& () const {
		return *EnumVal.getEnum();
	};

#ifdef VCF_VARIANT64
	/**
	converts the Variant to a long64