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);

  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 timeoutTimeMilliseconds_ >= 0.0 &&
             nowMilliseconds >= timeoutTimeMilliseconds_;
    }

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

  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())
  {
    onDataNotFoundForPrefix_[prefix.toUri()] = onDataNotFound;
    uint64_t registeredPrefixId = face_->registerPrefix
      (prefix, func_lib::ref(*this), onRegisterFailed, onRegisterSuccess, flags,
       wireFormat);
    // Remember the registeredPrefixId so unregisterAll can remove it.
    registeredPrefixIdList_.push_back(registeredPrefixId);
  }

  void
  setInterestFilter
    (const InterestFilter& filter,
     const OnInterestCallback& onDataNotFound = OnInterestCallback())
  {
    onDataNotFoundForPrefix_[filter.getPrefix().toUri()] = onDataNotFound;
    uint64_t interestFilterId = face_->setInterestFilter
      (filter, func_lib::ref(*this));
    // Remember the interestFilterId so unregisterAll can remove it.
    interestFilterIdList_.push_back(interestFilterId);
  }

  void
  setInterestFilter
    (const Name& prefix,
     const OnInterestCallback& onDataNotFound = OnInterestCallback())
  {
    onDataNotFoundForPrefix_[prefix.toUri()] = onDataNotFound;
    uint64_t interestFilterId = face_->setInterestFilter
      (prefix, func_lib::ref(*this));
    // Remember the interestFilterId so unregisterAll can remove it.
    interestFilterIdList_.push_back(interestFilterId);
  }

  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
  operator()
    (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 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_;
  };

  class StaleTimeContent : public Content {
  public:
    StaleTimeContent(const Data& data);

    bool
    isStale(MillisecondsSince1970 nowMilliseconds) const
    {
      return staleTimeMilliseconds_ <= 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->staleTimeMilliseconds_ < y->staleTimeMilliseconds_;
      }
    };

  private:
    MillisecondsSince1970 staleTimeMilliseconds_; 
  };

  void
  doCleanup();

  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_;
};

}

#endif