// Оператор умножения с присваиванием, для умножения значений с присваиванием
    template<typename T, typename X = typename std::enable_if<SupportsMultiply<valueType>::value && std::is_same<T, valueType>::value>::type>          
    Property& operator*=(const T& value) { _setter(_getter() * value); return *this; }                                                                                                                                                             
};

template<typename T, typename X = typename std::enable_if<SupportsMinus<valueType>::value && std::is_same<T, valueType>::value>::type>             

template<class T, class = void_t<>>
struct SupportsMinus : std::false_type {};

template<class T>
struct SupportsMinus<T, void_t<decltype(std::declval<T>() - std::declval<T>())>> : std::true_type {};

struct Actor
{
  Property<Matrix4x4> transform = Property<Matrix4x4>([this](Matrix4x4 x) { SetTransform(x); }, [this]() { return GetTransform(); }); // А вот и наша property 

  void SetTransform(const Matrix4x4& mtx) { _transform = mtx; UpdateVisual(); }
  Matrix4x4 GetTransform() const { return _transform; }

private:
  Matrix4x4 _transform;
};

struct Actor
{
  PROPERTY(Matrix4x4, transform, SetTransform, GetTransform); // А вот и наша property 

  void SetTransform(const Matrix4x4& mtx) { _transform = mtx; UpdateVisual(); }
  Matrix4x4 GetTransform() const { return _transform; }

private:
  Matrix4x4 _transform;
};

DataDocument doc; // корневой документ 

doc.LoadFromFile("file.json"); // Загрузить из файла

doc["player"]["name"] = "Hero";   // строка
doc["player"]["hp"]   = 100;      // число
doc["player"]["pos"].Add(12.5f);  // массив
doc["player"]["pos"].Add(-3.0f);

// Чтение
const DataValue& p = doc["player"];
int hp = p["hp"].Get<int>();
float x = p["pos"][0].Get<float>();

// Изменение
doc["player"]["hp"] = hp + 25;

// сохранение
doc.Save("save.json");

struct IValue { ... };

struct NullValue { ... };
struct IntValue { ... };
...
std::vector<IValue*> values

union ValueData
{
    IntData         intData;
    Int64Data       int64Data;
    DoubleData      doubleData;
    StringPtrData   stringPtrData;
    ShortStringData shortStringData;
    ObjectData      objectData;
    ArrayData       arrayData;

    ValueTypeData flagsData;
};

struct ValueTypeData
{
    Byte padding[DataPayloadSize]; // смещение
    Flags flags;                   // флаги
};

struct DoubleData
{
    double value;
    Byte padding[DataPayloadSize - sizeof(double)];
};

struct StringPtrData
{
    char* stringPtr;
    size_t stringLength;
};

struct ShortStringData
{
    static constexpr int maxLength = DataPayloadSize / sizeof(Byte) - 1;
    char stringValue[maxLength + 1];
};

struct ArrayData
{
    DataValue* elements;
    UInt count;
    UInt capacity;
};

struct DataMember
{
    DataValue name;
    DataValue value;
};

struct ObjectData
{
    DataMember* members;
    UInt count;
    UInt capacity;
};

void ChunkPoolAllocator::Deallocate(void* ptr) {}

    class JsonDataDocumentParseHandler
    {
    public:
        DataDocument& document;

        StackAllocator stack;

    public:
        JsonDataDocumentParseHandler(DataDocument& document);

        bool Null();
        bool Bool(bool value);
        bool Int(int value);
        bool Uint(unsigned value);
        bool Int64(int64_t value);
        bool Uint64(uint64_t value);
        bool Double(double value);
        bool String(const char* str, unsigned length, bool copy);
        bool RawNumber(const char* str, unsigned length, bool copy);
        bool StartObject();
        bool Key(const char* str, unsigned length, bool copy);
        bool EndObject(unsigned memberCount);
        bool StartArray();
        bool EndArray(unsigned elementCount);
    };

JsonDataDocumentParseHandler handler(document);
rapidjson::Reader reader;
rapidjson::StringStream stream(str);
auto result = reader.Parse(stream, handler);

// Specialize this template class for your custom serialization types
template<typename _type, typename _enable = void>
struct Converter
{
    static constexpr bool isSupported = false;
    using __type = typename std::conditional<std::is_same<void, _type>::value, int, _type>::type;

    static void Write(const __type& value, DataValue& data) {}
    static void Read(__type& value, const DataValue& data) {}
};

template<>
struct DataValue::Converter<Vec2I>
{
    static constexpr bool isSupported = true;

    static void Write(const Vec2I& value, DataValue& data)
    {
        data.AddMember("x") = value.x;
        data.AddMember("y") = value.y;
    }

    static void Read(Vec2I& value, const DataValue& data)
    {
        value.x = data.GetMember("x");
        value.y = data.GetMember("y");
    }
};

// Constructor as template value
template<typename _type>
DataValue(const _type& value, DataDocument& document);

// Cast to type operator
template<typename _type>
operator _type() const;

// Assign operator
template<typename _type>
DataValue& operator=(const _type& value);

// Объявляем структуру
struct MyData: public ISerializable
{
    int a;   // @SERIALIZABLE
    float b; // @SERIALIZABLE

    SERIALIZABLE(MyData);
};

// Создаем объект
MyData data;

// Загружаем json
DataDocument doc;
doc.LoadFromFile("data.json");

// Десериализуем данные объекта из данных
data = doc;

template<typename T>
struct DataValue::Converter<T, typename std::enable_if<IsRef<T>::value && !std::is_const<T>::value &&
    !std::is_base_of<ISerializable, T>::value&&
    std::is_base_of<o2::IObject, typename ExtractRefType<T>::type>::value>::type>
{
    static constexpr bool isSupported = true;

    using _ref_type = typename ExtractRefType<T>::type;

    static void Write(const T& value, DataValue& data)
    {
        if (value)
        {
            data.AddMember("Type").Set(value->GetType().GetName());
            data.AddMember("Value").Set(*value);
        }
    }

    static void Read(T& value, const DataValue& data)
    {
        if (auto typeNode = data.FindMember("Type"))
        {
            if (auto valueNode = data.FindMember("Value"))
            {
                String typeName = *typeNode;
                auto type = Reflection::GetType(typeName);
                if (!type)
                {
                    o2Debug.LogError("Failed to deserialize unknown type: " + typeName);
                    return;
                }

                auto sample = type->CreateSampleRef();
                value = DynamicCast<_ref_type>(sample);

                if (value)
                    valueNode->Get(*value);
            }
        }
    }
};