refactoring: inline StorageBackendSerialized private methods

Change-Id: I0483dceef8afa5ec4d160e6a1a785142490fb01a

diff --git a/src/internal/storage_backend_serialized.cpp b/src/internal/storage_backend_serialized.cpp
index ac3c5bc..53d76dc 100644 (file)
--- a/src/internal/storage_backend_serialized.cpp
+++ b/src/internal/storage_backend_serialized.cpp
@@ -126,35 +126,35 @@ void StorageBackendSerialized::release() {
        impl.release();
 }
 
-template <> auto StorageBackendSerialized::getPolicySet<ldp_xml_parser::MatchItemOwn>() const {
+template <> inline auto StorageBackendSerialized::getPolicySet<ldp_xml_parser::MatchItemOwn>() const {
        return impl.fileGetOwnSet(impl.getFile());
 }
 
-template <> auto StorageBackendSerialized::getPolicySet<ldp_xml_parser::MatchItemSend>() const {
+template <> inline auto StorageBackendSerialized::getPolicySet<ldp_xml_parser::MatchItemSend>() const {
        return impl.fileGetSendSet(impl.getFile());
 }
 
-template <> auto StorageBackendSerialized::getPolicySet<ldp_xml_parser::MatchItemReceive>() const {
+template <> inline auto StorageBackendSerialized::getPolicySet<ldp_xml_parser::MatchItemReceive>() const {
        return impl.fileGetReceiveSet(impl.getFile());
 }
 
-template <> auto StorageBackendSerialized::getPolicySet<ldp_xml_parser::MatchItemAccess>() const {
+template <> inline auto StorageBackendSerialized::getPolicySet<ldp_xml_parser::MatchItemAccess>() const {
        return impl.fileGetAccessSet(impl.getFile());
 }
 
 template <typename DI>
-ldp_xml_parser::DecisionItem StorageBackendSerialized::makeDecisionItem(const DI &item) const {
+inline ldp_xml_parser::DecisionItem StorageBackendSerialized::makeDecisionItem(const DI &item) const {
        return ldp_xml_parser::DecisionItem(makeDecision(impl.decisionItemGetDecision(item)),
                                                             impl.stringGetCStr(impl.decisionItemGetPrivilege(item)));
 }
 
 template <typename String>
-boost::string_ref StorageBackendSerialized::toStringRef(const String &str) const {
+inline boost::string_ref StorageBackendSerialized::toStringRef(const String &str) const {
        return boost::string_ref(impl.stringGetCStr(str), impl.stringGetSize(str));
 }
 
 template <typename T, typename I>
-bool StorageBackendSerialized::match(const T &match, const I &item) const {
+inline bool StorageBackendSerialized::match(const T &match, const I &item) const {
        return match.match(makeMessageType(impl.itemSrGetMessageType(item)),
                                           toStringRef(impl.itemSrGetInterface(item)),
                                           toStringRef(impl.itemSrGetPath(item)),
@@ -165,12 +165,12 @@ bool StorageBackendSerialized::match(const T &match, const I &item) const {
 }
 
 template <typename I>
-bool StorageBackendSerialized::match(const ldp_xml_parser::MatchItemAccess &match, const I &item) const {
+inline bool StorageBackendSerialized::match(const ldp_xml_parser::MatchItemAccess &match, const I &item) const {
        return match.match(makeBusAccessType(impl.itemAccessGetType(item)), impl.itemAccessGetUid(item), impl.itemAccessGetGid(item));
 }
 
 template <typename T, typename P>
-ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItem(const T &item, const P &policy, ldp_serialization::ItemsType) const {
+inline ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItem(const T &item, const P &policy, ldp_serialization::ItemsType) const {
        auto v = impl.policyGetItems(policy);
        auto rend = impl.containerGetReverseIteratorEnd(v);
        for (auto rit = impl.containerGetReverseIterator(v); rit != rend; ++rit) {
@@ -181,7 +181,7 @@ ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItem(const T &
 }
 
 template <typename P>
-ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItem(const ldp_xml_parser::MatchItemSend &item, const P &policy) const {
+inline ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItem(const ldp_xml_parser::MatchItemSend &item, const P &policy) const {
        if (!impl.policyHasIndex(policy))
                return getDecisionItem(item, policy, ldp_serialization::ItemsType());   // make it old way for old databases
 
@@ -255,7 +255,7 @@ ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItem(const ldp
 }
 
 template <typename OwnNode>
-auto StorageBackendSerialized::getDecisionItemFromTree(const OwnNode &node,
+inline auto StorageBackendSerialized::getDecisionItemFromTree(const OwnNode &node,
                                                           const tokenizer::iterator &tokens_end,
                                                           tokenizer::iterator &iterator) const {
        if (iterator == tokens_end) {
@@ -283,7 +283,7 @@ auto StorageBackendSerialized::getDecisionItemFromTree(const OwnNode &node,
 }
 
 template <typename T, typename P>
-ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItem(const T &item, const P &policy, ldp_serialization::TreeType) const {
+inline ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItem(const T &item, const P &policy, ldp_serialization::TreeType) const {
        if (item.getName().length() == 0)
                return ldp_xml_parser::Decision::DENY;
 
@@ -296,7 +296,7 @@ ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItem(const T &
 }
 
 template <typename T, typename P>
-ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItem(const T &item, const P &policy) const {
+inline ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItem(const T &item, const P &policy) const {
        return getDecisionItem(item, policy, typename ldp_serialization::PolicyContentType<P>::result());
 }
 
@@ -311,7 +311,7 @@ ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItemContextDef
 }
 
 template <typename MatchItem, typename Map>
-ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItem(const MatchItem &item, const Map &map, id_t id) const {
+inline ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItem(const MatchItem &item, const Map &map, id_t id) const {
        if (impl.containerEmpty(map))
                return ldp_xml_parser::Decision::ANY;
 

diff --git a/src/internal/storage_backend_serialized.hpp b/src/internal/storage_backend_serialized.hpp
index 4e25978..5e583e8 100644 (file)
--- a/src/internal/storage_backend_serialized.hpp
+++ b/src/internal/storage_backend_serialized.hpp
@@ -75,41 +75,41 @@ private:
        void releaseFD();
 
        template <typename MatchItem>
-       auto getPolicySet() const;
+       inline auto getPolicySet() const;
 
        template <typename T, typename P>
-       ldp_xml_parser::DecisionItem getDecisionItem(const T &item, const P &policy, ldp_serialization::ItemsType) const;
+       inline ldp_xml_parser::DecisionItem getDecisionItem(const T &item, const P &policy, ldp_serialization::ItemsType) const;
 
        template <typename T, typename P>
-       ldp_xml_parser::DecisionItem getDecisionItem(const T &item, const P &policy, ldp_serialization::TreeType) const;
+       inline ldp_xml_parser::DecisionItem getDecisionItem(const T &item, const P &policy, ldp_serialization::TreeType) const;
 
        template <typename T, typename P>
-       ldp_xml_parser::DecisionItem getDecisionItem(const T &item, const P &policy) const;
+       inline ldp_xml_parser::DecisionItem getDecisionItem(const T &item, const P &policy) const;
 
        template <typename P>
-       ldp_xml_parser::DecisionItem getDecisionItem(const ldp_xml_parser::MatchItemSend &item, const P &policy) const;
+       inline ldp_xml_parser::DecisionItem getDecisionItem(const ldp_xml_parser::MatchItemSend &item, const P &policy) const;
 
        template <typename MatchItem, typename Map>
-       ldp_xml_parser::DecisionItem getDecisionItem(const MatchItem &item, const Map &map, id_t id) const;
+       inline ldp_xml_parser::DecisionItem getDecisionItem(const MatchItem &item, const Map &map, id_t id) const;
 
        typedef boost::tokenizer<boost::char_separator<char>> tokenizer;
 
        template <typename OwnNode>
-       auto getDecisionItemFromTree(const OwnNode &node,
-                                        const tokenizer::iterator &tokens,
-                                        tokenizer::iterator &iterator) const;
+       inline auto getDecisionItemFromTree(const OwnNode &node,
+                                               const tokenizer::iterator &tokens,
+                                               tokenizer::iterator &iterator) const;
 
        template <typename T, typename I>
-       bool match(const T &match, const I &item) const;
+       inline bool match(const T &match, const I &item) const;
 
        template <typename I>
-       bool match(const ldp_xml_parser::MatchItemAccess &match, const I &item) const;
+       inline bool match(const ldp_xml_parser::MatchItemAccess &match, const I &item) const;
 
        template <typename DI>
-       ldp_xml_parser::DecisionItem makeDecisionItem(const DI &item) const;
+       inline ldp_xml_parser::DecisionItem makeDecisionItem(const DI &item) const;
 
        template <typename String>
-       boost::string_ref toStringRef(const String &str) const;
+       inline boost::string_ref toStringRef(const String &str) const;
 };
 
 }