refactoring: move local functions to an anonymous namespace

Change-Id: I9d9cf07877d59df88305e8847c3156a73e82efd8

diff --git a/src/internal/storage_backend_serialized.cpp b/src/internal/storage_backend_serialized.cpp
index 4859951..cf37c6b 100644 (file)
--- a/src/internal/storage_backend_serialized.cpp
+++ b/src/internal/storage_backend_serialized.cpp
@@ -43,6 +43,85 @@ typedef boost::tokenizer<boost::char_separator<char>> tokenizer;
 template <typename T>
 struct type_helper;
 
+namespace {
+
+inline boost::string_ref s(const flatbuffers::String *str) {
+       return boost::string_ref(str->c_str(), str->size());
+}
+
+template <typename T, typename I>
+bool match(const T &match, const I *i) {
+       return match.match(makeMessageType(i->type()),
+                                          s(i->interface()),
+                                          s(i->path()),
+                                          s(i->member()),
+                                          s(i->name()),
+                                          i->is_name_prefix(),
+                                          makeDecision(i->decision()->decision()));
+}
+
+template <> bool match(const ldp_xml_parser::MatchItemAccess &match, const FB::ItemAccess *item) {
+       return match.match(makeBusAccessType(item->type()), item->uid(), item->gid());
+}
+
+template <typename T, typename P = typename type_helper<T>::policy_type>
+ldp_xml_parser::DecisionItem getDecisionItem(const T &item, const P *policy) {
+       const auto *v = policy->items();
+       for (auto it = v->rbegin(); it != v->rend(); ++it) {
+               if (match(item, *it))
+                       return makeDecisionItem((*it)->decision());
+       }
+       return ldp_xml_parser::Decision::ANY;
+}
+
+const DecisionItem *getDecisionItemFromTree(const FB::PolicyOwnNode *node,
+                                                                                       tokenizer &tokens,
+                                                                                       tokenizer::iterator &iterator) {
+       if (iterator == tokens.end()) {
+               if (node->decision_item()->decision() != Decision_ANY)
+                       return node->decision_item();
+               else
+                       return node->prefix_decision_item();
+       }
+
+       auto child = node->children()->LookupByKey(iterator->c_str());
+       if (nullptr == child)
+               return node->prefix_decision_item();
+
+       ++iterator;
+       const DecisionItem *child_decision = getDecisionItemFromTree(child, tokens, iterator);
+       if (child_decision->decision() == Decision_ANY)
+               return node->prefix_decision_item();
+
+       return child_decision;
+}
+
+template <> ldp_xml_parser::DecisionItem getDecisionItem(const ldp_xml_parser::MatchItemOwn &item,
+                                                                                                                const PolicyOwn *policy) {
+       if (item.getName().length() == 0)
+               return ldp_xml_parser::Decision::DENY;
+
+       boost::char_separator<char> separator(".");
+       tokenizer tokens(item.getName(), separator);
+
+       auto node = policy->tree();
+       if (nullptr == node)
+               return ldp_xml_parser::Decision::ANY;
+
+       auto iterator = tokens.begin();
+
+       return makeDecisionItem(getDecisionItemFromTree(node, tokens, iterator));
+}
+
+template <typename T, typename P = typename type_helper<T>::policy_type>
+ldp_xml_parser::DecisionItem getDecisionItemMaybeNull(const T &item, const P *policyPair) {
+       if (nullptr == policyPair)
+               return ldp_xml_parser::Decision::ANY;
+       return getDecisionItem(item, policyPair->policy());
+}
+
+} // anonymous namespace
+
 class StorageBackendSerialized::StorageBackendSerializedImpl {
        int fd{-1};
        uint8_t *mem{static_cast<decltype(mem)>(MAP_FAILED)};
@@ -82,21 +161,6 @@ public:
        const M *getPolicySet();
 };
 
-inline boost::string_ref s(const flatbuffers::String *str) {
-       return boost::string_ref(str->c_str(), str->size());
-}
-
-template <typename T, typename I>
-bool match(const T &match, const I *i) {
-       return match.match(makeMessageType(i->type()),
-                                          s(i->interface()),
-                                          s(i->path()),
-                                          s(i->member()),
-                                          s(i->name()),
-                                          i->is_name_prefix(),
-                                          makeDecision(i->decision()->decision()));
-}
-
 ldp_xml_parser::DecisionItem StorageBackendSerialized::StorageBackendSerializedImpl::getDecisionFromSendIndex(const MatchItemSend &item,
                const MapIndex &index, const SendPrefixIndex &prefixIndex) {
        ldp_xml_parser::DecisionItem decision(ldp_xml_parser::Decision::ANY);
@@ -333,66 +397,6 @@ void StorageBackendSerialized::printContent(const bool xml_format) const {
        pimpl->printContent(xml_format);
 }
 
-template <> bool match(const ldp_xml_parser::MatchItemAccess &match, const FB::ItemAccess *item) {
-       return match.match(makeBusAccessType(item->type()), item->uid(), item->gid());
-}
-
-template <typename T, typename P = typename type_helper<T>::policy_type>
-ldp_xml_parser::DecisionItem getDecisionItem(const T &item, const P *policy) {
-       const auto *v = policy->items();
-       for (auto it = v->rbegin(); it != v->rend(); ++it) {
-               if (match(item, *it))
-                       return makeDecisionItem((*it)->decision());
-       }
-       return ldp_xml_parser::Decision::ANY;
-}
-
-const DecisionItem *getDecisionItemFromTree(const FB::PolicyOwnNode *node,
-                                                                                       tokenizer &tokens,
-                                                                                       tokenizer::iterator &iterator) {
-       if (iterator == tokens.end()) {
-               if (node->decision_item()->decision() != Decision_ANY)
-                       return node->decision_item();
-               else
-                       return node->prefix_decision_item();
-       }
-
-       auto child = node->children()->LookupByKey(iterator->c_str());
-       if (nullptr == child)
-               return node->prefix_decision_item();
-
-       ++iterator;
-       const DecisionItem *child_decision = getDecisionItemFromTree(child, tokens, iterator);
-       if (child_decision->decision() == Decision_ANY)
-               return node->prefix_decision_item();
-
-       return child_decision;
-}
-
-template <> ldp_xml_parser::DecisionItem getDecisionItem(const ldp_xml_parser::MatchItemOwn &item,
-                                                                                                                const PolicyOwn *policy) {
-       if (item.getName().length() == 0)
-               return ldp_xml_parser::Decision::DENY;
-
-       boost::char_separator<char> separator(".");
-       tokenizer tokens(item.getName(), separator);
-
-       auto node = policy->tree();
-       if (nullptr == node)
-               return ldp_xml_parser::Decision::ANY;
-
-       auto iterator = tokens.begin();
-
-       return makeDecisionItem(getDecisionItemFromTree(node, tokens, iterator));
-}
-
-template <typename T, typename P = typename type_helper<T>::policy_type>
-ldp_xml_parser::DecisionItem getDecisionItemMaybeNull(const T &item, const P *policyPair) {
-       if (nullptr == policyPair)
-               return ldp_xml_parser::Decision::ANY;
-       return getDecisionItem(item, policyPair->policy());
-}
-
 template <typename T>
 ldp_xml_parser::DecisionItem StorageBackendSerialized::getDecisionItemContextMandatory(const T &item) const {
        return getDecisionItem(item, pimpl->getPolicySet<T>()->context_mandatory());