1

a8/reflect.cc

@@ -0,0 +1,158 @@
+#include <a8/a8.h>
+
+#include <a8/reflect.h>
+#include <a8/xvalue.h>
+
+namespace a8
+{
+
+    namespace reflect {
+        a8::reflect::Field* Class::GetFieldByName(const std::string& name)
+        {
+            for (int i = 0; i < FieldNum(); ++i) {
+                if (name == fields_[i].field_name) {
+                    return &fields_[i];
+                }
+            }
+            return nullptr;
+        }
+
+        long long Class::GetFieldValueAsInt64(a8::reflect::Field* field, char* p)
+        {
+            switch (field->type) {
+            case a8::reflect::ET_INT32:
+                {
+                    return *((int*)p);
+                }
+                break;
+            case a8::reflect::ET_UINT32:
+                {
+                    return *((unsigned int*)p);
+                }
+                break;
+            case a8::reflect::ET_INT64:
+                {
+                    return *((long long*)p);
+                }
+                break;
+            case a8::reflect::ET_FLOAT:
+                {
+                    return *((float*)p);
+                }
+                break;
+            case a8::reflect::ET_DOUBLE:
+                {
+                    return *((double*)p);
+                }
+                break;
+            case a8::reflect::ET_STRING:
+                {
+                    return a8::XValue(*((std::string*)p));
+                }
+                break;
+            default:
+                {
+                    abort();
+                }
+            }
+        }
+
+        std::string Class::GetFieldValueAsString(a8::reflect::Field* field, char* p)
+        {
+            switch (field->type) {
+            case a8::reflect::ET_INT32:
+                {
+                    return a8::XValue(*((int*)p)).GetString();
+                }
+                break;
+            case a8::reflect::ET_UINT32:
+                {
+                    return a8::XValue(*((unsigned int*)p)).GetString();
+                }
+                break;
+            case a8::reflect::ET_INT64:
+                {
+                    return a8::XValue(*((long long*)p)).GetString();
+                }
+                break;
+            case a8::reflect::ET_FLOAT:
+                {
+                    return a8::XValue(*((float*)p)).GetString();
+                }
+                break;
+            case a8::reflect::ET_DOUBLE:
+                {
+                    return a8::XValue(*((double*)p));
+                }
+                break;
+            case a8::reflect::ET_STRING:
+                {
+                    return (*((std::string*)p));
+                }
+                break;
+            default:
+                {
+                    abort();
+                }
+            }
+        }
+
+        void Class::SetSimpleField(
+                                   int fieldidx,
+                                   const char* fieldname,
+                                   int type,
+                                   int offset
+                                   )
+        {
+            SetField(fieldidx,
+                     fieldname,
+                     type,
+                     a8::reflect::EST_SIMPLE,
+                     offset,
+                     nullptr,
+                     nullptr,
+                     nullptr,
+                     nullptr,
+                     nullptr,
+                     nullptr);
+        }
+
+        void Class::SetField(int fieldidx,
+                             const char* fieldname,
+                             int type,
+                             int subtype,
+                             int offset,
+                             a8::reflect::Class **pp_generic_class,
+                             void* (*create)(),
+                             void (*destroy)(void*),
+                             int (*size)(void*),
+                             void (*for_each)(a8::reflect::Field*, void*, void*, FIELD_FOR_EACH_FUNC),
+                             char* (*push_back)(void*)
+                             )
+        {
+            a8::reflect::Field *p = fields_ + fieldidx;
+            p->field_name = fieldname;
+            p->type = type;
+            p->subtype = subtype;
+            p->offset = offset;
+            p->pp_generic_class = pp_generic_class;
+            p->create = create;
+            p->destroy = destroy;
+            p->size = size;
+            p->for_each = for_each;
+            p->push_back = push_back;
+        }
+
+
+        int Class::GetFieldIdx(int offset)
+        {
+            for (int i = 0; i < fieldnum_; i++) {
+                if (fields_[i].offset == offset) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+    }
+
+}