lp-packet-lite.hpp

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

#include "../util/blob-lite.hpp"
#include "incoming-face-id-lite.hpp"
#include "../network-nack-lite.hpp"
#include "congestion-mark-lite.hpp"
#include "../../c/lp/lp-packet-types.h"

namespace ndn {

class LpPacketHeaderFieldLite : private ndn_LpPacketHeaderField {
public:
  ndn_LpPacketHeaderFieldType
  getType() const { return type; }

  const IncomingFaceIdLite&
  getIncomingFaceId() const { return IncomingFaceIdLite::downCast(incomingFaceId); }

  IncomingFaceIdLite&
  getIncomingFaceId() { return IncomingFaceIdLite::downCast(incomingFaceId); }

  const NetworkNackLite&
  getNetworkNack() const { return NetworkNackLite::downCast(networkNack); }

  NetworkNackLite&
  getNetworkNack() { return NetworkNackLite::downCast(networkNack); }

  const CongestionMarkLite&
  getCongestionMark() const { return CongestionMarkLite::downCast(congestionMark); }

  CongestionMarkLite&
  getCongestionMark() { return CongestionMarkLite::downCast(congestionMark); }

  static LpPacketHeaderFieldLite&
  downCast(ndn_LpPacketHeaderField& lpPacketHeaderField)
  {
    return *(LpPacketHeaderFieldLite*)&lpPacketHeaderField;
  }

  static const LpPacketHeaderFieldLite&
  downCast(const ndn_LpPacketHeaderField& lpPacketHeaderField)
  {
    return *(LpPacketHeaderFieldLite*)&lpPacketHeaderField;
  }
};

class LpPacketLite : private ndn_LpPacket {
public:
  LpPacketLite
    (struct ndn_LpPacketHeaderField* headerFields, size_t maxHeaderFields);

  const BlobLite&
  getFragmentWireEncoding() const { return BlobLite::downCast(fragmentWireEncoding); }

  size_t
  countHeaderFields() const { return nHeaderFields; }

  const LpPacketHeaderFieldLite&
  getHeaderField(int index) const
  {
    return LpPacketHeaderFieldLite::downCast(headerFields[index]);
  }

  LpPacketHeaderFieldLite&
  getHeaderField(int index)
  {
    return LpPacketHeaderFieldLite::downCast(headerFields[index]);
  }

  void
  setFragmentWireEncoding(const BlobLite& fragmentWireEncoding)
  {
    BlobLite::downCast(this->fragmentWireEncoding) = fragmentWireEncoding;
  }

  static LpPacketLite&
  downCast(ndn_LpPacket& lpPacket) { return *(LpPacketLite*)&lpPacket; }

  static const LpPacketLite&
  downCast(const ndn_LpPacket& lpPacket) { return *(LpPacketLite*)&lpPacket; }

private:
  // Declare friends who can downcast to the private base.
  friend class Tlv0_2WireFormatLite;
  friend class IncomingFaceIdLite;
  friend class NetworkNackLite;
  friend class CongestionMarkLite;

  LpPacketLite(const LpPacketLite& other);

  LpPacketLite& operator=(const LpPacketLite& other);
};

}

#endif