block.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2013-2022 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.
 *
 * @author Alexander Afanasyev <http://lasr.cs.ucla.edu/afanasyev/index.html>
 */

#ifndef NDN_CXX_ENCODING_BLOCK_HPP
#define NDN_CXX_ENCODING_BLOCK_HPP

#include "ndn-cxx/encoding/buffer.hpp"
#include "ndn-cxx/encoding/encoding-buffer-fwd.hpp"
#include "ndn-cxx/encoding/tlv.hpp"
#include "ndn-cxx/util/span.hpp"

namespace boost {
namespace asio {
class const_buffer;
} // namespace asio
} // namespace boost

namespace ndn {

class Block
{
public:
  using value_type             = Buffer::value_type;
  using const_iterator         = Buffer::const_iterator;
  using element_container      = std::vector<Block>;
  using element_iterator       = element_container::iterator;
  using element_const_iterator = element_container::const_iterator;

  class Error : public tlv::Error
  {
  public:
    using tlv::Error::Error;
  };

public: // construction, assignment
  Block();

  Block(const Block&);

  Block&
  operator=(const Block&);

  Block(Block&&) noexcept;

  Block&
  operator=(Block&&) noexcept;

  explicit
  Block(span<const uint8_t> buffer);

  explicit
  Block(const EncodingBuffer& buffer);

  explicit
  Block(const ConstBufferPtr& buffer);

  Block(ConstBufferPtr buffer, Buffer::const_iterator begin, Buffer::const_iterator end,
        bool verifyLength = true);

  Block(const Block& block, Block::const_iterator begin, Block::const_iterator end,
        bool verifyLength = true);

  Block(ConstBufferPtr buffer, uint32_t type,
        Buffer::const_iterator begin, Buffer::const_iterator end,
        Buffer::const_iterator valueBegin, Buffer::const_iterator valueEnd);

  explicit
  Block(uint32_t type);

  Block(uint32_t type, ConstBufferPtr value);

  Block(uint32_t type, const Block& value);

  NDN_CXX_NODISCARD static std::tuple<bool, Block>
  fromBuffer(ConstBufferPtr buffer, size_t offset = 0);

  NDN_CXX_NODISCARD static std::tuple<bool, Block>
  fromBuffer(span<const uint8_t> buffer);

  static Block
  fromStream(std::istream& is);

public: // wire format
  bool
  isValid() const noexcept
  {
    return m_type != tlv::Invalid;
  }

  void
  reset() noexcept;

  void
  resetWire() noexcept;

  bool
  hasWire() const noexcept
  {
    return m_buffer != nullptr && m_begin != m_end;
  }

  const_iterator
  begin() const;

  const_iterator
  end() const;

  const uint8_t*
  data() const;

  const uint8_t*
  wire() const
  {
    return data();
  }

  size_t
  size() const;

  ConstBufferPtr
  getBuffer() const
  {
    return m_buffer;
  }

public: // type and value
  uint32_t
  type() const noexcept
  {
    return m_type;
  }

  bool
  hasValue() const noexcept
  {
    return m_buffer != nullptr;
  }

  const_iterator
  value_begin() const noexcept
  {
    return m_valueBegin;
  }

  const_iterator
  value_end() const noexcept
  {
    return m_valueEnd;
  }

  size_t
  value_size() const noexcept
  {
    return hasValue() ? static_cast<size_t>(m_valueEnd - m_valueBegin) : 0;
  }

  span<const uint8_t>
  value_bytes() const noexcept
  {
    if (hasValue())
      return {m_valueBegin, m_valueEnd};
    else
      return {};
  }

  const uint8_t*
  value() const noexcept;

  Block
  blockFromValue() const;

public: // sub-elements
  void
  parse() const;

  void
  encode();

  const Block&
  get(uint32_t type) const;

  element_const_iterator
  find(uint32_t type) const;

  void
  remove(uint32_t type);

  element_iterator
  erase(element_const_iterator position);

  element_iterator
  erase(element_const_iterator first, element_const_iterator last);

  void
  push_back(const Block& element);

  void
  push_back(Block&& element);

  element_iterator
  insert(element_const_iterator pos, const Block& element);

  const element_container&
  elements() const
  {
    return m_elements;
  }

  element_const_iterator
  elements_begin() const
  {
    return m_elements.begin();
  }

  element_const_iterator
  elements_end() const
  {
    return m_elements.end();
  }

  size_t
  elements_size() const
  {
    return m_elements.size();
  }

public: // misc
  operator boost::asio::const_buffer() const;

private:
  size_t
  encode(EncodingEstimator& estimator) const;

  size_t
  encodeValue(EncodingEstimator& estimator) const;

  size_t
  encode(EncodingBuffer& encoder);

protected:
  shared_ptr<const Buffer> m_buffer;
  Buffer::const_iterator m_begin; 
  Buffer::const_iterator m_end; 

  Buffer::const_iterator m_valueBegin; 
  Buffer::const_iterator m_valueEnd; 

  uint32_t m_type = tlv::Invalid; 

  size_t m_size = 0;

  mutable element_container m_elements;

  friend std::ostream&
  operator<<(std::ostream& os, const Block& block);
};

inline
Block::Block(Block&&) noexcept = default;

inline Block&
Block::operator=(Block&&) noexcept = default;

bool
operator==(const Block& lhs, const Block& rhs);

inline bool
operator!=(const Block& lhs, const Block& rhs)
{
  return !(lhs == rhs);
}

Block
operator ""_block(const char* input, std::size_t len);

} // namespace ndn

#endif // NDN_CXX_ENCODING_BLOCK_HPP