serialization: use new interface for operations

Change-Id: Idfd52382dd4b3acd4d158d7604468e9fcc297a9b

2 files changed, 87 insertions, 66 deletions

diff --git a/src/internal/storage_backend_flatbuffers.cpp b/src/internal/storage_backend_flatbuffers.cpp
index 6aedb60..07b1213 100644
--- a/src/internal/storage_backend_flatbuffers.cpp
+++ b/src/internal/storage_backend_flatbuffers.cpp
@@ -41,30 +41,31 @@ ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::makeDecisionItem(const D
 }
 
 boost::string_ref StorageBackendFlatbuffers::toStringRef(const flatbuffers::String *str) const {
-	return boost::string_ref(str->c_str(), str->size());
+	return boost::string_ref(stringGetCStr(str), stringGetSize(str));
 }
 
 template <typename T, typename I>
 bool StorageBackendFlatbuffers::match(const T &match, const I *i) const {
-	return match.match(makeMessageType(i->type()),
-					   toStringRef(i->interface()),
-					   toStringRef(i->path()),
-					   toStringRef(i->member()),
-					   toStringRef(i->name()),
-					   i->is_name_prefix(),
-					   makeDecision(i->decision()->decision()));
+	return match.match(makeMessageType(itemSrGetMessageType(i)),
+					   toStringRef(itemSrGetInterface(i)),
+					   toStringRef(itemSrGetPath(i)),
+					   toStringRef(itemSrGetMember(i)),
+					   toStringRef(itemSrGetName(i)),
+					   itemSrGetIsNamePrefix(i),
+					   makeDecision(decisionItemGetDecision(itemGetDecisionItem(i))));
 }
 
 bool StorageBackendFlatbuffers::match(const ldp_xml_parser::MatchItemAccess &match, const FB::ItemAccess *item) const {
-	return match.match(makeBusAccessType(item->type()), item->uid(), item->gid());
+	return match.match(makeBusAccessType(itemAccessGetType(item)), itemAccessGetUid(item), itemAccessGetGid(item));
 }
 
 template <typename T, typename P = typename type_helper<T>::policy_type>
 ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItem(const T &item, const P *policy) const {
-	const auto *v = policy->items();
-	for (auto it = v->rbegin(); it != v->rend(); ++it) {
-		if (match(item, *it))
-			return makeDecisionItem((*it)->decision());
+	const auto *v = policyGetItems(policy);
+	auto rend = containerGetReverseIteratorEnd(v);
+	for (auto rit = containerGetReverseIterator(v); rit != rend; ++rit) {
+		if (match(item, *rit))
+			return makeDecisionItem(itemGetDecisionItem(*rit));
 	}
 	return ldp_xml_parser::Decision::ANY;
 }
@@ -73,20 +74,25 @@ auto StorageBackendFlatbuffers::getDecisionItemFromTree(const FB::PolicyOwnNode
                                                         const tokenizer::iterator &tokens_end,
                                                         tokenizer::iterator &iterator) const {
 	if (iterator == tokens_end) {
-		if (node->decision_item()->decision() != Decision_ANY)
-			return node->decision_item();
+		if (makeDecision(decisionItemGetDecision(ownNodeGetDecisionItem(node))) != ldp_xml_parser::Decision::ANY)
+			return ownNodeGetDecisionItem(node);
 		else
-			return node->prefix_decision_item();
+			return ownNodeGetPrefixDecisionItem(node);
 	}
 
-	auto child = node->children()->LookupByKey(iterator->c_str());
-	if (nullptr == child)
-		return node->prefix_decision_item();
+	auto children = ownNodeGetChildren(node);
+
+	if (containerEmpty(children))
+		return ownNodeGetPrefixDecisionItem(node);
+
+	auto child = containerLookupByKey(children, iterator->c_str());
+	if (!child.first)
+		return ownNodeGetPrefixDecisionItem(node);
 
 	++iterator;
-	const DecisionItem *child_decision = getDecisionItemFromTree(child, tokens_end, iterator);
-	if (child_decision->decision() == Decision_ANY)
-		return node->prefix_decision_item();
+	auto child_decision = getDecisionItemFromTree(child.second, tokens_end, iterator);
+	if (makeDecision(decisionItemGetDecision(child_decision)) == ldp_xml_parser::Decision::ANY)
+		return ownNodeGetPrefixDecisionItem(node);
 
 	return child_decision;
 }
@@ -100,69 +106,73 @@ ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItem(const ld
 	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.end(), iterator));
+	return makeDecisionItem(getDecisionItemFromTree(policyGetTree(policy), tokens.end(), iterator));
 }
 
-template <typename T, typename P = typename type_helper<T>::policy_type>
-ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemMaybeNull(const T &item, const P *policyPair) const {
-	if (nullptr == policyPair)
+template <typename MatchItem, typename Map>
+ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItem(const MatchItem &item, const Map &map, id_t id) const {
+	if (containerEmpty(map))
 		return ldp_xml_parser::Decision::ANY;
-	return getDecisionItem(item, policyPair->policy());
+
+	auto elem = containerLookupByKey(map, id);
+	if (!elem.first)
+		return ldp_xml_parser::Decision::ANY;
+	return getDecisionItem(item, setUserGroupGetPolicy(elem.second));
 }
 
 ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemFromSendIndex(const MatchItemSend &item, const FB::PolicySend *policy) const {
 
-	const auto *index = policy->index();
-
-	if (!index || index->size() == 0)           // this indicates version earlier than LDP2
+	if (!policyHasIndex(policy))
 		return getDecisionItem(item, policy);   // make it old way for old databases
 
-	std::pair<const ItemSend*, uint32_t> currentBest(nullptr, 0);
+	auto index = policyGetIndex(policy);
 
-	auto updateCurrentBest = [&](const flatbuffers::Vector<uint32_t> *vec) {
+	uint32_t currentBest = 0;
+
+	auto updateCurrentBest = [&currentBest, &item, &policy, this](const auto &vec) {
 		// look from the back, the rule is the same as for the full database
 		// we now only check among less elements, because the database is indexed to small lists
 		// item_scores are in increasing order in the index, and they serve also as ids of the policy rules
-		for (auto item_score_it = vec->rbegin(); item_score_it != vec->rend(); item_score_it++) {
-			const auto *fb_item = policy->items()->Get(*item_score_it - 1); // rules are indexed/scored from 1
-			if (*item_score_it > currentBest.second && match(item, fb_item)) {
-				currentBest.first = fb_item;
-				currentBest.second = *item_score_it;
+		for (auto item_score_it = containerGetReverseIterator(vec);
+		     item_score_it != containerGetReverseIteratorEnd(vec);
+		     item_score_it++) {
+			auto db_items = policyGetItems(policy);
+			auto db_item = containerLookupByIndex(db_items, *item_score_it - 1); // rules are indexed/scored from 1
+			if (*item_score_it > currentBest && match(item, db_item)) {
+				currentBest = *item_score_it;
 				return;
-			} else if (*item_score_it <= currentBest.second) {
+			} else if (*item_score_it <= currentBest) {
 				// there is no need to look further as we can't improve the score anymore
 				return;
 			}
 		}
 	};
 
-	auto searchAndUpdateCurrentBest = [&](boost::string_ref name_ref) {
+	auto searchAndUpdateCurrentBest = [&currentBest, &index, &updateCurrentBest, this](boost::string_ref name_ref) {
 		// we need to create C-string for flatbuffers lookups
 		// boost::string_ref gives us correct start, but possibly NUL-terminated in a wrong place, as it does not modify
 		// input string and keeps only the length
 		std::string name(name_ref.data(), name_ref.size());
 
+		if (containerEmpty(index))
+			return;
+
 		// check if there are any rules for the name
-		const auto *fit = index->LookupByKey(name.c_str());
-		if (!fit)
+		auto fit = containerLookupByKey(index, name.c_str());
+		if (!fit.first)
 			return;
 
 		// check if there's any chance to get better score
-		if (fit->best_score() <= currentBest.second)
+		if (policyIndexGetBestScore(fit.second) <= currentBest)
 			return;
 
 		// look for better score
-		updateCurrentBest(fit->item_refs());
+		updateCurrentBest(policyIndexGetItemRefs(fit.second));
 	};
 
-	const auto *prefixIndex = policy->prefix_index();
-	assert(prefixIndex);
+	auto prefixIndex = policyGetPrefixIndex(policy);
 
 	// iterate over names
 	for (const auto &name: item.getNames()) {
@@ -177,11 +187,13 @@ ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemFromSendI
 	searchAndUpdateCurrentBest("");
 
 	// if a matching rule was found, return the decision
-	if (currentBest.first)
-		return makeDecisionItem(currentBest.first->decision());
+	if (currentBest > 0) {
+		auto db_item = containerLookupByIndex(policyGetItems(policy), currentBest - 1);
+		return makeDecisionItem(itemGetDecisionItem(db_item));
+	}
 
 	// or if no matching rule was not found, return the default decision
-	return ldp_xml_parser::DecisionItem(ldp_xml_parser::Decision::ANY);
+	return ldp_xml_parser::Decision::ANY;
 }
 
 void StorageBackendFlatbuffers::release() {
@@ -222,7 +234,7 @@ bool StorageBackendFlatbuffers::initFromData(const uint8_t *mem, size_t size, bo
 	template <> \
 	auto StorageBackendFlatbuffers::getPolicySet<ldp_xml_parser::MatchItem##T>() const { \
 		assert(file); \
-		return file->m_##t##_set(); \
+		return fileGet##T##Set(getFile()); \
 	}
 
 TYPE_HELPER(Own, own)
@@ -232,45 +244,54 @@ TYPE_HELPER(Access, access)
 
 template <>
 ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemContextMandatory(const MatchItemSend &item) const {
-	return getDecisionItemFromSendIndex(item, getPolicySet<MatchItemSend>()->context_mandatory());
+	return getDecisionItemFromSendIndex(item, setGetContextMandatory(getPolicySet<MatchItemSend>()));
 }
 
 template <>
 ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemContextDefault(const MatchItemSend &item) const {
-	return getDecisionItemFromSendIndex(item, getPolicySet<MatchItemSend>()->context_default());
+	return getDecisionItemFromSendIndex(item, setGetContextDefault(getPolicySet<MatchItemSend>()));
 }
 
 template <>
 ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemUser(uid_t uid, const MatchItemSend &item) const {
-	auto *policyPair = getPolicySet<MatchItemSend>()->user()->LookupByKey(uid);
-	if (nullptr == policyPair)
+	auto map = setGetUser(getPolicySet<MatchItemSend>());
+
+	if (containerEmpty(map))
 		return ldp_xml_parser::Decision::ANY;
-	return getDecisionItemFromSendIndex(item, policyPair->policy());
+
+	auto elem = containerLookupByKey(map, uid);
+	if (!elem.first)
+		return ldp_xml_parser::Decision::ANY;
+	return getDecisionItemFromSendIndex(item, setUserGroupGetPolicy(elem.second));
 }
 
 template <typename T>
 ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemContextMandatory(const T &item) const {
-	return getDecisionItem(item, getPolicySet<T>()->context_mandatory());
+	return getDecisionItem(item, setGetContextMandatory(getPolicySet<T>()));
 }
 
 template <typename T>
 ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemContextDefault(const T &item) const {
-	return getDecisionItem(item, getPolicySet<T>()->context_default());
+	return getDecisionItem(item, setGetContextDefault(getPolicySet<T>()));
 }
 
 template <typename T>
 ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemUser(uid_t uid, const T &item) const {
-	return getDecisionItemMaybeNull(item, getPolicySet<T>()->user()->LookupByKey(uid));
+	return getDecisionItem(item, setGetUser(getPolicySet<T>()), uid);
 }
-
 template <typename T>
 ldp_xml_parser::DecisionItem StorageBackendFlatbuffers::getDecisionItemGroup(gid_t gid, const T &item) const {
-	return getDecisionItemMaybeNull(item, getPolicySet<T>()->group()->LookupByKey(gid));
+	return getDecisionItem(item, setGetGroup(getPolicySet<T>()), gid);
 }
 
 template <typename T>
 bool StorageBackendFlatbuffers::existsPolicyForGroup(gid_t gid) const {
-	return getPolicySet<T>()->group()->LookupByKey(gid) != nullptr;
+	auto map = setGetGroup(getPolicySet<T>());
+
+	if (containerEmpty(map))
+		return false;
+
+	return containerLookupByKey(map, gid).first;
 }
 
 #define T_INSTANTIATION(T) \
diff --git a/src/internal/storage_backend_flatbuffers.hpp b/src/internal/storage_backend_flatbuffers.hpp
index f831282..536808a 100644
--- a/src/internal/storage_backend_flatbuffers.hpp
+++ b/src/internal/storage_backend_flatbuffers.hpp
@@ -218,8 +218,8 @@ private:
 
 	ldp_xml_parser::DecisionItem getDecisionItemFromSendIndex(const ldp_xml_parser::MatchItemSend &item, const FB::PolicySend *policy) const;
 
-	template <typename T, typename P>
-	ldp_xml_parser::DecisionItem getDecisionItemMaybeNull(const T &item, const P *policyPair) const;
+	template <typename MatchItem, typename Map>
+	ldp_xml_parser::DecisionItem getDecisionItem(const MatchItem &item, const Map &map, id_t id) const;
 
 	auto getDecisionItemFromTree(const FB::PolicyOwnNode *node,
 	                             const tokenizer::iterator &tokens_end,