include/rive/core.hpp

#ifndef _RIVE_CORE_HPP_
#define _RIVE_CORE_HPP_

#include "rive/rive_types.hpp"
#include "rive/core/binary_reader.hpp"
#include "rive/status_code.hpp"

#ifdef DEBUG
#define DEBUG_PRINT(msg) fprintf(stderr, msg "\n");
#else
#define DEBUG_PRINT(msg)
#endif

namespace rive
{
class CoreContext;
class DataBind;
class ImportStack;
class Core
{
public:
    Core() = default;

    // m_firstObserver is intrusive — observers cache `this` as their target
    // and chain through `m_nextObserver` rooted at this Core. Cloning a Core
    // must NOT inherit the original's observer list head: the new instance
    // has no observers of its own, and propagating the head pointer would
    // cause notifyPropertyChanged to dirty binds that point at the original,
    // and ~Core() on the clone to wrongly detach them.
    Core(const Core&) : m_firstObserver(nullptr) {}
    Core& operator=(const Core&)
    {
        // Intentional no-op for the observer list: our existing observers
        // continue to point at us; theirs continue to point at them. Any
        // other state that's safe to copy lives in derived classes.
        return *this;
    }
    // Move ops follow the same rule: the observer chain is bound to the
    // original Core's address, so moving cannot transfer it. Default-init
    // the new instance's head; the moved-from instance keeps its observers
    // (and the responsibility to detach them at destruction).
    Core(Core&&) noexcept : m_firstObserver(nullptr) {}
    Core& operator=(Core&&) noexcept { return *this; }

    const uint32_t emptyId = -1;
    static const int invalidPropertyKey = 0;
    virtual ~Core();
    virtual uint16_t coreType() const = 0;
    virtual bool isTypeOf(uint16_t typeKey) const = 0;
    virtual bool deserialize(uint16_t propertyKey, BinaryReader& reader) = 0;

    template <typename T> inline bool is() const
    {
        return isTypeOf(T::typeKey);
    }
    template <typename T> inline T* as()
    {
        assert(is<T>());
        return static_cast<T*>(this);
    }

    /// Make a shallow copy of the object.
    virtual Core* clone() const { return nullptr; }

    template <typename T> inline const T* as() const
    {
        assert(is<T>());
        return static_cast<const T*>(this);
    }

    /// Called to validate the object can be used at runtime.
    virtual bool validate(CoreContext* context) { return true; }

    /// Called when the object is first added to the context, other objects
    /// may not have resolved their dependencies yet. This is an opportunity
    /// to look up objects referenced by id, but not assume that they in
    /// turn have resolved their references yet. Called during
    /// load/instance.
    virtual StatusCode onAddedDirty(CoreContext* context)
    {
        return StatusCode::Ok;
    }

    /// Called when all the objects in the context have had onAddedDirty
    /// called. This is an opportunity to reference things referenced by
    /// dependencies. (A path should be able to find a Shape somewhere in
    /// its hierarchy, which may be multiple levels up).
    virtual StatusCode onAddedClean(CoreContext* context)
    {
        return StatusCode::Ok;
    }

    virtual StatusCode import(ImportStack& importStack)
    {
        return StatusCode::Ok;
    }

    // Push-notification hook for target→source data binds. Property setters
    // generated in *_base.hpp call this with the affected property key after a
    // value changes. Default impl walks the intrusive observer list and
    // dirties any DataBind that subscribed for `propertyKey` on this Core.
    //
    // Non-virtual: every Core inherits the same dispatch. The hot path
    // (no observers) is a single null-pointer test.
    void notifyPropertyChanged(uint16_t propertyKey);

    // Intrusive subscriber list management. Used by DataBind to subscribe to
    // target value changes without paying a per-Core map allocation. Each
    // Core holds the list head; each subscribing DataBind holds m_nextObserver
    // for the same (target, key) chain. Observer order is not guaranteed.
    void addPropertyObserver(DataBind* observer);
    void removePropertyObserver(DataBind* observer);

private:
    DataBind* m_firstObserver = nullptr;
};
} // namespace rive
#endif