in-memory-storage.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2013-2021 Regents of the University of California.
 *
 * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
 *
 * ndn-cxx library is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later version.
 *
 * ndn-cxx library is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
 *
 * You should have received copies of the GNU General Public License and GNU Lesser
 * General Public License along with ndn-cxx, e.g., in COPYING.md file.  If not, see
 * <http://www.gnu.org/licenses/>.
 *
 * See AUTHORS.md for complete list of ndn-cxx authors and contributors.
 */

#ifndef NDN_CXX_IMS_IN_MEMORY_STORAGE_HPP
#define NDN_CXX_IMS_IN_MEMORY_STORAGE_HPP

#include "ndn-cxx/ims/in-memory-storage-entry.hpp"
#include "ndn-cxx/util/scheduler.hpp"

#include <iterator>
#include <stack>

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

namespace ndn {

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:
    using iterator_category = std::input_iterator_tag;
    using value_type        = const Data;
    using difference_type   = std::ptrdiff_t;
    using pointer           = value_type*;
    using reference         = value_type&;

    const_iterator(const Data* ptr, const Cache* cache,
                   Cache::index<byFullName>::type::iterator it);

    const_iterator&
    operator++();

    const_iterator
    operator++(int);

    reference
    operator*();

    pointer
    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(DummyIoService& 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;
  const size_t m_initCapacity = 16;
  size_t m_capacity;
  size_t m_nPackets;
  std::stack<InMemoryStorageEntry*> m_freeEntries;
  unique_ptr<scheduler::Scheduler> m_scheduler;
};

} // namespace ndn

#endif // NDN_CXX_IMS_IN_MEMORY_STORAGE_HPP