refactoring: extract Policy containers

Preparing for serialization.

Serialization needs to iterate over db structures. It needs a bit of insight
into the actual types stored.

This extracts Policy container classes from naive_policy_db.cpp.

Change-Id: I51d1ce5c63eef28c58423b0e64ff9f5a2bc5d09c

diff --git a/Makefile.am b/Makefile.am
index acc9fdc..249041b 100644 (file)
--- a/Makefile.am
+++ b/Makefile.am
@@ -56,6 +56,7 @@ COMMON_SRC =\
        src/internal/naive_policy_checker.cpp \
        src/internal/naive_policy_db.cpp \
        src/internal/policy.cpp \
+       src/internal/policy_containers.cpp \
        src/internal/own_tree.cpp \
        src/internal/xml_parser.cpp \
        src/internal/tslog.cpp

diff --git a/src/internal/naive_policy_db.cpp b/src/internal/naive_policy_db.cpp
index 10a443a..a727abd 100644 (file)
--- a/src/internal/naive_policy_db.cpp
+++ b/src/internal/naive_policy_db.cpp
@@ -1,4 +1,4 @@
-#include "own_tree.hpp"
+#include "policy_containers.hpp"
 #include "naive_policy_db.hpp"
 #include "cynara.hpp"
 #include "groups_proxy.hpp"
@@ -13,126 +13,6 @@
 
 namespace ldp_xml_parser {
 
-/****************** PolicySR: a base for PolicySend and PolicyReceive ************************/
-/** Class containing policy with send/receive rules */
-template <typename TI>
-class PolicySR {
-private:
-       /** Vector with policy items */
-       std::vector<TI> m_items;
-       typedef typename decltype(m_items)::const_reverse_iterator PolicyConstIterator;
-public:
-       PolicyConstIterator begin() const { return m_items.rbegin(); }
-       PolicyConstIterator end() const { return m_items.rend(); }
-
-       /** Adds given item to policy.
-        * \param[in] item Item to add to policy
-        */
-       void addItem(TI &item) { m_items.push_back(std::move(item)); }
-
-       DecisionItem getDecisionItem(const typename TI::match_type &item) const {
-               for (auto i : *this) {
-                       tslog::log_verbose("-read: ", i.getDecision(), " ", i, "\n");
-
-                       if (i.match(item)) {
-                               tslog::log_verbose("-matched: ", i.getDecision(), " ", i, "\n");
-
-                               return i.getDecision();
-                       }
-               }
-               return Decision::ANY;
-       }
-
-       void printContent() const {
-               for (const auto& i : m_items)
-                       std::cerr << i << std::endl;
-       }
-
-       size_t getSize() const {
-               size_t size = m_items.capacity() * sizeof(typename decltype(m_items)::value_type);
-               for (const auto& i : m_items)
-                       size += i.getSize();
-               return size;
-       }
-};
-
-/****************** PolicySend ************************/
-class PolicySend : public PolicySR<ItemSend> {
-public:
-       static constexpr const char *name = "send";
-};
-constexpr const char *PolicySend::name;
-
-/****************** PolicyReceive ************************/
-class PolicyReceive : public PolicySR<ItemReceive> {
-public:
-       static constexpr const char *name = "receive";
-};
-constexpr const char *PolicyReceive::name;
-
-/****************** PolicyOwn ************************/
-/** Class containing policy with ownership rules */
-class PolicyOwn {
-private:
-       class OwnershipTree ownership_tree;
-
-public:
-       /** Adds given item to tree by retrieving its name, decision and checking is it prefix.
-        * \param[in] item Item to add to policy
-        */
-       void addItem(const ItemOwn &item) { ownership_tree.addItem(item); }
-
-       DecisionItem getDecisionItem(const MatchItemOwn& item) const {
-               return ownership_tree.getDecisionItem(item);
-       }
-
-       void printContent() const { ownership_tree.printTree(); }
-
-       size_t getSize() const { return ownership_tree.getSize(); }
-
-       static constexpr const char *name = "own";
-};
-constexpr const char *PolicyOwn::name;
-
-/****************** PolicyAccess ************************/
-/** Class containing policy with access rules */
-class PolicyAccess {
-private:
-       std::vector<ItemAccess> m_items;
-
-public:
-       void addItem(const ItemAccess &item) { m_items.push_back(std::move(item)); }
-
-       DecisionItem getDecisionItem(const MatchItemAccess& query) const {
-               // All group and user rules are applied in the order in which they appear in config, so:
-               // - a subsequent matching group rule overrides all previous matched user and group rules,
-               // - a subsequent matching user rule overrides all previous matched user and group rules.
-               // (according to how dbus-daemon actually works, not stated clearly in documentation)
-               DecisionItem ret = Decision::ANY;
-               for (const auto& item : m_items) {
-                       if (item.match(query)) {
-                               ret = item.getDecision();
-                       }
-               }
-               return ret;
-       }
-
-       void printContent() const {
-               for (const auto& i : m_items)
-                       std::cerr << i << std::endl;
-       }
-
-       size_t getSize() const {
-               size_t size = m_items.capacity() * sizeof(decltype(m_items)::value_type);
-               for (const auto & i : m_items)
-                       size += i.getSize();
-               return size;
-       }
-
-       static constexpr const char *name = "access";
-};
-constexpr const char *PolicyAccess::name;
-
 /* The following two are building blocks for PolicySet class.
  * They specify if a given PolicySet class supports user and group policies.
  */

diff --git a/src/internal/policy_containers.cpp b/src/internal/policy_containers.cpp
new file mode 100644 (file)
index 0000000..92a4f64
--- /dev/null
+++ b/src/internal/policy_containers.cpp
@@ -0,0 +1,36 @@
+#include "policy_containers.hpp"
+
+namespace ldp_xml_parser {
+constexpr const char *PolicySend::name;
+constexpr const char *PolicyReceive::name;
+constexpr const char *PolicyOwn::name;
+constexpr const char *PolicyAccess::name;
+
+/****************** PolicyAccess ************************/
+DecisionItem PolicyAccess::getDecisionItem(const MatchItemAccess& query) const {
+       // All group and user rules are applied in the order in which they appear in config, so:
+       // - a subsequent matching group rule overrides all previous matched user and group rules,
+       // - a subsequent matching user rule overrides all previous matched user and group rules.
+       // (according to how dbus-daemon actually works, not stated clearly in documentation)
+       DecisionItem ret = Decision::ANY;
+       for (const auto& item : m_items) {
+               if (item.match(query)) {
+                       ret = item.getDecision();
+               }
+       }
+       return ret;
+}
+
+void PolicyAccess::printContent() const {
+       for (const auto& i : m_items)
+               std::cerr << i << std::endl;
+}
+
+size_t PolicyAccess::getSize() const {
+       size_t size = m_items.capacity() * sizeof(decltype(m_items)::value_type);
+       for (const auto & i : m_items)
+               size += i.getSize();
+       return size;
+}
+
+}

diff --git a/src/internal/policy_containers.hpp b/src/internal/policy_containers.hpp
new file mode 100644 (file)
index 0000000..e2b2664
--- /dev/null
+++ b/src/internal/policy_containers.hpp
@@ -0,0 +1,103 @@
+#pragma once
+
+#include "tslog.hpp"
+#include "policy.hpp"
+#include "own_tree.hpp"
+#include <vector>
+
+namespace ldp_xml_parser {
+/****************** PolicySR: a base for PolicySend and PolicyReceive ************************/
+/** Class containing policy with send/receive rules */
+template <typename TI>
+class PolicySR {
+private:
+       /** Vector with policy items */
+       std::vector<TI> m_items;
+       typedef typename decltype(m_items)::const_reverse_iterator PolicyConstIterator;
+       PolicyConstIterator begin() const { return m_items.rbegin(); }
+       PolicyConstIterator end() const { return m_items.rend(); }
+public:
+
+       /** Adds given item to policy.
+        * \param[in] item Item to add to policy
+        */
+       void addItem(TI &item) { m_items.push_back(std::move(item)); }
+
+       DecisionItem getDecisionItem(const typename TI::match_type &item) const {
+               for (auto i : *this) {
+                       tslog::log_verbose("-read: ", i.getDecision(), " ", i, "\n");
+
+                       if (i.match(item)) {
+                               tslog::log_verbose("-matched: ", i.getDecision(), " ", i, "\n");
+
+                               return i.getDecision();
+                       }
+               }
+               return Decision::ANY;
+       }
+
+       void printContent() const {
+               for (const auto& i : m_items)
+                       std::cerr << i << std::endl;
+       }
+
+       size_t getSize() const {
+               size_t size = m_items.capacity() * sizeof(typename decltype(m_items)::value_type);
+               for (const auto& i : m_items)
+                       size += i.getSize();
+               return size;
+       }
+};
+
+/****************** PolicySend ************************/
+class PolicySend : public PolicySR<ItemSend> {
+public:
+       static constexpr const char *name = "send";
+};
+
+/****************** PolicyReceive ************************/
+class PolicyReceive : public PolicySR<ItemReceive> {
+public:
+       static constexpr const char *name = "receive";
+};
+
+/****************** PolicyOwn ************************/
+/** Class containing policy with ownership rules */
+class PolicyOwn {
+private:
+       class OwnershipTree ownership_tree;
+
+public:
+       /** Adds given item to tree by retrieving its name, decision and checking is it prefix.
+        * \param[in] item Item to add to policy
+        */
+       void addItem(const ItemOwn &item) { ownership_tree.addItem(item); }
+
+       DecisionItem getDecisionItem(const MatchItemOwn& item) const {
+               return ownership_tree.getDecisionItem(item);
+       }
+
+       void printContent() const { ownership_tree.printTree(); }
+
+       size_t getSize() const { return ownership_tree.getSize(); }
+
+       static constexpr const char *name = "own";
+};
+
+/****************** PolicyAccess ************************/
+/** Class containing policy with access rules */
+class PolicyAccess {
+private:
+       std::vector<ItemAccess> m_items;
+
+public:
+       void addItem(const ItemAccess &item) { m_items.push_back(std::move(item)); }
+
+       DecisionItem getDecisionItem(const MatchItemAccess& query) const;
+
+       void printContent() const;
+       size_t getSize() const;
+
+       static constexpr const char *name = "access";
+};
+}