EpicSparrow/SparrowSerializer
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

changed some variable and macro naming

Browse Source
This commit is contained in:
Anselme 2017-01-22 12:26:45 +01:00
parent 5ade0127be
commit d1873c9de4
3 changed files with 122 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/main.cpp
View File

@ -9,11 +9,11 @@
class Foo : public Serializable class Foo : public Serializable
{ {
public: public:
INT (myInt) P_INT (myInt)
STRING (myString) P_STRING (myString)
VECTOR_FLOAT(myFloatArray) P_VECTOR_FLOAT(myFloatArray)
VEC3 (myVec3) P_VEC3 (myVec3)
REFERENCE (Foo, myFoo) P_REFERENCE (Foo, myFoo)
SERIALIZABLE(Foo, SERIALIZABLE(Foo,
CAST(myInt), CAST(myInt),

136
src/property.cpp
View File

@ -2,107 +2,107 @@
#include "serializable.h" #include "serializable.h"
// INTEGER PROPERTY // INTEGER PROPERTY
template <> std::ostream& Property<int>::saveBinary(std::ostream& os) { return os.write((char*)&value, sizeof(int)); } 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 << value; } 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*)&value, sizeof(int)); } 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 >> value; } template <> std::istream& Property<int>::loadAscii(std::istream& is) { return is >> m_value; }
template <> AbstractProperty::PropertyType Property<int>::getStaticPropertyType() { return AbstractProperty::INTEGER; } template <> AbstractProperty::PropertyType Property<int>::getStaticPropertyType() { return AbstractProperty::INTEGER; }
// FLOAT PROPERTY // FLOAT PROPERTY
template <> std::ostream& Property<float>::saveBinary(std::ostream& os) { return os.write((char*)&value, sizeof(float)); } 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 << value; } 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*)&value, sizeof(float)); } 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 >> value; } template <> std::istream& Property<float>::loadAscii(std::istream& is) { return is >> m_value; }
template <> AbstractProperty::PropertyType Property<float>::getStaticPropertyType() { return AbstractProperty::FLOAT; } template <> AbstractProperty::PropertyType Property<float>::getStaticPropertyType() { return AbstractProperty::FLOAT; }
// BOOLEAN PROPERTY // BOOLEAN PROPERTY
template <> std::ostream& Property<bool>::saveBinary(std::ostream& os) { return os.write((char*)&value, sizeof(bool)); } 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 << value; } 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*)&value, sizeof(bool)); } 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 >> value; } template <> std::istream& Property<bool>::loadAscii(std::istream& is) { return is >> m_value; }
template <> AbstractProperty::PropertyType Property<bool>::getStaticPropertyType() { return AbstractProperty::BOOLEAN; } template <> AbstractProperty::PropertyType Property<bool>::getStaticPropertyType() { return AbstractProperty::BOOLEAN; }
// UNSIGNED INTEGER PROPERTY // 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>::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 << value; } 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*)&value, sizeof(unsigned int)); } 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 >> value; } 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; } template <> AbstractProperty::PropertyType Property<unsigned int>::getStaticPropertyType() { return AbstractProperty::UNSIGNED_INTEGER; }
// BYTE PROPERTY // BYTE PROPERTY
template <> std::ostream& Property<char>::saveBinary(std::ostream& os) { return os.write((char*)&value, sizeof(char)); } 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 << value; } 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*)&value, sizeof(char)); } 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 >> value; } template <> std::istream& Property<char>::loadAscii(std::istream& is) { return is >> m_value; }
template <> AbstractProperty::PropertyType Property<char>::getStaticPropertyType() { return AbstractProperty::BYTE; } template <> AbstractProperty::PropertyType Property<char>::getStaticPropertyType() { return AbstractProperty::BYTE; }
// SHORT PROPERTY // SHORT PROPERTY
template <> std::ostream& Property<short>::saveBinary(std::ostream& os) { return os.write((char*)&value, sizeof(short)); } 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 << value; } 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*)&value, sizeof(short)); } 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 >> value; } template <> std::istream& Property<short>::loadAscii(std::istream& is) { return is >> m_value; }
template <> AbstractProperty::PropertyType Property<short>::getStaticPropertyType() { return AbstractProperty::SHORT; } template <> AbstractProperty::PropertyType Property<short>::getStaticPropertyType() { return AbstractProperty::SHORT; }
// LONG PROPERTY // LONG PROPERTY
template <> std::ostream& Property<long>::saveBinary(std::ostream& os) { return os.write((char*)&value, sizeof(long)); } 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 << value; } 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*)&value, sizeof(long)); } 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 >> value; } template <> std::istream& Property<long>::loadAscii(std::istream& is) { return is >> m_value; }
template <> AbstractProperty::PropertyType Property<long>::getStaticPropertyType() { return AbstractProperty::LONG; } template <> AbstractProperty::PropertyType Property<long>::getStaticPropertyType() { return AbstractProperty::LONG; }
// DOUBLE PROPERTY // DOUBLE PROPERTY
template <> std::ostream& Property<double>::saveBinary(std::ostream& os) { return os.write((char*)&value, sizeof(double)); } 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 << value; } 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*)&value, sizeof(double)); } 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 >> value; } template <> std::istream& Property<double>::loadAscii(std::istream& is) { return is >> m_value; }
template <> AbstractProperty::PropertyType Property<double>::getStaticPropertyType() { return AbstractProperty::DOUBLE; } template <> AbstractProperty::PropertyType Property<double>::getStaticPropertyType() { return AbstractProperty::DOUBLE; }
// VEC2 PROPERTY // 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>::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<value.length(); ++i) os << (glm::value_ptr(value)[i]) << (i == value.length()-1 ? "]" : ", "); return os; } 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(value), sizeof(float)*value.length()); } 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<value.length(); ++i) is >> (glm::value_ptr(value)[i]), is.ignore(1); return is; } 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; } template <> AbstractProperty::PropertyType Property<glm::vec2>::getStaticPropertyType() { return AbstractProperty::VEC2; }
// VEC3 PROPERTY // 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>::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<value.length(); ++i) os << (glm::value_ptr(value)[i]) << (i == value.length()-1 ? "]" : ", "); return os; } 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(value), sizeof(float)*value.length()); } 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<value.length(); ++i) is >> (glm::value_ptr(value)[i]), is.ignore(1); return is; } 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; } template <> AbstractProperty::PropertyType Property<glm::vec3>::getStaticPropertyType() { return AbstractProperty::VEC3; }
// VEC4 PROPERTY // 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>::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<value.length(); ++i) os << (glm::value_ptr(value)[i]) << (i == value.length()-1 ? "]" : ", "); return os; } 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(value), sizeof(float)*value.length()); } 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<value.length(); ++i) is >> (glm::value_ptr(value)[i]), is.ignore(1); return is; } 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; } template <> AbstractProperty::PropertyType Property<glm::vec4>::getStaticPropertyType() { return AbstractProperty::VEC4; }
// MAT3 PROPERTY // 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>::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<value.length(); ++i) os << (glm::value_ptr(value)[i]) << (i == value.length()-1 ? "]" : ", "); return os; } 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(value), sizeof(float)*value.length()); } 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<value.length(); ++i) is >> (glm::value_ptr(value)[i]), is.ignore(1); return is; } 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; } template <> AbstractProperty::PropertyType Property<glm::mat3>::getStaticPropertyType() { return AbstractProperty::MAT3; }
// MAT4 PROPERTY // 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>::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<value.length(); ++i) os << (glm::value_ptr(value)[i]) << (i == value.length()-1 ? "]" : ", "); return os; } 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(value), sizeof(float)*value.length()); } 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<value.length(); ++i) is >> (glm::value_ptr(value)[i]), is.ignore(1); return is; } 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; } template <> AbstractProperty::PropertyType Property<glm::mat4>::getStaticPropertyType() { return AbstractProperty::MAT4; }
// STRING PROPERTY // STRING PROPERTY
template <> std::ostream& Property<std::string>::saveBinary(std::ostream& os) template <> std::ostream& Property<std::string>::saveBinary(std::ostream& os)
{ {
static const char endChar = '\0'; 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));; return os.write(&endChar, sizeof(char));;
} }
template <> std::ostream& Property<std::string>::saveAscii(std::ostream& os) template <> std::ostream& Property<std::string>::saveAscii(std::ostream& os)
{ {
os << "\""; os << "\"";
for(char c : value) for(char c : m_value)
{ {
switch(c) 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) template <> std::istream& Property<std::string>::loadBinary(std::istream& is)
{ {
value = ""; m_value = "";
for(char c = is.get(); c != '\0'; c = is.get()) for(char c = is.get(); c != '\0'; c = is.get())
value.push_back(c); m_value.push_back(c);
return is; return is;
} }
template <> std::istream& Property<std::string>::loadAscii(std::istream& is) template <> std::istream& Property<std::string>::loadAscii(std::istream& is)
{ {
value = ""; m_value = "";
is.ignore(1); // " is.ignore(1); // "
for(char c = is.get(); c != '"'; c = is.get()) 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) switch(c)
{ {
case 't' : case 't' :
value.push_back('\t'); m_value.push_back('\t');
break; break;
case '\\' : case '\\' :
value.push_back('\\'); m_value.push_back('\\');
break; break;
case 'n' : case 'n' :
value.push_back('\n'); m_value.push_back('\n');
break; break;
case 'r' : case 'r' :
value.push_back('\r'); m_value.push_back('\r');
break; break;
case '"' : case '"' :
value.push_back('"'); m_value.push_back('"');
c = 'c'; c = 'c';
break; break;
default: default:
value.push_back(c); m_value.push_back(c);
} }
} }
else else
value.push_back(c); m_value.push_back(c);
} }
return is; return is;
} }
@ -175,17 +175,17 @@ template <> AbstractProperty::PropertyType Property<std::string>::getStaticPrope
// ARRAY PROPERTY SPECIAL BOOL HANDLING // ARRAY PROPERTY SPECIAL BOOL HANDLING
template <> std::ostream& ArrayProperty<bool>::saveBinary(std::ostream& os) 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)); os.write((char*)&size, sizeof(unsigned int));
for(bool it : value) for(bool it : m_value)
Property<bool>(it).saveBinary(os); Property<bool>(it).saveBinary(os);
return os; return os;
} }
template <> std::ostream& ArrayProperty<bool>::saveAscii(std::ostream& os) template <> std::ostream& ArrayProperty<bool>::saveAscii(std::ostream& os)
{ {
os << "{ " << value.size() << ", [" << std::endl; os << "{ " << m_value.size() << ", [" << std::endl;
for(bool it : value) for(bool it : m_value)
{ {
Property<bool>(it).saveAscii(os); Property<bool>(it).saveAscii(os);
os << "," << std::endl; os << "," << std::endl;

98
src/property.h
View File

@ -11,23 +11,23 @@
Property<type> var##Property;\ Property<type> var##Property;\
type &var = var##Property.getValueRef();\ type &var = var##Property.getValueRef();\
#define INT(var) PROPERTY(int, var) #define P_INT(var) PROPERTY(int, var)
#define UINT(var) PROPERTY(unsigned int, var) #define P_UINT(var) PROPERTY(unsigned int, var)
#define LONG(var) PROPERTY(long, var) #define P_LONG(var) PROPERTY(long, var)
#define SHORT(var) PROPERTY(short, var) #define P_SHORT(var) PROPERTY(short, var)
#define BYTE(var) PROPERTY(char, var) #define P_BYTE(var) PROPERTY(char, var)
#define DOUBLE(var) PROPERTY(double, var) #define P_DOUBLE(var) PROPERTY(double, var)
#define FLOAT(var) PROPERTY(float, var) #define P_FLOAT(var) PROPERTY(float, var)
#define BOOL(var) PROPERTY(bool, var) #define P_BOOL(var) PROPERTY(bool, var)
#define VEC2(var) PROPERTY(glm::vec2, var) #define P_VEC2(var) PROPERTY(glm::vec2, var)
#define VEC3(var) PROPERTY(glm::vec3, var) #define P_VEC3(var) PROPERTY(glm::vec3, var)
#define VEC4(var) PROPERTY(glm::vec4, var) #define P_VEC4(var) PROPERTY(glm::vec4, var)
#define MAT3(var) PROPERTY(glm::mat3, var) #define P_MAT3(var) PROPERTY(glm::mat3, var)
#define MAT4(var) PROPERTY(glm::mat4, var) #define P_MAT4(var) PROPERTY(glm::mat4, var)
#define STRING(var) PROPERTY(std::string, var) #define P_STRING(var) PROPERTY(std::string, var)
// the provided type must be a class inheriting Serializable // the provided type must be a class inheriting Serializable
#define REFERENCE(type, var)\ #define P_REFERENCE(type, var)\
Property<Serializable*> var##Property;\ Property<Serializable*> var##Property;\
type*& var = (type*&)(var##Property.getValueRef());\ type*& var = (type*&)(var##Property.getValueRef());\
@ -36,21 +36,21 @@
std::vector<type> &var = var##Property.getValueRef();\ std::vector<type> &var = var##Property.getValueRef();\
#define VECTOR_INT(var) VECTOR_PROPERTY(int, var) #define P_VECTOR_INT(var) VECTOR_PROPERTY(int, var)
#define VECTOR_UINT(var) VECTOR_PROPERTY(unsigned int, var) #define P_VECTOR_UINT(var) VECTOR_PROPERTY(unsigned int, var)
#define VECTOR_FLOAT(var) VECTOR_PROPERTY(float, var) #define P_VECTOR_FLOAT(var) VECTOR_PROPERTY(float, var)
#define VECTOR_BOOL(var) VECTOR_PROPERTY(bool, var) #define P_VECTOR_BOOL(var) VECTOR_PROPERTY(bool, var)
#define VECTOR_SHORT(var) VECTOR_PROPERTY(short, var) #define P_VECTOR_SHORT(var) VECTOR_PROPERTY(short, var)
#define VECTOR_BYTE(var) VECTOR_PROPERTY(char, var) #define P_VECTOR_BYTE(var) VECTOR_PROPERTY(char, var)
#define VECTOR_LONG(var) VECTOR_PROPERTY(long, var) #define P_VECTOR_LONG(var) VECTOR_PROPERTY(long, var)
#define VECTOR_DOUBLE(var) VECTOR_PROPERTY(double, var) #define P_VECTOR_DOUBLE(var) VECTOR_PROPERTY(double, var)
#define VECTOR_VEC2(var) VECTOR_PROPERTY(glm::vec2, var) #define P_VECTOR_VEC2(var) VECTOR_PROPERTY(glm::vec2, var)
#define VECTOR_VEC3(var) VECTOR_PROPERTY(glm::vec3, var) #define P_VECTOR_VEC3(var) VECTOR_PROPERTY(glm::vec3, var)
#define VECTOR_VEC4(var) VECTOR_PROPERTY(glm::vec4, var) #define P_VECTOR_VEC4(var) VECTOR_PROPERTY(glm::vec4, var)
#define VECTOR_MAT3(var) VECTOR_PROPERTY(glm::mat3, var) #define P_VECTOR_MAT3(var) VECTOR_PROPERTY(glm::mat3, var)
#define VECTOR_MAT4(var) VECTOR_PROPERTY(glm::mat4, var) #define P_VECTOR_MAT4(var) VECTOR_PROPERTY(glm::mat4, var)
#define VECTOR_STRING(var) VECTOR_PROPERTY(std::string, var) #define P_VECTOR_STRING(var) VECTOR_PROPERTY(std::string, var)
#define VECTOR_REFERENCE(type, var) VECTOR_PROPERTY(type*, var) #define P_VECTOR_REFERENCE(type, var) VECTOR_PROPERTY(type*, var)
#define CAST(var) (AbstractProperty*)&var##Property #define CAST(var) (AbstractProperty*)&var##Property
@ -110,9 +110,9 @@ public:
template <typename T> template <typename T>
class Property : public AbstractProperty class Property : public AbstractProperty
{ {
T value; T m_value;
public: public:
Property(T val) : value(val) {} Property(T val) : m_value(val) {}
Property() {} Property() {}
~Property() {} ~Property() {}
@ -125,7 +125,7 @@ public:
PropertyType getPropertyType() { return getStaticPropertyType(); } PropertyType getPropertyType() { return getStaticPropertyType(); }
static PropertyType getStaticPropertyType(); static PropertyType getStaticPropertyType();
T &getValueRef() { return value; } T &getValueRef() { return m_value; }
}; };
/** /**
@ -136,9 +136,9 @@ public:
template <typename T> template <typename T>
class Property<T*> : public AbstractProperty class Property<T*> : public AbstractProperty
{ {
T* value; T* m_value;
public: public:
Property(T* val) : value(val) {} Property(T* val) : m_value(val) {}
Property() {} Property() {}
~Property() {} ~Property() {}
@ -150,7 +150,7 @@ public:
PropertyType getPropertyType() { return getStaticPropertyType(); } PropertyType getPropertyType() { return getStaticPropertyType(); }
static PropertyType getStaticPropertyType() { return REFERENCE; } static PropertyType getStaticPropertyType() { return REFERENCE; }
T*& getValueRef() { return value; } T*& getValueRef() { return m_value; }
}; };
// GENERIC VECTOR PROPERTY // GENERIC VECTOR PROPERTY
@ -166,17 +166,17 @@ public:
template <typename T> template <typename T>
class ArrayProperty : public AbstractArrayProperty class ArrayProperty : public AbstractArrayProperty
{ {
std::vector<T> value; std::vector<T> m_value;
public: public:
ArrayProperty(const std::vector<T> &val) : value(val) {} ArrayProperty(const std::vector<T> &val) : m_value(val) {}
ArrayProperty() {} ArrayProperty() {}
~ArrayProperty() {} ~ArrayProperty() {}
std::ostream& saveBinary(std::ostream& os) std::ostream& saveBinary(std::ostream& os)
{ {
Property<int> size(value.size()); Property<int> size(m_value.size());
size.saveBinary(os); size.saveBinary(os);
for(T &it : value) for(T &it : m_value)
Property<T>(it).saveBinary(os); Property<T>(it).saveBinary(os);
return os; return os;
} }
@ -184,8 +184,8 @@ public:
std::ostream& saveAscii(std::ostream& os) std::ostream& saveAscii(std::ostream& os)
{ {
os << "["; os << "[";
int i = value.size(); int i = m_value.size();
for(T &it : value) for(T &it : m_value)
{ {
Property<T>(it).saveAscii(os); Property<T>(it).saveAscii(os);
if(--i) os << ", "; if(--i) os << ", ";
@ -197,25 +197,25 @@ public:
{ {
Property<int> size; Property<int> size;
size.loadBinary(is); size.loadBinary(is);
value.resize(size.getValueRef()); m_value.resize(size.getValueRef());
Property<T> p; Property<T> p;
for(int i=0; i<size.getValueRef(); ++i) for(int i=0; i<size.getValueRef(); ++i)
{ {
p.loadBinary(is); p.loadBinary(is);
value[i] = p.getValueRef(); m_value[i] = p.getValueRef();
} }
return is; return is;
} }
std::istream& loadAscii(std::istream& is) std::istream& loadAscii(std::istream& is)
{ {
value.clear(); m_value.clear();
is.ignore(1); // [ is.ignore(1); // [
Property<T> p; Property<T> p;
while(is.peek() != ']') while(is.peek() != ']')
{ {
p.loadAscii(is); p.loadAscii(is);
value.push_back(p.getValueRef()); m_value.push_back(p.getValueRef());
if(is.peek() == ',') if(is.peek() == ',')
is.ignore(1); // , is.ignore(1); // ,
} }
@ -226,10 +226,10 @@ public:
PropertyType getDataType() { return Property<T>::getStaticPropertyType(); } PropertyType getDataType() { return Property<T>::getStaticPropertyType(); }
std::vector<T> &getValueRef() { return value; } std::vector<T> &getValueRef() { return m_value; }
const std::vector<T> &getValueRef() const { return 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 #endif // PROPERTY_H