pcce::Variant Class Reference

Variant class that can store a single value of many types. More...

#include <Variant.h>

List of all members.

Public Member Functions
	Variant ()
	Default constructor, creates an empty Variant.
	Variant (const tVariant value)
	Constructs a new Variant with the given tVariant value.
	Variant (const int value)
	Constructs a new Variant with the given int value.
	Variant (const unsigned int value)
	Constructs a new Variant with the given unsigned int value.
	Variant (const long int value)
	Constructs a new Variant with the given long int value.
	Variant (const unsigned long int value)
	Constructs a new Variant with the given unsigned long int value.
	Variant (const tReal value)
	Constructs a new Variant with the given tReal value.
	Variant (const char value)
	Constructs a new Variant with the given char value.
	Variant (const unsigned char value)
	Constructs a new Variant with the given unsigned char value.
	Variant (const std::string value)
	Constructs a new Variant with the given string value.
	Variant (const char *value)
	Constructs a new Variant with the given const char* value.
	Variant (const tPropertyBagPtr value)
	Constructs a new Variant with the given tPropertyBagPtr.
bool	HasValue () const
	Returns true if the Variant has a value (i.e. is not empty).
void	Clear ()
	Clears the Variant's value.
tVariant	Get () const
	Returns the Variant's value.
void	Set (tVariant value)
	Sets the Variant's value.
int	AsInt () const
	Returns the Variant's value as an int.
bool	AsBool () const
	Returns the Variant's value as a bool.
unsigned int	AsUnsignedInt () const
	Returns the Variant's value as an unsigned int.
long int	AsLongInt () const
	Returns the Variant's value as a long int.
unsigned long int	AsUnsignedLongInt () const
	Returns the Variant's value as an unsigned long int.
tReal	AsReal () const
	Returns the Variant's value as a tReal.
char	AsChar () const
	Returns the Variant's value as a char.
unsigned char	AsUnsignedChar () const
	Returns the Variant's value as an unsigned char.
std::string	AsString () const
	Returns the Variant's value as a string.
tPropertyBagPtr	AsPropertyBagPtr () const
	Returns the Variant's value as a tPropertyBagPtr.
bool	IsInt () const
	Returns true if tVariant value can be converted to an int.
bool	IsBool () const
	Returns true if tVariant value can be converted to a bool.
bool	IsUnsignedInt () const
	Returns true if tVariant value can be converted to an unsigned int.
bool	IsLongInt () const
	Returns true if tVariant value can be converted to a long int.
bool	IsUnsignedLongInt () const
	Returns true if tVariant value can be converted to an unsigned long int.
bool	IsReal () const
	Returns true if tVariant value can be converted to a tReal.
bool	IsChar () const
	Returns true if tVariant value can be converted to a char.
bool	IsUnsignedChar () const
	Returns true if tVariant value can be converted to an unsigned char.
bool	IsString () const
	Returns true if tVariant value can be converted to a string.
bool	IsPropertyBagPtr () const
	Returns true if tVariant value can be converted to a tPropertyBagPtr.
Private Attributes
bool	mHasValue
tVariant	mValue

---

Detailed Description

Variant class that can store a single value of many types.

This variant class allows the user to store a single value from the tVariant and convert freely between them using a string stream. A Variant may also be empty, which can be checked using Variant::HasValue().

Definition at line 64 of file Variant.h.

---

Constructor & Destructor Documentation

Variant::Variant

(

)

Default constructor, creates an empty Variant.

Definition at line 103 of file Variant.cpp.

                : mHasValue(false), mValue(0) {
}

Variant::Variant

(

const tVariant

value

)

Constructs a new Variant with the given tVariant value.

Definition at line 106 of file Variant.cpp.

                                    : mHasValue(true), mValue(value) {
}

Variant::Variant

(

const int

value

)

Constructs a new Variant with the given int value.

Definition at line 109 of file Variant.cpp.

                               : mHasValue(true), mValue(value) {
}

Variant::Variant

(

const unsigned int

value

)

Constructs a new Variant with the given unsigned int value.

Definition at line 112 of file Variant.cpp.

                                        : mHasValue(true), mValue(value) {
}

Variant::Variant

(

const long int

value

)

Constructs a new Variant with the given long int value.

Definition at line 115 of file Variant.cpp.

                                    : mHasValue(true), mValue(value) {
}

Variant::Variant

(

const unsigned long int

value

)

Constructs a new Variant with the given unsigned long int value.

Definition at line 118 of file Variant.cpp.

                                             : mHasValue(true), mValue(value) {
}

Variant::Variant

(

const tReal

value

)

Constructs a new Variant with the given tReal value.

Definition at line 121 of file Variant.cpp.

                                 : mHasValue(true), mValue(value) {
}

Variant::Variant

(

const char

value

)

Constructs a new Variant with the given char value.

Definition at line 124 of file Variant.cpp.

                                : mHasValue(true), mValue(value) {
}

pcce::Variant::Variant

(

const unsigned char

value

)

Constructs a new Variant with the given unsigned char value.

Variant::Variant

(

const std::string

value

)

Constructs a new Variant with the given string value.

Definition at line 127 of file Variant.cpp.

                                     : mHasValue(true), mValue(value) {
}

Variant::Variant

(

const char *

value

)

Constructs a new Variant with the given const char* value.

This constructor takes a const char*, but converts the value to a string. It is provided for convenience.

Definition at line 130 of file Variant.cpp.

                                 : mHasValue(true), mValue(string(value)) {
}

Variant::Variant

(

const tPropertyBagPtr

value

)

Constructs a new Variant with the given tPropertyBagPtr.

Definition at line 133 of file Variant.cpp.

                                           : mHasValue(true), mValue(value) {
}

---

Member Function Documentation

bool Variant::HasValue

(

)

const

Returns true if the Variant has a value (i.e. is not empty).

Definition at line 136 of file Variant.cpp.

References mHasValue.

Referenced by pcce::GameObject::GetMaterialName(), pcce::GameObject::GetPhysicsModelName(), and pcce::GameObject::GetRenderModelName().

                             {
  return mHasValue;
}

void Variant::Clear

(

)

Clears the Variant's value.

This method clears the Variant's value. That will cause all of the Get*() methods to throw a VariantEmptyException if called, until a value is set again using Set().

Definition at line 140 of file Variant.cpp.

References mHasValue, and mValue.

                    {
  mHasValue = false;
  mValue = 0;
}

tVariant Variant::Get

(

)

const

Returns the Variant's value.

This returns the Variant's value as a tVariant. It will throw a VariantEmptyException if the Variant does not have a value.

Definition at line 145 of file Variant.cpp.

References mHasValue, and mValue.

Referenced by AsBool(), AsChar(), AsInt(), AsLongInt(), AsPropertyBagPtr(), AsReal(), AsString(), AsUnsignedChar(), AsUnsignedInt(), AsUnsignedLongInt(), IsBool(), IsChar(), IsInt(), IsLongInt(), IsPropertyBagPtr(), IsReal(), IsString(), IsUnsignedChar(), IsUnsignedInt(), and IsUnsignedLongInt().

                            {
  check< VariantEmptyException >(mHasValue, "Variant does not have a value", __FILE__, __LINE__);
  return mValue;
}

void Variant::Set

(

tVariant

value

)

Sets the Variant's value.

Definition at line 150 of file Variant.cpp.

References mHasValue, and mValue.

Referenced by pcce::GameObject::GetMaterialName(), pcce::GameObject::GetPhysicsModelName(), and pcce::GameObject::GetRenderModelName().

                                {
  mHasValue = true;
  mValue = value;
}

int Variant::AsInt

(

)

const

Returns the Variant's value as an int.

This method returns the Variant's value as an int. If the variant is empty, it will throw a VariantEmptyException. If the value cannot be converted to an int using std::stringstream, it will throw a VariantConversionException. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

See also:

Variant::Get()

Definition at line 155 of file Variant.cpp.

References Get(), mValue, ConvertResult< T >::success, and ConvertResult< T >::value.

Referenced by pcce::InputSubSystem::Impl::Initialize().

                         {
  tVariant v = Get();
  ConvertResult< int > result = apply_visitor(VariantConverter< int >(mValue), v);
  check< VariantConversionException >(result.success, "Could not convert variant to int", __FILE__, __LINE__);
  return result.value;
}

bool Variant::AsBool

(

)

const

Returns the Variant's value as a bool.

This method returns the Variant's value as a bool. If the variant is empty, it will throw a VariantEmptyException. If the value cannot be converted to a bool using std::stringstream, it will throw a VariantConversionException. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

See also:

Variant::Get()

Definition at line 162 of file Variant.cpp.

References Get(), mValue, ConvertResult< T >::success, and ConvertResult< T >::value.

                           {
  tVariant v = Get();
  // See the doc string for tVariant for explanation of why bool is excluded
  //   from the boost::variant template.
  ConvertResult< bool > result = apply_visitor(VariantConverter< bool >(mValue), v);
  check< VariantConversionException >(result.success, "Could not convert variant to bool", __FILE__, __LINE__);
  return result.value;
}

unsigned int Variant::AsUnsignedInt

(

)

const

Returns the Variant's value as an unsigned int.

This method returns the Variant's value as an unsigned int. If the variant is empty, it will throw a VariantEmptyException. If the value cannot be converted to an unsigned int using std::stringstream, it will throw a VariantConversionException. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

See also:

Variant::Get()

Definition at line 171 of file Variant.cpp.

References Get(), mValue, ConvertResult< T >::success, and ConvertResult< T >::value.

                                          {
  tVariant v = Get();
  ConvertResult< unsigned int > result = apply_visitor(VariantConverter< unsigned int >(mValue), v);
  check< VariantConversionException >(result.success, "Could not convert variant to unsigned int", __FILE__, __LINE__);
  return result.value;
}

long int Variant::AsLongInt

(

)

const

Returns the Variant's value as a long int.

This method returns the Variant's value as a long int. If the variant is empty, it will throw a VariantEmptyException. If the value cannot be converted to a long int using std::stringstream, it will throw a VariantConversionException. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

See also:

Variant::Get()

Definition at line 178 of file Variant.cpp.

References Get(), mValue, ConvertResult< T >::success, and ConvertResult< T >::value.

                                  {
  tVariant v = Get();
  ConvertResult< long int > result = apply_visitor(VariantConverter< long int >(mValue), v);
  check< VariantConversionException >(result.success, "Could not convert variant to long int", __FILE__, __LINE__);
  return result.value;
}

unsigned long int Variant::AsUnsignedLongInt

(

)

const

Returns the Variant's value as an unsigned long int.

This method returns the Variant's value as an unsigned long int. If the variant is empty, it will throw a VariantEmptyException. If the value cannot be converted to an unsigned long int using std::stringstream, it will throw a VariantConversionException. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

See also:

Variant::Get()

Definition at line 185 of file Variant.cpp.

References Get(), mValue, ConvertResult< T >::success, and ConvertResult< T >::value.

                                                   {
  tVariant v = Get();
  ConvertResult< unsigned long int > result = apply_visitor(VariantConverter< unsigned long int >(mValue), v);
  check< VariantConversionException >(result.success, "Could not convert variant to unsigned long int", __FILE__, __LINE__);
  return result.value;
}

tReal Variant::AsReal

(

)

const

Returns the Variant's value as a tReal.

This method returns the Variant's value as a tReal. If the variant is empty, it will throw a VariantEmptyException. If the value cannot be converted to a tReal using std::stringstream, it will throw a VariantConversionException. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

See also:

Variant::Get()

Definition at line 192 of file Variant.cpp.

References Get(), mValue, ConvertResult< T >::success, and ConvertResult< T >::value.

                            {
  tVariant v = Get();
  ConvertResult< tReal > result = apply_visitor(VariantConverter< tReal >(mValue), v);
  check< VariantConversionException >(result.success, "Could not convert variant to real", __FILE__, __LINE__);
  return result.value;
}

char Variant::AsChar

(

)

const

Returns the Variant's value as a char.

This method returns the Variant's value as a char. If the variant is empty, it will throw a VariantEmptyException. If the value cannot be converted to a char using std::stringstream, it will throw a VariantConversionException. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

See also:

Variant::Get()

Definition at line 199 of file Variant.cpp.

References Get(), mValue, ConvertResult< T >::success, and ConvertResult< T >::value.

                           {
  tVariant v = Get();
  ConvertResult< char > result = apply_visitor(VariantConverter< char >(mValue), v);
  check< VariantConversionException >(result.success, "Could not convert variant to char", __FILE__, __LINE__);
  return result.value;
}

unsigned char Variant::AsUnsignedChar

(

)

const

Returns the Variant's value as an unsigned char.

This method returns the Variant's value as an unsigned char. If the variant is empty, it will throw a VariantEmptyException. If the value cannot be converted to an unsigned char using std::stringstream, it will throw a VariantConversionException. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

See also:

Variant::Get()

Definition at line 206 of file Variant.cpp.

References Get(), mValue, ConvertResult< T >::success, and ConvertResult< T >::value.

                                            {
  tVariant v = Get();
  ConvertResult< unsigned char > result = apply_visitor(VariantConverter< unsigned char >(mValue), v);
  check< VariantConversionException >(result.success, "Could not convert variant to unsigned char", __FILE__, __LINE__);
  return result.value;
}

string Variant::AsString

(

)

const

Returns the Variant's value as a string.

This method returns the Variant's value as a string. If the variant is empty, it will throw a VariantEmptyException. If the value cannot be converted to a string using std::stringstream, it will throw a VariantConversionException. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

See also:

Variant::Get()

Definition at line 213 of file Variant.cpp.

References Get(), mValue, ConvertResult< T >::success, and ConvertResult< T >::value.

Referenced by pcce::GameObject::GetMaterialName(), pcce::GameObject::GetPhysicsModelName(), pcce::GameObject::GetRenderModelName(), pcce::XmlNode::SetAttribute(), and pcce::SoundResourceFactory::vCreateResource().

                               {
  tVariant v = Get();
  ConvertResult< string > result = apply_visitor(VariantConverter< string >(mValue), v);
  check< VariantConversionException >(result.success, "Could not convert variant to string", __FILE__, __LINE__);
  return result.value;
}

tPropertyBagPtr Variant::AsPropertyBagPtr

(

)

const

Returns the Variant's value as a tPropertyBagPtr.

This method returns the Variant's value as a tPropertyBagPtr. If the variant is empty, it will throw a VariantEmptyException. In this case, no conversion is attempted. Only an actual tPropertyBagPtr can be retrieved by this method.

See also:

Variant::Get()

Definition at line 220 of file Variant.cpp.

References Get(), ConvertResult< T >::success, and ConvertResult< T >::value.

Referenced by pcce::Configuration::TryGetConfigSection().

                                                {
  tVariant v = Get();
  ConvertResult< tPropertyBagPtr > result = apply_visitor(VariantPropBagConverter(), v);
  check< VariantConversionException >(result.success, "Variant is not a PropertyBagPtr", __FILE__, __LINE__);
  return result.value;
}

bool Variant::IsInt

(

)

const

Returns true if tVariant value can be converted to an int.

This method returns true if the tVariant value can be converted to an int. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

Definition at line 227 of file Variant.cpp.

References Get(), mHasValue, mValue, and ConvertResult< T >::success.

Referenced by pcce::InputSubSystem::Impl::Initialize().

                          {
  if (!mHasValue) {
    return false;
  } else {
    tVariant v = Get();
    ConvertResult< int > result = apply_visitor(VariantConverter< int >(mValue), v);
    return result.success;
  }
}

bool Variant::IsBool

(

)

const

Returns true if tVariant value can be converted to a bool.

This method returns true if the tVariant value can be converted to a bool. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

Definition at line 237 of file Variant.cpp.

References Get(), mHasValue, mValue, and ConvertResult< T >::success.

                           {
  if (!mHasValue) {
    return false;
  } else {
    tVariant v = Get();
    // See the doc string for tVariant for explanation of why bool is excluded
    //   from the boost::variant template.
    ConvertResult< bool > result = apply_visitor(VariantConverter< bool >(mValue), v);
    return result.success;
  }
}

bool Variant::IsUnsignedInt

(

)

const

Returns true if tVariant value can be converted to an unsigned int.

This method returns true if the tVariant value can be converted to an unsigned int. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

Definition at line 249 of file Variant.cpp.

References Get(), mHasValue, mValue, and ConvertResult< T >::success.

                                  {
  if (!mHasValue) {
    return false;
  } else {
    tVariant v = Get();
    ConvertResult< unsigned int > result = apply_visitor(VariantConverter< unsigned int >(mValue), v);
    return result.success;
  }
}

bool Variant::IsLongInt

(

)

const

Returns true if tVariant value can be converted to a long int.

This method returns true if the tVariant value can be converted to a long int. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

Definition at line 259 of file Variant.cpp.

References Get(), mHasValue, mValue, and ConvertResult< T >::success.

                              {
  if (!mHasValue) {
    return false;
  } else {
    tVariant v = Get();
    ConvertResult< long int > result = apply_visitor(VariantConverter< long int >(mValue), v);
    return result.success;
  }
}

bool Variant::IsUnsignedLongInt

(

)

const

Returns true if tVariant value can be converted to an unsigned long int.

This method returns true if the tVariant value can be converted to an unsigned long int. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

Definition at line 269 of file Variant.cpp.

References Get(), mHasValue, mValue, and ConvertResult< T >::success.

                                      {
  if (!mHasValue) {
    return false;
  } else {
    tVariant v = Get();
    ConvertResult< unsigned long int > result = apply_visitor(VariantConverter< unsigned long int >(mValue), v);
    return result.success;
  }
}

bool Variant::IsReal

(

)

const

Returns true if tVariant value can be converted to a tReal.

This method returns true if the tVariant value can be converted to a tReal. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

Definition at line 279 of file Variant.cpp.

References Get(), mHasValue, mValue, and ConvertResult< T >::success.

                           {
  if (!mHasValue) {
    return false;
  } else {
    tVariant v = Get();
    ConvertResult< tReal > result = apply_visitor(VariantConverter< tReal >(mValue), v);
    return result.success;
  }
}

bool Variant::IsChar

(

)

const

Returns true if tVariant value can be converted to a char.

This method returns true if the tVariant value can be converted to a char. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

Definition at line 289 of file Variant.cpp.

References Get(), mHasValue, mValue, and ConvertResult< T >::success.

                           {
  if (!mHasValue) {
    return false;
  } else {
    tVariant v = Get();
    ConvertResult< char > result = apply_visitor(VariantConverter< char >(mValue), v);
    return result.success;
  }
}

bool Variant::IsUnsignedChar

(

)

const

Returns true if tVariant value can be converted to an unsigned char.

This method returns true if the tVariant value can be converted to an unsigned char. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

Definition at line 299 of file Variant.cpp.

References Get(), mHasValue, mValue, and ConvertResult< T >::success.

                                   {
  if (!mHasValue) {
    return false;
  } else {
    tVariant v = Get();
    ConvertResult< unsigned char > result = apply_visitor(VariantConverter< unsigned char >(mValue), v);
    return result.success;
  }
}

bool Variant::IsString

(

)

const

Returns true if tVariant value can be converted to a string.

This method returns true if the tVariant value can be converted to a string. Note: This method actually does the conversion and changes the tVariant value to the type specified. That way, if you write something like "Variant v("123"); if (v.IsInt()) { cout << v.AsInt(); }", you will only do one conversion. However, if you alternate between say "AsInt()" and "AsString()", the conversion will happen every time.

Definition at line 309 of file Variant.cpp.

References Get(), mHasValue, mValue, and ConvertResult< T >::success.

                             {
  if (!mHasValue) {
    return false;
  } else {
    tVariant v = Get();
    ConvertResult< string > result = apply_visitor(VariantConverter< string >(mValue), v);
    return result.success;
  }
}

bool Variant::IsPropertyBagPtr

(

)

const

Returns true if tVariant value can be converted to a tPropertyBagPtr.

This method returns true if the tVariant value can be converted to a tPropertyBagPtr. This method will only return true if the tVariant value actually is a tPropertyBagPtr, since conversion to/from othe types is not possible in this case.

Definition at line 319 of file Variant.cpp.

References Get(), mHasValue, and ConvertResult< T >::success.

Referenced by pcce::Configuration::TryGetConfigSection().

                                     {
  if (!mHasValue) {
    return false;
  } else {
    tVariant v = Get();
    ConvertResult< tPropertyBagPtr > result = apply_visitor(VariantPropBagConverter(), v);
    return result.success;
  }
}

---

Member Data Documentation

bool pcce::Variant::mHasValue [private]

Definition at line 387 of file Variant.h.

Referenced by Clear(), Get(), HasValue(), IsBool(), IsChar(), IsInt(), IsLongInt(), IsPropertyBagPtr(), IsReal(), IsString(), IsUnsignedChar(), IsUnsignedInt(), IsUnsignedLongInt(), and Set().

tVariant pcce::Variant::mValue [mutable, private]

Definition at line 390 of file Variant.h.

Referenced by AsBool(), AsChar(), AsInt(), AsLongInt(), AsReal(), AsString(), AsUnsignedChar(), AsUnsignedInt(), AsUnsignedLongInt(), Clear(), Get(), IsBool(), IsChar(), IsInt(), IsLongInt(), IsReal(), IsString(), IsUnsignedChar(), IsUnsignedInt(), IsUnsignedLongInt(), and Set().

---

The documentation for this class was generated from the following files:

• include/Variant.h
• src/Variant.cpp