wire-format.hpp

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

#include "../common.hpp"
#include "../util/blob.hpp"

namespace ndn {

class Name;
class Interest;
class Data;
class ControlParameters;
class ControlResponse;
class Signature;
class DelegationSet;
class EncryptedContent;

class WireFormat {
public:
  virtual Blob
  encodeName(const Name& name);

  virtual void
  decodeName(Name& name, const uint8_t *input, size_t inputLength);

  virtual Blob
  encodeInterest
    (const Interest& interest, size_t *signedPortionBeginOffset,
     size_t *signedPortionEndOffset);

  Blob
  encodeInterest(const Interest& interest)
  {
    size_t dummyBeginOffset, dummyEndOffset;
    return encodeInterest(interest, &dummyBeginOffset, &dummyEndOffset);
  }

  virtual void
  decodeInterest
    (Interest& interest, const uint8_t *input, size_t inputLength,
     size_t *signedPortionBeginOffset, size_t *signedPortionEndOffset);

  void
  decodeInterest(Interest& interest, const uint8_t *input, size_t inputLength)
  {
    size_t dummyBeginOffset, dummyEndOffset;
    decodeInterest
      (interest, input, inputLength, &dummyBeginOffset, &dummyEndOffset);
  }

  virtual Blob
  encodeData
    (const Data& data, size_t *signedPortionBeginOffset, size_t *signedPortionEndOffset);

  Blob
  encodeData(const Data& data)
  {
    size_t dummyBeginOffset, dummyEndOffset;
    return encodeData(data, &dummyBeginOffset, &dummyEndOffset);
  }

  virtual void
  decodeData
    (Data& data, const uint8_t *input, size_t inputLength, size_t *signedPortionBeginOffset, size_t *signedPortionEndOffset);

  void
  decodeData(Data& data, const uint8_t *input, size_t inputLength)
  {
    size_t dummyBeginOffset, dummyEndOffset;
    decodeData(data, input, inputLength, &dummyBeginOffset, &dummyEndOffset);
  }

  virtual Blob
  encodeControlParameters(const ControlParameters& controlParameters);

  virtual void
  decodeControlParameters
    (ControlParameters& controlParameters, const uint8_t *input,
     size_t inputLength);

  virtual Blob
  encodeControlResponse(const ControlResponse& controlResponse);

  virtual void
  decodeControlResponse
    (ControlResponse& controlResponse, const uint8_t *input,
     size_t inputLength);

  virtual Blob
  encodeSignatureInfo(const Signature& signature);

  virtual Blob
  encodeSignatureValue(const Signature& signature);

  virtual ptr_lib::shared_ptr<Signature>
  decodeSignatureInfoAndValue
    (const uint8_t *signatureInfo, size_t signatureInfoLength,
     const uint8_t *signatureValue, size_t signatureValueLength);

  virtual ptr_lib::shared_ptr<Signature>
  decodeSignatureInfoAndValue
    (const Blob& signatureInfo, const Blob& signatureValue)
  {
    return decodeSignatureInfoAndValue
      (signatureInfo.buf(), signatureInfo.size(), signatureValue.buf(),
       signatureValue.size());
  }

  virtual Blob
  encodeDelegationSet(const DelegationSet& delegationSet);

  virtual void
  decodeDelegationSet
    (DelegationSet& delegationSet, const uint8_t *input, size_t inputLength);

  virtual Blob
  encodeEncryptedContent(const EncryptedContent& encryptedContent);

  virtual void
  decodeEncryptedContent
    (EncryptedContent& encryptedContent, const uint8_t *input,
     size_t inputLength);

  static void
  setDefaultWireFormat(WireFormat *wireFormat)
  {
    defaultWireFormat_ = wireFormat;
  }

  static WireFormat*
  getDefaultWireFormat();

private:
  static WireFormat*
  newInitialDefaultWireFormat();

  static WireFormat *defaultWireFormat_;
};

}

#endif