reconstruct_projected_composite()

template<typename ValueT , typename T >
requires (detail::is_composite_operation_data_v<T> && ArithmeticData<ValueT> && Kakshya::DataVariantElement<ValueT>)

static std::optional< Kakshya::CompositeArray > MayaFlux::Yantra::OperationHelper::reconstruct_projected_composite ( const T &  compute_data, const CompositeFieldDoubleData &  projected  )

inlinestatic

Copy Composite records and replace one projected numeric field.

Template Parameters

ValueT

Exact destination field type.

Returns

Updated records, or nullopt for incompatible shape, type, or value.

Note

Unprojected fields are retained; the mask sets field presence.

Definition at line 170 of file OperationHelper.hpp.

    {
        const auto& source = extract_composite_data(compute_data);
        if (!projected.source_structure.composite_layout)
            return std::nullopt;
 
        const auto& original_layout = *projected.source_structure.composite_layout;
        const auto& current_layout = source.layout();
        if (original_layout.stride_bytes() != current_layout.stride_bytes()
            || original_layout.presence_bytes() != current_layout.presence_bytes()
            || original_layout.fields().size() != current_layout.fields().size())
            return std::nullopt;
 
        for (size_t i = 0; i < current_layout.fields().size(); ++i) {
            const auto& original = original_layout.fields()[i];
            const auto& current = current_layout.fields()[i];
            if (original.name != current.name || original.type != current.type
                || original.offset_bytes != current.offset_bytes
                || original.size_bytes != current.size_bytes)
                return std::nullopt;
        }
 
        const auto field_index = source.layout().find_field(projected.field_name);
        if (!field_index || source.layout().fields()[*field_index].type != typeid(ValueT)
            || projected.values.size() != source.size()
            || projected.presence.size() != source.size())
            return std::nullopt;
 
        Kakshya::CompositeArray result(source);
        for (size_t row = 0; row < source.size(); ++row) {
            if (!projected.presence[row]) {
                if (!result.clear(row, projected.field_name))
                    return std::nullopt;
                continue;
            }
 
            const double value = projected.values[row];
            if constexpr (std::integral<ValueT>) {
                if (!std::isfinite(value) || std::trunc(value) != value
                    || value < static_cast<double>(std::numeric_limits<ValueT>::lowest())
                    || value > static_cast<double>(std::numeric_limits<ValueT>::max()))
                    return std::nullopt;
            } else if constexpr (std::same_as<ValueT, float>) {
                if (std::isfinite(value)
                    && (value < -static_cast<double>(std::numeric_limits<float>::max())
                        || value > static_cast<double>(std::numeric_limits<float>::max())))
                    return std::nullopt;
            }
 
            if (!result.set(row, projected.field_name, static_cast<ValueT>(value)))
                return std::nullopt;
        }
 
        return std::optional<Kakshya::CompositeArray>(std::move(result));
    }

References MayaFlux::Kakshya::CompositeArray::clear(), MayaFlux::Yantra::DataStructureInfo::composite_layout, current, MayaFlux::Yantra::CompositeFieldDoubleData::field_name, MayaFlux::Yantra::CompositeFieldDoubleData::presence, MayaFlux::Kakshya::CompositeArray::set(), size, MayaFlux::Yantra::CompositeFieldDoubleData::source_structure, value, and MayaFlux::Yantra::CompositeFieldDoubleData::values.

Here is the call graph for this function: