in-memory-storage.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2013-2024 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 <limits>
#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;
 
  using Cache = 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>
      >
    >
  >;
 
  class const_iterator : public boost::forward_iterator_helper<const_iterator, const Data>
  {
  public:
    const_iterator(const Data* ptr, const Cache* cache,
                   Cache::index<byFullName>::type::iterator it) noexcept
      : m_ptr(ptr)
      , m_cache(cache)
      , m_it(it)
    {
    }
 
    reference
    operator*() const noexcept
    {
      return *m_ptr;
    }
 
    const_iterator&
    operator++();
 
    friend bool
    operator==(const const_iterator& lhs, const const_iterator& rhs) noexcept
    {
      return lhs.m_it == rhs.m_it;
    }
 
  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_context& ioCtx,
                  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 constexpr time::milliseconds INFINITE_WINDOW = -1_ms;
 
private:
  Cache m_cache;
  size_t m_limit = 0;
  size_t m_capacity = 0;
  size_t m_nPackets = 0;
  std::stack<InMemoryStorageEntry*> m_freeEntries;
  unique_ptr<Scheduler> m_scheduler;
};
 
} // namespace ndn
 
#endif // NDN_CXX_IMS_IN_MEMORY_STORAGE_HPP