control-parameters.hpp

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

#include "name.hpp"
#include "forwarding-flags.hpp"
#include "encoding/wire-format.hpp"

struct ndn_ControlParameters;

namespace ndn {

class ControlParameters {
public:
  ControlParameters()
  : hasName_(false), faceId_(-1), localControlFeature_(-1), origin_(-1), cost_(-1),
    expirationPeriod_(-1.0)
  {
  }

  Blob
  wireEncode(WireFormat& wireFormat = *WireFormat::getDefaultWireFormat()) const
  {
    return wireFormat.encodeControlParameters(*this);
  }

  void
  wireDecode(const uint8_t *input, size_t inputLength, WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    wireFormat.decodeControlParameters(*this, input, inputLength);
  }

  void
  wireDecode(const std::vector<uint8_t>& input, WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    wireDecode(&input[0], input.size(), wireFormat);
  }

  void
  wireDecode
    (const Blob& input,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    wireDecode(input.buf(), input.size(), wireFormat);
  }

  void
  get(struct ndn_ControlParameters& controlParametersStruct) const;

  bool
  getHasName() const { return hasName_; }

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

  int
  getFaceId() const { return faceId_; }

  const std::string&
  getUri() const { return uri_; }

  int
  getLocalControlFeature() const { return localControlFeature_; }

  int
  getOrigin() const { return origin_; }

  int
  getCost() const { return cost_; }

  ForwardingFlags&
  getForwardingFlags() { return flags_; }

  const ForwardingFlags&
  getForwardingFlags() const { return flags_; }

  Name&
  getStrategy() { return strategy_; }

  const Name&
  getStrategy() const { return strategy_; }

  Milliseconds
  getExpirationPeriod() const { return expirationPeriod_; }

  void
  set(const struct ndn_ControlParameters& controlParametersStruct);

  void
  setHasName(bool hasName) { hasName_ = hasName; }

  ControlParameters&
  setName(const Name& name)
  {
    hasName_ = true;
    name_ = name;
    return *this;
  }

  ControlParameters&
  setFaceId(int faceId)
  {
    faceId_ = faceId;
    return *this;
  }

  ControlParameters&
  setUri(const std::string& uri)
  {
    uri_ = uri;
    return *this;
  }

  ControlParameters&
  setLocalControlFeature(int localControlFeature)
  {
    localControlFeature_ = localControlFeature;
    return *this;
  }

  ControlParameters&
  setOrigin(int origin)
  {
    origin_ = origin;
    return *this;
  }

  ControlParameters&
  setCost(int cost)
  {
    cost_ = cost;
    return *this;
  }

  ControlParameters&
  setForwardingFlags(const ForwardingFlags& flags)
  {
    flags_ = flags;
    return *this;
  }

  ControlParameters&
  setStrategy(const Name& strategy)
  {
    strategy_ = strategy;
    return *this;
  }

  ControlParameters&
  setExpirationPeriod(Milliseconds expirationPeriod)
  {
    expirationPeriod_ = expirationPeriod;
    return *this;
  }

private:
  bool hasName_;
  Name name_;                     
  int faceId_;                    
  std::string uri_;               
  int localControlFeature_;       
  int origin_;                    
  int cost_;                      
  ForwardingFlags flags_;
  Name strategy_;                 
  Milliseconds expirationPeriod_; 
};

}

#endif