Reflection Class

#include <unigine.h>

/*
 * Implementation of a MyClass, the user class with special functions for XML serialization
 */

class MyClass {
    
  private:
    
    int int_value;
    vec3 vec3_value;
    
  public:
    
    [serialize:int_value]
    int getIntValue() {
      return int_value;
    }
    
    [serialize:int_value]
    void setIntValue(int value) {
      int_value = value;
    }
    
    [serialize:vec3_value]
    vec3 getVec3Value() {
      return vec3_value;
    }
    
    [serialize:vec3_value]
    void setVec3Value(vec3 value) {
      vec3_value = value;
    }
};

/*
 * Serialize XML for any class instance
 */

Xml serialize(int instance) {
  
  // specify only simple types of data to be serialized
  string function_types[] = (
    "int"     : "int",
    "float"   : "float",
    "double"  : "double",
    "vec3"    : "vec3",
    "Vec3"    : "Vec3",
    "vec4"    : "vec4",
    "Vec4"    : "Vec4",
    "string"  : "string",
  );
  
  // create a reflection class
  Reflection reflection = new Reflection();
  
  // return NULL value if the instance cannot be reflected
  if(reflection.reflect(instance) == false) return NULL;
  
  // create an XML class instance
  Xml xml = new Xml();
  xml.setName("inctance");
  
  // write the instance class name as an attribute 
  xml.setArg("type",reflection.getName());
  
  // simple check of an attribute function for serialization
  int is_serialize(string str,string &name) {
    
    // the attribute string must be like [serialize:%parameter_name]
    string ret[0];
    strsplit(str,":",ret);
    if(ret.size() < 2) return false;
    if(trim(ret[0]) != "serialize") return false;
    name = ret[1];
    return true;
  }
  
  // a loop for all class functions
  forloop(int i = 0; reflection.getNumFunctions()) {
    string name = "";
    
    // check function for a "serialize" attribute
    if(is_serialize(reflection.getFunctionAttribute(i),name) == false) continue;
    
    // specify get and check function types
    string type = function_types.check(reflection.getFunctionType(i),"");
    if(type == "") continue;
    
    // specify that the parameter "get" function must have zero arguments
    if(reflection.getNumFunctionArgs(i) != 0) continue;
    
    // add parameter child to XML
    Xml parameter = xml.addChild("parameter");
    parameter.setArg("name",name);
    parameter.setArg("type",type);
    
    // call the "get" function instance to get a parameter value
    parameter.setData(string(instance.call(reflection.getFunctionID(i))));
  }
  
  // return the XML with instance parameters data
  return xml;
}

int init() {
  
  // create MyClass instance
  MyClass instance = new MyClass();
  
  // set the parameters to the class instance
  instance.setIntValue(33);
  instance.setVec3Value(vec3(1.2f,2.3f,3.1f));
  
  // create the XML
  Xml xml = serialize(instance);
  
  // write XML to the file
  if(xml != NULL) {
    xml.save("my_class.xml");
  }
  
  return 1;
}

<?xml version="1.0" encoding="utf-8"?>
<instance type="MyClass">
  <parameter name="int_value" type="int">33</parameter>
  <parameter name="vec3_value" type="vec3">1.2 2.3 3.1</parameter>
</instance>