name-tree.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#ifndef NFD_DAEMON_TABLE_NAME_TREE_HPP
#define NFD_DAEMON_TABLE_NAME_TREE_HPP

#include "common.hpp"
#include "name-tree-entry.hpp"

namespace nfd {
namespace name_tree {

size_t
computeHash(const Name& prefix);

std::vector<size_t>
computeHashSet(const Name& prefix);

typedef function<bool (const Entry& entry)> EntrySelector;

typedef function<std::pair<bool,bool> (const Entry& entry)> EntrySubTreeSelector;

struct AnyEntry {
  bool
  operator()(const Entry& entry)
  {
    return true;
  }
};

struct AnyEntrySubTree {
  std::pair<bool, bool>
  operator()(const Entry& entry)
  {
    return std::make_pair(true, true);
  }
};

} // namespace name_tree

class NameTree : noncopyable
{
public:
  class const_iterator;

  explicit
  NameTree(size_t nBuckets = 1024);

  ~NameTree();

public: // information
  size_t
  size() const;

  size_t
  getNBuckets() const;

  void
  dump(std::ostream& output) const;

public: // mutation
  shared_ptr<name_tree::Entry>
  lookup(const Name& prefix);

  bool
  eraseEntryIfEmpty(shared_ptr<name_tree::Entry> entry);

public: // shortcut access
  shared_ptr<name_tree::Entry>
  get(const fib::Entry& fibEntry) const;

  shared_ptr<name_tree::Entry>
  get(const pit::Entry& pitEntry) const;

  shared_ptr<name_tree::Entry>
  get(const measurements::Entry& measurementsEntry) const;

  shared_ptr<name_tree::Entry>
  get(const strategy_choice::Entry& strategyChoiceEntry) const;

public: // matching
  shared_ptr<name_tree::Entry>
  findExactMatch(const Name& prefix) const;

  shared_ptr<name_tree::Entry>
  findLongestPrefixMatch(const Name& prefix,
                         const name_tree::EntrySelector& entrySelector =
                         name_tree::AnyEntry()) const;

  shared_ptr<name_tree::Entry>
  findLongestPrefixMatch(shared_ptr<name_tree::Entry> entry,
                         const name_tree::EntrySelector& entrySelector =
                         name_tree::AnyEntry()) const;

  boost::iterator_range<const_iterator>
  findAllMatches(const Name& prefix,
                 const name_tree::EntrySelector& entrySelector = name_tree::AnyEntry()) const;

public: // enumeration
  boost::iterator_range<const_iterator>
  fullEnumerate(const name_tree::EntrySelector& entrySelector = name_tree::AnyEntry()) const;

  boost::iterator_range<const_iterator>
  partialEnumerate(const Name& prefix,
                   const name_tree::EntrySubTreeSelector& entrySubTreeSelector =
                         name_tree::AnyEntrySubTree()) const;

  const_iterator
  begin() const;

  const_iterator
  end() const;

  enum IteratorType {
    FULL_ENUMERATE_TYPE,
    PARTIAL_ENUMERATE_TYPE,
    FIND_ALL_MATCHES_TYPE
  };

  class const_iterator : public std::iterator<std::forward_iterator_tag, const name_tree::Entry>
  {
  public:
    friend class NameTree;

    const_iterator();

    const_iterator(NameTree::IteratorType type,
      const NameTree& nameTree,
      shared_ptr<name_tree::Entry> entry,
      const name_tree::EntrySelector& entrySelector = name_tree::AnyEntry(),
      const name_tree::EntrySubTreeSelector& entrySubTreeSelector = name_tree::AnyEntrySubTree());

    ~const_iterator();

    const name_tree::Entry&
    operator*() const;

    shared_ptr<name_tree::Entry>
    operator->() const;

    const_iterator
    operator++();

    const_iterator
    operator++(int);

    bool
    operator==(const const_iterator& other) const;

    bool
    operator!=(const const_iterator& other) const;

  private:
    const NameTree*                             m_nameTree;
    shared_ptr<name_tree::Entry>                m_entry;
    shared_ptr<name_tree::Entry>                m_subTreeRoot;
    shared_ptr<name_tree::EntrySelector>        m_entrySelector;
    shared_ptr<name_tree::EntrySubTreeSelector> m_entrySubTreeSelector;
    NameTree::IteratorType                      m_type;
    bool                                        m_shouldVisitChildren;
  };

private:
  void
  resize(size_t newNBuckets);

private:
  size_t                        m_nItems;  // Number of items being stored
  size_t                        m_nBuckets; // Number of hash buckets
  size_t                        m_minNBuckets; // Minimum number of hash buckets
  double                        m_enlargeLoadFactor;
  size_t                        m_enlargeThreshold;
  int                           m_enlargeFactor;
  double                        m_shrinkLoadFactor;
  size_t                        m_shrinkThreshold;
  double                        m_shrinkFactor;
  name_tree::Node**             m_buckets; // Name Tree Buckets in the NPHT
  shared_ptr<name_tree::Entry>  m_end;
  const_iterator                m_endIterator;

  std::pair<shared_ptr<name_tree::Entry>, bool>
  insert(const Name& prefix);
};

inline NameTree::const_iterator::~const_iterator()
{
}

inline size_t
NameTree::size() const
{
  return m_nItems;
}

inline size_t
NameTree::getNBuckets() const
{
  return m_nBuckets;
}

inline shared_ptr<name_tree::Entry>
NameTree::get(const fib::Entry& fibEntry) const
{
  return fibEntry.m_nameTreeEntry;
}

inline shared_ptr<name_tree::Entry>
NameTree::get(const pit::Entry& pitEntry) const
{
  return pitEntry.m_nameTreeEntry;
}

inline shared_ptr<name_tree::Entry>
NameTree::get(const measurements::Entry& measurementsEntry) const
{
  return measurementsEntry.m_nameTreeEntry;
}

inline shared_ptr<name_tree::Entry>
NameTree::get(const strategy_choice::Entry& strategyChoiceEntry) const
{
  return strategyChoiceEntry.m_nameTreeEntry;
}

inline NameTree::const_iterator
NameTree::begin() const
{
  return fullEnumerate().begin();
}

inline NameTree::const_iterator
NameTree::end() const
{
  return m_endIterator;
}

inline const name_tree::Entry&
NameTree::const_iterator::operator*() const
{
  return *m_entry;
}

inline shared_ptr<name_tree::Entry>
NameTree::const_iterator::operator->() const
{
  return m_entry;
}

inline NameTree::const_iterator
NameTree::const_iterator::operator++(int)
{
  NameTree::const_iterator temp(*this);
  ++(*this);
  return temp;
}

inline bool
NameTree::const_iterator::operator==(const NameTree::const_iterator& other) const
{
  return m_entry == other.m_entry;
}

inline bool
NameTree::const_iterator::operator!=(const NameTree::const_iterator& other) const
{
  return m_entry != other.m_entry;
}

} // namespace nfd

#endif // NFD_DAEMON_TABLE_NAME_TREE_HPP