bool ok = false;
cout << "Read from: " << input_filename << ", checking " << output_filename << "..." << endl;
- ldp_xml_parser::Serializer serializer;
+ ldp_serializer::Serializer serializer;
ostringstream output;
serializer.serialize(input_filename, output);
return check(input_filename, output_filename);
cout << "Read from: " << input_filename << " write to: " << output_filename << endl;
- ldp_xml_parser::Serializer serializer;
+ ldp_serializer::Serializer serializer;
ofstream output(output_filename, ofstream::binary);
uint8_t *data = serializer.serialize(input_filename, output);
#include <iostream>
#include <string>
-namespace ldp_xml_parser {
+using namespace ldp_xml_parser;
+
+namespace ldp_serializer {
std::map<Decision, FB::Decision> decisions_map {
{ Decision::ANY, FB::Decision_ANY },
#include "storage_backend_xml.hpp"
#include "policy_containers.hpp"
-namespace ldp_xml_parser
+namespace ldp_serializer
{
enum class SetType : uint8_t {
OWN,
template <typename T>
auto get_create_item() -> decltype(type_helper<T>::create_item);
- FbOff<FB::PolicyOwn> serialize_tree(const OwnershipTree &tree);
- FbOff<FB::PolicyOwnNode> serialize_tree(const std::shared_ptr<TreeNode> &node);
- FbOff<FB::DecisionItem> serialize_decision(const DecisionItem &item);
+ FbOff<FB::PolicyOwn> serialize_tree(const ldp_xml_parser::OwnershipTree &tree);
+ FbOff<FB::PolicyOwnNode> serialize_tree(const std::shared_ptr<ldp_xml_parser::TreeNode> &node);
+ FbOff<FB::DecisionItem> serialize_decision(const ldp_xml_parser::DecisionItem &item);
template <typename T, typename P>
auto serialize_item(const P &item) -> FbOff<typename type_helper<T>::item>;
size_t length{0};
const FB::File *file{nullptr};
- std::unique_ptr<ldp_xml_parser::Serializer> serializer;
+ std::unique_ptr<ldp_serializer::Serializer> serializer;
void releaseMMap();
void releaseFD();
assert(nullptr == file);
assert(nullptr == serializer.get());
- serializer.reset(new ldp_xml_parser::Serializer());
+ serializer.reset(new ldp_serializer::Serializer());
size_t serialized_size;
uint8_t *data = serializer->serialize(config_name, serialized_size);
#include <sys/types.h>
#include <unistd.h>
-using namespace ldp_xml_parser;
using namespace ldp_serialized;
+using namespace ldp_serializer;
enum class Choice {
NONE,
#include <sys/types.h>
#include <unistd.h>
-using namespace ldp_xml_parser;
using namespace ldp_serialized;
+using namespace ldp_serializer;
+using namespace ldp_xml_parser;
std::map<Decision, const char*> DECISIONS {
{ Decision::ANY, "ANY" },
#include <vector>
using namespace ldp_xml_parser;
-using namespace ldp_serialized;
struct AccessTest {
Decision expected_result;
bool run_fb(const std::pair<TestBusSetup, TestBusSetup> access_test) {
bool passed = true;
int i = 0;
- Serializer serializer;
+ ldp_serializer::Serializer serializer;
const auto& system_bus_setup = access_test.first;
const auto& session_bus_setup = access_test.second;
if (session_bus_setup.first == "")
buff_ses = serializer.serialize(session_bus_setup.first.c_str(), size);
- StorageBackendSerialized storage_sys, storage_ses;
+ ldp_serialized::StorageBackendSerialized storage_sys, storage_ses;
printf("FLATBUFFERS:\n");
#include <map>
using namespace ldp_xml_parser;
-using namespace ldp_serialized;
std::map<Decision, const char*> DECISIONS {
{Decision::ANY, "ANY" },
}
bool run_fb() {
- Serializer serializer;
+ ldp_serializer::Serializer serializer;
size_t size;
const uint8_t *buff = serializer.serialize("tests/default_allow/system.conf", size);
- StorageBackendSerialized storage;
+ ldp_serialized::StorageBackendSerialized storage;
storage.initFromData(buff);
printf("FLATBUFFERS:\n");
bool ret = method_test(storage);
#include <map>
using namespace ldp_xml_parser;
-using namespace ldp_serialized;
struct OwnershipTest {
Decision expected_result;
}
bool run_fb() {
- Serializer serializer;
+ ldp_serializer::Serializer serializer;
size_t size;
uint8_t *buff = serializer.serialize("tests/default_deny/system.conf", size);
- StorageBackendSerialized storage;
+ ldp_serialized::StorageBackendSerialized storage;
storage.initFromData(buff);
printf("FRAMEBUFFERS:\n");
#include <map>
using namespace ldp_xml_parser;
-using namespace ldp_serialized;
struct OwnershipTest {
Decision expected_result;
}
bool run_fb() {
- Serializer serializer;
+ ldp_serializer::Serializer serializer;
size_t size;
uint8_t *buff = serializer.serialize("tests/default_allow/system.conf", size);
- StorageBackendSerialized storage;
+ ldp_serialized::StorageBackendSerialized storage;
storage.initFromData(buff);
printf("FLATBUFFERS:\n");
return ownership_test(storage);
#include <map>
using namespace ldp_xml_parser;
-using namespace ldp_serialized;
std::map<Decision, const char*> DECISIONS {
{ Decision::ANY, "ANY" },
}
bool run_fb() {
- Serializer serializer;
+ ldp_serializer::Serializer serializer;
size_t size;
uint8_t *buff = serializer.serialize("tests/default_deny/system.conf", size);
- StorageBackendSerialized storage;
+ ldp_serialized::StorageBackendSerialized storage;
storage.initFromData(buff);
printf("FLATBUFFERS:\n");
#include <map>
using namespace ldp_xml_parser;
-using namespace ldp_serialized;
struct SignalTest {
Decision expected_result;
}
bool run_fb() {
- Serializer serializer;
+ ldp_serializer::Serializer serializer;
size_t size;
uint8_t *buff = serializer.serialize("tests/default_allow/system.conf", size);
- StorageBackendSerialized storage;
+ ldp_serialized::StorageBackendSerialized storage;
storage.initFromData(buff);
printf("FLATBUFFERS:\n");
};
class SerializerTests {
- Serializer serializer;
+ ldp_serializer::Serializer serializer;
const FB::File *file;
void serialize_xml(const std::string &file_name) {