Span.h

 
#ifndef MFRAME_C222A481_2EF7_4AD5_8C4E_DF6A3BF277C3
#define MFRAME_C222A481_2EF7_4AD5_8C4E_DF6A3BF277C3
 
/* ***************************************************************************************
 * Include
 */
 
//----------------------------------------------------------------------------------------
#include "./../lang/Iterable.h"
#include "./../lang/Object.h"
#include "./../util/Iterator.h"
 
//----------------------------------------------------------------------------------------
 
/* ***************************************************************************************
 * Namespace
 */
namespace ufm::util {
  template <typename T>
  class Span;
}  // namespace ufm::util
 
/* ***************************************************************************************
 * Class/Interface/Struct/Enum
 */
 
template <typename T>
class ufm::util::Span : public ufm::lang::Object, public ufm::lang::Iterable<T> {
  /* *************************************************************************************
   * Variable
   */
 private:
  T const* vData;
 
  const size_t vSize;
 
  /* *************************************************************************************
   * Abstract Method
   */
 
  /* *************************************************************************************
   * Construct Method
   */
 public:
  Span(T const* data, size_t size) noexcept : vData(data), vSize(size) {
    return;
  }
 
  template <size_t N>
  Span(T const (&data)[N]) noexcept : vData(data), vSize(N) {
    return;
  }
 
  virtual ~Span(void) override {
    return;
  }
 
  /* *************************************************************************************
   * Operator Method
   */
 public:
  Span(const Span& other) noexcept = default;
 
  Span& operator=(const Span& other) noexcept = default;
 
  Span(Span&& other) noexcept = default;
 
  Span& operator=(Span&& other) noexcept = default;
 
  /* *************************************************************************************
   * Override - ufm::lang::Iterable<T*>
   */
 public:
  virtual void forEach(ufm::func::Consumer<T&>& action) override {
    for (size_t i = 0; i < this->vSize; ++i) {
      action.accept(const_cast<T&>(this->vData[i]));
    }
    return;
  }
 
  virtual T* elementAt(int index) const override {
    if (index < 0 || index >= static_cast<int>(this->vSize)) { return nullptr; }
    return const_cast<T*>(&this->vData[index]);
  }
 
  virtual int nextIndex(int index) const override {
    if (index < -1 || index > static_cast<int>(this->vSize)) return -1;
 
    return index + 1;
  }
 
  virtual ufm::util::Iterator<T> begin(void) override {
    return ufm::util::Iterator<T>(*this, 0);
  }
 
  virtual ufm::util::Iterator<T> end(void) override {
    return ufm::util::Iterator<T>(*this, static_cast<int>(this->vSize));
  }
 
  /* *************************************************************************************
   * Public Method
   */
 public:
  size_t size(void) const noexcept {
    return this->vSize;
  }
 
  bool empty(void) const noexcept {
    return this->vSize == 0;
  }
 
  T const* data(void) const noexcept {
    return this->vData;
  }
 
  T const& operator[](size_t index) const noexcept {
    return this->vData[index];
  }
 
  /* *************************************************************************************
   * Protected Method
   */
 
  /* *************************************************************************************
   * Private Method
   */
 
  /* *************************************************************************************
   * Static Variable
   */
 
  /* *************************************************************************************
   * Static Method
   */
};
 
/* ***************************************************************************************
 * End of file
 */
 
#endif /* MFRAME_C222A481_2EF7_4AD5_8C4E_DF6A3BF277C3 */