convert_variant() [2/2]

template<ProcessableData T>

std::span< T > MayaFlux::Kakshya::convert_variant	(	DataVariant &	variant,
		ComplexConversionStrategy	strategy = ComplexConversionStrategy::MAGNITUDE
	)

Get const span from DataVariant without conversion (zero-copy for matching types)

Template Parameters

T	Data type (must match DataVariant contents)

Parameters

variant

DataVariant to extract from

Returns

Const span of type T

Exceptions

std::runtime_error

if type doesn't match

Definition at line 382 of file DataUtils.hpp.

{
    if (std::holds_alternative<std::vector<T>>(variant)) {
        auto& vec = std::get<std::vector<T>>(variant);
        return std::span<T>(vec.data(), vec.size());
    }
 
    return std::visit([&variant, strategy](auto& data) -> std::span<T> {
        using ValueType = typename std::decay_t<decltype(data)>::value_type;
 
        if constexpr (is_convertible_data_v<ValueType, T>) {
            std::vector<T> new_storage;
            auto source_span = std::span<ValueType>(data.data(), data.size());
            auto result = convert_data(source_span, new_storage, strategy);
 
            variant = std::move(new_storage);
            auto& new_vec = std::get<std::vector<T>>(variant);
            return std::span<T>(new_vec.data(), new_vec.size());
        } else {
            error<std::invalid_argument>(
                Journal::Component::Kakshya,
                Journal::Context::Runtime,
                std::source_location::current(),
                "No conversion available from {} to {}",
                typeid(ValueType).name(),
                typeid(T).name());
        }
    },
        variant);
}

References convert_data(), MayaFlux::Journal::Kakshya, name, and MayaFlux::Journal::Runtime.

Here is the call graph for this function: