19579013407

Committed 21 Nov 2025 05:53PM UTC coverage: 89.184% (+0.4%) from 88.811%

Build # 19579013407

Build Type

Pull #85

github

Committed by

web-flow

Commit Message

Merge eb3e6b946 into 1bb98f803

Pull Request Pull Request #85: Add json import/export to SimulationData

Run Details

420 of 448 new or added lines in 17 files covered. (93.75%)

10 existing lines in 4 files now uncovered.

5970 of 6694 relevant lines covered (89.18%)

7997777.28 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.37

/coretrace/simulation_data/composite_element.cpp


#include "composite_element.hpp"
#include "single_element.hpp"

#include <sstream>

namespace SolTrace::Data
{

    CompositeElement::CompositeElement() : ElementBase(),
                                           number_of_elements(0),
                                           my_elements()
    {
        return;
    }

    CompositeElement::CompositeElement(const nlohmann::ordered_json& jnode) : ElementBase(jnode),
        number_of_elements(0),
        my_elements()
    {
        using json = nlohmann::ordered_json;

        // Common parameters are set in ElementBase constructor before here

        json jelements = jnode.at("elements");
        for (auto& [key, jelement] : jelements.items())
        {
            bool is_single = jelement.at("is_single");
            if (is_single)
            {
                element_ptr el = make_element<SingleElement>(jelement);
                this->add_element(el);
            }
            else
            {
                composite_element_ptr comp = make_element<CompositeElement>(jelement);
                this->add_element(comp);
            }
        }
        return;
    }

    CompositeElement::~CompositeElement()
    {
        this->clear();
        return;
    }

    void CompositeElement::disable() const
    {
        this->active = false;
        for (auto iter = this->get_const_iterator();
             !this->is_at_end(iter);
             ++iter)
        {
            iter->second->disable();
        }
        return;
    }

    void CompositeElement::enable() const
    {
        this->active = true;
        for (auto iter = this->get_const_iterator();
             !this->is_at_end(iter);
             ++iter)
        {
            iter->second->enable();
        }
        return;
    }

    void CompositeElement::mark_virtual() const
    {
        this->ElementBase::mark_virtual();
        for (auto iter = this->get_const_iterator();
             !this->is_at_end(iter);
             ++iter)
        {
            iter->second->mark_virtual();
        }
        return;
    }

    void CompositeElement::unmark_virtual() const
    {
        this->ElementBase::unmark_virtual();
        for (auto iter = this->get_const_iterator();
             !this->is_at_end(iter);
             ++iter)
        {
            iter->second->unmark_virtual();
        }
        return;
    }

    void CompositeElement::set_stage(int_fast64_t stage)
    {
        this->stage = stage;
        for (auto iter = this->get_iterator(); !this->is_at_end(iter); ++iter)
        {
            iter->second->set_stage(stage);
        }
        return;
    }

    element_id CompositeElement::add_element(element_ptr el)
    {
        // Cannot nest a StageElement in another CompositeElement
        // assert(!el->is_stage());
        // Disable adding CompositeElements unless `this` is a StageElement
        // assert(this->is_stage() || el->is_single());

        if (el->is_stage() ||
            (el->is_composite() && !this->is_stage()))
        {
            return ELEMENT_INVALID_SETUP;
        }

        el->enforce_user_fields_set();

        element_id id = this->my_elements.add_item(el);
        if (is_success(id))
        {
            this->number_of_elements += el->get_number_of_elements();
            el->set_reference_element(this);
        }
        return id;
    }

    uint_fast64_t CompositeElement::remove_element(element_id id)
    {
        element_ptr el = this->my_elements.get_item(id);
        uint_fast64_t nremoved = this->my_elements.remove_item(id);

        if (nremoved > 0)
        {
            nremoved = el->get_number_of_elements();
            this->number_of_elements -= nremoved;
        }

        return nremoved;
    }

    element_ptr CompositeElement::get_element(element_id id)
    {
        return this->my_elements.get_item(id);
    }

    bool CompositeElement::replace_element(element_id id, element_ptr el)
    {
        element_ptr old_el = this->my_elements.get_item(id);
        bool replaced = this->my_elements.replace_item(id, el);

        if (replaced)
        {
            this->number_of_elements -= old_el->get_number_of_elements();
            this->number_of_elements += el->get_number_of_elements();
        }

        return replaced;
    }

    void CompositeElement::clear()
    {
        this->number_of_elements = 0;
        this->my_elements.clear();
        return;
    }

    void CompositeElement::enforce_user_fields_set() const
    {
        ElementBase::enforce_user_fields_set();

        if (this->number_of_elements == 0)
        {
            std::stringstream ss;
            ss << "CompositeElement (Name: " << this->get_name()
               << ", UUID: " << this->get_id()
               << ") has no subelements.";
            throw std::invalid_argument(ss.str());
        }
        return;
    }

    // Stage and Composite should have the same function
    void CompositeElement::write_json(nlohmann::ordered_json& jnode) const
    {
        using json = nlohmann::ordered_json;

        // Composite/stage specific info
        jnode["is_composite"] = true;
        jnode["is_single"] = false;
        jnode["number_of_elements"] = this->get_number_of_elements();

        // Common properties of all elements
        this->write_common_json(jnode);

        // Loop through each element, writing json node
        json jelements;
        for (auto it = this->get_const_iterator(); !this->is_at_end(it); ++it)
        {
            json jelement;

            SolTrace::Data::element_id i = it->first;
            auto element = it->second;

            element->write_json(jelement);

            jelements[std::to_string(i)] = jelement;
        }
        jnode["elements"] = jelements;
    }

} // namespace SolTrace::Data

1
2	#include "composite_element.hpp"
3	#include "single_element.hpp"
4
5	#include <sstream>
6
7	namespace SolTrace::Data
8	{
9
10	CompositeElement::CompositeElement() : ElementBase(),	346✔
11	number_of_elements(0),	346✔
12	my_elements()	346✔
13	{
14	return;	346✔
15	}
16
17	CompositeElement::CompositeElement(const nlohmann::ordered_json& jnode) : ElementBase(jnode),	9✔
18	number_of_elements(0),	9✔
19	my_elements()	9✔
20	{
21	using json = nlohmann::ordered_json;
22
23	// Common parameters are set in ElementBase constructor before here
24
25	json jelements = jnode.at("elements");	9✔
26	for (auto& [key, jelement] : jelements.items())	4,859✔
27	{
28	bool is_single = jelement.at("is_single");	2,425✔
29	if (is_single)	2,425✔
30	{
31	element_ptr el = make_element<SingleElement>(jelement);	2,425✔
32	this->add_element(el);	2,425✔
33	}	2,425✔
34	else
35	{
NEW 36	composite_element_ptr comp = make_element<CompositeElement>(jelement);	×
NEW 37	this->add_element(comp);	×
NEW 38	}	×
39	}	9✔
40	return;	18✔
41	}	9✔
42
43	CompositeElement::~CompositeElement()	355✔
44	{
45	this->clear();	355✔
46	return;	355✔
47	}	355✔
48
49	void CompositeElement::disable() const	1✔
50	{
51	this->active = false;	1✔
52	for (auto iter = this->get_const_iterator();	1✔
53	!this->is_at_end(iter);	5✔
54	++iter)	4✔
55	{
56	iter->second->disable();	4✔
57	}
58	return;	1✔
59	}
60
61	void CompositeElement::enable() const	258✔
62	{
63	this->active = true;	258✔
64	for (auto iter = this->get_const_iterator();	258✔
65	!this->is_at_end(iter);	493✔
66	++iter)	235✔
67	{
68	iter->second->enable();	235✔
69	}
70	return;	258✔
71	}
72
73	void CompositeElement::mark_virtual() const	1✔
74	{
75	this->ElementBase::mark_virtual();	1✔
76	for (auto iter = this->get_const_iterator();	1✔
77	!this->is_at_end(iter);	5✔
78	++iter)	4✔
79	{
80	iter->second->mark_virtual();	4✔
81	}
82	return;	1✔
83	}
84
85	void CompositeElement::unmark_virtual() const	1✔
86	{
87	this->ElementBase::unmark_virtual();	1✔
88	for (auto iter = this->get_const_iterator();	1✔
89	!this->is_at_end(iter);	5✔
90	++iter)	4✔
91	{
92	iter->second->unmark_virtual();	4✔
93	}
94	return;	1✔
95	}
96
97	void CompositeElement::set_stage(int_fast64_t stage)	294✔
98	{
99	this->stage = stage;	294✔
100	for (auto iter = this->get_iterator(); !this->is_at_end(iter); ++iter)	4,659✔
101	{
102	iter->second->set_stage(stage);	4,365✔
103	}
104	return;	294✔
105	}
106
107	element_id CompositeElement::add_element(element_ptr el)	19,987✔
108	{
109	// Cannot nest a StageElement in another CompositeElement
110	// assert(!el->is_stage());
111	// Disable adding CompositeElements unless `this` is a StageElement
112	// assert(this->is_stage() \|\| el->is_single());
113
114	if (el->is_stage() \|\|	39,974✔
115	(el->is_composite() && !this->is_stage()))	19,987✔
116	{
117	return ELEMENT_INVALID_SETUP;	1✔
118	}
119
120	el->enforce_user_fields_set();	19,986✔
121
122	element_id id = this->my_elements.add_item(el);	19,985✔
123	if (is_success(id))	19,985✔
124	{
125	this->number_of_elements += el->get_number_of_elements();	19,985✔
126	el->set_reference_element(this);	19,985✔
127	}
128	return id;	19,985✔
129	}
130
131	uint_fast64_t CompositeElement::remove_element(element_id id)	1✔
132	{
133	element_ptr el = this->my_elements.get_item(id);	1✔
134	uint_fast64_t nremoved = this->my_elements.remove_item(id);	1✔
135
136	if (nremoved > 0)	1✔
137	{
138	nremoved = el->get_number_of_elements();	1✔
139	this->number_of_elements -= nremoved;	1✔
140	}
141
142	return nremoved;	1✔
143	}	1✔
144
145	element_ptr CompositeElement::get_element(element_id id)	3✔
146	{
147	return this->my_elements.get_item(id);	3✔
148	}
149
150	bool CompositeElement::replace_element(element_id id, element_ptr el)	1✔
151	{
152	element_ptr old_el = this->my_elements.get_item(id);	1✔
153	bool replaced = this->my_elements.replace_item(id, el);	1✔
154
155	if (replaced)	1✔
156	{
157	this->number_of_elements -= old_el->get_number_of_elements();	1✔
158	this->number_of_elements += el->get_number_of_elements();	1✔
159	}
160
161	return replaced;	1✔
162	}	1✔
163
164	void CompositeElement::clear()	621✔
165	{
166	this->number_of_elements = 0;	621✔
167	this->my_elements.clear();	621✔
168	return;	621✔
169	}
170
171	void CompositeElement::enforce_user_fields_set() const	541✔
172	{
173	ElementBase::enforce_user_fields_set();	541✔
174
175	if (this->number_of_elements == 0)	541✔
176	{
177	std::stringstream ss;	2✔
178	ss << "CompositeElement (Name: " << this->get_name()	4✔
179	<< ", UUID: " << this->get_id()	2✔
180	<< ") has no subelements.";	2✔
181	throw std::invalid_argument(ss.str());	2✔
182	}	2✔
183	return;	539✔
184	}
185
186	// Stage and Composite should have the same function
187	void CompositeElement::write_json(nlohmann::ordered_json& jnode) const	11✔
188	{
189	using json = nlohmann::ordered_json;
190
191	// Composite/stage specific info
192	jnode["is_composite"] = true;	11✔
193	jnode["is_single"] = false;	11✔
194	jnode["number_of_elements"] = this->get_number_of_elements();	11✔
195
196	// Common properties of all elements
197	this->write_common_json(jnode);	11✔
198
199	// Loop through each element, writing json node
200	json jelements;	11✔
201	for (auto it = this->get_const_iterator(); !this->is_at_end(it); ++it)	2,463✔
202	{
203	json jelement;	2,452✔
204
205	SolTrace::Data::element_id i = it->first;	2,452✔
206	auto element = it->second;	2,452✔
207
208	element->write_json(jelement);	2,452✔
209
210	jelements[std::to_string(i)] = jelement;	2,452✔
211	}	2,452✔
212	jnode["elements"] = jelements;	11✔
213	}	11✔
214
215	} // namespace SolTrace::Data

NREL / SolTrace / 19579013407

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous