SerializableObject.h

Go to the documentation of this file.

#ifndef _SERIALIZABLE_OBJECT_LIB_H_
#define _SERIALIZABLE_OBJECT_LIB_H_
 
#include <Logger/Logger/Logger.h>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/crc.hpp>
#include <boost/algorithm/string/replace.hpp>
 
#include <cstring>
#include <string>
#include <unordered_set>
#include <set>
#include <unordered_map>
#include <typeinfo>
#include <map>
#include <vector>
#include <regex>
 
using namespace std;
#define LOCAL_SECTION LOG_INFRA
 
#define SRL_LOG(...)    global_logger.log(LOG_SRL, LOG_DEF_LEVEL, __VA_ARGS__)
#define SRL_LOG_D(...)  global_logger.log(LOG_SRL, DEBUG_LOG_LEVEL, __VA_ARGS__)
#define SRL_ERR(...)    global_logger.log(LOG_SRL, MAX_LOG_LEVEL, __VA_ARGS__)
 
class SerializableObject {
public:
    virtual int version() const { return  0; }
 
    virtual string my_class_name() const { return "SerializableObject"; }
 
    virtual void serialized_fields_name(vector<string> &field_names) const {};
 
    virtual void *new_polymorphic(string derived_name) { return NULL; }
 
    // next adds an option to add some actions before and after a serialization is done
    virtual void pre_serialization() {};
    virtual void post_deserialization() {};
 
    // Virtual serialization
    virtual size_t get_size() { return 0; } 
    virtual size_t serialize(unsigned char *blob) { return 0; } 
    virtual size_t deserialize(unsigned char *blob) { return 0; } 
 
                                                                  // APIs for vectors
    size_t serialize_vec(vector<unsigned char> &blob) { size_t size = get_size(); blob.resize(size); return serialize(&blob[0]); }
    size_t deserialize_vec(vector<unsigned char> &blob) { return deserialize(&blob[0]); }
    virtual size_t serialize(vector<unsigned char> &blob) { return serialize_vec(blob); }
    virtual size_t deserialize(vector<unsigned char> &blob) { return deserialize_vec(blob); }
 
 
 
    virtual int read_from_file(const string &fname);
 
    virtual int write_to_file(const string &fname);
 
    virtual int read_from_file_unsafe(const string &fname);
 
    int init_from_string(string init_string);
    int init_params_from_file(string init_file);
    int init_param_from_file(string file_str, string &param);
    virtual int init(map<string, string>& map) { return 0; } 
 
    int update_from_string(const string &init_string);
    virtual int update(map<string, string>& map) { return init(map); } 
 
    virtual string object_json() const;
private:
    void _read_from_file(const string &fname, bool throw_on_version_error);
};
 
template <class T> void copy_serializable_object(T &source, T& dst) {
    vector<unsigned char> blob;
    source.serialize_vec(blob);
    dst.deserialize_vec(blob);
}
 
 
// generalized safe stoi/stof
inline float med_stof(const string &_Str)
{
    try
    {
        return stof(_Str);
    }
    catch (exception &e)
    {
        HMTHROW_AND_ERR("invalid stof argument [%s]\n", _Str.c_str());
    }
}
 
inline int med_stoi(const string &_Str)
{
    try
    {
        return stoi(_Str);
    }
    catch (exception &e)
    {
        HMTHROW_AND_ERR("invalid stoi argument [%s]\n", _Str.c_str());
    }
}
 
inline long long med_stoll(const string &_Str)
{
    try
    {
        return stoll(_Str);
    }
    catch (exception &e)
    {
        HMTHROW_AND_ERR("invalid stoll argument [%s]\n", _Str.c_str());
    }
}
 
#define MEDSERIALIZE_SUPPORT(Type)                                                                                  \
namespace MedSerialize {                                                                                            \
    template<> inline size_t get_size<Type>(Type &elem) { return elem.get_size(); }                                 \
    template<> inline size_t serialize<Type>(unsigned char *blob, Type &elem) { return elem.serialize(blob); }      \
    template<> inline size_t deserialize<Type>(unsigned char *blob, Type &elem) { return elem.deserialize(blob); }  \
    template<> inline string object_json<const Type>(const Type &elem) { return elem.object_json(); }   \
}
 
//size_t serialize(unsigned char *blob) { pre_serialization(); return MedSerialize::serialize(blob, __VA_ARGS__); }     
 
#define ADD_SERIALIZATION_FUNCS(...)                                                                \
    virtual size_t get_size() { pre_serialization(); return MedSerialize::get_size_top(#__VA_ARGS__, __VA_ARGS__); }                                \
    virtual size_t serialize(unsigned char *blob) { pre_serialization(); return MedSerialize::serialize_top(blob,  #__VA_ARGS__, __VA_ARGS__); }        \
    virtual size_t deserialize(unsigned char *blob) { size_t size = MedSerialize::deserialize_top(blob, #__VA_ARGS__, __VA_ARGS__); post_deserialization(); return size;} \
    virtual void serialized_fields_name(vector<string> &field_names) const { MedSerialize::get_list_names(#__VA_ARGS__, field_names); } \
    virtual string object_json() const { return MedSerialize::object_json_start(my_class_name(), this->version(), #__VA_ARGS__, __VA_ARGS__); }
 
// in some cases we must add the serializations in the implementation file due to forward declerations issues
// the following is the same as the previous but should be placed in the cpp file
#define ADD_SERIALIZATION_HEADERS()                                                             \
    virtual size_t get_size(); \
    virtual size_t serialize(unsigned char *blob); \
    virtual size_t deserialize(unsigned char *blob); \
    virtual void serialized_fields_name(vector<string> &field_names) const; \
    virtual string object_json() const;
 
#define ADD_SERIALIZATION_FUNCS_CPP(ClassName,...)                                                              \
    size_t ClassName::get_size() { pre_serialization(); return MedSerialize::get_size_top(#__VA_ARGS__, __VA_ARGS__); }                             \
    size_t ClassName::serialize(unsigned char *blob) { pre_serialization(); return MedSerialize::serialize_top(blob,  #__VA_ARGS__, __VA_ARGS__); }     \
    size_t ClassName::deserialize(unsigned char *blob) { return MedSerialize::deserialize_top(blob, #__VA_ARGS__, __VA_ARGS__); post_deserialization();} \
    void  ClassName::serialized_fields_name(vector<string> &field_names) const { MedSerialize::get_list_names(#__VA_ARGS__, field_names); } \
    string ClassName::object_json() const { return MedSerialize::object_json_start(my_class_name(), this->version(), #__VA_ARGS__, __VA_ARGS__); }
 
 
#define ADD_CLASS_NAME(Type)    string my_class_name() const {return string(#Type);}
 
#define CONDITIONAL_NEW_CLASS(s,c) \
    if (s == string(#c)) return new c;
 
 
#include "SerializableObject_imp.h"
 
#endif