Class array_view_strided

src/include/array_view.h:198–327

/// be modified), whereas an array_view_strided<const T> is not mutable.
template <typename T>
class array_view_strided {
public:
    typedef T value_type;
    typedef strided_ptr<T> pointer;
    typedef strided_ptr<const T> const_pointer;
    typedef T& reference;
    typedef const T& const_reference;
    typedef const_pointer const_iterator;
    typedef pointer iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef ptrdiff_t stride_t;
    static const size_type npos = ~size_type(0);
    static const stride_t AutoStride = ~stride_t(0);

    /// Default ctr -- points to nothing
    array_view_strided () : m_data(NULL), m_len(0), m_stride(0) {}

    /// Copy constructor
    array_view_strided (const array_view_strided &copy)
        : m_data(copy.data()), m_len(copy.size()), m_stride(copy.stride()) {}

    /// Construct from T* and length.
    array_view_strided (T *data, size_t len) { init(data,len); }

    /// Construct from T*, length, and stride (in bytes).
    array_view_strided (T *data, size_t len, ptrdiff_t stride) {
        init(data,len,stride);
    }

    /// Construct from a single T&.
    array_view_strided (T &data) { init (&data, 1); }

    /// Construct from a range (begin and end pointers).
    array_view_strided (T *begin, T *end) { init (begin, end-begin); }

    /// Construct from a fixed-length C array.  Template magic automatically
    /// finds the length from the declared type of the array.
    template<size_t N>
    array_view_strided (T (&data)[N]) { init(data,N); }

    /// Construct from std::vector<T>.
    array_view_strided (std::vector<T> &v)
        : m_data(v.size() ? &v[0] : NULL), m_len(v.size()), m_stride(sizeof(T)) {}

    // assignments
    array_view_strided& operator= (const array_view_strided &copy) {
        m_data = copy.data();
        m_len = copy.size();
        m_stride = copy.stride();
        return *this;
    }

    // iterators
    iterator begin() const { return pointer(m_data,m_stride); }
    iterator end() const { return pointer(getptr(m_len),m_stride); }