in-memory-storage.hpp

Go to the documentation of this file.

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

#include "../common.hpp"
#include "../interest.hpp"
#include "../data.hpp"
#include "scheduler.hpp"
#include "in-memory-storage-entry.hpp"

#include <boost/multi_index/member.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index/identity.hpp>
#include <boost/multi_index/mem_fun.hpp>

#include <stack>
#include <iterator>

namespace ndn {
namespace util {

class InMemoryStorage : noncopyable
{
public:
  //multi_index_container to implement storage
  class byFullName;

  typedef boost::multi_index_container<
    InMemoryStorageEntry*,
    boost::multi_index::indexed_by<

      // by Full Name
      boost::multi_index::ordered_unique<
        boost::multi_index::tag<byFullName>,
        boost::multi_index::const_mem_fun<InMemoryStorageEntry, const Name&,
                                          &InMemoryStorageEntry::getFullName>,
        std::less<Name>
      >

    >
  > Cache;

  class const_iterator : public std::iterator<std::input_iterator_tag, const Data>
  {
  public:
    const_iterator(const Data* ptr, const Cache* cache,
                   Cache::index<byFullName>::type::iterator it);

    const_iterator&
    operator++();

    const_iterator
    operator++(int);

    const Data&
    operator*();

    const Data*
    operator->();

    bool
    operator==(const const_iterator& rhs);

    bool
    operator!=(const const_iterator& rhs);

  private:
    const Data* m_ptr;
    const Cache* m_cache;
    Cache::index<byFullName>::type::iterator m_it;
  };

  class Error : public std::runtime_error
  {
  public:
    Error() : std::runtime_error("Cannot reduce the capacity of the in-memory storage!")
    {
    }
  };

  explicit
  InMemoryStorage(size_t limit = std::numeric_limits<size_t>::max());

  explicit
  InMemoryStorage(boost::asio::io_service& ioService,
                  size_t limit = std::numeric_limits<size_t>::max());

  virtual
  ~InMemoryStorage();

  void
  insert(const Data& data, const time::milliseconds& mustBeFreshProcessingWindow = INFINITE_WINDOW);

  shared_ptr<const Data>
  find(const Interest& interest);

  shared_ptr<const Data>
  find(const Name& name);

  void
  erase(const Name& prefix, const bool isPrefix = true);

  size_t
  getLimit() const
  {
    return m_limit;
  }

  size_t
  size() const
  {
    return m_nPackets;
  }

  InMemoryStorage::const_iterator
  begin() const;

  InMemoryStorage::const_iterator
  end() const;

NDN_CXX_PUBLIC_WITH_TESTS_ELSE_PROTECTED:
  virtual void
  afterAccess(InMemoryStorageEntry* entry);

  virtual void
  afterInsert(InMemoryStorageEntry* entry);

  virtual void
  beforeErase(InMemoryStorageEntry* entry);

  virtual bool
  evictItem() = 0;

NDN_CXX_PUBLIC_WITH_TESTS_ELSE_PROTECTED:
  void
  setCapacity(size_t nMaxPackets);

  size_t
  getCapacity() const
  {
    return m_capacity;
  }

  bool
  isFull() const
  {
    return size() >= m_capacity;
  }

  void
  eraseImpl(const Name& name);

  void
  printCache(std::ostream& os) const;

NDN_CXX_PUBLIC_WITH_TESTS_ELSE_PRIVATE:
  Cache::iterator
  freeEntry(Cache::iterator it);

  InMemoryStorageEntry*
  selectChild(const Interest& interest,
              Cache::index<byFullName>::type::iterator startingPoint) const;

  Cache::index<byFullName>::type::iterator
  findNextFresh(Cache::index<byFullName>::type::iterator startingPoint) const;

private:
  void
  init();

public:
  static const time::milliseconds INFINITE_WINDOW;

private:
  static const time::milliseconds ZERO_WINDOW;

private:
  Cache m_cache;
  size_t m_limit;
  size_t m_capacity;
  size_t m_nPackets;
  std::stack<InMemoryStorageEntry*> m_freeEntries;
  unique_ptr<Scheduler> m_scheduler;
};

} // namespace util
} // namespace ndn

#endif // NDN_UTIL_IN_MEMORY_STORAGE_HPP