face.hpp

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

#include "interest.hpp"
#include "data.hpp"
#include "network-nack.hpp"
#include "forwarding-flags.hpp"
#include "encoding/wire-format.hpp"
#include "interest-filter.hpp"
#include "transport/transport.hpp"

namespace ndn {

class Face;

typedef func_lib::function<void(const ptr_lib::shared_ptr<const Interest>&,
                                const ptr_lib::shared_ptr<Data>&)> OnData;

typedef func_lib::function<void(const ptr_lib::shared_ptr<const Interest>&)> OnTimeout;

typedef func_lib::function<void(const ptr_lib::shared_ptr<const Interest>&,
                                const ptr_lib::shared_ptr<NetworkNack>&)> OnNetworkNack;

typedef func_lib::function<void
  (const ptr_lib::shared_ptr<const Name>&, const ptr_lib::shared_ptr<const Interest>&, Transport&, uint64_t)> OnInterest;

typedef func_lib::function<void
  (const ptr_lib::shared_ptr<const Name>&,
   const ptr_lib::shared_ptr<const Interest>&, Face&, uint64_t,
   const ptr_lib::shared_ptr<const InterestFilter>&)> OnInterestCallback;

typedef func_lib::function<void(const ptr_lib::shared_ptr<const Name>&)> OnRegisterFailed;

typedef func_lib::function<void(const ptr_lib::shared_ptr<const Name>&, uint64_t)>
  OnRegisterSuccess;

class Node;
class KeyChain;

class Face {
public:
  Face(const ptr_lib::shared_ptr<Transport>& transport, const ptr_lib::shared_ptr<const Transport::ConnectionInfo>& connectionInfo);

  Face(const char *host, unsigned short port = 6363);

  Face();

  virtual ~Face();

  virtual uint64_t
  expressInterest
    (const Interest& interest, const OnData& onData, 
     const OnTimeout& onTimeout, const OnNetworkNack& onNetworkNack,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat());

  virtual uint64_t
  expressInterest
    (const Name& name, const Interest *interestTemplate, const OnData& onData, 
     const OnTimeout& onTimeout, const OnNetworkNack& onNetworkNack,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat());

  uint64_t
  expressInterest
    (const Name& name, const OnData& onData, 
     const OnTimeout& onTimeout, const OnNetworkNack& onNetworkNack,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    return expressInterest(name, 0, onData, onTimeout, onNetworkNack, wireFormat);
  }

  uint64_t
  expressInterest
    (const Interest& interest, const OnData& onData,
     const OnTimeout& onTimeout = OnTimeout(),
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    return expressInterest
      (interest, onData, onTimeout, OnNetworkNack(), wireFormat);
  }

  uint64_t
  expressInterest
    (const Name& name, const Interest *interestTemplate, const OnData& onData,
     const OnTimeout& onTimeout = OnTimeout(),
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    return expressInterest
      (name, interestTemplate, onData, onTimeout, OnNetworkNack(), wireFormat);
  }

  uint64_t
  expressInterest
    (const Name& name, const OnData& onData,
     const OnTimeout& onTimeout = OnTimeout(),
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    return expressInterest
      (name, 0, onData, onTimeout, OnNetworkNack(), wireFormat);
  }

  virtual void
  removePendingInterest(uint64_t pendingInterestId);

  void
  setCommandSigningInfo(KeyChain& keyChain, const Name& certificateName)
  {
    commandKeyChain_ = &keyChain;
    commandCertificateName_ = certificateName;
  }

  void
  setCommandCertificateName(const Name& certificateName)
  {
    commandCertificateName_ = certificateName;
  }

  KeyChain*
  getCommandKeyChain() { return commandKeyChain_; }

  const Name&
  getCommandCertificateName() { return commandCertificateName_; }

  virtual void
  makeCommandInterest
    (Interest& interest,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat());

  virtual uint64_t
  registerPrefix
    (const Name& prefix, const OnInterestCallback& onInterest,
     const OnRegisterFailed& onRegisterFailed,
     const OnRegisterSuccess& onRegisterSuccess,
     const ForwardingFlags& flags = ForwardingFlags(),
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat());

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

  uint64_t
  registerPrefix
    (const Name& prefix, const OnInterestCallback& onInterest,
     const OnRegisterFailed& onRegisterFailed)
  {
    return registerPrefix
      (prefix, onInterest, onRegisterFailed, OnRegisterSuccess(),
       ForwardingFlags(), *WireFormat::getDefaultWireFormat());
  }

  uint64_t
  DEPRECATED_IN_NDN_CPP registerPrefix
    (const Name& prefix, const OnInterest& onInterest,
     const OnRegisterFailed& onRegisterFailed,
     const ForwardingFlags& flags = ForwardingFlags(),
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat());

  virtual void
  removeRegisteredPrefix(uint64_t registeredPrefixId);

  virtual uint64_t
  setInterestFilter
    (const InterestFilter& filter, const OnInterestCallback& onInterest);

  virtual uint64_t
  setInterestFilter(const Name& prefix, const OnInterestCallback& onInterest);

  virtual void
  unsetInterestFilter(uint64_t interestFilterId);

  void
  putData
    (const Data& data,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat());

  void
  send(const Blob& encoding)
  {
    send(encoding.buf(), encoding.size());
  }

  virtual void
  send(const uint8_t *encoding, size_t encodingLength);

  void
  processEvents();

  virtual bool
  isLocal();

  void
  shutdown();

  static size_t
  getMaxNdnPacketSize() { return MAX_NDN_PACKET_SIZE; }

  typedef func_lib::function<void()> Callback;

  virtual void
  callLater(Milliseconds delayMilliseconds, const Callback& callback);

protected:
  static std::string
  getUnixSocketFilePathForLocalhost();

  static ptr_lib::shared_ptr<const Interest>
  getInterestCopy(const Name& name, const Interest *interestTemplate)
  {
    if (interestTemplate) {
      // Copy the interestTemplate.
      ptr_lib::shared_ptr<Interest> interestCopy(new Interest(*interestTemplate));
      interestCopy->setName(name);
      return interestCopy;
    }
    else
      return ptr_lib::make_shared<Interest>(name, 4000.0);
  }

  Node *node_;
  KeyChain* commandKeyChain_;
  Name commandCertificateName_;

private:
  static void
  onInterestWrapper
    (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,
     const OnInterest callerOnInterest);

  static ptr_lib::shared_ptr<Transport>
  getDefaultTransport();

  static ptr_lib::shared_ptr<Transport::ConnectionInfo>
  getDefaultConnectionInfo();
};

}

#endif