1892 lines
46 KiB
C++
1892 lines
46 KiB
C++
#pragma once
|
|
/****************************************************************************
|
|
Copyright (c) 2006, Radon Labs GmbH
|
|
Copyright (c) 2011-2013,WebJet Business Division,CYOU
|
|
|
|
http://www.genesis-3d.com.cn
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
****************************************************************************/
|
|
|
|
#include "math/float4.h"
|
|
#include "math/matrix44.h"
|
|
#include "util/string.h"
|
|
#include "util/guid.h"
|
|
#include "util/blob.h"
|
|
#include "memory/memory.h"
|
|
#include "core/refcounted.h"
|
|
|
|
//------------------------------------------------------------------------------
|
|
namespace Util
|
|
{
|
|
class Variant
|
|
{
|
|
public:
|
|
/// variant types
|
|
enum Type
|
|
{
|
|
Void,
|
|
Int,
|
|
Float,
|
|
Bool,
|
|
Float4,
|
|
String,
|
|
Matrix44,
|
|
Blob,
|
|
Guid,
|
|
Object,
|
|
IntArray,
|
|
FloatArray,
|
|
BoolArray,
|
|
Float4Array,
|
|
StringArray,
|
|
Matrix44Array,
|
|
BlobArray,
|
|
GuidArray,
|
|
};
|
|
|
|
/// default constructor
|
|
Variant();
|
|
/// int constructor
|
|
Variant(int rhs);
|
|
/// float constructor
|
|
Variant(float rhs);
|
|
/// bool constructor
|
|
Variant(bool rhs);
|
|
/// float4 constructor
|
|
Variant(const Math::float4& v);
|
|
/// matrix44 constructor
|
|
Variant(const Math::matrix44& m);
|
|
/// string constructor
|
|
Variant(const Util::String& rhs);
|
|
/// blob constructor
|
|
Variant(const Util::Blob& blob);
|
|
/// guid constructor
|
|
Variant(const Util::Guid& guid);
|
|
/// const char constructor
|
|
Variant(const char* chrPtr);
|
|
/// object constructor
|
|
Variant(Core::RefCounted* ptr);
|
|
/// int array constructor
|
|
Variant(const Util::Array<int>& rhs);
|
|
/// float array constructor
|
|
Variant(const Util::Array<float>& rhs);
|
|
/// bool array constructor
|
|
Variant(const Util::Array<bool>& rhs);
|
|
/// float4 array constructor
|
|
Variant(const Util::Array<Math::float4>& rhs);
|
|
/// matrix44 array constructor
|
|
Variant(const Util::Array<Math::matrix44>& rhs);
|
|
/// string array constructor
|
|
Variant(const Util::Array<Util::String>& rhs);
|
|
/// blob array constructor
|
|
Variant(const Util::Array<Util::Blob>& rhs);
|
|
/// guid array constructor
|
|
Variant(const Util::Array<Util::Guid>& rhs);
|
|
/// copy constructor
|
|
Variant(const Variant& rhs);
|
|
|
|
/// destructor
|
|
~Variant();
|
|
/// set type of attribute
|
|
void SetType(Type t);
|
|
/// get type
|
|
Type GetType() const;
|
|
/// clear content, resets type to void
|
|
void Clear();
|
|
|
|
/// assignment operator
|
|
void operator=(const Variant& rhs);
|
|
/// int assignment operator
|
|
void operator=(int val);
|
|
/// float assignment operator
|
|
void operator=(float val);
|
|
/// bool assigment operator
|
|
void operator=(bool val);
|
|
/// float4 assignment operator
|
|
void operator=(const Math::float4& val);
|
|
/// matrix44 assignment operator
|
|
void operator=(const Math::matrix44& val);
|
|
/// string assignment operator
|
|
void operator=(const Util::String& s);
|
|
/// blob assignment operator
|
|
void operator=(const Util::Blob& val);
|
|
/// guid assignment operator
|
|
void operator=(const Util::Guid& val);
|
|
/// char pointer assignment
|
|
void operator=(const char* chrPtr);
|
|
/// object assignment
|
|
void operator=(Core::RefCounted* ptr);
|
|
/// int array assignment
|
|
void operator=(const Util::Array<int>& rhs);
|
|
/// float array assignment
|
|
void operator=(const Util::Array<float>& rhs);
|
|
/// bool array assignment
|
|
void operator=(const Util::Array<bool>& rhs);
|
|
/// float4 array assignment
|
|
void operator=(const Util::Array<Math::float4>& rhs);
|
|
/// matrix44 array assignment
|
|
void operator=(const Util::Array<Math::matrix44>& rhs);
|
|
/// string array assignment
|
|
void operator=(const Util::Array<Util::String>& rhs);
|
|
/// blob array assignment
|
|
void operator=(const Util::Array<Util::Blob>& rhs);
|
|
/// guid array assignment
|
|
void operator=(const Util::Array<Util::Guid>& rhs);
|
|
|
|
/// equality operator
|
|
bool operator==(const Variant& rhs) const;
|
|
/// int equality operator
|
|
bool operator==(int rhs) const;
|
|
/// float equality operator
|
|
bool operator==(float rhs) const;
|
|
/// bool equality operator
|
|
bool operator==(bool rhs) const;
|
|
/// float4 equality operator
|
|
bool operator==(const Math::float4& rhs) const;
|
|
/// string equality operator
|
|
bool operator==(const Util::String& rhs) const;
|
|
/// guid equality operator
|
|
bool operator==(const Util::Guid& rhs) const;
|
|
/// char ptr equality operator
|
|
bool operator==(const char* chrPtr) const;
|
|
/// pointer equality operator
|
|
bool operator==(Core::RefCounted* ptr) const;
|
|
|
|
/// inequality operator
|
|
bool operator!=(const Variant& rhs) const;
|
|
/// int inequality operator
|
|
bool operator!=(int rhs) const;
|
|
/// float inequality operator
|
|
bool operator!=(float rhs) const;
|
|
/// bool inequality operator
|
|
bool operator!=(bool rhs) const;
|
|
/// float4 inequality operator
|
|
bool operator!=(const Math::float4& rhs) const;
|
|
/// string inequality operator
|
|
bool operator!=(const Util::String& rhs) const;
|
|
/// guid inequality operator
|
|
bool operator!=(const Util::Guid& rhs) const;
|
|
/// char ptr inequality operator
|
|
bool operator!=(const char* chrPtr) const;
|
|
/// pointer equality operator
|
|
bool operator!=(Core::RefCounted* ptr) const;
|
|
|
|
/// greater operator
|
|
bool operator>(const Variant& rhs) const;
|
|
/// less operator
|
|
bool operator<(const Variant& rhs) const;
|
|
/// greater equal operator
|
|
bool operator>=(const Variant& rhs) const;
|
|
/// less equal operator
|
|
bool operator<=(const Variant& rhs) const;
|
|
|
|
/// set integer content
|
|
void SetInt(int val);
|
|
/// get integer content
|
|
int GetInt() const;
|
|
/// set float content
|
|
void SetFloat(float val);
|
|
/// get float content
|
|
float GetFloat() const;
|
|
/// set bool content
|
|
void SetBool(bool val);
|
|
/// get bool content
|
|
bool GetBool() const;
|
|
/// set string content
|
|
void SetString(const Util::String& val);
|
|
/// get string content
|
|
const Util::String& GetString() const;
|
|
/// set float4 content
|
|
void SetFloat4(const Math::float4& val);
|
|
/// get float4 content
|
|
Math::float4 GetFloat4() const;
|
|
/// set x component of float4 Type
|
|
void SetFloat4_X(float val);
|
|
/// get x component of float4 Type
|
|
float GetFloat4_X() const;
|
|
/// set y component of float4 Type
|
|
void SetFloat4_Y(float val);
|
|
/// get y component of float4 Type
|
|
float GetFloat4_Y() const;
|
|
/// set z component of float4 Type
|
|
void SetFloat4_Z(float val);
|
|
/// get z component of float4 Type
|
|
float GetFloat4_Z() const;
|
|
/// set w component of float4 Type
|
|
void SetFloat4_W(float val);
|
|
/// get w component of float4 Type
|
|
float GetFloat4_W() const;
|
|
/// set matrix44 content
|
|
void SetMatrix44(const Math::matrix44& val);
|
|
/// get matrix44 content
|
|
const Math::matrix44& GetMatrix44() const;
|
|
/// set blob
|
|
void SetBlob(const Util::Blob& val);
|
|
/// get blob
|
|
const Util::Blob& GetBlob() const;
|
|
/// set guid content
|
|
void SetGuid(const Util::Guid& val);
|
|
/// get guid content
|
|
const Util::Guid& GetGuid() const;
|
|
/// set object pointer
|
|
void SetObject(Core::RefCounted* ptr);
|
|
/// get object pointer
|
|
Core::RefCounted* GetObject() const;
|
|
/// set int array content
|
|
void SetIntArray(const Util::Array<int>& val);
|
|
/// get int array content
|
|
const Util::Array<int>& GetIntArray() const;
|
|
/// set float array content
|
|
void SetFloatArray(const Util::Array<float>& val);
|
|
/// get float array content
|
|
const Util::Array<float>& GetFloatArray() const;
|
|
/// set bool array content
|
|
void SetBoolArray(const Util::Array<bool>& val);
|
|
/// get bool array content
|
|
const Util::Array<bool>& GetBoolArray() const;
|
|
/// set float4 array content
|
|
void SetFloat4Array(const Util::Array<Math::float4>& val);
|
|
/// get float4 array content
|
|
const Util::Array<Math::float4>& GetFloat4Array() const;
|
|
/// set matrix44 array content
|
|
void SetMatrix44Array(const Util::Array<Math::matrix44>& val);
|
|
/// get matrix44 array content
|
|
const Util::Array<Math::matrix44>& GetMatrix44Array() const;
|
|
/// set string array content
|
|
void SetStringArray(const Util::Array<Util::String>& val);
|
|
/// get string array content
|
|
const Util::Array<Util::String>& GetStringArray() const;
|
|
/// set guid array content
|
|
void SetGuidArray(const Util::Array<Util::Guid>& val);
|
|
/// get guid array content
|
|
const Util::Array<Util::Guid>& GetGuidArray() const;
|
|
/// set blob array content
|
|
void SetBlobArray(const Util::Array<Util::Blob>& val);
|
|
/// get blob array content
|
|
const Util::Array<Util::Blob>& GetBlobArray() const;
|
|
|
|
/// convert type to string
|
|
static Util::String TypeToString(Type t);
|
|
/// convert string to type
|
|
static Type StringToType(const Util::String& str);
|
|
|
|
private:
|
|
/// delete current content
|
|
void Delete();
|
|
/// copy current content
|
|
void Copy(const Variant& rhs);
|
|
|
|
Type type;
|
|
union
|
|
{
|
|
int i;
|
|
bool b;
|
|
float f[4];
|
|
Math::matrix44* m;
|
|
Util::String* string;
|
|
Util::Guid* guid;
|
|
Util::Blob* blob;
|
|
Core::RefCounted* object;
|
|
Util::Array<int>* intArray;
|
|
Util::Array<float>* floatArray;
|
|
Util::Array<bool>* boolArray;
|
|
Util::Array<Math::float4>* float4Array;
|
|
Util::Array<Math::matrix44>* matrix44Array;
|
|
Util::Array<Util::String>* stringArray;
|
|
Util::Array<Util::Guid>* guidArray;
|
|
Util::Array<Util::Blob>* blobArray;
|
|
};
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant() :
|
|
type(Void),
|
|
string(0)
|
|
{
|
|
// empty
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::Delete()
|
|
{
|
|
if (String == this->type)
|
|
{
|
|
n_assert(this->string);
|
|
n_delete(this->string);
|
|
this->string = 0;
|
|
}
|
|
else if (Matrix44 == this->type)
|
|
{
|
|
n_assert(this->m);
|
|
n_delete(this->m);
|
|
this->m = 0;
|
|
}
|
|
else if (Guid == this->type)
|
|
{
|
|
n_assert(this->guid);
|
|
n_delete(this->guid);
|
|
this->guid = 0;
|
|
}
|
|
else if (Blob == this->type)
|
|
{
|
|
n_assert(this->blob);
|
|
n_delete(this->blob);
|
|
this->blob = 0;
|
|
}
|
|
else if (Object == this->type)
|
|
{
|
|
if (this->object)
|
|
{
|
|
this->object->Release();
|
|
this->object = 0;
|
|
}
|
|
}
|
|
else if (IntArray == this->type)
|
|
{
|
|
n_assert(this->intArray);
|
|
n_delete(this->intArray);
|
|
this->intArray = 0;
|
|
}
|
|
else if (FloatArray == this->type)
|
|
{
|
|
n_assert(this->floatArray);
|
|
n_delete(this->floatArray);
|
|
this->floatArray = 0;
|
|
}
|
|
else if (BoolArray == this->type)
|
|
{
|
|
n_assert(this->boolArray);
|
|
n_delete(this->boolArray);
|
|
this->boolArray = 0;
|
|
}
|
|
else if (Float4Array == this->type)
|
|
{
|
|
n_assert(this->float4Array);
|
|
n_delete(this->float4Array);
|
|
this->float4Array = 0;
|
|
}
|
|
else if (Matrix44Array == this->type)
|
|
{
|
|
n_assert(this->matrix44Array);
|
|
n_delete(this->matrix44Array);
|
|
this->matrix44Array = 0;
|
|
}
|
|
else if (StringArray == this->type)
|
|
{
|
|
n_assert(this->stringArray);
|
|
n_delete(this->stringArray);
|
|
this->stringArray = 0;
|
|
}
|
|
else if (GuidArray == this->type)
|
|
{
|
|
n_assert(this->guidArray);
|
|
n_delete(this->guidArray);
|
|
this->guidArray = 0;
|
|
}
|
|
else if (BlobArray == this->type)
|
|
{
|
|
n_assert(this->blobArray);
|
|
n_delete(this->blobArray);
|
|
this->blobArray = 0;
|
|
}
|
|
this->type = Void;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::Clear()
|
|
{
|
|
this->Delete();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::Copy(const Variant& rhs)
|
|
{
|
|
n_assert(Void == this->type);
|
|
this->type = rhs.type;
|
|
switch (rhs.type)
|
|
{
|
|
case Void:
|
|
break;
|
|
case Int:
|
|
this->i = rhs.i;
|
|
break;
|
|
case Float:
|
|
this->f[0] = rhs.f[0];
|
|
break;
|
|
case Bool:
|
|
this->b = rhs.b;
|
|
break;
|
|
case Float4:
|
|
this->f[0] = rhs.f[0];
|
|
this->f[1] = rhs.f[1];
|
|
this->f[2] = rhs.f[2];
|
|
this->f[3] = rhs.f[3];
|
|
break;
|
|
case String:
|
|
this->string = n_new(Util::String(*rhs.string));
|
|
break;
|
|
case Matrix44:
|
|
this->m = n_new(Math::matrix44(*rhs.m));
|
|
break;
|
|
case Blob:
|
|
this->blob = n_new(Util::Blob(*rhs.blob));
|
|
break;
|
|
case Guid:
|
|
this->guid = n_new(Util::Guid(*rhs.guid));
|
|
break;
|
|
case Object:
|
|
this->object = rhs.object;
|
|
if (this->object)
|
|
{
|
|
this->object->AddRef();
|
|
}
|
|
break;
|
|
case IntArray:
|
|
this->intArray = n_new(Util::Array<int>(*rhs.intArray));
|
|
break;
|
|
case FloatArray:
|
|
this->floatArray = n_new(Util::Array<float>(*rhs.floatArray));
|
|
break;
|
|
case BoolArray:
|
|
this->boolArray = n_new(Util::Array<bool>(*rhs.boolArray));
|
|
break;
|
|
case Float4Array:
|
|
this->float4Array = n_new(Util::Array<Math::float4>(*rhs.float4Array));
|
|
break;
|
|
case Matrix44Array:
|
|
this->matrix44Array = n_new(Util::Array<Math::matrix44>(*rhs.matrix44Array));
|
|
break;
|
|
case StringArray:
|
|
this->stringArray = n_new(Util::Array<Util::String>(*rhs.stringArray));
|
|
break;
|
|
case GuidArray:
|
|
this->guidArray = n_new(Util::Array<Util::Guid>(*rhs.guidArray));
|
|
break;
|
|
case BlobArray:
|
|
this->blobArray = n_new(Util::Array<Util::Blob>(*rhs.blobArray));
|
|
break;
|
|
default:
|
|
n_error("Variant::Copy(): invalid type!");
|
|
break;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(const Variant& rhs) :
|
|
type(Void)
|
|
{
|
|
this->Copy(rhs);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(int rhs) :
|
|
type(Int),
|
|
i(rhs)
|
|
{
|
|
// empty
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(float rhs) :
|
|
type(Float)
|
|
{
|
|
this->f[0] = rhs;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(bool rhs) :
|
|
type(Bool),
|
|
b(rhs)
|
|
{
|
|
// empty
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(const Math::float4& rhs) :
|
|
type(Float4)
|
|
{
|
|
rhs.storeu(this->f);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(const Util::String& rhs) :
|
|
type(String)
|
|
{
|
|
this->string = n_new(Util::String(rhs));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(const char* chrPtr) :
|
|
type(String)
|
|
{
|
|
this->string = n_new(Util::String(chrPtr));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(Core::RefCounted* ptr) :
|
|
type(Object)
|
|
{
|
|
this->object = ptr;
|
|
if (this->object)
|
|
{
|
|
this->object->AddRef();
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(const Math::matrix44& rhs) :
|
|
type(Matrix44)
|
|
{
|
|
this->m = n_new(Math::matrix44(rhs));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(const Util::Blob& rhs) :
|
|
type(Blob)
|
|
{
|
|
this->blob = n_new(Util::Blob(rhs));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(const Util::Guid& rhs) :
|
|
type(Guid)
|
|
{
|
|
this->guid = n_new(Util::Guid(rhs));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(const Util::Array<int>& rhs) :
|
|
type(IntArray)
|
|
{
|
|
this->intArray = n_new(Util::Array<int>(rhs));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(const Util::Array<float>& rhs) :
|
|
type(FloatArray)
|
|
{
|
|
this->floatArray = n_new(Util::Array<float>(rhs));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(const Util::Array<bool>& rhs) :
|
|
type(BoolArray)
|
|
{
|
|
this->boolArray = n_new(Util::Array<bool>(rhs));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(const Util::Array<Math::float4>& rhs) :
|
|
type(Float4Array)
|
|
{
|
|
this->float4Array = n_new(Util::Array<Math::float4>(rhs));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(const Util::Array<Math::matrix44>& rhs) :
|
|
type(Matrix44Array)
|
|
{
|
|
this->matrix44Array = n_new(Util::Array<Math::matrix44>(rhs));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(const Util::Array<Util::String>& rhs) :
|
|
type(StringArray)
|
|
{
|
|
this->stringArray = n_new(Util::Array<Util::String>(rhs));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(const Util::Array<Util::Guid>& rhs) :
|
|
type(GuidArray)
|
|
{
|
|
this->guidArray = n_new(Util::Array<Util::Guid>(rhs));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::Variant(const Util::Array<Util::Blob>& rhs) :
|
|
type(BlobArray)
|
|
{
|
|
this->blobArray = n_new(Util::Array<Util::Blob>(rhs));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
Variant::~Variant()
|
|
{
|
|
this->Delete();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetType(Type t)
|
|
{
|
|
this->Delete();
|
|
this->type = t;
|
|
switch (t)
|
|
{
|
|
case String:
|
|
this->string = n_new(Util::String);
|
|
break;
|
|
case Matrix44:
|
|
this->m = n_new(Math::matrix44);
|
|
break;
|
|
case Blob:
|
|
this->blob = n_new(Util::Blob);
|
|
break;
|
|
case Guid:
|
|
this->guid = n_new(Util::Guid);
|
|
break;
|
|
case Object:
|
|
this->object = 0;
|
|
break;
|
|
case IntArray:
|
|
this->intArray = n_new(Util::Array<int>);
|
|
break;
|
|
case FloatArray:
|
|
this->floatArray = n_new(Util::Array<float>);
|
|
break;
|
|
case BoolArray:
|
|
this->boolArray = n_new(Util::Array<bool>);
|
|
break;
|
|
case Float4Array:
|
|
this->float4Array = n_new(Util::Array<Math::float4>);
|
|
break;
|
|
case Matrix44Array:
|
|
this->matrix44Array = n_new(Util::Array<Math::matrix44>);
|
|
break;
|
|
case StringArray:
|
|
this->stringArray = n_new(Util::Array<Util::String>);
|
|
break;
|
|
case GuidArray:
|
|
this->guidArray = n_new(Util::Array<Util::Guid>);
|
|
break;
|
|
case BlobArray:
|
|
this->blobArray = n_new(Util::Array<Util::Blob>);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline Variant::Type
|
|
Variant::GetType() const
|
|
{
|
|
return this->type;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(const Variant& rhs)
|
|
{
|
|
this->Delete();
|
|
this->Copy(rhs);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(int val)
|
|
{
|
|
this->Delete();
|
|
this->type = Int;
|
|
this->i = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(float val)
|
|
{
|
|
this->Delete();
|
|
this->type = Float;
|
|
this->f[0] = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(bool val)
|
|
{
|
|
this->Delete();
|
|
this->type = Bool;
|
|
this->b = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(const Math::float4& val)
|
|
{
|
|
this->Delete();
|
|
this->type = Float4;
|
|
val.storeu(this->f);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(const Util::String& s)
|
|
{
|
|
if (String == this->type)
|
|
{
|
|
*this->string = s;
|
|
}
|
|
else
|
|
{
|
|
this->Delete();
|
|
this->string = n_new(Util::String(s));
|
|
}
|
|
this->type = String;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(const char* chrPtr)
|
|
{
|
|
*this = Util::String(chrPtr);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(const Math::matrix44& val)
|
|
{
|
|
if (Matrix44 == this->type)
|
|
{
|
|
*this->m = val;
|
|
}
|
|
else
|
|
{
|
|
this->Delete();
|
|
this->m = n_new(Math::matrix44(val));
|
|
}
|
|
this->type = Matrix44;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(const Util::Guid& val)
|
|
{
|
|
if (Guid == this->type)
|
|
{
|
|
*this->guid = val;
|
|
}
|
|
else
|
|
{
|
|
this->Delete();
|
|
this->guid = n_new(Util::Guid(val));
|
|
}
|
|
this->type = Guid;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(const Util::Blob& val)
|
|
{
|
|
if (Blob == this->type)
|
|
{
|
|
*this->blob = val;
|
|
}
|
|
else
|
|
{
|
|
this->Delete();
|
|
this->blob = n_new(Util::Blob(val));
|
|
}
|
|
this->type = Blob;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(Core::RefCounted* ptr)
|
|
{
|
|
this->Delete();
|
|
this->type = Object;
|
|
this->object = ptr;
|
|
if (this->object)
|
|
{
|
|
this->object->AddRef();
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(const Util::Array<int>& val)
|
|
{
|
|
if (IntArray == this->type)
|
|
{
|
|
*this->intArray = val;
|
|
}
|
|
else
|
|
{
|
|
this->Delete();
|
|
this->intArray = n_new(Util::Array<int>(val));
|
|
}
|
|
this->type = IntArray;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(const Util::Array<float>& val)
|
|
{
|
|
if (FloatArray == this->type)
|
|
{
|
|
*this->floatArray = val;
|
|
}
|
|
else
|
|
{
|
|
this->Delete();
|
|
this->floatArray = n_new(Util::Array<float>(val));
|
|
}
|
|
this->type = FloatArray;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(const Util::Array<bool>& val)
|
|
{
|
|
if (BoolArray == this->type)
|
|
{
|
|
*this->boolArray = val;
|
|
}
|
|
else
|
|
{
|
|
this->Delete();
|
|
this->boolArray = n_new(Util::Array<bool>(val));
|
|
}
|
|
this->type = BoolArray;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(const Util::Array<Math::float4>& val)
|
|
{
|
|
if (Float4Array == this->type)
|
|
{
|
|
*this->float4Array = val;
|
|
}
|
|
else
|
|
{
|
|
this->Delete();
|
|
this->float4Array = n_new(Util::Array<Math::float4>(val));
|
|
}
|
|
this->type = Float4Array;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(const Util::Array<Math::matrix44>& val)
|
|
{
|
|
if (Matrix44Array == this->type)
|
|
{
|
|
*this->matrix44Array = val;
|
|
}
|
|
else
|
|
{
|
|
this->Delete();
|
|
this->matrix44Array = n_new(Util::Array<Math::matrix44>(val));
|
|
}
|
|
this->type = Matrix44Array;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(const Util::Array<Util::String>& val)
|
|
{
|
|
if (StringArray == this->type)
|
|
{
|
|
*this->stringArray = val;
|
|
}
|
|
else
|
|
{
|
|
this->Delete();
|
|
this->stringArray = n_new(Util::Array<Util::String>(val));
|
|
}
|
|
this->type = StringArray;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(const Util::Array<Util::Guid>& val)
|
|
{
|
|
if (GuidArray == this->type)
|
|
{
|
|
*this->guidArray = val;
|
|
}
|
|
else
|
|
{
|
|
this->Delete();
|
|
this->guidArray = n_new(Util::Array<Util::Guid>(val));
|
|
}
|
|
this->type = GuidArray;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::operator=(const Util::Array<Util::Blob>& val)
|
|
{
|
|
if (BlobArray == this->type)
|
|
{
|
|
*this->blobArray = val;
|
|
}
|
|
else
|
|
{
|
|
this->Delete();
|
|
this->blobArray = n_new(Util::Array<Util::Blob>(val));
|
|
}
|
|
this->type = BlobArray;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator==(const Variant& rhs) const
|
|
{
|
|
if (rhs.type == this->type)
|
|
{
|
|
switch (rhs.type)
|
|
{
|
|
case Void:
|
|
return true;
|
|
case Int:
|
|
return (this->i == rhs.i);
|
|
case Bool:
|
|
return (this->b == rhs.b);
|
|
case Float:
|
|
return (this->f[0] == rhs.f[0]);
|
|
case String:
|
|
return ((*this->string) == (*rhs.string));
|
|
case Float4:
|
|
return ((this->f[0] == rhs.f[0]) &&
|
|
(this->f[1] == rhs.f[1]) &&
|
|
(this->f[2] == rhs.f[2]) &&
|
|
(this->f[3] == rhs.f[3]));
|
|
case Guid:
|
|
return ((*this->guid) == (*rhs.guid));
|
|
case Blob:
|
|
return ((*this->blob) == (*rhs.blob));
|
|
case Object:
|
|
return (this->object == rhs.object);
|
|
case Matrix44:
|
|
return this->m == rhs.m;
|
|
default:
|
|
n_error("Variant::operator==(): invalid variant type!");
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator>(const Variant& rhs) const
|
|
{
|
|
if (rhs.type == this->type)
|
|
{
|
|
switch (rhs.type)
|
|
{
|
|
case Void:
|
|
return true;
|
|
case Int:
|
|
return (this->i > rhs.i);
|
|
case Bool:
|
|
return (this->b > rhs.b);
|
|
case Float:
|
|
return (this->f[0] > rhs.f[0]);
|
|
case String:
|
|
return ((*this->string) > (*rhs.string));
|
|
case Float4:
|
|
return ((this->f[0] > rhs.f[0]) &&
|
|
(this->f[1] > rhs.f[1]) &&
|
|
(this->f[2] > rhs.f[2]) &&
|
|
(this->f[3] > rhs.f[3]));
|
|
case Guid:
|
|
return ((*this->guid) > (*rhs.guid));
|
|
case Blob:
|
|
return ((*this->blob) > (*rhs.blob));
|
|
case Object:
|
|
return (this->object > rhs.object);
|
|
default:
|
|
n_error("Variant::operator>(): invalid variant type!");
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator<(const Variant& rhs) const
|
|
{
|
|
if (rhs.type == this->type)
|
|
{
|
|
switch (rhs.type)
|
|
{
|
|
case Void:
|
|
return true;
|
|
case Int:
|
|
return (this->i < rhs.i);
|
|
case Bool:
|
|
return (this->b < rhs.b);
|
|
case Float:
|
|
return (this->f[0] < rhs.f[0]);
|
|
case String:
|
|
return ((*this->string) < (*rhs.string));
|
|
case Float4:
|
|
return ((this->f[0] < rhs.f[0]) &&
|
|
(this->f[1] < rhs.f[1]) &&
|
|
(this->f[2] < rhs.f[2]) &&
|
|
(this->f[3] < rhs.f[3]));
|
|
case Guid:
|
|
return ((*this->guid) < (*rhs.guid));
|
|
case Blob:
|
|
return ((*this->blob) < (*rhs.blob));
|
|
case Object:
|
|
return (this->object < rhs.object);
|
|
default:
|
|
n_error("Variant::operator<(): invalid variant type!");
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator>=(const Variant& rhs) const
|
|
{
|
|
if (rhs.type == this->type)
|
|
{
|
|
switch (rhs.type)
|
|
{
|
|
case Void:
|
|
return true;
|
|
case Int:
|
|
return (this->i >= rhs.i);
|
|
case Bool:
|
|
return (this->b >= rhs.b);
|
|
case Float:
|
|
return (this->f[0] >= rhs.f[0]);
|
|
case String:
|
|
return ((*this->string) >= (*rhs.string));
|
|
case Float4:
|
|
return ((this->f[0] >= rhs.f[0]) &&
|
|
(this->f[1] >= rhs.f[1]) &&
|
|
(this->f[2] >= rhs.f[2]) &&
|
|
(this->f[3] >= rhs.f[3]));
|
|
case Guid:
|
|
return ((*this->guid) >= (*rhs.guid));
|
|
case Blob:
|
|
return ((*this->blob) >= (*rhs.blob));
|
|
case Object:
|
|
return (this->object >= rhs.object);
|
|
default:
|
|
n_error("Variant::operator>(): invalid variant type!");
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator<=(const Variant& rhs) const
|
|
{
|
|
if (rhs.type == this->type)
|
|
{
|
|
switch (rhs.type)
|
|
{
|
|
case Void:
|
|
return true;
|
|
case Int:
|
|
return (this->i <= rhs.i);
|
|
case Bool:
|
|
return (this->b <= rhs.b);
|
|
case Float:
|
|
return (this->f[0] <= rhs.f[0]);
|
|
case String:
|
|
return ((*this->string) <= (*rhs.string));
|
|
case Float4:
|
|
return ((this->f[0] <= rhs.f[0]) &&
|
|
(this->f[1] <= rhs.f[1]) &&
|
|
(this->f[2] <= rhs.f[2]) &&
|
|
(this->f[3] <= rhs.f[3]));
|
|
case Guid:
|
|
return ((*this->guid) <= (*rhs.guid));
|
|
case Blob:
|
|
return ((*this->blob) <= (*rhs.blob));
|
|
case Object:
|
|
return (this->object <= rhs.object);
|
|
default:
|
|
n_error("Variant::operator<(): invalid variant type!");
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator!=(const Variant& rhs) const
|
|
{
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator==(int rhs) const
|
|
{
|
|
n_assert(Int == this->type);
|
|
return (this->i == rhs);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator==(float rhs) const
|
|
{
|
|
n_assert(Float == this->type);
|
|
return (this->f[0] == rhs);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator==(bool rhs) const
|
|
{
|
|
n_assert(Bool == this->type);
|
|
return (this->b == rhs);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator==(const Util::String& rhs) const
|
|
{
|
|
n_assert(String == this->type);
|
|
return ((*this->string) == rhs);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator==(const char* chrPtr) const
|
|
{
|
|
return *this == Util::String(chrPtr);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator==(const Math::float4& rhs) const
|
|
{
|
|
n_assert(Float4 == this->type);
|
|
return ((this->f[0] == rhs.x()) &&
|
|
(this->f[1] == rhs.y()) &&
|
|
(this->f[2] == rhs.z()) &&
|
|
(this->f[3] == rhs.w()));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator==(const Util::Guid& rhs) const
|
|
{
|
|
n_assert(Guid == this->type);
|
|
return (*this->guid) == rhs;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator==(Core::RefCounted* ptr) const
|
|
{
|
|
n_assert(Object == this->type);
|
|
return this->object == ptr;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator!=(int rhs) const
|
|
{
|
|
n_assert(Int == this->type);
|
|
return (this->i != rhs);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator!=(float rhs) const
|
|
{
|
|
n_assert(Float == this->type);
|
|
return (this->f[0] != rhs);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator!=(bool rhs) const
|
|
{
|
|
n_assert(Bool == this->type);
|
|
return (this->b != rhs);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator!=(const Util::String& rhs) const
|
|
{
|
|
n_assert(String == this->type);
|
|
return (*this->string) != rhs;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator!=(const char* chrPtr) const
|
|
{
|
|
return *this != Util::String(chrPtr);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator!=(const Math::float4& rhs) const
|
|
{
|
|
n_assert(Float4 == this->type);
|
|
return ((this->f[0] != rhs.x()) ||
|
|
(this->f[1] != rhs.y()) ||
|
|
(this->f[2] != rhs.z()) ||
|
|
(this->f[3] != rhs.w()));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator!=(const Util::Guid& rhs) const
|
|
{
|
|
n_assert(Guid == this->type);
|
|
return (*this->guid) != rhs;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::operator!=(Core::RefCounted* ptr) const
|
|
{
|
|
n_assert(Object == this->type);
|
|
return (this->object == ptr);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetInt(int val)
|
|
{
|
|
*this = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline int
|
|
Variant::GetInt() const
|
|
{
|
|
n_assert(Int == this->type);
|
|
return this->i;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetFloat(float val)
|
|
{
|
|
*this = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline float
|
|
Variant::GetFloat() const
|
|
{
|
|
n_assert(Float == this->type);
|
|
return this->f[0];
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetBool(bool val)
|
|
{
|
|
*this = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Variant::GetBool() const
|
|
{
|
|
n_assert(Bool == this->type);
|
|
return this->b;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetString(const Util::String& val)
|
|
{
|
|
*this = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline const Util::String&
|
|
Variant::GetString() const
|
|
{
|
|
n_assert(String == this->type);
|
|
return *(this->string);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetFloat4(const Math::float4& val)
|
|
{
|
|
*this = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline Math::float4
|
|
Variant::GetFloat4() const
|
|
{
|
|
n_assert(Float4 == this->type);
|
|
return Math::float4(this->f[0], this->f[1], this->f[2], this->f[3]);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/inline void
|
|
Variant::SetFloat4_X(float val)
|
|
{
|
|
this->f[0] = val;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline float
|
|
Variant::GetFloat4_X() const
|
|
{
|
|
n_assert(Float4 == this->type);
|
|
return this->f[0];
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetFloat4_Y(float val)
|
|
{
|
|
this->f[1] = val;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline float
|
|
Variant::GetFloat4_Y() const
|
|
{
|
|
n_assert(Float4 == this->type);
|
|
return this->f[1];
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetFloat4_Z(float val)
|
|
{
|
|
this->f[2] = val;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline float
|
|
Variant::GetFloat4_Z() const
|
|
{
|
|
n_assert(Float4 == this->type);
|
|
return this->f[2];
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetFloat4_W(float val)
|
|
{
|
|
this->f[3] = val;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline float
|
|
Variant::GetFloat4_W() const
|
|
{
|
|
n_assert(Float4 == this->type);
|
|
return this->f[3];
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetMatrix44(const Math::matrix44& val)
|
|
{
|
|
*this = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline const Math::matrix44&
|
|
Variant::GetMatrix44() const
|
|
{
|
|
n_assert(Matrix44 == this->type);
|
|
return *(this->m);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetGuid(const Util::Guid& val)
|
|
{
|
|
*this = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline const Util::Guid&
|
|
Variant::GetGuid() const
|
|
{
|
|
n_assert(Guid == this->type);
|
|
return *(this->guid);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetBlob(const Util::Blob& val)
|
|
{
|
|
*this = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline const Util::Blob&
|
|
Variant::GetBlob() const
|
|
{
|
|
n_assert(Blob == this->type);
|
|
return *(this->blob);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetObject(Core::RefCounted* ptr)
|
|
{
|
|
*this = ptr;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline Core::RefCounted*
|
|
Variant::GetObject() const
|
|
{
|
|
n_assert(Object == this->type);
|
|
return this->object;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetIntArray(const Util::Array<int>& val)
|
|
{
|
|
*this = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline const Util::Array<int>&
|
|
Variant::GetIntArray() const
|
|
{
|
|
n_assert(IntArray == this->type);
|
|
return *(this->intArray);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetFloatArray(const Util::Array<float>& val)
|
|
{
|
|
*this = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline const Util::Array<float>&
|
|
Variant::GetFloatArray() const
|
|
{
|
|
n_assert(FloatArray == this->type);
|
|
return *(this->floatArray);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetBoolArray(const Util::Array<bool>& val)
|
|
{
|
|
*this = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline const Util::Array<bool>&
|
|
Variant::GetBoolArray() const
|
|
{
|
|
n_assert(BoolArray == this->type);
|
|
return *(this->boolArray);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetFloat4Array(const Util::Array<Math::float4>& val)
|
|
{
|
|
*this = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline const Util::Array<Math::float4>&
|
|
Variant::GetFloat4Array() const
|
|
{
|
|
n_assert(Float4Array == this->type);
|
|
return *(this->float4Array);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetMatrix44Array(const Util::Array<Math::matrix44>& val)
|
|
{
|
|
*this = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline const Util::Array<Math::matrix44>&
|
|
Variant::GetMatrix44Array() const
|
|
{
|
|
n_assert(Matrix44Array == this->type);
|
|
return *(this->matrix44Array);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetStringArray(const Util::Array<Util::String>& val)
|
|
{
|
|
*this = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline const Util::Array<Util::String>&
|
|
Variant::GetStringArray() const
|
|
{
|
|
n_assert(StringArray == this->type);
|
|
return *(this->stringArray);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetGuidArray(const Util::Array<Util::Guid>& val)
|
|
{
|
|
*this = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline const Util::Array<Util::Guid>&
|
|
Variant::GetGuidArray() const
|
|
{
|
|
n_assert(GuidArray == this->type);
|
|
return *(this->guidArray);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Variant::SetBlobArray(const Util::Array<Util::Blob>& val)
|
|
{
|
|
*this = val;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline const Util::Array<Util::Blob>&
|
|
Variant::GetBlobArray() const
|
|
{
|
|
n_assert(BlobArray == this->type);
|
|
return *(this->blobArray);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline Util::String
|
|
Variant::TypeToString(Type t)
|
|
{
|
|
switch (t)
|
|
{
|
|
case Void: return "void";
|
|
case Int: return "int";
|
|
case Float: return "float";
|
|
case Bool: return "bool";
|
|
case Float4: return "float4";
|
|
case String: return "string";
|
|
case Matrix44: return "matrix44";
|
|
case Blob: return "blob";
|
|
case Guid: return "guid";
|
|
case Object: return "object";
|
|
case IntArray: return "intarray";
|
|
case FloatArray: return "floatarray";
|
|
case BoolArray: return "boolarray";
|
|
case Float4Array: return "float4array";
|
|
case Matrix44Array: return "matrix44array";
|
|
case StringArray: return "stringarray";
|
|
case GuidArray: return "guidarray";
|
|
case BlobArray: return "blobarray";
|
|
default:
|
|
n_error("Variant::TypeToString(): invalid type enum '%d'!", t);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline Variant::Type
|
|
Variant::StringToType(const Util::String& str)
|
|
{
|
|
if ("void" == str) return Void;
|
|
else if ("int" == str) return Int;
|
|
else if ("float" == str) return Float;
|
|
else if ("bool" == str) return Bool;
|
|
else if ("float4" == str) return Float4;
|
|
else if ("color" == str) return Float4; // NOT A BUG!
|
|
else if ("string" == str) return String;
|
|
else if ("matrix44" == str) return Matrix44;
|
|
else if ("blob" == str) return Blob;
|
|
else if ("guid" == str) return Guid;
|
|
else if ("object" == str) return Object;
|
|
else if ("intarray" == str) return IntArray;
|
|
else if ("floatarray" == str) return FloatArray;
|
|
else if ("boolarray" == str) return BoolArray;
|
|
else if ("float4array" == str) return Float4Array;
|
|
else if ("matrix44array" == str) return Matrix44Array;
|
|
else if ("stringarray" == str) return StringArray;
|
|
else if ("guidarray" == str) return GuidArray;
|
|
else if ("blobarray" == str) return BlobArray;
|
|
else
|
|
{
|
|
n_error("Variant::StringToType(): invalid type string '%s'!", str.AsCharPtr());
|
|
return Void;
|
|
}
|
|
}
|
|
|
|
} // namespace Util
|
|
//------------------------------------------------------------------------------
|