write() [9/16]

template<typename T , typename Processor , typename Assemble >

void MayaFlux::Portal::Forma::Bridge::write ( Layer &  layer, const std::vector< std::shared_ptr< MappedState< T > > > &  states, Assemble  assemble, std::shared_ptr< Processor >  target  )

inline

Assemble a typed state range into DataVariant for a write processor.

Each tick copies the current values of states, in order, into a contiguous span of their native T type. assemble authors the conversion from that span to DataVariant. Bridge owns the repeated sampling, layer lifetime, and delivery through Processor::set_data(DataVariant).

Template Parameters

T	Mapped state value type.
Processor	Destination exposing set_data(DataVariant).
Assemble	Callable returning DataVariant from span<const T>.

Parameters

layer	Layer whose lifetime owns the aggregate route.
states	Non-null states to sample in range order.
assemble	Author-supplied conversion into DataVariant.
target	Processor receiving each assembled result.

Definition at line 277 of file Bridge.hpp.

    {
        static_assert(std::is_same_v<
                          std::remove_cvref_t<std::invoke_result_t<Assemble&, std::span<const T>>>,
                          Kakshya::DataVariant>,
            "Bridge aggregate assembly must return Kakshya::DataVariant");
 
        auto sources = states;
        auto assembler = std::make_shared<Assemble>(std::move(assemble));
        auto values = std::make_shared<std::vector<T>>();
 
        write_assembled_data(layer, [sources = std::move(sources), assembler, values]() mutable {
                values->resize(sources.size());
                for (size_t i = 0; i < sources.size(); ++i)
                    (*values)[i] = sources[i]->value;
                return (*assembler)(std::span<const T>(*values)); }, [target = std::move(target)](Kakshya::DataVariant data) { target->set_data(std::move(data)); });
    }

References values.