delegation-set.hpp

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

#include "name.hpp"
#include "lite/delegation-set-lite.hpp"

namespace ndn {

class DelegationSet {
public:
  DelegationSet()
  : changeCount_(0), getDefaultWireEncodingChangeCount_(0)
  {
  }

  DelegationSet(const DelegationSet& delegationSet)
  // A DelegationSet::Delegation is immutable, so just make a shallow copy.
  : delegations_(delegationSet.delegations_),
    changeCount_(delegationSet.changeCount_)
  {
    setDefaultWireEncoding
      (delegationSet.getDefaultWireEncoding(),
       delegationSet.defaultWireEncodingFormat_);
  }

  DelegationSet& operator=(const DelegationSet& delegationSet);

  class Delegation {
  public:
    Delegation(int preference, const Name& name)
    : preference_(preference), name_(name)
    {
    }

    Delegation(const DelegationSetLite::Delegation& delegationLite);

    int
    getPreference() const { return preference_; }

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

    int
    compare(const Delegation& other);

    void
    get(DelegationSetLite::Delegation& delegationLite) const;

  private:
    int preference_;
    Name name_;
  };

  void
  add(int preference, const Name& name);

  void
  addUnsorted(const ptr_lib::shared_ptr<Delegation>& delegation)
  {
    delegations_.push_back(delegation);
    ++changeCount_;
  }

  bool
  remove(const Name& name);

  void
  clear()
  {
    delegations_.clear();
    ++changeCount_;
  }

  size_t
  size() const { return delegations_.size(); }

  const Delegation&
  get(size_t i) const;

  int
  find(const Name& name) const;

  Blob
  wireEncode
    (WireFormat& wireFormat = *WireFormat::getDefaultWireFormat()) const;

  void
  wireDecode
    (const uint8_t *input, size_t inputLength,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat());

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

  const Blob&
  getDefaultWireEncoding() const
  {
    if (getDefaultWireEncodingChangeCount_ != getChangeCount()) {
      // The values have changed, so the default wire encoding is invalidated.
      // This method can be called on a const object, but we want to be able to
      // update the default cached value.
      const_cast<DelegationSet*>(this)->defaultWireEncoding_ = Blob();
      const_cast<DelegationSet*>(this)->defaultWireEncodingFormat_ = 0;
      const_cast<DelegationSet*>(this)->getDefaultWireEncodingChangeCount_ =
        getChangeCount();
    }

    return defaultWireEncoding_;
  }

  WireFormat*
  getDefaultWireEncodingFormat() const { return defaultWireEncodingFormat_; }

  uint64_t
  getChangeCount() const { return changeCount_; }

private:
  void
  setDefaultWireEncoding
    (const Blob& defaultWireEncoding, WireFormat *defaultWireEncodingFormat)
  {
    defaultWireEncoding_ = defaultWireEncoding;
    defaultWireEncodingFormat_ = defaultWireEncodingFormat;
    // Set getDefaultWireEncodingChangeCount_ so that the next call to
    //   getDefaultWireEncoding() won't clear defaultWireEncoding_.
    getDefaultWireEncodingChangeCount_ = getChangeCount();
  }

  std::vector<ptr_lib::shared_ptr<Delegation> > delegations_;
  Blob defaultWireEncoding_;
  WireFormat *defaultWireEncodingFormat_;
  uint64_t getDefaultWireEncodingChangeCount_;
  uint64_t changeCount_;
};

}

#endif