array1.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_ARRAY1_H_
#define INCLUDE_JET_ARRAY1_H_
 
#include <jet/array.h>
#include <jet/array_accessor1.h>
 
#include <fstream>
#include <functional>
#include <iostream>
#include <utility>  // just make cpplint happy..
#include <vector>
 
namespace jet {
 
template <typename T>
class Array<T, 1> final {
 public:
    typedef std::vector<T> ContainerType;
    typedef typename ContainerType::iterator Iterator;
    typedef typename ContainerType::const_iterator ConstIterator;
 
    Array();
 
    explicit Array(size_t size, const T& initVal = T());
 
    Array(const 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<T>& lst);
 
    void clear();
 
    void resize(size_t size, const T& initVal = T());
 
    T& at(size_t i);
 
    const T& at(size_t i) const;
 
    size_t size() const;
 
    T* data();
 
    const T* const data() const;
 
    Iterator begin();
 
    ConstIterator begin() const;
 
    Iterator end();
 
    ConstIterator end() const;
 
    ArrayAccessor1<T> accessor();
 
    ConstArrayAccessor1<T> constAccessor() const;
 
    void swap(Array& other);
 
    void append(const T& newVal);
 
    void append(const 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;
 
    Array& operator=(const T& other);
 
    Array& operator=(const Array& other);
 
    Array& operator=(Array&& other);
 
    Array& operator=(const std::initializer_list<T>& lst);
 
    operator ArrayAccessor1<T>();
 
    operator ConstArrayAccessor1<T>() const;
 
 private:
    ContainerType _data;
};
 
template <typename T>
using Array1 = Array<T, 1>;
 
}  // namespace jet
 
#include "detail/array1-inl.h"
 
#endif  // INCLUDE_JET_ARRAY1_H_