lx/watrbx-game-engine
1
0
Fork 0
mirror of https://github.com/copyrighttxt/watrbx-game-engine.git synced 2026-09-04 20:57:49 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
watrbx-game-engine/App/v8tree/EnumProperty.cpp
T
watrabi 977f1ff4b8 GEEKING
2025-09-18 17:55:52 -04:00

2016 lines
56 KiB
C++
Raw Permalink Blame History

#include "reflection/enumconverter.h"
#include "G3D/Color3uint8.h"
#include "util/exception.h"
#include "Util/BrickColor.h"
#include "Util/NormalId.h"
#include "Util/SystemAddress.h"
#include "Util/Region3.h"
#include "Util/Region3int16.h"
#include "Util/UDim.h"
#include "Util/Faces.h"
#include "Util/Axes.h"
#include "Util/BinaryString.h"
#include "Util/base64.hpp"
#include "Util/PhysicalProperties.h"
#include "v8tree/Instance.h"
#include "Script/ThreadRef.h"
#include "rbx/make_shared.h"
#include "rbx/signal.h"
using namespace RBX;
using namespace RBX::Reflection;
namespace RBX {
float getElementValueOrDefault(const XmlElement* ele, int dflt)
{
float output;
if (ele)
ele->getValue(output);
else
output = dflt;
return output;
}
template<>
bool StringConverter<NormalId>::convertToValue(const std::string& text, NormalId& value)
{
if(text.find("Top") != std::string::npos || text.find("top") != std::string::npos ){
value = NORM_Y;
return true;
}
if(text.find("Bottom") != std::string::npos || text.find("bottom") != std::string::npos ){
value = NORM_Y_NEG;
return true;
}
if(text.find("Back") != std::string::npos || text.find("back") != std::string::npos ){
value = NORM_Z;
return true;
}
if(text.find("Front") != std::string::npos || text.find("front") != std::string::npos ){
value = NORM_Z_NEG;
return true;
}
if(text.find("Right") != std::string::npos || text.find("right") != std::string::npos ){
value = NORM_X;
return true;
}
if(text.find("Left") != std::string::npos || text.find("left") != std::string::npos ){
value = NORM_X_NEG;
return true;
}
return false;
}
template<>
bool StringConverter<SystemAddress>::convertToValue(const std::string& text, SystemAddress& value)
{
return false;
}
template<>
std::string StringConverter<BinaryString>::convertToString(const BinaryString& value)
{
return value.value();
}
template<>
bool StringConverter<BinaryString>::convertToValue(const std::string& text, BinaryString& value)
{
value = BinaryString(text);
return true;
}
} //namespace RBX
namespace RBX {
namespace Reflection
{
//////////////////////////////////////////////////////////
template<>
Reflection::EnumDesc<NormalId>::EnumDesc()
:Reflection::EnumDescriptor("NormalId")
{
/*
TODO:
Should be: (Also in PartInstance)
> -Z eyes, nose, mouth
> +Z back
> -X left ear
> +X right ear
> -Y neck
> +Y top
*/
addPair(NORM_Y, "Top");
addPair(NORM_Y_NEG, "Bottom");
addPair(NORM_Z, "Back");
addPair(NORM_Z_NEG, "Front");
addPair(NORM_X, "Right");
addPair(NORM_X_NEG, "Left");
//addPair(NORM_UNDEFINED, "Undefined");
}
template<>
RBX::NormalId& RBX::Reflection::Variant::convert<RBX::NormalId>(void)
{
return genericConvert<RBX::NormalId>();
}
template<>
int TypedPropertyDescriptor<std::string>::getDataSize(const DescribedBase* instance) const
{
return sizeof(std::string) + getValue(instance).size();
}
template<>
bool RBX::Reflection::TypedPropertyDescriptor<std::string>::hasStringValue() const {
return true;
}
template<>
std::string RBX::Reflection::TypedPropertyDescriptor<std::string>::getStringValue(const DescribedBase* instance) const{
return getValue(instance);
}
template<>
bool RBX::Reflection::TypedPropertyDescriptor<std::string>::setStringValue(DescribedBase* instance, const std::string& text) const {
setValue(instance, text);
return true;
}
template<>
int TypedPropertyDescriptor<bool>::getDataSize(const DescribedBase* instance) const
{
return sizeof(bool);
}
template<>
bool TypedPropertyDescriptor<bool>::hasStringValue() const {
return true;
}
template<>
std::string TypedPropertyDescriptor<bool>::getStringValue(const DescribedBase* instance) const{
return StringConverter<bool>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<bool>::setStringValue(DescribedBase* instance, const std::string& text) const {
bool value;
if (StringConverter<bool>::convertToValue(text, value))
{
setValue(instance, value);
return true;
}
else
return false;
}
template<>
int TypedPropertyDescriptor<float>::getDataSize(const DescribedBase* instance) const
{
return sizeof(float);
}
template<>
bool TypedPropertyDescriptor<float>::hasStringValue() const {
return true;
}
template<>
std::string TypedPropertyDescriptor<float>::getStringValue(const DescribedBase* instance) const{
return StringConverter<float>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<float>::setStringValue(DescribedBase* instance, const std::string& text) const {
float value;
if (StringConverter<float>::convertToValue(text, value))
{
setValue(instance, value);
return true;
}
else
return false;
}
template<>
int TypedPropertyDescriptor<double>::getDataSize(const DescribedBase* instance) const
{
return sizeof(double);
}
template<>
bool TypedPropertyDescriptor<double>::hasStringValue() const {
return true;
}
template<>
std::string TypedPropertyDescriptor<double>::getStringValue(const DescribedBase* instance) const{
return StringConverter<double>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<double>::setStringValue(DescribedBase* instance, const std::string& text) const {
double value;
if (StringConverter<double>::convertToValue(text, value))
{
setValue(instance, value);
return true;
}
else
return false;
}
template<>
int TypedPropertyDescriptor<int>::getDataSize(const DescribedBase* instance) const
{
return sizeof(int);
}
template<>
bool TypedPropertyDescriptor<int>::hasStringValue() const {
return true;
}
template<>
std::string TypedPropertyDescriptor<int>::getStringValue(const DescribedBase* instance) const{
return StringConverter<int>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<int>::setStringValue(DescribedBase* instance, const std::string& text) const {
int value;
if (StringConverter<int>::convertToValue(text, value))
{
setValue(instance, value);
return true;
}
else
return false;
}
template<>
int TypedPropertyDescriptor<RBX::Region3>::getDataSize(const DescribedBase* instance) const
{
return sizeof(RBX::Region3);
}
template<>
bool TypedPropertyDescriptor<RBX::Region3>::hasStringValue() const {
return false;
}
template<>
std::string TypedPropertyDescriptor<RBX::Region3>::getStringValue(const DescribedBase* instance) const{
return StringConverter<RBX::Region3>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<RBX::Region3>::setStringValue(DescribedBase* instance, const std::string& text) const {
RBX::Region3 value;
if (StringConverter<RBX::Region3>::convertToValue(text, value))
{
setValue(instance, value);
return true;
}
else
return false;
}
static bool ReadValue(Vector3int16& output, const XmlElement* element)
{
if (!element->isXsiNil())
{
const XmlElement* xElement = element->findFirstChildByTag(tag_X);
if (!xElement)
return false;
const XmlElement* yElement = element->findFirstChildByTag(tag_Y);
const XmlElement* zElement = element->findFirstChildByTag(tag_Z);
xElement->getValue((int&)output.x);
yElement->getValue((int&)output.y);
zElement->getValue((int&)output.z);
return true;
}
return false;
}
static void WriteValue(XmlElement* element, const Vector3int16& v)
{
XmlElement* xElement = element->addChild(tag_X);
XmlElement* yElement = element->addChild(tag_Y);
XmlElement* zElement = element->addChild(tag_Z);
xElement->setValue((int&)v.x);
yElement->setValue((int&)v.y);
zElement->setValue((int&)v.z);
}
template<>
int TypedPropertyDescriptor<RBX::Region3int16>::getDataSize(const DescribedBase* instance) const
{
return sizeof(Region3int16);
}
template<>
bool TypedPropertyDescriptor<RBX::Region3int16>::hasStringValue() const {
return false;
}
template<>
std::string TypedPropertyDescriptor<RBX::Region3int16>::getStringValue(const DescribedBase* instance) const{
return StringConverter<RBX::Region3int16>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<RBX::Region3int16>::setStringValue(DescribedBase* instance, const std::string& text) const {
RBX::Region3int16 value;
if (StringConverter<RBX::Region3int16>::convertToValue(text, value))
{
setValue(instance, value);
return true;
}
else
return false;
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<RBX::Region3int16>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
const XmlElement* minElement = element->findFirstChildByTag(tag_Min);
const XmlElement* maxElement = element->findFirstChildByTag(tag_Max);
Vector3int16 min, max;
if(ReadValue(min, minElement) && ReadValue(max, maxElement))
{
Region3int16 v( min, max );
setValue(instance, v);
}
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<RBX::Region3int16>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
XmlElement* minElement = element->addChild(tag_Min);
XmlElement* maxElement = element->addChild(tag_Max);
Region3int16 v = getValue(instance);
WriteValue(minElement, v.getMinPos());
WriteValue(maxElement, v.getMaxPos());
}
template<>
int TypedPropertyDescriptor<G3D::Vector3>::getDataSize(const DescribedBase* instance) const
{
return sizeof(G3D::Vector3);
}
template<>
bool TypedPropertyDescriptor<G3D::Vector3>::hasStringValue() const {
return true;
}
template<>
std::string TypedPropertyDescriptor<G3D::Vector3>::getStringValue(const DescribedBase* instance) const{
return StringConverter<G3D::Vector3>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<G3D::Vector3>::setStringValue(DescribedBase* instance, const std::string& text) const {
G3D::Vector3 value;
if (StringConverter<G3D::Vector3>::convertToValue(text, value))
{
setValue(instance, value);
return true;
}
else
return false;
}
template<>
int TypedPropertyDescriptor<G3D::Vector2>::getDataSize(const DescribedBase* instance) const
{
return sizeof(G3D::Vector2);
}
template<>
bool TypedPropertyDescriptor<G3D::Vector2>::hasStringValue() const {
return true;
}
template<>
std::string TypedPropertyDescriptor<G3D::Vector2>::getStringValue(const DescribedBase* instance) const{
return StringConverter<G3D::Vector2>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<G3D::Vector2>::setStringValue(DescribedBase* instance, const std::string& text) const {
G3D::Vector2 value;
if (StringConverter<G3D::Vector2>::convertToValue(text, value))
{
setValue(instance, value);
return true;
}
else
return false;
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<std::string>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
std::string value;
if (element->getValue(value))
setValue(instance, value);
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<std::string>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
element->setValue(getValue(instance));
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<float>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
float value;
if (element->getValue(value))
setValue(instance, value);
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<float>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
element->setValue(getValue(instance));
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<bool>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
bool value;
if (element->getValue(value))
setValue(instance, value);
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<double>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
element->setValue(getValue(instance));
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<double>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
double value;
if (element->getValue(value))
setValue(instance, value);
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<bool>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
element->setValue(getValue(instance));
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<int>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
int value;
if (element->getValue(value))
setValue(instance, value);
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<int>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
element->setValue(getValue(instance));
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<class G3D::Vector2>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
const XmlElement* xElement = element->findFirstChildByTag(tag_X);
if (!xElement)
return;
const XmlElement* yElement = element->findFirstChildByTag(tag_Y);
G3D::Vector2 v;
xElement->getValue(v.x);
yElement->getValue(v.y);
setValue(instance, v);
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<class G3D::Vector2>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
// Write the data out in accordance with ROBLOX Schema
XmlElement* xElement = element->addChild(tag_X);
XmlElement* yElement = element->addChild(tag_Y);
G3D::Vector2 v = getValue(instance);
xElement->setValue(v.x);
yElement->setValue(v.y);
}
static bool ReadValue(Vector3& output, const XmlElement* element)
{
if (!element->isXsiNil())
{
const XmlElement* xElement = element->findFirstChildByTag(tag_X);
if (!xElement)
return false;
const XmlElement* yElement = element->findFirstChildByTag(tag_Y);
const XmlElement* zElement = element->findFirstChildByTag(tag_Z);
xElement->getValue(output.x);
yElement->getValue(output.y);
zElement->getValue(output.z);
return true;
}
return false;
}
static void WriteValue(XmlElement* element, const Vector3& v)
{
XmlElement* xElement = element->addChild(tag_X);
XmlElement* yElement = element->addChild(tag_Y);
XmlElement* zElement = element->addChild(tag_Z);
xElement->setValue(v.x);
yElement->setValue(v.y);
zElement->setValue(v.z);
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<class G3D::Vector3>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
G3D::Vector3 v;
if(ReadValue(v, element)){
setValue(instance, v);
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<class G3D::Vector3>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
G3D::Vector3 v = getValue(instance);
WriteValue(element, v);
}
template<>
const Reflection::Type& Reflection::Type::getSingleton< shared_ptr<Reflection::DescribedBase> >()
{
static TType< shared_ptr<Reflection::DescribedBase> > type("Object");
return type;
}
template<>
const Type& Reflection::Type::getSingleton< shared_ptr<Instance> >()
{
static TType< shared_ptr<Instance> > type("Instance");
return type;
}
template<>
const Type& Type::getSingleton<shared_ptr<const Instances> >()
{
static TType<shared_ptr<const Instances> > type("Objects");
return type;
}
template<>
const Type& Type::getSingleton<int>()
{
static TType<int> type("int");
return type;
}
template<>
const Type& Type::getSingleton<long>()
{
static TType<long> type("long");
return type;
}
template<>
int& RBX::Reflection::Variant::convert<int>(void)
{
// Convert double to int
if (_type->isType<double>())
{
value = G3D::iRound(cast<double>());
_type = &Type::singleton<int>();
}
// Convert float to int
if (_type->isType<float>())
{
value = G3D::iRound(cast<float>());
_type = &Type::singleton<int>();
}
// Convert bool to int
if (_type->isType<bool>())
{
value = (cast<bool>() ? 1 : 0);
_type = &Type::singleton<int>();
}
return genericConvert<int>();
}
template<>
const Type& Type::getSingleton<bool>()
{
static TType<bool> type("bool");
return type;
}
template<>
bool& RBX::Reflection::Variant::convert<bool>(void)
{
// Convert int to bool
if (_type->isType<int>())
{
value = (bool) (cast<int>()!=0);
_type = &Type::singleton<bool>();
}
// Convert float to bool
else if (_type->isType<float>())
{
value = (bool) (cast<float>()!=0.0f);
_type = &Type::singleton<bool>();
}
// Convert double to bool
else if (_type->isType<double>())
{
value = (bool) (cast<double>()!=0.0);
_type = &Type::singleton<bool>();
}
return genericConvert<bool>();
}
template<>
const Type& Type::getSingleton<float>()
{
static TType<float> type("float");
return type;
}
template<>
float& RBX::Reflection::Variant::convert<float>(void)
{
// Convert double to float
if (_type->isType<double>())
{
value = (float) cast<double>();
_type = &Type::singleton<float>();
}
// Convert int to float
else if (_type->isType<int>())
{
value = (float) cast<int>();
_type = &Type::singleton<float>();
}
// Convert bool to float
else if (_type->isType<bool>())
{
value = (float) (cast<bool>() ? 1 : 0);
_type = &Type::singleton<float>();
}
return genericConvert<float>();
}
template<>
const Type& Type::getSingleton<double>()
{
static TType<double> type("double");
return type;
}
template<>
double& RBX::Reflection::Variant::convert<double>(void)
{
// Convert int to double
if (_type->isType<int>())
{
value = (double) cast<int>();
_type = &Type::singleton<double>();
}
// Convert bool to double
else if (_type->isType<bool>())
{
value = (double) (cast<bool>() ? 1 : 0);
_type = &Type::singleton<double>();
}
// Convert float to double
else if (_type->isType<float>())
{
value = (double) cast<float>();
_type = &Type::singleton<double>();
}
return genericConvert<double>();
}
template<>
RBX::Region3& RBX::Reflection::Variant::convert<RBX::Region3>(void)
{
return genericConvert<RBX::Region3>();
}
template<>
RBX::Region3int16& RBX::Reflection::Variant::convert<RBX::Region3int16>(void)
{
return genericConvert<RBX::Region3int16>();
}
template<>
G3D::Vector3& RBX::Reflection::Variant::convert<G3D::Vector3>(void)
{
return genericConvert<G3D::Vector3>();
}
template<>
RBX::Vector2& RBX::Reflection::Variant::convert<RBX::Vector2>(void)
{
return genericConvert<RBX::Vector2>();
}
template<>
G3D::CoordinateFrame& RBX::Reflection::Variant::convert<G3D::CoordinateFrame>(void)
{
return genericConvert<G3D::CoordinateFrame>();
}
template<>
const Type& Type::getSingleton<RBX::ContentId>()
{
static TType<RBX::ContentId> type("Content");
return type;
}
template<>
ContentId& RBX::Reflection::Variant::convert<ContentId>(void)
{
if (_type->isType<std::string>())
{
value = ContentId(cast<std::string>());
_type = &Type::singleton<ContentId>();
}
return genericConvert<ContentId>();
}
template<>
const Type& Type::getSingleton<std::string>()
{
static TType<std::string> type("string");
return type;
}
template<>
const Type& Type::getSingleton<G3D::Vector3>()
{
static TType<G3D::Vector3> type("Vector3");
return type;
}
template<>
const Type& Type::getSingleton<RBX::Vector2>()
{
static TType<RBX::Vector2> type("Vector2");
return type;
}
template<>
const Type& Type::getSingleton<rbx::signals::connection>()
{
static TType<rbx::signals::connection> type("Connection");
return type;
}
template<>
const Type& Type::getSingleton<shared_ptr<const Tuple> >()
{
static TType<shared_ptr<const Tuple> > type("Tuple");
return type;
}
template<>
std::string& RBX::Reflection::Variant::convert<std::string>(void)
{
// TODO: This should be made compact somehow!!!
if (isType<bool>())
{
value = StringConverter<bool>::convertToString(cast<bool>());
_type = &Type::singleton<std::string>();
}
else if (isType<int>())
{
value = StringConverter<int>::convertToString(cast<int>());
_type = &Type::singleton<std::string>();
}
else if (isType<long>())
{
value = StringConverter<long>::convertToString(cast<long>());
_type = &Type::singleton<std::string>();
}
else if (isType<float>())
{
value = StringConverter<float>::convertToString(cast<float>());
_type = &Type::singleton<std::string>();
}
else if (isType<double>())
{
value = StringConverter<double>::convertToString(cast<double>());
_type = &Type::singleton<std::string>();
}
else if (isType<G3D::Vector3>())
{
value = StringConverter<G3D::Vector3>::convertToString(cast<G3D::Vector3>());
_type = &Type::singleton<std::string>();
}
else if (isType<RBX::CoordinateFrame>())
{
if (cast<RBX::CoordinateFrame>() == RBX::CoordinateFrame())
value = std::string("Identity");
else
value = std::string("?");
_type = &Type::singleton<std::string>();
}
else if (isType<Lua::WeakFunctionRef>())
{
if(cast<Lua::WeakFunctionRef>().empty())
value = std::string("nil");
else
value = std::string("function");
_type = &Type::singleton<std::string>();
}
else if (isType<shared_ptr<Instance> >())
{
const shared_ptr<Instance>& v = cast<shared_ptr<Instance> >();
if (v)
value = std::string(Type::singleton< shared_ptr<Instance> >().name.c_str());
else
value = std::string("nil");
_type = &Type::singleton<std::string>();
}
else if(isType<shared_ptr<const Reflection::ValueArray> >())
{
value = std::string("{}");
_type = &Type::singleton<std::string>();
}
else if (const Reflection::EnumDescriptor* desc = Reflection::EnumDescriptor::lookupDescriptor(type()))
{
const Reflection::EnumDescriptor::Item* item = desc->lookup(*this);
if (item!=NULL)
{
std::string stringValue;
if(item->convertToString(stringValue)){
value = stringValue;
_type = &Type::singleton<std::string>();
}
}
}
std::string* id = tryCast<std::string>();
if (id==NULL)
throw std::runtime_error("Unable to cast value to std::string");
return *id;
}
template<>
shared_ptr<Instance>& Reflection::Variant::convert<shared_ptr<Instance> >(void)
{
// Interpret "void" (Lua nil) as a null Instance
if (isType<void>())
{
value = shared_ptr<Instance>();
_type = &Type::singleton<shared_ptr<Instance> >();
}
else if (isType<shared_ptr<Reflection::DescribedBase> >())
{
const shared_ptr<Reflection::DescribedBase>& v = cast<shared_ptr<Reflection::DescribedBase> >();
value = shared_dynamic_cast<Instance>(v);
_type = &Type::singleton<shared_ptr<Instance> >();
}
shared_ptr<Instance>* v = tryCast<shared_ptr<Instance> >();
if (v==NULL)
throw std::runtime_error("Unable to cast value to Object");
return *v;
}
}}
static void CastInstance(Variant value, shared_ptr<Instances> instancesCollection)
{
instancesCollection->push_back(value.convert<shared_ptr<Instance> >());
}
namespace RBX {
namespace Reflection {
template<>
shared_ptr<const Instances>& Reflection::Variant::convert<shared_ptr<const Instances> >(void)
{
{
shared_ptr<const Instances>* v = tryCast<shared_ptr<const Instances> >();
if (v!=NULL){
return *v;
}
}
{
shared_ptr<const ValueArray>* v = tryCast<shared_ptr<const ValueArray> >();
if(v != NULL){
shared_ptr<Instances> newInstances(new Instances());
std::for_each((*v)->begin(), (*v)->end(), boost::bind(&CastInstance, _1, newInstances));
value = shared_ptr<const Instances>(newInstances);
_type = &Type::singleton<shared_ptr<const Instances> >();
return cast<shared_ptr<const Instances> >();
}
}
throw std::runtime_error("Unable to cast value to Objects");
}
template<>
shared_ptr<Reflection::DescribedBase>& Reflection::Variant::convert<shared_ptr<Reflection::DescribedBase> >(void)
{
// Interpret "void" (Lua nil) as a null Instance
if (isType<void>())
{
value = shared_ptr<Reflection::DescribedBase>();
_type = &Type::singleton<shared_ptr<Reflection::DescribedBase> >();
}
else if (isType<shared_ptr<Instance> >())
{
const shared_ptr<Instance>& v = cast<shared_ptr<Instance> >();
value = shared_static_cast<Reflection::DescribedBase>(v);
_type = &Type::singleton<shared_ptr<Reflection::DescribedBase> >();
}
shared_ptr<Reflection::DescribedBase>* v = tryCast<shared_ptr<Reflection::DescribedBase> >();
if (v==NULL)
throw std::runtime_error("Unable to cast value to Object");
return *v;
}
template<>
shared_ptr<const Tuple>& Variant::convert<shared_ptr<const Tuple> >(void)
{
shared_ptr<const Tuple>* v = tryCast<shared_ptr<const Tuple> >();
if (v != NULL)
return *v;
if (isVoid())
{
value = shared_ptr<const Tuple>(); // null is equivalent to 0 items (optimization)
_type = &Type::singleton< shared_ptr<const Tuple> >();
return cast< shared_ptr<const Tuple> >();
}
// Any value can be converted to a tuple of 1
shared_ptr<Tuple> tuple = rbx::make_shared<Tuple>(1);
tuple->values[0] = *this;
value = shared_ptr<const Tuple>(tuple);
_type = &Type::singleton< shared_ptr<const Tuple> >();
return cast< shared_ptr<const Tuple> >();
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//
// Vector2int16
// convert, getSingleton, hasStringValue, getStringValue, setStringValue, readValue, writeValue
template<>
G3D::Vector2int16& RBX::Reflection::Variant::convert<G3D::Vector2int16>(void)
{
return genericConvert<G3D::Vector2int16>();
}
template<>
const Type& Type::getSingleton<G3D::Vector2int16>()
{
static TType<G3D::Vector2int16> type("Vector2int16");
return type;
}
template<>
int TypedPropertyDescriptor<G3D::Vector2int16>::getDataSize(const DescribedBase* instance) const
{
return sizeof(G3D::Vector2int16);
}
template<>
bool TypedPropertyDescriptor<G3D::Vector2int16>::hasStringValue() const {
return true;
}
template<>
std::string TypedPropertyDescriptor<G3D::Vector2int16>::getStringValue(const DescribedBase* instance) const{
return StringConverter<G3D::Vector2int16>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<G3D::Vector2int16>::setStringValue(DescribedBase* instance, const std::string& text) const {
G3D::Vector2int16 value;
if (StringConverter<G3D::Vector2int16>::convertToValue(text, value))
{
setValue(instance, value);
return true;
}
else
return false;
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<G3D::Vector2int16>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
const XmlElement* xElement = element->findFirstChildByTag(tag_X);
const XmlElement* yElement = element->findFirstChildByTag(tag_Y);
int x, y;
xElement->getValue(x);
yElement->getValue(y);
setValue(instance, G3D::Vector2int16(x,y));
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<G3D::Vector2int16>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
// Write the data out in accordance with ROBLOX Schema
XmlElement* xElement = element->addChild(tag_X);
XmlElement* yElement = element->addChild(tag_Y);
G3D::Vector2int16 v = getValue(instance);
xElement->setValue((int)v.x);
yElement->setValue((int)v.y);
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//
// Vector3int16
// convert, getSingleton, hasStringValue, getStringValue, setStringValue, readValue, writeValue
template<>
G3D::Vector3int16& RBX::Reflection::Variant::convert<G3D::Vector3int16>(void)
{
return genericConvert<G3D::Vector3int16>();
}
template<>
const Type& Type::getSingleton<G3D::Vector3int16>()
{
static TType<G3D::Vector3int16> type("Vector3int16");
return type;
}
template<>
int TypedPropertyDescriptor<G3D::Vector3int16>::getDataSize(const DescribedBase* instance) const
{
return sizeof(G3D::Vector3int16);
}
template<>
bool TypedPropertyDescriptor<G3D::Vector3int16>::hasStringValue() const
{
return true;
}
template<>
std::string TypedPropertyDescriptor<G3D::Vector3int16>::getStringValue(const DescribedBase* instance) const
{
return StringConverter<G3D::Vector3int16>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<G3D::Vector3int16>::setStringValue(DescribedBase* instance, const std::string& text) const
{
G3D::Vector3int16 value;
if (StringConverter<G3D::Vector3int16>::convertToValue(text, value))
{
setValue(instance, value);
return true;
}
else
return false;
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<G3D::Vector3int16>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
const XmlElement* xElement = element->findFirstChildByTag(tag_X);
const XmlElement* yElement = element->findFirstChildByTag(tag_Y);
const XmlElement* zElement = element->findFirstChildByTag(tag_Z);
int x, y, z;
xElement->getValue(x);
yElement->getValue(y);
zElement->getValue(z);
setValue(instance, G3D::Vector3int16(x,y,z));
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<G3D::Vector3int16>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
XmlElement* xElement = element->addChild(tag_X);
XmlElement* yElement = element->addChild(tag_Y);
XmlElement* zElement = element->addChild(tag_Z);
G3D::Vector3int16 v = getValue(instance);
xElement->setValue((int)v.x);
yElement->setValue((int)v.y);
zElement->setValue((int)v.z);
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//
// PhysicalProperties
// convert, getSingleton, hasStringValue, getStringValue, setStringValue, readValue, writeValue
template<>
PhysicalProperties& RBX::Reflection::Variant::convert<PhysicalProperties>(void)
{
return genericConvert<PhysicalProperties>();
}
template<>
const Type& Type::getSingleton<PhysicalProperties>()
{
static TType<PhysicalProperties> type("PhysicalProperties");
return type;
}
template<>
int TypedPropertyDescriptor<PhysicalProperties>::getDataSize(const DescribedBase* instance) const
{
return sizeof(PhysicalProperties);
}
template<>
bool TypedPropertyDescriptor<PhysicalProperties>::hasStringValue() const {
return true;
}
template<>
std::string TypedPropertyDescriptor<PhysicalProperties>::getStringValue(const DescribedBase* instance) const{
return StringConverter<PhysicalProperties>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<PhysicalProperties>::setStringValue(DescribedBase* instance, const std::string& text) const {
return false;
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<PhysicalProperties>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
bool customPhysEnabled = false;
const XmlElement* customPhysPropElement = element->findFirstChildByTag(tag_customPhysProp);
if (customPhysPropElement)
{
customPhysPropElement->getValue(customPhysEnabled);
}
if (customPhysEnabled)
{
const XmlElement* densityElement = element->findFirstChildByTag(tag_customDensity);
const XmlElement* frictionElement = element->findFirstChildByTag(tag_customFriction);
const XmlElement* elasticityElement = element->findFirstChildByTag(tag_customElasticity);
const XmlElement* frictionWeightElement = element->findFirstChildByTag(tag_customFrictionWeight);
const XmlElement* elasticityWeightElement = element->findFirstChildByTag(tag_customElasticityWeight);
float density = getElementValueOrDefault(densityElement, 1.0f);
float friction = getElementValueOrDefault(frictionElement, 0.0f);
float elasticity = getElementValueOrDefault(elasticityElement, 0.0f);
float frictionWeight = getElementValueOrDefault(frictionWeightElement, 1.0f);
float elasticityWeight = getElementValueOrDefault(elasticityWeightElement, 1.0f);
setValue(instance, PhysicalProperties(density, friction, elasticity, frictionWeight, elasticityWeight));
}
else
{
setValue(instance, PhysicalProperties());
}
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<PhysicalProperties>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
//Only worth saving if CustomPhysicalProperties is enabled
PhysicalProperties currentProperties = getValue(instance);
bool customEnabled = currentProperties.getCustomEnabled();
XmlElement* customPhysPropElement = element->addChild(tag_customPhysProp);
customPhysPropElement->setValue(customEnabled);
if (customEnabled)
{
XmlElement* densityElement = element->addChild(tag_customDensity);
XmlElement* frictionElement = element->addChild(tag_customFriction);
XmlElement* elasticityElement = element->addChild(tag_customElasticity);
XmlElement* frictionWeightElement = element->addChild(tag_customFrictionWeight);
XmlElement* elasticityWeightElement = element->addChild(tag_customElasticityWeight);
densityElement->setValue(currentProperties.getDensity());
frictionElement->setValue(currentProperties.getFriction());
elasticityElement->setValue(currentProperties.getElasticity());
frictionWeightElement->setValue(currentProperties.getFrictionWeight());
elasticityWeightElement->setValue(currentProperties.getElasticityWeight());
}
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//
// Rect2D
// convert, getSingleton, hasStringValue, getStringValue, setStringValue, readValue, writeValue
template<>
G3D::Rect2D& RBX::Reflection::Variant::convert<G3D::Rect2D>(void)
{
return genericConvert<G3D::Rect2D>();
}
template<>
const Type& Type::getSingleton<G3D::Rect2D>()
{
static TType<G3D::Rect2D> type("Rect2D");
return type;
}
template<>
int TypedPropertyDescriptor<G3D::Rect2D>::getDataSize(const DescribedBase* instance) const
{
return sizeof(G3D::Rect2D);
}
template<>
bool TypedPropertyDescriptor<G3D::Rect2D>::hasStringValue() const {
return true;
}
template<>
std::string TypedPropertyDescriptor<G3D::Rect2D>::getStringValue(const DescribedBase* instance) const{
return StringConverter<G3D::Rect2D>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<G3D::Rect2D>::setStringValue(DescribedBase* instance, const std::string& text) const {
return false;
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<G3D::Rect2D>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
const XmlElement* minElement = element->findFirstChildByTag(tag_Min);
const XmlElement* maxElement = element->findFirstChildByTag(tag_Max);
Vector2 min;
Vector2 max;
// TODO: re-use vector2 code?
{
const XmlElement* xElement = minElement->findFirstChildByTag(tag_X);
const XmlElement* yElement = minElement->findFirstChildByTag(tag_Y);
xElement->getValue(min.x);
yElement->getValue(min.y);
}
{
const XmlElement* xElement = maxElement->findFirstChildByTag(tag_X);
const XmlElement* yElement = maxElement->findFirstChildByTag(tag_Y);
xElement->getValue(max.x);
yElement->getValue(max.y);
}
setValue(instance, G3D::Rect2D(min,max));
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<G3D::Rect2D>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
// Write the data out in accordance with ROBLOX Schema
XmlElement* minElement = element->addChild(tag_Min);
XmlElement* maxElement = element->addChild(tag_Max);
// TODO: re-use vector2 code?
G3D::Rect2D v = getValue(instance);
{
XmlElement* xElement = minElement->addChild(tag_X);
XmlElement* yElement = minElement->addChild(tag_Y);
xElement->setValue(v.x0());
yElement->setValue(v.y0());
}
{
XmlElement* xElement = maxElement->addChild(tag_X);
XmlElement* yElement = maxElement->addChild(tag_Y);
xElement->setValue(v.x1());
yElement->setValue(v.y1());
}
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//
// UDim
// convert, getSingleton, hasStringValue, getStringValue, setStringValue, readValue, writeValue
template<>
RBX::UDim& RBX::Reflection::Variant::convert<RBX::UDim>(void)
{
return genericConvert<RBX::UDim>();
}
template<>
const Type& Type::getSingleton<RBX::UDim>()
{
static TType<RBX::UDim> type("UDim");
return type;
}
template<>
int TypedPropertyDescriptor<RBX::UDim>::getDataSize(const DescribedBase* instance) const
{
return sizeof(RBX::UDim);
}
template<>
bool TypedPropertyDescriptor<RBX::UDim>::hasStringValue() const {
return true;
}
template<>
std::string TypedPropertyDescriptor<RBX::UDim>::getStringValue(const DescribedBase* instance) const{
return StringConverter<RBX::UDim>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<RBX::UDim>::setStringValue(DescribedBase* instance, const std::string& text) const {
return false;
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<RBX::UDim>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
const XmlElement* sElement = element->findFirstChildByTag(tag_S);
const XmlElement* oElement = element->findFirstChildByTag(tag_O);
float s;
int o;
sElement->getValue(s);
oElement->getValue(o);
setValue(instance, RBX::UDim(s,o));
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<RBX::UDim>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
// Write the data out in accordance with ROBLOX Schema
XmlElement* sElement = element->addChild(tag_S);
XmlElement* oElement = element->addChild(tag_O);
RBX::UDim v = getValue(instance);
sElement->setValue(v.scale);
oElement->setValue((int)v.offset);
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//
// UDim2
// convert, getSingleton, hasStringValue, getStringValue, setStringValue, readValue, writeValue
template<>
RBX::UDim2& RBX::Reflection::Variant::convert<RBX::UDim2>(void)
{
return genericConvert<RBX::UDim2>();
}
template<>
const Type& Type::getSingleton<RBX::UDim2>()
{
static TType<RBX::UDim2> type("UDim2");
return type;
}
template<>
int TypedPropertyDescriptor<RBX::UDim2>::getDataSize(const DescribedBase* instance) const
{
return sizeof(RBX::UDim2);
}
template<>
bool TypedPropertyDescriptor<RBX::UDim2>::hasStringValue() const {
return true;
}
template<>
std::string TypedPropertyDescriptor<RBX::UDim2>::getStringValue(const DescribedBase* instance) const{
return StringConverter<RBX::UDim2>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<RBX::UDim2>::setStringValue(DescribedBase* instance, const std::string& text) const {
return false;
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<RBX::UDim2>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
const XmlElement* xsElement = element->findFirstChildByTag(tag_XS);
const XmlElement* xoElement = element->findFirstChildByTag(tag_XO);
const XmlElement* ysElement = element->findFirstChildByTag(tag_YS);
const XmlElement* yoElement = element->findFirstChildByTag(tag_YO);
float xs,ys;
int xo,yo;
xsElement->getValue(xs);
xoElement->getValue(xo);
ysElement->getValue(ys);
yoElement->getValue(yo);
setValue(instance, RBX::UDim2(xs,xo, ys,yo));
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<RBX::UDim2>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
// Write the data out in accordance with ROBLOX Schema
XmlElement* xsElement = element->addChild(tag_XS);
XmlElement* xoElement = element->addChild(tag_XO);
XmlElement* ysElement = element->addChild(tag_YS);
XmlElement* yoElement = element->addChild(tag_YO);
RBX::UDim2 v = getValue(instance);
xsElement->setValue(v.x.scale);
xoElement->setValue((int)v.x.offset);
ysElement->setValue(v.y.scale);
yoElement->setValue((int)v.y.offset);
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//
// Faces
// convert, getSingleton, hasStringValue, getStringValue, setStringValue, readValue, writeValue
template<>
RBX::Faces& RBX::Reflection::Variant::convert<RBX::Faces>(void)
{
return genericConvert<RBX::Faces>();
}
template<>
const Type& Type::getSingleton<RBX::Faces>()
{
static TType<RBX::Faces> type("Faces");
return type;
}
template<>
int TypedPropertyDescriptor<RBX::Faces>::getDataSize(const DescribedBase* instance) const
{
return sizeof(RBX::Faces);
}
template<>
bool TypedPropertyDescriptor<RBX::Faces>::hasStringValue() const {
return true;
}
template<>
std::string TypedPropertyDescriptor<RBX::Faces>::getStringValue(const DescribedBase* instance) const{
return StringConverter<RBX::Faces>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<RBX::Faces>::setStringValue(DescribedBase* instance, const std::string& text) const {
return false;
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<RBX::Faces>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
const XmlElement* facesElement = element->findFirstChildByTag(tag_faces);
int faces;
facesElement->getValue(faces);
setValue(instance, RBX::Faces(faces));
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<RBX::Faces>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
// Write the data out in accordance with ROBLOX Schema
XmlElement* facesElement = element->addChild(tag_faces);
RBX::Faces v = getValue(instance);
facesElement->setValue(v.normalIdMask);
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//
// Axes
// convert, getSingleton, hasStringValue, getStringValue, setStringValue, readValue, writeValue
template<>
RBX::Axes& RBX::Reflection::Variant::convert<RBX::Axes>(void)
{
return genericConvert<RBX::Axes>();
}
template<>
const Type& Type::getSingleton<RBX::Axes>()
{
static TType<RBX::Axes> type("Axes");
return type;
}
template<>
int TypedPropertyDescriptor<RBX::Axes>::getDataSize(const DescribedBase* instance) const
{
return sizeof(RBX::Axes);
}
template<>
bool TypedPropertyDescriptor<RBX::Axes>::hasStringValue() const {
return true;
}
template<>
std::string TypedPropertyDescriptor<RBX::Axes>::getStringValue(const DescribedBase* instance) const{
return StringConverter<RBX::Axes>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<RBX::Axes>::setStringValue(DescribedBase* instance, const std::string& text) const {
return false;
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<RBX::Axes>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
const XmlElement* axesElement = element->findFirstChildByTag(tag_axes);
int axes;
axesElement->getValue(axes);
setValue(instance, RBX::Axes(axes));
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<RBX::Axes>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
// Write the data out in accordance with ROBLOX Schema
XmlElement* axesElement = element->addChild(tag_axes);
RBX::Axes v = getValue(instance);
axesElement->setValue(v.axisMask);
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//
// Color3
// convert, getSingleton, hasStringValue, getStringValue, setStringValue, readValue, writeValue
template<>
G3D::Color3& RBX::Reflection::Variant::convert<G3D::Color3>(void)
{
return genericConvert<G3D::Color3>();
}
template<>
const Type& Type::getSingleton<G3D::Color3>()
{
static TType<G3D::Color3> type("Color3");
return type;
}
template<>
int TypedPropertyDescriptor<G3D::Color3>::getDataSize(const DescribedBase* instance) const
{
return sizeof(G3D::Color3);
}
template<>
bool TypedPropertyDescriptor<G3D::Color3>::hasStringValue() const {
return true;
}
template<>
std::string TypedPropertyDescriptor<G3D::Color3>::getStringValue(const DescribedBase* instance) const{
return StringConverter<G3D::Color3>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<G3D::Color3>::setStringValue(DescribedBase* instance, const std::string& text) const {
G3D::Color3 value;
if (StringConverter<G3D::Color3>::convertToValue(text, value))
{
setValue(instance, value);
return true;
}
else
return false;
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<G3D::Color3>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
unsigned int argb;
if (element->getValue(argb))
{
setValue(instance, G3D::Color3uint8::fromARGB(argb));
}
else
{
// Old-style
const XmlElement* xElement = element->findFirstChildByTag(tag_R);
const XmlElement* yElement = element->findFirstChildByTag(tag_G);
const XmlElement* zElement = element->findFirstChildByTag(tag_B);
if (xElement && yElement && zElement)
{
G3D::Color3 v;
xElement->getValue(v.r);
yElement->getValue(v.g);
zElement->getValue(v.b);
setValue(instance, v);
}
}
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<G3D::Color3>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
// Write the data out in accordance with ROBLOX Schema
G3D::Color3uint8 v = G3D::Color3uint8(getValue(instance));
element->setValue(v.asUInt32());
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//
// Ray
// convert, getSingleton, hasStringValue, getStringValue, setStringValue, readValue, writeValue
template<>
RBX::RbxRay& RBX::Reflection::Variant::convert<RBX::RbxRay>(void)
{
return genericConvert<RBX::RbxRay>();
}
template<>
const Type& Type::getSingleton<RBX::RbxRay>()
{
static TType<RBX::RbxRay> type("Ray");
return type;
}
template<>
int TypedPropertyDescriptor<RBX::RbxRay>::getDataSize(const DescribedBase* instance) const
{
return sizeof(RBX::RbxRay);
}
template<>
bool TypedPropertyDescriptor<RBX::RbxRay>::hasStringValue() const {
return true;
}
template<>
std::string TypedPropertyDescriptor<RBX::RbxRay>::getStringValue(const DescribedBase* instance) const{
return StringConverter<RBX::RbxRay>::convertToString(getValue(instance));
}
template<>
bool TypedPropertyDescriptor<RBX::RbxRay>::setStringValue(DescribedBase* instance, const std::string& text) const {
RBX::RbxRay value;
if (StringConverter<RBX::RbxRay>::convertToValue(text, value))
{
setValue(instance, value);
return true;
}
else
return false;
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<class RBX::RbxRay>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
const XmlElement* originElement = element->findFirstChildByTag(tag_Origin);
const XmlElement* directionElement = element->findFirstChildByTag(tag_Direction);
RbxRay v;
if(ReadValue(v.origin(), originElement) && ReadValue(v.direction(), directionElement)){
setValue(instance, v);
}
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<class RBX::RbxRay>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
XmlElement* originElement = element->addChild(tag_Origin);
XmlElement* directionElement = element->addChild(tag_Direction);
RBX::RbxRay v = getValue(instance);
WriteValue(originElement, v.origin());
WriteValue(directionElement, v.direction());
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//
// Brick Color
// convert, getSingleton, hasStringValue, getStringValue, setStringValue, readValue, writeValue
template<>
RBX::BrickColor& RBX::Reflection::Variant::convert<RBX::BrickColor>(void)
{
return genericConvert<RBX::BrickColor>();
}
template<>
const Type& Type::getSingleton<BrickColor>()
{
static TType<BrickColor> type("BrickColor", "int");
return type;
}
template<>
int TypedPropertyDescriptor<BrickColor>::getDataSize(const DescribedBase* instance) const
{
return sizeof(BrickColor);
}
template<>
bool TypedPropertyDescriptor<BrickColor>::hasStringValue() const {
return false;
}
template<>
std::string TypedPropertyDescriptor<BrickColor>::getStringValue(const DescribedBase* instance) const {
return Super::getStringValue(instance);
}
template<>
bool TypedPropertyDescriptor<BrickColor>::setStringValue(DescribedBase* instance, const std::string& text) const {
return Super::setStringValue(instance, text);
}
template<>
void TypedPropertyDescriptor<BrickColor>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
int number;
if (element->getValue(number))
{
setValue(instance, BrickColor(number));
}
}
}
template<>
void TypedPropertyDescriptor<BrickColor>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
// Write the data out in accordance with ROBLOX Schema
element->setValue(getValue(instance).asInt());
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//
// SystemAddress
// convert, getSingleton, hasStringValue, getStringValue, setStringValue, readValue, writeValue, convertToValue
template<>
RBX::SystemAddress& RBX::Reflection::Variant::convert<RBX::SystemAddress>(void)
{
return genericConvert<RBX::SystemAddress>();
}
template<>
const Type& Type::getSingleton<SystemAddress>()
{
static TType<SystemAddress> type("SystemAddress");
return type;
}
template<>
int TypedPropertyDescriptor<SystemAddress>::getDataSize(const DescribedBase* instance) const
{
return sizeof(SystemAddress);
}
template<>
bool TypedPropertyDescriptor<SystemAddress>::hasStringValue() const {
return false;
}
template<>
std::string TypedPropertyDescriptor<SystemAddress>::getStringValue(const DescribedBase* instance) const {
return Super::getStringValue(instance);
}
template<>
bool TypedPropertyDescriptor<SystemAddress>::setStringValue(DescribedBase* instance, const std::string& text) const {
return Super::setStringValue(instance, text);
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<RBX::SystemAddress>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
RBXASSERT(0); // should never be streamed... REPLICATE_ONLY
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<RBX::SystemAddress>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
RBXASSERT(0); // should never be streamed... REPLICATE_ONLY
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
template<>
void RBX::Reflection::TypedPropertyDescriptor<RBX::ContentId>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
ContentId value;
if (element->getValue(value))
setValue(instance, value);
}
}
template<>
void RBX::Reflection::TypedPropertyDescriptor<RBX::ContentId>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
element->setValue(ContentId(getValue(instance)));
}
template<>
int TypedPropertyDescriptor<RBX::ContentId>::getDataSize(const DescribedBase* instance) const
{
return sizeof(RBX::ContentId) + getValue(instance).toString().size();
}
template<>
bool RBX::Reflection::TypedPropertyDescriptor<ContentId>::hasStringValue() const {
return true;
}
template<>
std::string RBX::Reflection::TypedPropertyDescriptor<ContentId>::getStringValue(const DescribedBase* instance) const{
return StringConverter<ContentId>::convertToString(getValue(instance));
}
template<>
bool RBX::Reflection::TypedPropertyDescriptor<ContentId>::setStringValue(DescribedBase* instance, const std::string& text) const {
ContentId value;
if (StringConverter<ContentId>::convertToValue(text, value))
{
setValue(instance, value);
return true;
}
else
return false;
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//
// BinaryString
template<>
const Type& Type::getSingleton<BinaryString>()
{
static TType<RBX::BinaryString> type("BinaryString");
return type;
}
template<>
void TypedPropertyDescriptor<BinaryString>::readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
{
if (!element->isXsiNil())
{
std::string text;
if (element->getValue(text))
{
std::ostringstream result;
base64<char> decoder;
int state = 0;
std::ostreambuf_iterator<char> out(result);
decoder.get(text.begin(), text.end(), out, state);
BinaryString value(result.str());
setValue(instance, value);
}
}
}
template<>
void TypedPropertyDescriptor<BinaryString>::writeValue(const DescribedBase* instance, XmlElement* element) const
{
BinaryString value = getValue(instance);
std::string result;
base64<char>::encode(value.value().c_str(), value.value().length(), result, base64<>::lf());
element->setValue(result);
}
template<>
BinaryString& Variant::convert<BinaryString>(void)
{
return genericConvert<BinaryString>();
}
template<>
int TypedPropertyDescriptor<BinaryString>::getDataSize(const DescribedBase* instance) const
{
return sizeof(BinaryString) + getValue(instance).value().length();
}
template<>
bool TypedPropertyDescriptor<BinaryString>::hasStringValue() const {
return true;
}
template<>
std::string TypedPropertyDescriptor<BinaryString>::getStringValue(const DescribedBase* instance) const{
return getValue(instance).value();
}
template<>
bool TypedPropertyDescriptor<BinaryString>::setStringValue(DescribedBase* instance, const std::string& text) const {
setValue(instance, BinaryString(text));
return true;
}
}} // namespaces
Reference in New Issue View Git Blame Copy Permalink