delegation-list.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2013-2019 Regents of the University of California.
 *
 * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
 *
 * ndn-cxx library is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later version.
 *
 * ndn-cxx library is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
 *
 * You should have received copies of the GNU General Public License and GNU Lesser
 * General Public License along with ndn-cxx, e.g., in COPYING.md file.  If not, see
 * <http://www.gnu.org/licenses/>.
 *
 * See AUTHORS.md for complete list of ndn-cxx authors and contributors.
 */
 
#ifndef NDN_DELEGATION_LIST_HPP
#define NDN_DELEGATION_LIST_HPP
 
#include "ndn-cxx/delegation.hpp"
 
#include <initializer_list>
 
namespace ndn {
 
class DelegationList
{
public:
  class Error : public tlv::Error
  {
  public:
    using tlv::Error::Error;
  };
 
  DelegationList();
 
  DelegationList(std::initializer_list<Delegation> dels);
 
  explicit
  DelegationList(const Block& block, bool wantSort = true);
 
  template<encoding::Tag TAG>
  size_t
  wireEncode(EncodingImpl<TAG>& encoder, uint32_t type = tlv::ForwardingHint) const;
 
  void
  wireDecode(const Block& block, bool wantSort = true);
 
  bool
  isSorted() const noexcept
  {
    return m_isSorted;
  }
 
  using const_iterator = std::vector<Delegation>::const_iterator;
 
  const_iterator
  begin() const noexcept
  {
    return m_dels.begin();
  }
 
  const_iterator
  end() const noexcept
  {
    return m_dels.end();
  }
 
  NDN_CXX_NODISCARD bool
  empty() const noexcept
  {
    return m_dels.empty();
  }
 
  size_t
  size() const noexcept
  {
    return m_dels.size();
  }
 
  const Delegation&
  operator[](size_t i) const
  {
    BOOST_ASSERT(i < size());
    return m_dels[i];
  }
 
  const Delegation&
  at(size_t i) const
  {
    return m_dels.at(i);
  }
 
public: // modifiers
  void
  sort();
 
  enum InsertConflictResolution {
    INS_REPLACE,
 
    INS_APPEND,
 
    INS_SKIP
  };
 
  bool
  insert(uint64_t preference, const Name& name,
         InsertConflictResolution onConflict = INS_REPLACE);
 
  bool
  insert(const Delegation& del, InsertConflictResolution onConflict = INS_REPLACE)
  {
    return this->insert(del.preference, del.name, onConflict);
  }
 
  size_t
  erase(uint64_t preference, const Name& name)
  {
    return this->eraseImpl(preference, name);
  }
 
  size_t
  erase(const Delegation& del)
  {
    return this->eraseImpl(del.preference, del.name);
  }
 
  size_t
  erase(const Name& name)
  {
    return this->eraseImpl(nullopt, name);
  }
 
private:
  static bool
  isValidTlvType(uint32_t type);
 
  void
  insertImpl(uint64_t preference, const Name& name);
 
  size_t
  eraseImpl(optional<uint64_t> preference, const Name& name);
 
private: // non-member operators
  // NOTE: the following "hidden friend" operators are available via
  //       argument-dependent lookup only and must be defined inline.
 
  friend bool
  operator==(const DelegationList& lhs, const DelegationList& rhs)
  {
    return lhs.m_dels == rhs.m_dels;
  }
 
  friend bool
  operator!=(const DelegationList& lhs, const DelegationList& rhs)
  {
    return lhs.m_dels != rhs.m_dels;
  }
 
private:
  bool m_isSorted;
 
  std::vector<Delegation> m_dels;
};
 
#ifndef DOXYGEN
extern template size_t
DelegationList::wireEncode<encoding::EncoderTag>(EncodingBuffer&, uint32_t) const;
 
extern template size_t
DelegationList::wireEncode<encoding::EstimatorTag>(EncodingEstimator&, uint32_t) const;
#endif
 
std::ostream&
operator<<(std::ostream& os, const DelegationList& dl);
 
} // namespace ndn
 
#endif // NDN_DELEGATION_LIST_HPP