reflection/ser_opaque_vector

• C

  View on GitHub

  #include <ser_opaque_vector.h>
  #include <stdio.h>
   
  // Simple integer vector type
  typedef struct {
      size_t count;
      int32_t *array;
  } IntVector;
   
  // Reflection support for IntVector
  int IntVector_serialize(const ecs_serializer_t *ser, const void *ptr) {
      const IntVector *data = ptr;
      for (size_t i = 0; i < data->count; i ++) {
          ser->value(ser, ecs_id(ecs_i32_t), &data->array[i]);
      }
      return 0;
  }
   
  size_t IntVector_count(const void *ptr) {
      const IntVector *data = ptr;
      return data->count;
  }
   
  static void IntVector_resize(void *ptr, size_t size) {
      IntVector *data = ptr;
      if (data->count != size) {
          data->count = size;
          if (!data->count) {
              ecs_os_free(data->array);
              data->array = NULL;
          } else {
              data->array = ecs_os_realloc_n(data->array, int32_t, (ecs_size_t)size);
          }
      }
  }
   
  static void* IntVector_ensure_element(void *ptr, size_t index) {
      IntVector *data = ptr;
      if (data->count <= index) {
          IntVector_resize(ptr, index + 1);
      }
      return &data->array[index];
  }
   
  int main(int argc, char *argv[]) {
      ecs_world_t *ecs = ecs_init_w_args(argc, argv);
   
      // Register type as component so the size is known
      ECS_COMPONENT(ecs, IntVector);
   
      // Register IntVector as opaque type. An opaque type is a type of which the
      // reflection framework doesn't know the layout, but which it can serialize.
      ecs_opaque(ecs, {
          // Link reflection with component
          .entity = ecs_id(IntVector),
          .type = {
              // Let reflection framework know the type represents a vector<i32>
              .as_type = ecs_vector(ecs, { .type = ecs_id(ecs_i32_t) }),
              // Register functions for de/serializing vector contents
              .serialize = IntVector_serialize,
              .count = IntVector_count,
              .resize = IntVector_resize,
              .ensure_element = IntVector_ensure_element
          }
      });
   
      IntVector v = {0};
   
      // Deserialize new value into vector
      ecs_ptr_from_json(ecs, ecs_id(IntVector), &v, "[10, 20, 30]", NULL);
   
      // Print vector contents
      printf("[");
      for (size_t i = 0; i < v.count; i ++) {
          if (i) printf(", ");
          printf("%d", v.array[i]);
      }
      printf("]\n");
   
      // Serialize vector contents to JSON
      char *json = ecs_ptr_to_json(ecs, ecs_id(IntVector), &v);
      printf("%s\n", json);
      ecs_os_free(json);
   
      // Free array of vector. If this type were used as a component, we could
      // register a dtor to do this for us (see the entity/hooks example).
      ecs_os_free(v.array);
   
      ecs_fini(ecs);
   
      // Output
      //   [10, 20, 30]
      //   [10, 20, 30]
  }