array2.h

Go to the documentation of this file.

// Copyright (c) 2018 Doyub Kim
//
// I am making my contributions/submissions to this project solely in my
// personal capacity and am not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef INCLUDE_JET_ARRAY2_H_
#define INCLUDE_JET_ARRAY2_H_
 
#include <jet/array.h>
#include <jet/array_accessor2.h>
#include <jet/size2.h>
 
#include <fstream>
#include <functional>
#include <iostream>
#include <utility>  // just make cpplint happy..
#include <vector>
 
namespace jet {
 
template <typename T>
class Array<T, 2> final {
 public:
    typedef std::vector<T> ContainerType;
    typedef typename ContainerType::iterator Iterator;
    typedef typename ContainerType::const_iterator ConstIterator;
 
    Array();
 
    explicit Array(const Size2& size, const T& initVal = T());
 
    Array(size_t width, size_t height, const T& initVal = T());
 
    Array(const std::initializer_list<std::initializer_list<T>>& lst);
 
    Array(const Array& other);
 
    Array(Array&& other);
 
    void set(const T& value);
 
    void set(const Array& other);
 
    void set(const std::initializer_list<std::initializer_list<T>>& lst);
 
    void clear();
 
    void resize(const Size2& size, const T& initVal = T());
 
    void resize(size_t width, size_t height, const T& initVal = T());
 
    T& at(size_t i);
 
    const T& at(size_t i) const;
 
    T& at(const Point2UI& pt);
 
    const T& at(const Point2UI& pt) const;
 
    T& at(size_t i, size_t j);
 
    const T& at(size_t i, size_t j) const;
 
    Size2 size() const;
 
    size_t width() const;
 
    size_t height() const;
 
    T* data();
 
    const T* const data() const;
 
    Iterator begin();
 
    ConstIterator begin() const;
 
    Iterator end();
 
    ConstIterator end() const;
 
    ArrayAccessor2<T> accessor();
 
    ConstArrayAccessor2<T> constAccessor() const;
 
    void swap(Array& other);
 
    template <typename Callback>
    void forEach(Callback func) const;
 
    template <typename Callback>
    void forEachIndex(Callback func) const;
 
    template <typename Callback>
    void parallelForEach(Callback func);
 
    template <typename Callback>
    void parallelForEachIndex(Callback func) const;
 
    T& operator[](size_t i);
 
    const T& operator[](size_t i) const;
 
    T& operator()(const Point2UI& pt);
 
    const T& operator()(const Point2UI& pt) const;
 
    T& operator()(size_t i, size_t j);
 
    const T& operator()(size_t i, size_t j) const;
 
    Array& operator=(const T& other);
 
    Array& operator=(const Array& other);
 
    Array& operator=(Array&& other);
 
    Array& operator=(
        const std::initializer_list<std::initializer_list<T>>& lst);
 
    operator ArrayAccessor2<T>();
 
    operator ConstArrayAccessor2<T>() const;
 
 private:
    Size2 _size;
    std::vector<T> _data;
};
 
template <typename T>
using Array2 = Array<T, 2>;
 
}  // namespace jet
 
#include "detail/array2-inl.h"
 
#endif  // INCLUDE_JET_ARRAY2_H_