refactoring: prepare for PolicySet customization

PolicySets are composed of context, user, and group policies.
However, PolicySet for PolicyAccess does not need user and group
policies.
This commit prepares base classes for PolicySets that will allow
handy customization of behaviour and composition.

Change-Id: Idde9daf06e2caa2975d899b99f091ece49b66113

diff --git a/src/internal/naive_policy_db.cpp b/src/internal/naive_policy_db.cpp
index 8fb4609..134c8bb 100755 (executable)
--- a/src/internal/naive_policy_db.cpp
+++ b/src/internal/naive_policy_db.cpp
@@ -153,9 +153,9 @@ void NaivePolicyDb::updateSupplementaryGroups(const VGid &groups, uid_t uid, gid
 
        /* insert supplementary group */
        for (const auto group : groups) {
-               if (m_send_set.group.find(group) != m_send_set.group.end())
+               if (m_send_set.getPolicyGroup(group) != nullptr)
                        vsend.push_back(group);
-               if (m_receive_set.group.find(group) != m_receive_set.group.end())
+               if (m_receive_set.getPolicyGroup(group) != nullptr)
                        vrecv.push_back(group);
                vaccess.push_back(group);       // no filtering, it will be used once
        }
@@ -173,7 +173,7 @@ void NaivePolicyDb::updateSupplementaryGroupsOwn(const VGid &groups, uid_t uid,
                vown.push_back(gid);
        } else {
                for (const auto group : groups) {
-                       if (m_own_set.group.find(group) != m_own_set.group.end())
+                       if (m_own_set.getPolicyGroup(group) != nullptr)
                                vown.push_back(group);
                }
        }
@@ -228,28 +228,93 @@ void NaivePolicyDb::initializeGroups(uid_t uid, gid_t gid)
        pthread_mutex_unlock(&mutexGroup);
 }
 
-/****************** NaivePolicyDb::PolicySet ************************/
+/****************** NaivePolicyDb::UserAndGroupContext **************/
 template <typename P>
-size_t NaivePolicyDb::PolicySet<P>::getSetSize() const
-{
-       size_t size = sizeof(*this);
-
-       for (const auto e : { ContextType::DEFAULT, ContextType::MANDATORY })
-               size += context[static_cast<std::size_t>(e)].getSize();
-
-       size += user.size() * sizeof(typename decltype(user)::value_type);
+size_t NaivePolicyDb::UserAndGroupContext<P>::getSize() const {
+       size_t size = user.size() * sizeof(typename decltype(user)::value_type);
        for (const auto& i : user)
                size += i.second.getSize();
 
        size += group.size() * sizeof(typename decltype(group)::value_type);
        for (const auto& i : group)
                size += i.second.getSize();
-
        return size;
 }
 
 template <typename P>
-void NaivePolicyDb::PolicySet<P>::printMap() const
+void NaivePolicyDb::UserAndGroupContext<P>::printContent() const {
+       for (const auto& i : user)
+               i.second.printContent();
+
+       for (const auto& i : group)
+               i.second.printContent();
+}
+
+template <typename P>
+const P *NaivePolicyDb::UserAndGroupContext<P>::getPolicyUser(uid_t uid) const {
+       tslog::log("USER =", uid, "\n");
+
+       auto it = user.find(uid);
+       if (it == user.end()) {
+               tslog::log_verbose("GetPolicy: Out of Range exception\n");
+               return nullptr;
+       }
+       return &(it->second);
+}
+
+template <typename P>
+const P *NaivePolicyDb::UserAndGroupContext<P>::getPolicyGroup(gid_t gid) const {
+       tslog::log("GROUP = ", gid, "\n");
+
+       auto it = group.find(gid);
+       if (it == group.end()) {
+               tslog::log_verbose("GetPolicy: Out of Range exception\n");
+               return nullptr;
+       }
+       return &(it->second);
+}
+
+template <typename P> template <typename T>
+void NaivePolicyDb::UserAndGroupContext<P>::addItemUser(uid_t uid, T &item)
+{
+       user[uid].addItem(item);
+}
+
+template <typename P> template <typename T>
+void NaivePolicyDb::UserAndGroupContext<P>::addItemGroup(gid_t gid, T &item)
+{
+       group[gid].addItem(item);
+}
+
+/****************** NaivePolicyDb::NoUserAndGroupContext ************/
+template <typename T>
+void NaivePolicyDb::NoUserAndGroupContext::addItemUser(uid_t, T &)
+{
+       assert(false);
+}
+
+template <typename T>
+void NaivePolicyDb::NoUserAndGroupContext::addItemGroup(gid_t, T &)
+{
+       assert(false);
+}
+
+/****************** NaivePolicyDb::PolicySet ************************/
+template <typename P, typename UG>
+size_t NaivePolicyDb::PolicySet<P, UG>::getSetSize() const
+{
+       size_t size = sizeof(*this);
+
+       for (const auto e : { ContextType::DEFAULT, ContextType::MANDATORY })
+               size += context[static_cast<std::size_t>(e)].getSize();
+
+       size += UG::getSize();
+
+       return size;
+}
+
+template <typename P, typename UG>
+void NaivePolicyDb::PolicySet<P, UG>::printMap() const
 {
        int size = sizeof(mapGroup) + mapGroup.size() * sizeof(typename std::remove_reference<decltype(mapGroup)>::type::value_type);
 
@@ -264,23 +329,19 @@ void NaivePolicyDb::PolicySet<P>::printMap() const
        std::cerr << "Memory consumption: " << size << " B" << std::endl;
 }
 
-template <typename P>
-void NaivePolicyDb::PolicySet<P>::printSet() const
+template <typename P, typename UG>
+void NaivePolicyDb::PolicySet<P, UG>::printSet() const
 {
        for (const auto e : {ContextType::DEFAULT, ContextType::MANDATORY})
                context[static_cast<std::size_t>(e)].printContent();
 
-       for (const auto& i : user)
-               i.second.printContent();
-
-       for (const auto& i : group)
-               i.second.printContent();
+       UG::printContent();
 
        std::cerr << "Memory consumption: " << getSetSize() << " B" << std::endl;
 }
 
-template<typename P>
-const P *NaivePolicyDb::PolicySet<P>::getPolicy(const PolicyType policy_type,
+template<typename P, typename UG>
+const P *NaivePolicyDb::PolicySet<P, UG>::getPolicy(const PolicyType policy_type,
                                                                                        const PolicyTypeValue policy_type_value) const
 {
        tslog::log("---policy_type =");
@@ -290,27 +351,9 @@ const P *NaivePolicyDb::PolicySet<P>::getPolicy(const PolicyType policy_type,
                tslog::log("CONTEXT =", (int)policy_type_value.context, "\n");
                return &context[static_cast<std::size_t>(policy_type_value.context)];
        case PolicyType::USER:
-               {
-                       tslog::log("USER =", (int)policy_type_value.user, "\n");
-
-                       auto it = user.find(policy_type_value.user);
-                       if (it == user.end()) {
-                               tslog::log_verbose("GetPolicy: Out of Range exception\n");
-                               return nullptr;
-                       }
-                       return &(it->second);
-               }
+               return UG::getPolicyUser(policy_type_value.user);
        case PolicyType::GROUP:
-               {
-                       tslog::log("GROUP = ", (int)policy_type_value.group, "\n");
-
-                       auto it = group.find(policy_type_value.group);
-                       if (it == group.end()) {
-                               tslog::log_verbose("GetPolicy: Out of Range exception\n");
-                               return nullptr;
-                       }
-                       return &(it->second);
-               }
+               return UG::getPolicyGroup(policy_type_value.group);
        default:
                tslog::log("NO POLICY\n");
        }
@@ -318,8 +361,8 @@ const P *NaivePolicyDb::PolicySet<P>::getPolicy(const PolicyType policy_type,
        return nullptr;
 }
 
-template <typename P> template<typename T>
-void NaivePolicyDb::PolicySet<P>::addItem(const PolicyType policy_type,
+template <typename P, typename UG> template <typename T>
+void NaivePolicyDb::PolicySet<P, UG>::addItem(const PolicyType policy_type,
                                                                           const PolicyTypeValue policy_type_value,
                                                                           T &item) {
        switch (policy_type) {
@@ -327,10 +370,10 @@ void NaivePolicyDb::PolicySet<P>::addItem(const PolicyType policy_type,
                context[static_cast<std::size_t>(policy_type_value.context)].addItem(item);
                break;
        case PolicyType::USER:
-               user[policy_type_value.user].addItem(item);
+               UG::addItemUser(policy_type_value.user, item);
                break;
        case PolicyType::GROUP:
-               group[policy_type_value.group].addItem(item);
+               UG::addItemGroup(policy_type_value.group, item);
                break;
        case PolicyType::NONE:
                assert(false);

diff --git a/src/internal/naive_policy_db.hpp b/src/internal/naive_policy_db.hpp
index 29782f3..ba94966 100755 (executable)
--- a/src/internal/naive_policy_db.hpp
+++ b/src/internal/naive_policy_db.hpp
@@ -93,19 +93,47 @@ namespace ldp_xml_parser
                        static constexpr const char *name = "access";
                };
 
+               template <typename P>
+               class UserAndGroupContext {
+               protected:
+                       /** Map with policies for different users */
+                       std::map<uid_t, P> user;
+                       /** Map with policies for different groups */
+                       std::map<gid_t, P> group;
+
+                       template <typename T>
+                       void addItemUser(uid_t uid, T &item);
+                       template <typename T>
+                       void addItemGroup(gid_t gid, T &item);
+
+                       void printContent() const;
+                       size_t getSize() const;
+
+               public:
+                       const P *getPolicyUser(uid_t) const;
+                       const P *getPolicyGroup(gid_t) const;
+               };
+
+               class NoUserAndGroupContext {
+               protected:
+                       template <typename T>
+                       void addItemUser(uid_t uid, T &item);
+                       template <typename T>
+                       void addItemGroup(gid_t gid, T &item);
+
+                       void printContent() const {}
+                       size_t getSize() const { return 0; }
+               };
+
                typedef std::vector<gid_t> VGid;
 
-               template<typename P>
-               class PolicySet {
+               template <typename P, typename UG = UserAndGroupContext<P>>
+               class PolicySet : public UG {
                        mutable std::map<gid_t, VGid> mapGroup;
                public:
                        typedef P type;
                        /** Policies for all contexts */
                        P context[static_cast<std::size_t>(ContextType::MAX)];
-                       /** Map with policies for different users */
-                       std::map<uid_t, P> user;
-                       /** Map with policies for different groups */
-                       std::map<gid_t, P> group;
 
                        /** Adds given item to policy
                         * \param[in] set Set to add item to