memory-content-cache.hpp

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

#include <map>
#include <deque>
#include "../face.hpp"

namespace ndn {

class MemoryContentCache {
public:
  MemoryContentCache
    (Face* face, Milliseconds cleanupIntervalMilliseconds = 1000.0)
  : impl_(new Impl(face, cleanupIntervalMilliseconds))
  {
    impl_->initialize();
  }

  class PendingInterest {
  public:
    PendingInterest
      (const ptr_lib::shared_ptr<const Interest>& interest, Face& face);

    const ptr_lib::shared_ptr<const Interest>&
    getInterest() const { return interest_; }

    MillisecondsSince1970
    getTimeoutPeriodStart() const { return timeoutPeriodStart_; }

    Face&
    getFace() const { return face_; }

    bool
    isTimedOut(MillisecondsSince1970 nowMilliseconds) const
    {
      return nowMilliseconds >= timeoutTimeMilliseconds_;
    }

  private:
    ptr_lib::shared_ptr<const Interest> interest_;
    Face& face_;
    MillisecondsSince1970 timeoutPeriodStart_;
    MillisecondsSince1970 timeoutTimeMilliseconds_; 
  };

  class Content {
  public:
    Content(const Data& data)
    // wireEncode returns the cached encoding if available.
    : name_(data.getName()), dataEncoding_(data.wireEncode())
    {}

    const Name&
    getName() const { return name_; }

    const Blob&
    getDataEncoding() const { return dataEncoding_; }

  private:
    Name name_;
    Blob dataEncoding_;
  };

  typedef std::vector<ptr_lib::shared_ptr<const Content> > ContentList;

  typedef func_lib::function<void
    (const ptr_lib::shared_ptr<ContentList>& contentList)> OnContentRemoved;

  void
  registerPrefix
    (const Name& prefix, const OnRegisterFailed& onRegisterFailed,
     const OnInterestCallback& onDataNotFound = OnInterestCallback(),
     const ForwardingFlags& flags = ForwardingFlags(),
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    registerPrefix
      (prefix, onRegisterFailed, OnRegisterSuccess(), onDataNotFound, flags,
       wireFormat);
  }

  void
  registerPrefix
    (const Name& prefix, const OnRegisterFailed& onRegisterFailed,
     const OnRegisterSuccess& onRegisterSuccess,
     const OnInterestCallback& onDataNotFound = OnInterestCallback(),
     const ForwardingFlags& flags = ForwardingFlags(),
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    impl_->registerPrefix
      (prefix, onRegisterFailed, onRegisterSuccess, onDataNotFound, flags,
       wireFormat);
  }

  void
  setInterestFilter
    (const InterestFilter& filter,
     const OnInterestCallback& onDataNotFound = OnInterestCallback())
  {
    impl_->setInterestFilter(filter, onDataNotFound);
  }

  void
  setInterestFilter
    (const Name& prefix,
     const OnInterestCallback& onDataNotFound = OnInterestCallback())
  {
    impl_->setInterestFilter(prefix, onDataNotFound);
  }

  void
  unregisterAll() { impl_->unregisterAll(); }

  void
  add(const Data& data) { impl_->add(data); }

  void
  storePendingInterest
    (const ptr_lib::shared_ptr<const Interest>& interest, Face& face)
  {
    impl_->storePendingInterest(interest, face);
  }

  const OnInterestCallback&
  getStorePendingInterest() { return impl_->getStorePendingInterest(); }

  void
  getPendingInterestsForName
    (const Name& name,
     std::vector<ptr_lib::shared_ptr<const PendingInterest> >& pendingInterests)
  {
    impl_->getPendingInterestsForName(name, pendingInterests);
  }

  void
  getPendingInterestsWithPrefix
    (const Name& prefix,
     std::vector<ptr_lib::shared_ptr<const PendingInterest> >& pendingInterests)
  {
    impl_->getPendingInterestsWithPrefix(prefix, pendingInterests);
  }

  void
  setOnContentRemoved(const OnContentRemoved& onContentRemoved)
  {
    impl_->setOnContentRemoved(onContentRemoved);
  }

  Milliseconds
  getMinimumCacheLifetime() { return impl_->getMinimumCacheLifetime(); }

  void
  setMinimumCacheLifetime(Milliseconds minimumCacheLifetime)
  {
    impl_->setMinimumCacheLifetime(minimumCacheLifetime);
  }

private:
  class Impl : public ptr_lib::enable_shared_from_this<Impl> {
  public:
    Impl(Face* face, Milliseconds cleanupIntervalMilliseconds);

    void
    initialize();

    void
    registerPrefix
      (const Name& prefix, const OnRegisterFailed& onRegisterFailed,
       const OnRegisterSuccess& onRegisterSuccess,
       const OnInterestCallback& onDataNotFound,
       const ForwardingFlags& flags, WireFormat& wireFormat);

    void
    setInterestFilter
      (const InterestFilter& filter, const OnInterestCallback& onDataNotFound);

    void
    setInterestFilter
      (const Name& prefix, const OnInterestCallback& onDataNotFound);

    void
    unregisterAll();

    void
    add(const Data& data);

    void
    storePendingInterest
      (const ptr_lib::shared_ptr<const Interest>& interest, Face& face);

    const OnInterestCallback&
    getStorePendingInterest() { return storePendingInterestCallback_; }

    void
    getPendingInterestsForName
      (const Name& name,
       std::vector<ptr_lib::shared_ptr<const PendingInterest> >& pendingInterests);

    void
    getPendingInterestsWithPrefix
      (const Name& prefix,
       std::vector<ptr_lib::shared_ptr<const PendingInterest> >& pendingInterests);

    void
    setOnContentRemoved(const OnContentRemoved& onContentRemoved)
    {
      onContentRemoved_ = onContentRemoved;
    }

    Milliseconds
    getMinimumCacheLifetime() { return minimumCacheLifetime_; }

    void
    setMinimumCacheLifetime(Milliseconds minimumCacheLifetime)
    {
      minimumCacheLifetime_ = minimumCacheLifetime;
    }

    void
    onInterest
      (const ptr_lib::shared_ptr<const Name>& prefix,
       const ptr_lib::shared_ptr<const Interest>& interest, Face& face,
       uint64_t interestFilterId,
       const ptr_lib::shared_ptr<const InterestFilter>& filter);

  private:
    class StaleTimeContent : public Content {
    public:
      StaleTimeContent
        (const Data& data, MillisecondsSince1970 nowMilliseconds,
         Milliseconds minimumCacheLifetime);

      bool
      isPastRemovalTime(MillisecondsSince1970 nowMilliseconds) const
      {
        return cacheRemovalTimeMilliseconds_ <= nowMilliseconds;
      }

      bool
      isFresh(MillisecondsSince1970 nowMilliseconds) const
      {
        return freshnessExpiryTimeMilliseconds_ > nowMilliseconds;
      }

      class Compare {
      public:
        bool
        operator()
          (const ptr_lib::shared_ptr<const StaleTimeContent>& x,
           const ptr_lib::shared_ptr<const StaleTimeContent>& y) const
        {
          return x->cacheRemovalTimeMilliseconds_ < y->cacheRemovalTimeMilliseconds_;
        }
      };

    private:
      MillisecondsSince1970 cacheRemovalTimeMilliseconds_; 
      MillisecondsSince1970 freshnessExpiryTimeMilliseconds_; 
    };

    void
    doCleanup(MillisecondsSince1970 nowMilliseconds);

    void
    storePendingInterestCallback
      (const ptr_lib::shared_ptr<const Name>& prefix,
       const ptr_lib::shared_ptr<const Interest>& interest, Face& face,
       uint64_t interestFilterId,
       const ptr_lib::shared_ptr<const InterestFilter>& filter)
    {
      storePendingInterest(interest, face);
    }

    Face* face_;
    Milliseconds cleanupIntervalMilliseconds_;
    MillisecondsSince1970 nextCleanupTime_;
    std::map<std::string, OnInterestCallback> onDataNotFoundForPrefix_; 
    std::vector<uint64_t> interestFilterIdList_;
    std::vector<uint64_t> registeredPrefixIdList_;
    std::vector<ptr_lib::shared_ptr<const Content> > noStaleTimeCache_;
    // Use a deque so we can efficiently remove from the front.
    std::deque<ptr_lib::shared_ptr<const StaleTimeContent> > staleTimeCache_;
    StaleTimeContent::Compare contentCompare_;
    Name::Component emptyComponent_;
    std::vector<ptr_lib::shared_ptr<const PendingInterest> > pendingInterestTable_;
    OnInterestCallback storePendingInterestCallback_;
    OnContentRemoved onContentRemoved_;
    bool isDoingCleanup_;
    Milliseconds minimumCacheLifetime_;
  };

  ndn::ptr_lib::shared_ptr<Impl> impl_;
};

}

#endif