const_config.h - Engine C API Reference

const_config.h
  1. #pragma once
  3. #include <string.h>
  4. #include "assert.h"
  5. #include "platform.h"
  7. // This file is the runtime representation of a config data structure. A config data structure
  8. // is a JSON-like object for representing generic data. This format is suitable when the
  9. // development cost of creating a custom binary format is big and the benefits are small.
  10. // (I.e. for any data that is not massive bulk data -- such as small configuration files.)
  11. //
  12. // The runtime format is essential (type, data) where type is a four-byte type identifier
  13. // and data is four bytes of data. We use four bytes for the type identifier for alignment
  14. // purposes. Note that the runtime format represent an entire config object as a single
  15. // memory block. Local pointers inside the memory block are used to build structure.
  16. //
  17. // Note that it is possible to optimize this format further to squeeze out a few more bytes.
  19. namespace stingray_plugin_foundation {
  21. struct ConstConfigArray;
  22. struct ConstConfigObject;
  24. namespace const_config
  25. {
  26.     // Type used for offset parameters
  27.     typedef unsigned offset_t;
  29.     // The supported value types
  30.     enum ValueType {NIL, BOOL, INTEGER, FLOAT, STRING, ARRAY, OBJECT};
  32.     // Generic representation of a value of one of the types.
  33.     union Value {
  34.         int b;
  35.         int i;
  36.         float f;
  37.         offset_t s;     // Offset to char *
  38.         offset_t a;     // Offset to ConstConfigArray *
  39.         offset_t o;     // Offset toConstConfigObject *
  40.     };
  41. }
  43. // Represents the root object (the first item in the memory block).
  44. struct ConstConfigRoot
  45. {
  46.     int type;                   // ValueType
  47.     const_config::Value value;
  48. };
  50. // Represents an array. Note that the type is only stored once, all objects in an array
  51. // must have the same type. In the memory layout, the ConstConfigArray block is followed
  52. // by *size* data items (which are bool, int, float, etc) depending on type.
  53. struct ConstConfigArray
  54. {
  55.     int type;                           // ValueType
  56.     int size;
  57.     const_config::Value first_item;     // size data items follows in memory
  58. };
  60. // Represents an entry in a ConstConfigObject. Stores the key (always a string), the
  61. // type of the entry and the value.
  62. struct ConstConfigObjectEntry
  63. {
  64.     const_config::offset_t name;    // Offset to name
  65.     int type;                       // ValueType
  66.     const_config::Value value;
  67. };
  69. // Represents an object. In the memory layout, ConstConfigObject is followed by
  70. // *size* ConstConfigObjectEntry structures that contain the actual objects.
  71. struct ConstConfigObject
  72. {
  73.     int size;
  74.     ConstConfigObjectEntry first_entry;
  75. };
  77. // Convenience class used to access config data.
  78. class ConstConfigItem
  79. {
  80. public:
  81.     // Creates a nil config item.
  82.     ConstConfigItem() : _base(nullptr), _type(const_config::NIL) {}
  84.     // Creates a config item from the specified root.
  85.     ConstConfigItem(const ConstConfigRoot &root) : _base((const char *)&root), _type(root.type), _value(root.value) {}
  87.     // Creates a config item with the specified base, type and data.
  88.     ConstConfigItem(const char *base, const_config::ValueType t, const_config::Value v) : _base(base), _type(t), _value(v) {}
  90.     bool is_nil() const {return _type == const_config::NIL;}
  91.     bool is_bool() const {return _type == const_config::BOOL;}
  92.     bool is_false() const {return _type == const_config::BOOL && !_value.b;}
  93.     bool is_true() const {return _type == const_config::BOOL && _value.b;}
  94.     bool is_integer() const {return _type == const_config::INTEGER;}
  95.     bool is_float() const {return _type == const_config::FLOAT;}
  96.     bool is_number() const {return is_integer() || is_float();}
  97.     bool is_string() const {return _type == const_config::STRING;}
  98.     bool is_resource() const { return is_string() || is_object() && (*this)["$resource_name"].is_string(); }
  99.     bool is_resource(const char *type) const { return is_resource() && (is_string() || (*this)["$resource_type"].is_string() && strcmp((*this)["$resource_type"].to_string(),type)==0); }
  100.     bool is_array() const { return _type == const_config::ARRAY; }
  101.     bool is_object() const {return _type == const_config::OBJECT;}
  103.     bool to_bool() const    {XENSURE(is_bool()); return _value.b != 0;}
  104.     int to_integer() const  {XENSURE(is_integer()); return _value.i;}
  105.     float to_float() const  {return is_float() ? _value.f : float(to_integer());}
  106.     const char *to_string() const {XENSURE(is_string()); return raw_s();}
  107.     const char *to_resource(const char *type) const {
  108.         XENSURE(is_resource(type));
  109.         if (is_string()) {
  110.             return to_string();
  111.         }
  112.         return (*this)["$resource_name"].to_string();
  113.     }
  115.     bool operator||(bool b) const {return is_bool() ? to_bool() : b;}
  116.     int operator||(int i) const {return is_integer() ? _value.i : i;}
  117.     unsigned operator||(unsigned i) const {return is_integer() ? unsigned(_value.i) : i;}
  118.     float operator||(float f) const {return is_float() ? _value.f : (is_integer() ? _value.i : f);}
  119.     const char *operator||(const char *s) const {return is_string() ? raw_s() : s;}
  120.     ConstConfigItem operator||(ConstConfigItem o) {return is_nil() ? o : *this;}
  122.     int size() const {return is_array() ? raw_a()->size : 0;}
  123.     int n_items() const {return is_object() ? raw_o()->size : 0;}
  125.     ConstConfigItem operator[](int i) const {
  126.         if (!is_array())
  127.             return ConstConfigItem();
  128.         if (i<0 || i>=raw_a()->size)
  129.             return ConstConfigItem();
  130.         const ConstConfigArray &arr = *raw_a();
  131.         return ConstConfigItem(_base, (const_config::ValueType)arr.type, *(&arr.first_item + i));
  132.     }
  134.     ConstConfigItem operator[](const char *s) const {
  135.         if (!is_object())
  136.             return ConstConfigItem();
  137.         const ConstConfigObject &obj = *raw_o();
  138.         for (int i=0; i<obj.size; ++i) {
  139.             const ConstConfigObjectEntry &e = *(&obj.first_entry + i);
  140.             if (strcmp(_base + e.name, s) == 0)
  141.                 return ConstConfigItem(_base, (const_config::ValueType)e.type, e.value);
  142.         }
  143.         return ConstConfigItem();
  144.     }
  146.     ConstConfigItem item(int i, const char **s = 0) const {
  147.         if (!is_object())
  148.             return ConstConfigItem();
  149.         const ConstConfigObject &obj = *raw_o();
  150.         if (i<0 || i>=obj.size)
  151.             return ConstConfigItem();
  153.         const ConstConfigObjectEntry &e = *(&obj.first_entry + i);
  154.         if(s) *s = _base + e.name;
  155.         return ConstConfigItem(_base, (const_config::ValueType)e.type, e.value);
  156.     }
  158. private:
  159.     const char *raw_s() const {return _base + _value.s;}
  160.     const ConstConfigArray *raw_a() const {return (ConstConfigArray *)(_base + _value.a);}
  161.     const ConstConfigObject *raw_o() const {return (ConstConfigObject *)(_base + _value.o);}
  163.     const char *_base;              // Base for offsets
  164.     int _type;                      // ValueType
  165.     const_config::Value _value;
  166. };
  168. } // namespace stingray_plugin_foundation
Please send us your comment about this page