decl_block_base.hpp

#pragma once
 
#include <stdexcept>
#include <utility>
 
#include "../../rect.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS

  template <class AccessTrait>
  class BlockBase
  {
    template <class OTHER_ACCESSTRAIT>
    friend class BlockBase;
 
    Size2D<int> size_;    
    AccessTrait access_;  
 
  protected:
    /*
     * \brief Creates a new block.
     *
     * \pre
     * _access_.Valid() == \b true \n
     * \a size not empty
     *
     * \param [in] access Access trait instance.
     * \param [in] size Size in pixels of this block.
     * \throws std::logic_error if this not Valid().
     */
    explicit BlockBase(const AccessTrait &access, Size2D<int> size)
        : size_(std::move(size))
        , access_(access)
    {
      if (!this->Valid())
        throw std::logic_error{"Block is invalid"};
    }
 
    /*
     * \brief Creates a new block.
     *
     * \pre
     * _other_.Valid() == \b true \n
     * \a aoi is inside _other_.Size() and not empty
     *
     * \param [in] other Block to create a new one from.
     * \param [in] aoi Area of interest of this block.
     * \throws std::logic_error if this not Valid().
     * \throws std::length_error if \a aoi is outside _other_'s bounds.
     */
    template <class OTHER_ACCESSTRAIT>
    explicit BlockBase(const BlockBase<OTHER_ACCESSTRAIT> &other, Rect<int> aoi)
        : size_(aoi.Size())
        , access_(other.access_.NewMoved(aoi))
    {
      if (aoi.Left() < 0 || aoi.Right() >= other.Size().Width() || aoi.Top() < 0
          || aoi.Bottom() >= other.Size().Height())
        throw std::length_error{"aoi out of bounds"};
 
      if (!this->Valid())
        throw std::logic_error{"Block is invalid"};
    }
 
    BlockBase(const BlockBase &other) noexcept            = default;
    BlockBase &operator=(const BlockBase &other) noexcept = default;
    BlockBase(BlockBase &&other) noexcept                 = default;
    BlockBase &operator=(BlockBase &&other) noexcept      = default;
    ~BlockBase()                                          = default;
 
  public:
    CVB_FORCE_INLINE const AccessTrait &Access() const noexcept
    {
      return access_;
    }
    CVB_FORCE_INLINE const AccessTrait &Access() const noexcept {…}

    CVB_FORCE_INLINE AccessTrait &Access() noexcept
    {
      return access_;
    }
    CVB_FORCE_INLINE AccessTrait &Access() noexcept {…}

    CVB_FORCE_INLINE size_t Length() const noexcept
    {
      return static_cast<size_t>(size_.Width()) * static_cast<size_t>(size_.Height());
    }
    CVB_FORCE_INLINE size_t Length() const noexcept {…}

    CVB_FORCE_INLINE Size2D<int> Size() const noexcept
    {
      return size_;
    }
    CVB_FORCE_INLINE Size2D<int> Size() const noexcept {…}

    CVB_FORCE_INLINE int Width() const noexcept
    {
      return size_.Width();
    }
    CVB_FORCE_INLINE int Width() const noexcept {…}

    CVB_FORCE_INLINE int Height() const noexcept
    {
      return size_.Height();
    }
    CVB_FORCE_INLINE int Height() const noexcept {…}

    bool Valid() const noexcept
    {
      return size_.Width() > 0 && size_.Height() > 0 && access_.Valid();
    }
    bool Valid() const noexcept {…}
  };
  class BlockBase {…};
 
  CVB_END_INLINE_NS
}  // namespace Cvb