changed some variable and macro naming
This commit is contained in:
Anselme
parent
5ade0127be
commit
d1873c9de4
10
src/main.cpp
10
src/main.cpp
@ -9,11 +9,11 @@
|
||||
class Foo : public Serializable
|
||||
{
|
||||
public:
|
||||
INT (myInt)
|
||||
STRING (myString)
|
||||
VECTOR_FLOAT(myFloatArray)
|
||||
VEC3 (myVec3)
|
||||
REFERENCE (Foo, myFoo)
|
||||
P_INT (myInt)
|
||||
P_STRING (myString)
|
||||
P_VECTOR_FLOAT(myFloatArray)
|
||||
P_VEC3 (myVec3)
|
||||
P_REFERENCE (Foo, myFoo)
|
||||
|
||||
SERIALIZABLE(Foo,
|
||||
CAST(myInt),
|
||||
|
||||
136
src/property.cpp
136
src/property.cpp
@ -2,107 +2,107 @@
|
||||
#include "serializable.h"
|
||||
|
||||
// INTEGER PROPERTY
|
||||
template <> std::ostream& Property<int>::saveBinary(std::ostream& os) { return os.write((char*)&value, sizeof(int)); }
|
||||
template <> std::ostream& Property<int>::saveAscii(std::ostream& os) { return os << value; }
|
||||
template <> std::istream& Property<int>::loadBinary(std::istream& is) { return is.read((char*)&value, sizeof(int)); }
|
||||
template <> std::istream& Property<int>::loadAscii(std::istream& is) { return is >> value; }
|
||||
template <> std::ostream& Property<int>::saveBinary(std::ostream& os) { return os.write((char*)&m_value, sizeof(int)); }
|
||||
template <> std::ostream& Property<int>::saveAscii(std::ostream& os) { return os << m_value; }
|
||||
template <> std::istream& Property<int>::loadBinary(std::istream& is) { return is.read((char*)&m_value, sizeof(int)); }
|
||||
template <> std::istream& Property<int>::loadAscii(std::istream& is) { return is >> m_value; }
|
||||
template <> AbstractProperty::PropertyType Property<int>::getStaticPropertyType() { return AbstractProperty::INTEGER; }
|
||||
|
||||
// FLOAT PROPERTY
|
||||
template <> std::ostream& Property<float>::saveBinary(std::ostream& os) { return os.write((char*)&value, sizeof(float)); }
|
||||
template <> std::ostream& Property<float>::saveAscii(std::ostream& os) { return os << value; }
|
||||
template <> std::istream& Property<float>::loadBinary(std::istream& is) { return is.read((char*)&value, sizeof(float)); }
|
||||
template <> std::istream& Property<float>::loadAscii(std::istream& is) { return is >> value; }
|
||||
template <> std::ostream& Property<float>::saveBinary(std::ostream& os) { return os.write((char*)&m_value, sizeof(float)); }
|
||||
template <> std::ostream& Property<float>::saveAscii(std::ostream& os) { return os << m_value; }
|
||||
template <> std::istream& Property<float>::loadBinary(std::istream& is) { return is.read((char*)&m_value, sizeof(float)); }
|
||||
template <> std::istream& Property<float>::loadAscii(std::istream& is) { return is >> m_value; }
|
||||
template <> AbstractProperty::PropertyType Property<float>::getStaticPropertyType() { return AbstractProperty::FLOAT; }
|
||||
|
||||
// BOOLEAN PROPERTY
|
||||
template <> std::ostream& Property<bool>::saveBinary(std::ostream& os) { return os.write((char*)&value, sizeof(bool)); }
|
||||
template <> std::ostream& Property<bool>::saveAscii(std::ostream& os) { return os << value; }
|
||||
template <> std::istream& Property<bool>::loadBinary(std::istream& is) { return is.read((char*)&value, sizeof(bool)); }
|
||||
template <> std::istream& Property<bool>::loadAscii(std::istream& is) { return is >> value; }
|
||||
template <> std::ostream& Property<bool>::saveBinary(std::ostream& os) { return os.write((char*)&m_value, sizeof(bool)); }
|
||||
template <> std::ostream& Property<bool>::saveAscii(std::ostream& os) { return os << m_value; }
|
||||
template <> std::istream& Property<bool>::loadBinary(std::istream& is) { return is.read((char*)&m_value, sizeof(bool)); }
|
||||
template <> std::istream& Property<bool>::loadAscii(std::istream& is) { return is >> m_value; }
|
||||
template <> AbstractProperty::PropertyType Property<bool>::getStaticPropertyType() { return AbstractProperty::BOOLEAN; }
|
||||
|
||||
// UNSIGNED INTEGER PROPERTY
|
||||
template <> std::ostream& Property<unsigned int>::saveBinary(std::ostream& os) { return os.write((char*)&value, sizeof(unsigned int)); }
|
||||
template <> std::ostream& Property<unsigned int>::saveAscii(std::ostream& os) { return os << value; }
|
||||
template <> std::istream& Property<unsigned int>::loadBinary(std::istream& is) { return is.read((char*)&value, sizeof(unsigned int)); }
|
||||
template <> std::istream& Property<unsigned int>::loadAscii(std::istream& is) { return is >> value; }
|
||||
template <> std::ostream& Property<unsigned int>::saveBinary(std::ostream& os) { return os.write((char*)&m_value, sizeof(unsigned int)); }
|
||||
template <> std::ostream& Property<unsigned int>::saveAscii(std::ostream& os) { return os << m_value; }
|
||||
template <> std::istream& Property<unsigned int>::loadBinary(std::istream& is) { return is.read((char*)&m_value, sizeof(unsigned int)); }
|
||||
template <> std::istream& Property<unsigned int>::loadAscii(std::istream& is) { return is >> m_value; }
|
||||
template <> AbstractProperty::PropertyType Property<unsigned int>::getStaticPropertyType() { return AbstractProperty::UNSIGNED_INTEGER; }
|
||||
|
||||
// BYTE PROPERTY
|
||||
template <> std::ostream& Property<char>::saveBinary(std::ostream& os) { return os.write((char*)&value, sizeof(char)); }
|
||||
template <> std::ostream& Property<char>::saveAscii(std::ostream& os) { return os << value; }
|
||||
template <> std::istream& Property<char>::loadBinary(std::istream& is) { return is.read((char*)&value, sizeof(char)); }
|
||||
template <> std::istream& Property<char>::loadAscii(std::istream& is) { return is >> value; }
|
||||
template <> std::ostream& Property<char>::saveBinary(std::ostream& os) { return os.write((char*)&m_value, sizeof(char)); }
|
||||
template <> std::ostream& Property<char>::saveAscii(std::ostream& os) { return os << m_value; }
|
||||
template <> std::istream& Property<char>::loadBinary(std::istream& is) { return is.read((char*)&m_value, sizeof(char)); }
|
||||
template <> std::istream& Property<char>::loadAscii(std::istream& is) { return is >> m_value; }
|
||||
template <> AbstractProperty::PropertyType Property<char>::getStaticPropertyType() { return AbstractProperty::BYTE; }
|
||||
|
||||
// SHORT PROPERTY
|
||||
template <> std::ostream& Property<short>::saveBinary(std::ostream& os) { return os.write((char*)&value, sizeof(short)); }
|
||||
template <> std::ostream& Property<short>::saveAscii(std::ostream& os) { return os << value; }
|
||||
template <> std::istream& Property<short>::loadBinary(std::istream& is) { return is.read((char*)&value, sizeof(short)); }
|
||||
template <> std::istream& Property<short>::loadAscii(std::istream& is) { return is >> value; }
|
||||
template <> std::ostream& Property<short>::saveBinary(std::ostream& os) { return os.write((char*)&m_value, sizeof(short)); }
|
||||
template <> std::ostream& Property<short>::saveAscii(std::ostream& os) { return os << m_value; }
|
||||
template <> std::istream& Property<short>::loadBinary(std::istream& is) { return is.read((char*)&m_value, sizeof(short)); }
|
||||
template <> std::istream& Property<short>::loadAscii(std::istream& is) { return is >> m_value; }
|
||||
template <> AbstractProperty::PropertyType Property<short>::getStaticPropertyType() { return AbstractProperty::SHORT; }
|
||||
|
||||
// LONG PROPERTY
|
||||
template <> std::ostream& Property<long>::saveBinary(std::ostream& os) { return os.write((char*)&value, sizeof(long)); }
|
||||
template <> std::ostream& Property<long>::saveAscii(std::ostream& os) { return os << value; }
|
||||
template <> std::istream& Property<long>::loadBinary(std::istream& is) { return is.read((char*)&value, sizeof(long)); }
|
||||
template <> std::istream& Property<long>::loadAscii(std::istream& is) { return is >> value; }
|
||||
template <> std::ostream& Property<long>::saveBinary(std::ostream& os) { return os.write((char*)&m_value, sizeof(long)); }
|
||||
template <> std::ostream& Property<long>::saveAscii(std::ostream& os) { return os << m_value; }
|
||||
template <> std::istream& Property<long>::loadBinary(std::istream& is) { return is.read((char*)&m_value, sizeof(long)); }
|
||||
template <> std::istream& Property<long>::loadAscii(std::istream& is) { return is >> m_value; }
|
||||
template <> AbstractProperty::PropertyType Property<long>::getStaticPropertyType() { return AbstractProperty::LONG; }
|
||||
|
||||
// DOUBLE PROPERTY
|
||||
template <> std::ostream& Property<double>::saveBinary(std::ostream& os) { return os.write((char*)&value, sizeof(double)); }
|
||||
template <> std::ostream& Property<double>::saveAscii(std::ostream& os) { return os << value; }
|
||||
template <> std::istream& Property<double>::loadBinary(std::istream& is) { return is.read((char*)&value, sizeof(double)); }
|
||||
template <> std::istream& Property<double>::loadAscii(std::istream& is) { return is >> value; }
|
||||
template <> std::ostream& Property<double>::saveBinary(std::ostream& os) { return os.write((char*)&m_value, sizeof(double)); }
|
||||
template <> std::ostream& Property<double>::saveAscii(std::ostream& os) { return os << m_value; }
|
||||
template <> std::istream& Property<double>::loadBinary(std::istream& is) { return is.read((char*)&m_value, sizeof(double)); }
|
||||
template <> std::istream& Property<double>::loadAscii(std::istream& is) { return is >> m_value; }
|
||||
template <> AbstractProperty::PropertyType Property<double>::getStaticPropertyType() { return AbstractProperty::DOUBLE; }
|
||||
|
||||
// VEC2 PROPERTY
|
||||
template <> std::ostream& Property<glm::vec2>::saveBinary(std::ostream& os) { return os.write((char*)glm::value_ptr(value), sizeof(float)*value.length()); }
|
||||
template <> std::ostream& Property<glm::vec2>::saveAscii(std::ostream& os) { os << "["; for(int i=0; i<value.length(); ++i) os << (glm::value_ptr(value)[i]) << (i == value.length()-1 ? "]" : ", "); return os; }
|
||||
template <> std::istream& Property<glm::vec2>::loadBinary(std::istream& is) { return is.read((char*)glm::value_ptr(value), sizeof(float)*value.length()); }
|
||||
template <> std::istream& Property<glm::vec2>::loadAscii(std::istream& is) { is.ignore(1); for(int i=0; i<value.length(); ++i) is >> (glm::value_ptr(value)[i]), is.ignore(1); return is; }
|
||||
template <> std::ostream& Property<glm::vec2>::saveBinary(std::ostream& os) { return os.write((char*)glm::value_ptr(m_value), sizeof(float)*m_value.length()); }
|
||||
template <> std::ostream& Property<glm::vec2>::saveAscii(std::ostream& os) { os << "["; for(int i=0; i<m_value.length(); ++i) os << (glm::value_ptr(m_value)[i]) << (i == m_value.length()-1 ? "]" : ", "); return os; }
|
||||
template <> std::istream& Property<glm::vec2>::loadBinary(std::istream& is) { return is.read((char*)glm::value_ptr(m_value), sizeof(float)*m_value.length()); }
|
||||
template <> std::istream& Property<glm::vec2>::loadAscii(std::istream& is) { is.ignore(1); for(int i=0; i<m_value.length(); ++i) is >> (glm::value_ptr(m_value)[i]), is.ignore(1); return is; }
|
||||
template <> AbstractProperty::PropertyType Property<glm::vec2>::getStaticPropertyType() { return AbstractProperty::VEC2; }
|
||||
|
||||
// VEC3 PROPERTY
|
||||
template <> std::ostream& Property<glm::vec3>::saveBinary(std::ostream& os) { return os.write((char*)glm::value_ptr(value), sizeof(float)*value.length()); }
|
||||
template <> std::ostream& Property<glm::vec3>::saveAscii(std::ostream& os) { os << "["; for(int i=0; i<value.length(); ++i) os << (glm::value_ptr(value)[i]) << (i == value.length()-1 ? "]" : ", "); return os; }
|
||||
template <> std::istream& Property<glm::vec3>::loadBinary(std::istream& is) { return is.read((char*)glm::value_ptr(value), sizeof(float)*value.length()); }
|
||||
template <> std::istream& Property<glm::vec3>::loadAscii(std::istream& is) { is.ignore(1); for(int i=0; i<value.length(); ++i) is >> (glm::value_ptr(value)[i]), is.ignore(1); return is; }
|
||||
template <> std::ostream& Property<glm::vec3>::saveBinary(std::ostream& os) { return os.write((char*)glm::value_ptr(m_value), sizeof(float)*m_value.length()); }
|
||||
template <> std::ostream& Property<glm::vec3>::saveAscii(std::ostream& os) { os << "["; for(int i=0; i<m_value.length(); ++i) os << (glm::value_ptr(m_value)[i]) << (i == m_value.length()-1 ? "]" : ", "); return os; }
|
||||
template <> std::istream& Property<glm::vec3>::loadBinary(std::istream& is) { return is.read((char*)glm::value_ptr(m_value), sizeof(float)*m_value.length()); }
|
||||
template <> std::istream& Property<glm::vec3>::loadAscii(std::istream& is) { is.ignore(1); for(int i=0; i<m_value.length(); ++i) is >> (glm::value_ptr(m_value)[i]), is.ignore(1); return is; }
|
||||
template <> AbstractProperty::PropertyType Property<glm::vec3>::getStaticPropertyType() { return AbstractProperty::VEC3; }
|
||||
|
||||
// VEC4 PROPERTY
|
||||
template <> std::ostream& Property<glm::vec4>::saveBinary(std::ostream& os) { return os.write((char*)glm::value_ptr(value), sizeof(float)*value.length()); }
|
||||
template <> std::ostream& Property<glm::vec4>::saveAscii(std::ostream& os) { os << "["; for(int i=0; i<value.length(); ++i) os << (glm::value_ptr(value)[i]) << (i == value.length()-1 ? "]" : ", "); return os; }
|
||||
template <> std::istream& Property<glm::vec4>::loadBinary(std::istream& is) { return is.read((char*)glm::value_ptr(value), sizeof(float)*value.length()); }
|
||||
template <> std::istream& Property<glm::vec4>::loadAscii(std::istream& is) { is.ignore(1); for(int i=0; i<value.length(); ++i) is >> (glm::value_ptr(value)[i]), is.ignore(1); return is; }
|
||||
template <> std::ostream& Property<glm::vec4>::saveBinary(std::ostream& os) { return os.write((char*)glm::value_ptr(m_value), sizeof(float)*m_value.length()); }
|
||||
template <> std::ostream& Property<glm::vec4>::saveAscii(std::ostream& os) { os << "["; for(int i=0; i<m_value.length(); ++i) os << (glm::value_ptr(m_value)[i]) << (i == m_value.length()-1 ? "]" : ", "); return os; }
|
||||
template <> std::istream& Property<glm::vec4>::loadBinary(std::istream& is) { return is.read((char*)glm::value_ptr(m_value), sizeof(float)*m_value.length()); }
|
||||
template <> std::istream& Property<glm::vec4>::loadAscii(std::istream& is) { is.ignore(1); for(int i=0; i<m_value.length(); ++i) is >> (glm::value_ptr(m_value)[i]), is.ignore(1); return is; }
|
||||
template <> AbstractProperty::PropertyType Property<glm::vec4>::getStaticPropertyType() { return AbstractProperty::VEC4; }
|
||||
|
||||
// MAT3 PROPERTY
|
||||
template <> std::ostream& Property<glm::mat3>::saveBinary(std::ostream& os) { return os.write((char*)glm::value_ptr(value), sizeof(float)*value.length()); }
|
||||
template <> std::ostream& Property<glm::mat3>::saveAscii(std::ostream& os) { os << "["; for(int i=0; i<value.length(); ++i) os << (glm::value_ptr(value)[i]) << (i == value.length()-1 ? "]" : ", "); return os; }
|
||||
template <> std::istream& Property<glm::mat3>::loadBinary(std::istream& is) { return is.read((char*)glm::value_ptr(value), sizeof(float)*value.length()); }
|
||||
template <> std::istream& Property<glm::mat3>::loadAscii(std::istream& is) { is.ignore(1); for(int i=0; i<value.length(); ++i) is >> (glm::value_ptr(value)[i]), is.ignore(1); return is; }
|
||||
template <> std::ostream& Property<glm::mat3>::saveBinary(std::ostream& os) { return os.write((char*)glm::value_ptr(m_value), sizeof(float)*m_value.length()); }
|
||||
template <> std::ostream& Property<glm::mat3>::saveAscii(std::ostream& os) { os << "["; for(int i=0; i<m_value.length(); ++i) os << (glm::value_ptr(m_value)[i]) << (i == m_value.length()-1 ? "]" : ", "); return os; }
|
||||
template <> std::istream& Property<glm::mat3>::loadBinary(std::istream& is) { return is.read((char*)glm::value_ptr(m_value), sizeof(float)*m_value.length()); }
|
||||
template <> std::istream& Property<glm::mat3>::loadAscii(std::istream& is) { is.ignore(1); for(int i=0; i<m_value.length(); ++i) is >> (glm::value_ptr(m_value)[i]), is.ignore(1); return is; }
|
||||
template <> AbstractProperty::PropertyType Property<glm::mat3>::getStaticPropertyType() { return AbstractProperty::MAT3; }
|
||||
|
||||
// MAT4 PROPERTY
|
||||
template <> std::ostream& Property<glm::mat4>::saveBinary(std::ostream& os) { return os.write((char*)glm::value_ptr(value), sizeof(float)*value.length()); }
|
||||
template <> std::ostream& Property<glm::mat4>::saveAscii(std::ostream& os) { os << "["; for(int i=0; i<value.length(); ++i) os << (glm::value_ptr(value)[i]) << (i == value.length()-1 ? "]" : ", "); return os; }
|
||||
template <> std::istream& Property<glm::mat4>::loadBinary(std::istream& is) { return is.read((char*)glm::value_ptr(value), sizeof(float)*value.length()); }
|
||||
template <> std::istream& Property<glm::mat4>::loadAscii(std::istream& is) { is.ignore(1); for(int i=0; i<value.length(); ++i) is >> (glm::value_ptr(value)[i]), is.ignore(1); return is; }
|
||||
template <> std::ostream& Property<glm::mat4>::saveBinary(std::ostream& os) { return os.write((char*)glm::value_ptr(m_value), sizeof(float)*m_value.length()); }
|
||||
template <> std::ostream& Property<glm::mat4>::saveAscii(std::ostream& os) { os << "["; for(int i=0; i<m_value.length(); ++i) os << (glm::value_ptr(m_value)[i]) << (i == m_value.length()-1 ? "]" : ", "); return os; }
|
||||
template <> std::istream& Property<glm::mat4>::loadBinary(std::istream& is) { return is.read((char*)glm::value_ptr(m_value), sizeof(float)*m_value.length()); }
|
||||
template <> std::istream& Property<glm::mat4>::loadAscii(std::istream& is) { is.ignore(1); for(int i=0; i<m_value.length(); ++i) is >> (glm::value_ptr(m_value)[i]), is.ignore(1); return is; }
|
||||
template <> AbstractProperty::PropertyType Property<glm::mat4>::getStaticPropertyType() { return AbstractProperty::MAT4; }
|
||||
|
||||
// STRING PROPERTY
|
||||
template <> std::ostream& Property<std::string>::saveBinary(std::ostream& os)
|
||||
{
|
||||
static const char endChar = '\0';
|
||||
os.write(value.data(), sizeof(char)*value.size());
|
||||
os.write(m_value.data(), sizeof(char)*m_value.size());
|
||||
return os.write(&endChar, sizeof(char));;
|
||||
}
|
||||
template <> std::ostream& Property<std::string>::saveAscii(std::ostream& os)
|
||||
{
|
||||
os << "\"";
|
||||
for(char c : value)
|
||||
for(char c : m_value)
|
||||
{
|
||||
switch(c)
|
||||
{
|
||||
@ -129,14 +129,14 @@ template <> std::ostream& Property<std::string>::saveAscii(std::ostream& os)
|
||||
}
|
||||
template <> std::istream& Property<std::string>::loadBinary(std::istream& is)
|
||||
{
|
||||
value = "";
|
||||
m_value = "";
|
||||
for(char c = is.get(); c != '\0'; c = is.get())
|
||||
value.push_back(c);
|
||||
m_value.push_back(c);
|
||||
return is;
|
||||
}
|
||||
template <> std::istream& Property<std::string>::loadAscii(std::istream& is)
|
||||
{
|
||||
value = "";
|
||||
m_value = "";
|
||||
is.ignore(1); // "
|
||||
for(char c = is.get(); c != '"'; c = is.get())
|
||||
{
|
||||
@ -146,27 +146,27 @@ template <> std::istream& Property<std::string>::loadAscii(std::istream& is)
|
||||
switch(c)
|
||||
{
|
||||
case 't' :
|
||||
value.push_back('\t');
|
||||
m_value.push_back('\t');
|
||||
break;
|
||||
case '\\' :
|
||||
value.push_back('\\');
|
||||
m_value.push_back('\\');
|
||||
break;
|
||||
case 'n' :
|
||||
value.push_back('\n');
|
||||
m_value.push_back('\n');
|
||||
break;
|
||||
case 'r' :
|
||||
value.push_back('\r');
|
||||
m_value.push_back('\r');
|
||||
break;
|
||||
case '"' :
|
||||
value.push_back('"');
|
||||
m_value.push_back('"');
|
||||
c = 'c';
|
||||
break;
|
||||
default:
|
||||
value.push_back(c);
|
||||
m_value.push_back(c);
|
||||
}
|
||||
}
|
||||
else
|
||||
value.push_back(c);
|
||||
m_value.push_back(c);
|
||||
}
|
||||
return is;
|
||||
}
|
||||
@ -175,17 +175,17 @@ template <> AbstractProperty::PropertyType Property<std::string>::getStaticPrope
|
||||
// ARRAY PROPERTY SPECIAL BOOL HANDLING
|
||||
template <> std::ostream& ArrayProperty<bool>::saveBinary(std::ostream& os)
|
||||
{
|
||||
unsigned int size = value.size();
|
||||
unsigned int size = m_value.size();
|
||||
os.write((char*)&size, sizeof(unsigned int));
|
||||
for(bool it : value)
|
||||
for(bool it : m_value)
|
||||
Property<bool>(it).saveBinary(os);
|
||||
return os;
|
||||
}
|
||||
|
||||
template <> std::ostream& ArrayProperty<bool>::saveAscii(std::ostream& os)
|
||||
{
|
||||
os << "{ " << value.size() << ", [" << std::endl;
|
||||
for(bool it : value)
|
||||
os << "{ " << m_value.size() << ", [" << std::endl;
|
||||
for(bool it : m_value)
|
||||
{
|
||||
Property<bool>(it).saveAscii(os);
|
||||
os << "," << std::endl;
|
||||
|
||||
@ -11,23 +11,23 @@
|
||||
Property<type> var##Property;\
|
||||
type &var = var##Property.getValueRef();\
|
||||
|
||||
#define INT(var) PROPERTY(int, var)
|
||||
#define UINT(var) PROPERTY(unsigned int, var)
|
||||
#define LONG(var) PROPERTY(long, var)
|
||||
#define SHORT(var) PROPERTY(short, var)
|
||||
#define BYTE(var) PROPERTY(char, var)
|
||||
#define DOUBLE(var) PROPERTY(double, var)
|
||||
#define FLOAT(var) PROPERTY(float, var)
|
||||
#define BOOL(var) PROPERTY(bool, var)
|
||||
#define VEC2(var) PROPERTY(glm::vec2, var)
|
||||
#define VEC3(var) PROPERTY(glm::vec3, var)
|
||||
#define VEC4(var) PROPERTY(glm::vec4, var)
|
||||
#define MAT3(var) PROPERTY(glm::mat3, var)
|
||||
#define MAT4(var) PROPERTY(glm::mat4, var)
|
||||
#define STRING(var) PROPERTY(std::string, var)
|
||||
#define P_INT(var) PROPERTY(int, var)
|
||||
#define P_UINT(var) PROPERTY(unsigned int, var)
|
||||
#define P_LONG(var) PROPERTY(long, var)
|
||||
#define P_SHORT(var) PROPERTY(short, var)
|
||||
#define P_BYTE(var) PROPERTY(char, var)
|
||||
#define P_DOUBLE(var) PROPERTY(double, var)
|
||||
#define P_FLOAT(var) PROPERTY(float, var)
|
||||
#define P_BOOL(var) PROPERTY(bool, var)
|
||||
#define P_VEC2(var) PROPERTY(glm::vec2, var)
|
||||
#define P_VEC3(var) PROPERTY(glm::vec3, var)
|
||||
#define P_VEC4(var) PROPERTY(glm::vec4, var)
|
||||
#define P_MAT3(var) PROPERTY(glm::mat3, var)
|
||||
#define P_MAT4(var) PROPERTY(glm::mat4, var)
|
||||
#define P_STRING(var) PROPERTY(std::string, var)
|
||||
|
||||
// the provided type must be a class inheriting Serializable
|
||||
#define REFERENCE(type, var)\
|
||||
#define P_REFERENCE(type, var)\
|
||||
Property<Serializable*> var##Property;\
|
||||
type*& var = (type*&)(var##Property.getValueRef());\
|
||||
|
||||
@ -36,21 +36,21 @@
|
||||
std::vector<type> &var = var##Property.getValueRef();\
|
||||
|
||||
|
||||
#define VECTOR_INT(var) VECTOR_PROPERTY(int, var)
|
||||
#define VECTOR_UINT(var) VECTOR_PROPERTY(unsigned int, var)
|
||||
#define VECTOR_FLOAT(var) VECTOR_PROPERTY(float, var)
|
||||
#define VECTOR_BOOL(var) VECTOR_PROPERTY(bool, var)
|
||||
#define VECTOR_SHORT(var) VECTOR_PROPERTY(short, var)
|
||||
#define VECTOR_BYTE(var) VECTOR_PROPERTY(char, var)
|
||||
#define VECTOR_LONG(var) VECTOR_PROPERTY(long, var)
|
||||
#define VECTOR_DOUBLE(var) VECTOR_PROPERTY(double, var)
|
||||
#define VECTOR_VEC2(var) VECTOR_PROPERTY(glm::vec2, var)
|
||||
#define VECTOR_VEC3(var) VECTOR_PROPERTY(glm::vec3, var)
|
||||
#define VECTOR_VEC4(var) VECTOR_PROPERTY(glm::vec4, var)
|
||||
#define VECTOR_MAT3(var) VECTOR_PROPERTY(glm::mat3, var)
|
||||
#define VECTOR_MAT4(var) VECTOR_PROPERTY(glm::mat4, var)
|
||||
#define VECTOR_STRING(var) VECTOR_PROPERTY(std::string, var)
|
||||
#define VECTOR_REFERENCE(type, var) VECTOR_PROPERTY(type*, var)
|
||||
#define P_VECTOR_INT(var) VECTOR_PROPERTY(int, var)
|
||||
#define P_VECTOR_UINT(var) VECTOR_PROPERTY(unsigned int, var)
|
||||
#define P_VECTOR_FLOAT(var) VECTOR_PROPERTY(float, var)
|
||||
#define P_VECTOR_BOOL(var) VECTOR_PROPERTY(bool, var)
|
||||
#define P_VECTOR_SHORT(var) VECTOR_PROPERTY(short, var)
|
||||
#define P_VECTOR_BYTE(var) VECTOR_PROPERTY(char, var)
|
||||
#define P_VECTOR_LONG(var) VECTOR_PROPERTY(long, var)
|
||||
#define P_VECTOR_DOUBLE(var) VECTOR_PROPERTY(double, var)
|
||||
#define P_VECTOR_VEC2(var) VECTOR_PROPERTY(glm::vec2, var)
|
||||
#define P_VECTOR_VEC3(var) VECTOR_PROPERTY(glm::vec3, var)
|
||||
#define P_VECTOR_VEC4(var) VECTOR_PROPERTY(glm::vec4, var)
|
||||
#define P_VECTOR_MAT3(var) VECTOR_PROPERTY(glm::mat3, var)
|
||||
#define P_VECTOR_MAT4(var) VECTOR_PROPERTY(glm::mat4, var)
|
||||
#define P_VECTOR_STRING(var) VECTOR_PROPERTY(std::string, var)
|
||||
#define P_VECTOR_REFERENCE(type, var) VECTOR_PROPERTY(type*, var)
|
||||
|
||||
#define CAST(var) (AbstractProperty*)&var##Property
|
||||
|
||||
@ -110,9 +110,9 @@ public:
|
||||
template <typename T>
|
||||
class Property : public AbstractProperty
|
||||
{
|
||||
T value;
|
||||
T m_value;
|
||||
public:
|
||||
Property(T val) : value(val) {}
|
||||
Property(T val) : m_value(val) {}
|
||||
Property() {}
|
||||
~Property() {}
|
||||
|
||||
@ -125,7 +125,7 @@ public:
|
||||
PropertyType getPropertyType() { return getStaticPropertyType(); }
|
||||
static PropertyType getStaticPropertyType();
|
||||
|
||||
T &getValueRef() { return value; }
|
||||
T &getValueRef() { return m_value; }
|
||||
};
|
||||
|
||||
/**
|
||||
@ -136,9 +136,9 @@ public:
|
||||
template <typename T>
|
||||
class Property<T*> : public AbstractProperty
|
||||
{
|
||||
T* value;
|
||||
T* m_value;
|
||||
public:
|
||||
Property(T* val) : value(val) {}
|
||||
Property(T* val) : m_value(val) {}
|
||||
Property() {}
|
||||
~Property() {}
|
||||
|
||||
@ -150,7 +150,7 @@ public:
|
||||
|
||||
PropertyType getPropertyType() { return getStaticPropertyType(); }
|
||||
static PropertyType getStaticPropertyType() { return REFERENCE; }
|
||||
T*& getValueRef() { return value; }
|
||||
T*& getValueRef() { return m_value; }
|
||||
};
|
||||
|
||||
// GENERIC VECTOR PROPERTY
|
||||
@ -166,17 +166,17 @@ public:
|
||||
template <typename T>
|
||||
class ArrayProperty : public AbstractArrayProperty
|
||||
{
|
||||
std::vector<T> value;
|
||||
std::vector<T> m_value;
|
||||
public:
|
||||
ArrayProperty(const std::vector<T> &val) : value(val) {}
|
||||
ArrayProperty(const std::vector<T> &val) : m_value(val) {}
|
||||
ArrayProperty() {}
|
||||
~ArrayProperty() {}
|
||||
|
||||
std::ostream& saveBinary(std::ostream& os)
|
||||
{
|
||||
Property<int> size(value.size());
|
||||
Property<int> size(m_value.size());
|
||||
size.saveBinary(os);
|
||||
for(T &it : value)
|
||||
for(T &it : m_value)
|
||||
Property<T>(it).saveBinary(os);
|
||||
return os;
|
||||
}
|
||||
@ -184,8 +184,8 @@ public:
|
||||
std::ostream& saveAscii(std::ostream& os)
|
||||
{
|
||||
os << "[";
|
||||
int i = value.size();
|
||||
for(T &it : value)
|
||||
int i = m_value.size();
|
||||
for(T &it : m_value)
|
||||
{
|
||||
Property<T>(it).saveAscii(os);
|
||||
if(--i) os << ", ";
|
||||
@ -197,25 +197,25 @@ public:
|
||||
{
|
||||
Property<int> size;
|
||||
size.loadBinary(is);
|
||||
value.resize(size.getValueRef());
|
||||
m_value.resize(size.getValueRef());
|
||||
Property<T> p;
|
||||
for(int i=0; i<size.getValueRef(); ++i)
|
||||
{
|
||||
p.loadBinary(is);
|
||||
value[i] = p.getValueRef();
|
||||
m_value[i] = p.getValueRef();
|
||||
}
|
||||
return is;
|
||||
}
|
||||
|
||||
std::istream& loadAscii(std::istream& is)
|
||||
{
|
||||
value.clear();
|
||||
m_value.clear();
|
||||
is.ignore(1); // [
|
||||
Property<T> p;
|
||||
while(is.peek() != ']')
|
||||
{
|
||||
p.loadAscii(is);
|
||||
value.push_back(p.getValueRef());
|
||||
m_value.push_back(p.getValueRef());
|
||||
if(is.peek() == ',')
|
||||
is.ignore(1); // ,
|
||||
}
|
||||
@ -226,10 +226,10 @@ public:
|
||||
|
||||
PropertyType getDataType() { return Property<T>::getStaticPropertyType(); }
|
||||
|
||||
std::vector<T> &getValueRef() { return value; }
|
||||
const std::vector<T> &getValueRef() const { return value; }
|
||||
std::vector<T> &getValueRef() { return m_value; }
|
||||
const std::vector<T> &getValueRef() const { return m_value; }
|
||||
|
||||
unsigned int getArraySize() { return value.size(); }
|
||||
unsigned int getArraySize() { return m_value.size(); }
|
||||
};
|
||||
|
||||
#endif // PROPERTY_H
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user