#include <stdlib.h>
#include <assert.h>
#include <iostream>
#include <string>
#include <unordered_map>
#include <memory>
static const std::string S_EMPTY_STRING;
#define BIT(n) (1 << n)
#define PROPERTY_STRING(name, mask) \
    public: \
        inline const std::string &get_##name() const { return (mask_ & mask)? name##_ : S_EMPTY_STRING; } \
        inline void set_##name(const std::string &v) {name##_ = v;  mask_ |= mask;} \
    private:    \
        std::string name##_;

#define PROPERTY_INT(name, mask) \
    public: \
        inline int get_##name() const { return (mask_ & mask)? name##_ : 0; } \
        inline void set_##name(const int &v) {name##_ = v;  mask_ |= mask;} \
    private:    \
        int name##_;

enum class ColumnType {
    INT,
    STRING
};
struct MyTableColumn;
struct MyTableMeta;
class MyTable {
    friend class MyTablecolumn;
public:
    MyTable() {
        mask_ = 0;
    }
    virtual  MyTable *create() = 0;
    virtual  MyTableMeta &metaData() = 0;
    virtual ~MyTable() = default;
public:
    unsigned mask_;
    MyTableColumn *key_column_;
};
struct MyTableColumn {
    const std::string name; 
    const ColumnType type;  
    const size_t offset;   
    const size_t id;       
    const bool is_key;     
    const bool is_index;   
    inline const std::string &get_string(void *obj) const {
        bool r = (ColumnType::STRING == type);
        assert(r);
        return *((std::string *)((static_cast<char *>(obj) + offset)));
    }
    inline int get_int(void *obj) const {
        bool r = (ColumnType::INT == type);
        assert(r);
        return *((int *)((static_cast<char *>(obj) + offset)));
    }
    inline void set_string(void *obj, const std::string &value) {
        bool r = (ColumnType::STRING == type);
        assert(r);
        std::cout << "offset = " << offset << std::endl;
        *((std::string *)((static_cast<char *>(obj) + offset))) = value;
        static_cast<MyTable *>(obj)->mask_ |= id;
    }
    inline void set_int(void *obj, int value) {
        bool r = (ColumnType::INT == type);
        assert(r);
        *((int *)((static_cast<char *>(obj) + offset))) = value;
        static_cast<MyTable *>(obj)->mask_ |= id;
        std::cout << "offset1 = " << offset << std::endl;
    }
};
struct MyTableMeta {
    const std::string table_name;
    std::unordered_map<std::string, MyTableColumn>column_list;
};
#define PROPERTY_DEF_STRING(cls, name, mask, key, is_index) \
    { #name, MyTableColumn{  #name, ColumnType::STRING, __builtin_offsetof(cls,name##_),  mask, key, is_index}}

#define PROPERTY_DEF_INT(cls, name, mask, key, is_index) \
    { #name, MyTableColumn{  #name, ColumnType::INT, __builtin_offsetof(cls,name##_),  mask, key, is_index}}

class CustomerSession : public MyTable {
public:
    enum {
        SESSION_ID    = BIT(0),
        CUSTOMER_ID   = BIT(1),
        CLIENT_ID     = BIT(2)
    };
    PROPERTY_STRING(session_id,   SESSION_ID);
    PROPERTY_INT(customer_id,     CUSTOMER_ID);
    PROPERTY_INT(client_id,       CLIENT_ID);
public:
    virtual MyTableMeta &metaData() override {
         return redis_table_meta_;
    }
    virtual MyTable *create() override {
        return new CustomerSession;
    }
private:
    static MyTableMeta redis_table_meta_;
};
MyTableMeta CustomerSession::redis_table_meta_ = {
    "CustomerSession", 
    std::unordered_map<std::string, MyTableColumn> {
        PROPERTY_DEF_STRING(CustomerSession,    session_id,   SESSION_ID, true,  false),
        PROPERTY_DEF_INT   (CustomerSession,    customer_id,  CUSTOMER_ID, false, false),
        PROPERTY_DEF_INT   (CustomerSession,    client_id,    CLIENT_ID,  false, true)
    }
};
int main() {
    CustomerSession cs;
    auto *rt = cs.create();
    for (auto &kv : rt->metaData().column_list) {
        if ("session_id" == kv.first) {
            auto &column = kv.second;
            column.set_string(rt, "123");
        }
        if ("customer_id" == kv.first) {
            auto &column = kv.second;
            column.set_int(rt, 456);
        }
    }
    delete rt;

    return 0;
}