4329255112

Build Type

github

Committed by GitHub

Commit Message

Merge 948c96a03 into 3166d7e57

Pull Request Pull Request #504: Integrate Message Exchange (Purification/Entanglement Swapping) into RuleSet and Runtime

Run Details

957 of 957 new or added lines in 22 files covered. (100.0%)

2287 of 5806 relevant lines covered (39.39%)

46937.47 hits per line

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

89.66

/quisp/rules/RuleSet.cc

#include "RuleSet.h"

#include <random>
#include <string>

#include <omnetpp.h>

#include "RuleSetConverter/RuleSetConverter.h"

using json = nlohmann::json;

namespace quisp::rules {
RuleSet::RuleSet(unsigned long ruleset_id, int owner_address) : ruleset_id(ruleset_id), owner_addr(owner_address) {}

Rule *RuleSet::addRule(std::unique_ptr<Rule> rule) {
  Rule *raw_ptr = rule.get();
  rules.push_back(std::move(rule));
  return raw_ptr;
};

json RuleSet::serialize_json() {
  // inialize json and put metadata
  json ruleset_json;
  ruleset_json["ruleset_id"] = ruleset_id;
  ruleset_json["owner_address"] = owner_addr;
  ruleset_json["num_rules"] = rules.size();
  for (auto &rule : rules) {
    ruleset_json["rules"].push_back(rule->serialize_json());
  }
  return ruleset_json;
};

void RuleSet::deserialize_json(json serialized) {
  // if this function is directly called, check if there is json serialization
  if (serialized == nullptr) {
    throw omnetpp::cRuntimeError("No json serialization found");
  }

  // get properties from json with type conversion
  serialized.at("ruleset_id").get_to(ruleset_id);
  serialized.at("owner_address").get_to(owner_addr);

  // deserialize rules and push them back
  auto serialized_rules = serialized.at("rules");
  for (auto rule : serialized_rules) {
    auto deserialized_rule = std::make_unique<Rule>(rule);
    rules.push_back(std::move(deserialized_rule));
  }
};

runtime::RuleSet RuleSet::construct() const { return rs_converter::RuleSetConverter::construct(*this); }
}  // namespace quisp::rules

1	#include "RuleSet.h"
2
3	#include <random>
4	#include <string>
5
6	#include <omnetpp.h>
7
8	#include "RuleSetConverter/RuleSetConverter.h"
9
10	using json = nlohmann::json;
11
12	namespace quisp::rules {
13	RuleSet::RuleSet(unsigned long ruleset_id, int owner_address) : ruleset_id(ruleset_id), owner_addr(owner_address) {}	15✔
14
15	Rule *RuleSet::addRule(std::unique_ptr<Rule> rule) {	27✔
16	Rule *raw_ptr = rule.get();	27✔
17	rules.push_back(std::move(rule));	27✔
18	return raw_ptr;	27✔
19	};	27✔
20
21	json RuleSet::serialize_json() {	9✔
22	// inialize json and put metadata
23	json ruleset_json;	9✔
24	ruleset_json["ruleset_id"] = ruleset_id;	9✔
25	ruleset_json["owner_address"] = owner_addr;	9✔
26	ruleset_json["num_rules"] = rules.size();	9✔
27	for (auto &rule : rules) {	17✔
28	ruleset_json["rules"].push_back(rule->serialize_json());	17✔
29	}	17✔
30	return ruleset_json;	9✔
31	};	9✔
32
33	void RuleSet::deserialize_json(json serialized) {	1✔
34	// if this function is directly called, check if there is json serialization
35	if (serialized == nullptr) {	1✔
36	throw omnetpp::cRuntimeError("No json serialization found");	×
37	}	×
38
39	// get properties from json with type conversion
40	serialized.at("ruleset_id").get_to(ruleset_id);	1✔
41	serialized.at("owner_address").get_to(owner_addr);	1✔
42
43	// deserialize rules and push them back
44	auto serialized_rules = serialized.at("rules");	1✔
45	for (auto rule : serialized_rules) {	1✔
46	auto deserialized_rule = std::make_unique<Rule>(rule);	1✔
47	rules.push_back(std::move(deserialized_rule));	1✔
48	}	1✔
49	};	1✔
50
51	runtime::RuleSet RuleSet::construct() const { return rs_converter::RuleSetConverter::construct(*this); }	×
52	} // namespace quisp::rules

sfc-aqua / quisp / 4329255112

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