i_property.hpp

Go to the documentation of this file.

#pragma once
 
// IProperty — type-erased, ABI-friendly view over a Property<T>.
//
// `aria::Property<T>` inherits from this interface and
// implements all four virtuals.
//
// Motivation:
//   `Property<T>` is a header-only template, so its symbols live in the
//   consumer's translation unit. That is fine for an in-process API,
//   but plug-ins / RPC / live binding scenarios need a stable,
//   non-template surface. IProperty is that surface.
//
// Design:
//   * One virtual call per get / set / subscribe.
//   * `std::any` for the value payload (so the dynamic library and
//     consumer don't have to agree on `T`'s mangled name).
//   * No throwing accessor: a wrong-typed `set_any` returns false and
//     leaves the property untouched, matching how dynamic binding
//     systems handle type mismatches.
//
// Threading:
//   The same contract as `Property<T>::set/get` — all four virtuals
//   must be invoked on the graph's owning thread (assertions fire
//   in debug builds otherwise). Cross-thread plug-ins must marshal
//   through a Dispatcher, exactly like typed callers.
//
// Cost vs template direct call (microbench in modules/core/bench):
//   ~5-7 ns extra per get/set on Apple Silicon for trivially-copyable
//   payloads (int, double — fit in std::any's SBO). Larger payload
//   types pay for an additional heap allocation when std::any spills
//   out of its SBO, so the gap widens. Either way, template-direct
//   should still be preferred in hot paths inside the host module.
//   See `benchmark/bench_iproperty.cpp` for the full numbers.
 
#include "aria/subscription.hpp"
 
#include <any>
#include <functional>
#include <typeinfo>
 
namespace aria {

class IProperty {
public:
    virtual ~IProperty() noexcept = default;

    [[nodiscard]] virtual std::any get_any() const = 0;

    [[nodiscard]] virtual bool set_any(const std::any& value) = 0;

    [[nodiscard]] virtual Subscription subscribe_any(
        std::function<void(const std::any&)> on_changed) = 0;

    [[nodiscard]] virtual const std::type_info& type() const noexcept = 0;
 
protected:
    IProperty() noexcept = default;
    IProperty(const IProperty&) = delete;
    IProperty& operator=(const IProperty&) = delete;
    IProperty(IProperty&&)                 = delete;
    IProperty& operator=(IProperty&&)      = delete;
};
 
}  // namespace aria