erf_auxiliary::AuxiliaryProjection Class Reference

#include <ERF_AuxiliaryProjection.H>

Collaboration diagram for erf_auxiliary::AuxiliaryProjection:

Public Member Functions
	AuxiliaryProjection ()=default
	AuxiliaryProjection (std::vector< ProjectionRule > rules)
const std::vector< ProjectionRule > &	rules () const noexcept
ProjectionValidation	validate (const int source_components) const

Private Attributes
std::vector< ProjectionRule >	m_rules

Detailed Description

Generic, fixed-range projection metadata.

Constructor & Destructor Documentation

AuxiliaryProjection() [1/2]

erf_auxiliary::AuxiliaryProjection::AuxiliaryProjection ( )

default

AuxiliaryProjection() [2/2]

erf_auxiliary::AuxiliaryProjection::AuxiliaryProjection ( std::vector< ProjectionRule >  rules )

inlineexplicit

        : m_rules(std::move(rules)) {}

Member Function Documentation

rules()

const std::vector<ProjectionRule>& erf_auxiliary::AuxiliaryProjection::rules ( ) const

inlinenoexcept

{ return m_rules; }

validate()

ProjectionValidation erf_auxiliary::AuxiliaryProjection::validate

(

const int

source_components

)

const

{
    if (source_components < 0) return {false, "negative auxiliary component count"};
    std::set<std::string> targets;
    std::vector<int> seen(static_cast<std::size_t>(source_components), 0);
    for (const auto& rule : m_rules) {
        if (rule.target.empty()) return {false, "projection target is empty"};
        if (rule.target_kind != ProjectionTargetKind::BulkCoupling) {
            return {false, "non-bulk target cannot be used by this coupling projection"};
        }
        if (rule.source_kind != ProjectionSourceKind::AuxiliaryMass) {
            return {false, "only auxiliary mass components may enter this coupling projection"};
        }
        if (!targets.insert(rule.target).second) return {false, "duplicate projection target"};
        if (rule.source_begin < 0 || rule.source_count <= 0 ||
            rule.source_begin + rule.source_count > source_components) {
            return {false, "projection source range is outside the auxiliary state"};
        }
        for (int c = rule.source_begin; c < rule.source_begin + rule.source_count; ++c) {
            if (seen[static_cast<std::size_t>(c)] != 0) return {false, "overlapping projection source ranges"};
            seen[static_cast<std::size_t>(c)] = 1;
        }
    }
    return {true, {}};
}

Referenced by erf_sbm::SBMLayout::SBMLayout().

Here is the caller graph for this function:

Member Data Documentation

m_rules

std::vector<ProjectionRule> erf_auxiliary::AuxiliaryProjection::m_rules

private

Referenced by rules(), and validate().

---

The documentation for this class was generated from the following files:

• Source/AuxiliaryState/ERF_AuxiliaryProjection.H
• Source/AuxiliaryState/ERF_AuxiliaryProjection.cpp