19578767093

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

Build # 19578767093

Build Type

Pull #85

github

Committed by

web-flow

Commit Message

Merge 7bb36476f into 1bb98f803

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

Run Details

416 of 443 new or added lines in 17 files covered. (93.91%)

6 existing lines in 2 files now uncovered.

5963 of 6683 relevant lines covered (89.23%)

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

NREL / SolTrace / 19578767093

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