exclude.hpp

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

#include "name.hpp"
#include "lite/exclude-lite.hpp"

namespace ndn {

class Exclude {
public:
  Exclude()
  : changeCount_(0)
  {
  }

  class Entry {
  public:
    Entry()
    : type_(ndn_Exclude_ANY)
    {
    }

    Entry(const uint8_t *component, size_t componentLen)
    : type_(ndn_Exclude_COMPONENT), component_(component, componentLen)
    {
    }

    Entry(const Name::Component& component)
    : type_(ndn_Exclude_COMPONENT), component_(component)
    {
    }

    ndn_ExcludeType
    getType() const { return type_; }

    const Name::Component&
    getComponent() const { return component_; }

  private:
    ndn_ExcludeType type_;
    Name::Component component_; 
  };

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

  const Exclude::Entry&
  get(size_t i) const { return entries_[i]; }

  size_t
  DEPRECATED_IN_NDN_CPP getEntryCount() const { return entries_.size(); }

  const Exclude::Entry&
  DEPRECATED_IN_NDN_CPP getEntry(size_t i) const { return entries_[i]; }

  void
  get(ExcludeLite& excludeLite) const;

  void
  set(const ExcludeLite& excludeLite);

  Exclude&
  appendAny()
  {
    entries_.push_back(Entry());
    ++changeCount_;
    return *this;
  }

  Exclude&
  appendComponent(const uint8_t *component, size_t componentLength)
  {
    entries_.push_back(Entry(component, componentLength));
    ++changeCount_;
    return *this;
  }

  Exclude&
  appendComponent(const Name::Component &component)
  {
    entries_.push_back(Entry(component));
    ++changeCount_;
    return *this;
  }

  Exclude&
  DEPRECATED_IN_NDN_CPP addAny() { return appendAny(); }

  Exclude&
  DEPRECATED_IN_NDN_CPP addComponent(uint8_t *component, size_t componentLength)
  {
    return appendComponent(component, componentLength);
  }

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

  bool
  matches(const Name::Component& component) const;

  std::string
  toUri() const;

  const Exclude::Entry&
  operator [] (int i) const
  {
    return get(i);
  }

  uint64_t
  getChangeCount() const { return changeCount_; }

private:
  std::vector<Entry> entries_;
  uint64_t changeCount_;
};

}

#endif