kirylkaveryn/organicmaps
1
Fork 0
forked from organicmaps/organicmaps-tmp
Code Pull requests Activity

[new downloader] Using unique_ptr and raw pointer instead of shared_ptr. Forwarding some functions args.

Browse source
This commit is contained in:
Vladimir Byko-Ianko 2016-03-02 11:06:24 +03:00 • committed by Sergey Yershov
parent 953f9c06c0
commit 3634925c8c
2 changed files with 26 additions and 19 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
storage/country_tree.hpp
View file

@ -3,12 +3,12 @@
#include "base/assert.hpp"
#include "std/algorithm.hpp"
#include "std/shared_ptr.hpp"
#include "std/unique_ptr.hpp"
#include "std/vector.hpp"
/// This class is developed for using in Storage. It's a implementation of a tree.
/// This class is developed for using in CountryTreeFacade. It's a implementation of a tree.
/// It should be filled with AddAtDepth method.
/// This class is used in Storage and filled based on countries.txt (countries_migrate.txt).
/// This class is used in filled based on countries.txt (countries_migrate.txt).
/// While filling CountryTree nodes in countries.txt should be visited in DFS order.
template <class T>
class CountryTree
@ -18,14 +18,14 @@ class CountryTree
/// \brief m_children contains all first generation descendants of the node.
/// Note. Once created the order of elements of |m_children| should not be changed.
/// See implementation of AddAtDepth and Add methods for details.
vector<shared_ptr<CountryTree<T>>> m_children;
vector<unique_ptr<CountryTree<T>>> m_children;
CountryTree<T> * m_parent;
/// @return reference is valid only up to the next tree structure modification
shared_ptr<CountryTree<T>> Add(T const & value)
CountryTree<T> * Add(T const & value)
{
m_children.emplace_back(make_shared<CountryTree<T>>(value, this));
return m_children.back();
m_children.emplace_back(make_unique<CountryTree<T>>(value, this));
return m_children.back().get();
}
public:
@ -41,7 +41,7 @@ public:
T & Value() { return m_value; }
/// @return reference is valid only up to the next tree structure modification
shared_ptr<CountryTree<T>> AddAtDepth(int level, T const & value)
CountryTree<T> * AddAtDepth(int level, T const & value)
{
CountryTree<T> * node = this;
while (level-- > 0 && !node->m_children.empty())

29
storage/country_tree_facade.hpp
View file

@ -21,14 +21,15 @@ private:
hash<int> m_hash;
};
/// This class is developed for using in Storage. It's a implementation of a tree.
/// This class is developed for using in Storage. It's a implementation of a tree with ability
/// of access to its nodes in constant time with the help of hash table.
/// It should be filled with AddAtDepth method.
/// This class is used in Storage and filled based on countries.txt (countries_migrate.txt).
/// While filling CountryTree nodes in countries.txt should be visited in DFS order.
template <class T>
class CountryTreeFacade
{
using TCountryTreeHashTable = unordered_multimap<T, shared_ptr<CountryTree<T>>, CountryTreeKeyHasher<T>>;
using TCountryTreeHashTable = unordered_multimap<T, CountryTree<T> *, CountryTreeKeyHasher<T>>;
CountryTree<T> m_countryTree;
TCountryTreeHashTable m_countryTreeHashTable;
@ -46,7 +47,7 @@ public:
/// @return reference is valid only up to the next tree structure modification
T & AddAtDepth(int level, T const & value)
{
shared_ptr<CountryTree<T>> const added = m_countryTree.AddAtDepth(level, value);
CountryTree<T> * const added = m_countryTree.AddAtDepth(level, value);
m_countryTreeHashTable.insert(make_pair(value, added));
return added->Value();
}
@ -112,29 +113,35 @@ public:
/// \brief Calls functor f for each first generation descendant of the node.
template <class TFunctor>
void ForEachChild(TFunctor && f) { return m_countryTree.ForEachChild(f); }
void ForEachChild(TFunctor && f) { return m_countryTree.ForEachChild(forward<T>(f)); }
template <class TFunctor>
void ForEachChild(TFunctor && f) const { return m_countryTree.ForEachChild(f); }
void ForEachChild(TFunctor && f) const { return m_countryTree.ForEachChild(forward<T>(f)); }
/// \brief Calls functor f for all nodes (add descendant) in the tree.
template <class TFunctor>
void ForEachDescendant(TFunctor && f) { return m_countryTree.ForEachDescendant(f); }
void ForEachDescendant(TFunctor && f) { return m_countryTree.ForEachDescendant(forward<T>(f)); }
template <class TFunctor>
void ForEachDescendant(TFunctor && f) const { return m_countryTree.ForEachDescendant(f); }
void ForEachDescendant(TFunctor && f) const { return m_countryTree.ForEachDescendant(forward<T>(f)); }
template <class TFunctor>
void ForEachInSubtree(TFunctor && f) { return m_countryTree.ForEachInSubtree(f); }
void ForEachInSubtree(TFunctor && f) { return m_countryTree.ForEachInSubtree(forward<T>(f)); }
template <class TFunctor>
void ForEachInSubtree(TFunctor && f) const { return m_countryTree.ForEachInSubtree(f); }
void ForEachInSubtree(TFunctor && f) const { return m_countryTree.ForEachInSubtree(forward<T>(f)); }
template <class TFunctor>
void ForEachAncestorExceptForTheRoot(TFunctor && f) { return m_countryTree.ForEachAncestorExceptForTheRoot(f); }
void ForEachAncestorExceptForTheRoot(TFunctor && f)
{
return m_countryTree.ForEachAncestorExceptForTheRoot(forward<T>(f));
}
template <class TFunctor>
void ForEachAncestorExceptForTheRoot(TFunctor && f) const { return m_countryTree.ForEachAncestorExceptForTheRoot(f); }
void ForEachAncestorExceptForTheRoot(TFunctor && f) const
{
return m_countryTree.ForEachAncestorExceptForTheRoot(forward<T>(f));
}
private:
static bool IsEqual(T const & v1, T const & v2) { return !(v1 < v2) && !(v2 < v1); }