NativeArrayView.h

/*
 * (C) Copyright 2013 ECMWF.
 *
 * This software is licensed under the terms of the Apache Licence Version 2.0
 * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
 * In applying this licence, ECMWF does not waive the privileges and immunities
 * granted to it by virtue of its status as an intergovernmental organisation
 * nor does it submit to any jurisdiction.
 */


#pragma once

#include <array>
#include <cstddef>
#include <initializer_list>
#include <iostream>
#include <type_traits>

#include "atlas/array/ArrayUtil.h"
#include "atlas/array/ArrayViewDefs.h"
#include "atlas/array/LocalView.h"
#include "atlas/array/Range.h"
#include "atlas/array/helpers/ArraySlicer.h"
#include "atlas/library/config.h"

//------------------------------------------------------------------------------------------------------

namespace atlas {
namespace array {

//------------------------------------------------------------------------------------------------------


template <typename Value, int Rank>
class ArrayView {
    template <typename T>
    using is_non_const_value_type = typename std::is_same<T, typename std::remove_const<Value>::type>;

#define ENABLE_IF_NON_CONST                                                                               \
    template <bool EnableBool                                                                     = true, \
              typename std::enable_if<( !std::is_const<Value>::value && EnableBool ), int>::type* = nullptr>

#define ENABLE_IF_CONST_WITH_NON_CONST( T )                                                                 \
    template <typename T,                                                                                   \
              typename std::enable_if<( std::is_const<Value>::value && is_non_const_value_type<T>::value ), \
                                      int>::type* = nullptr>

public:
    // -- Type definitions
    using value_type                   = Value;
    using non_const_value_type         = typename std::remove_const<Value>::type;
    static constexpr bool is_const     = std::is_const<Value>::value;
    static constexpr bool is_non_const = !std::is_const<Value>::value;
    static constexpr int RANK{Rank};

private:
    using slicer_t       = typename helpers::ArraySlicer<ArrayView<Value, Rank>>;
    using const_slicer_t = typename helpers::ArraySlicer<const ArrayView<const Value, Rank>>;

    template <typename... Args>
    struct slice_t {
        using type = typename slicer_t::template Slice<Args...>::type;
    };

    template <typename... Args>
    struct const_slice_t {
        using type = typename const_slicer_t::template Slice<Args...>::type;
    };

public:
    // -- Constructors

    ArrayView( const ArrayView& other ) :
        data_( other.data_ ), size_( other.size_ ), shape_( other.shape_ ), strides_( other.strides_ ) {}

    ENABLE_IF_CONST_WITH_NON_CONST( value_type )
    ArrayView( const ArrayView<value_type, Rank>& other ) : data_( other.data() ), size_( other.size() ) {
        for ( idx_t j = 0; j < Rank; ++j ) {
            shape_[j]   = other.shape( j );
            strides_[j] = other.stride( j );
        }
    }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    // This constructor should not be used directly, but only through a array::make_view() function.
    ArrayView( value_type* data, const ArrayShape& shape, const ArrayStrides& strides ) : data_( data ) {
        size_ = 1;
        for ( int j = 0; j < Rank; ++j ) {
            shape_[j]   = shape[j];
            strides_[j] = strides[j];
            size_ *= size_t( shape_[j] );
        }
    }
#endif

    ENABLE_IF_CONST_WITH_NON_CONST( value_type )
    operator const ArrayView<value_type, Rank>&() const { return *(const ArrayView<value_type, Rank>*)( this ); }


    // -- Access methods

    template <typename... Idx>
    value_type& operator()( Idx... idx ) {
        check_bounds( idx... );
        return data_[index( idx... )];
    }

    template <typename... Ints>
    const value_type& operator()( Ints... idx ) const {
        return data_[index( idx... )];
    }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    template <typename Int, bool EnableBool = true>
    typename std::enable_if<( Rank == 1 && EnableBool ), const value_type&>::type operator[]( Int idx ) const {
#else
    // Doxygen API is cleaner!
    template <typename Int>
    value_type operator[]( Int idx ) const {
#endif
        check_bounds( idx );
        return data_[idx * strides_[0]];
    }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    template <typename Int, bool EnableBool = true>
    typename std::enable_if<( Rank == 1 && EnableBool ), value_type&>::type operator[]( Int idx ) {
#else
    // Doxygen API is cleaner!
    template <typename Int>
    value_type operator[]( Int idx ) {
#endif
        check_bounds( idx );
        return data_[idx * strides_[0]];
    }

    template <unsigned int Dim>
    idx_t shape() const {
        return shape_[Dim];
    }

    template <unsigned int Dim>
    idx_t stride() const {
        return strides_[Dim];
    }

    size_t size() const { return size_; }

    static constexpr idx_t rank() { return Rank; }

    const idx_t* strides() const { return strides_.data(); }

    const idx_t* shape() const { return shape_.data(); }

    template <typename Int>
    idx_t shape( Int idx ) const {
        return shape_[idx];
    }

    template <typename Int>
    idx_t stride( Int idx ) const {
        return strides_[idx];
    }

    value_type const* data() const { return data_; }

    value_type* data() { return data_; }

    bool valid() const { return true; }

    bool contiguous() const { return ( size_ == size_t( shape_[0] ) * size_t( strides_[0] ) ? true : false ); }

    ENABLE_IF_NON_CONST
    void assign( const value_type& value );

    ENABLE_IF_NON_CONST
    void assign( const std::initializer_list<value_type>& list );

    void dump( std::ostream& os ) const;

    template <typename... Args>
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    typename slice_t<Args...>::type slice( Args... args ) {
#else
    // C++14 will allow auto return type
    auto slice( Args... args ) {
#endif
        return slicer_t( *this ).apply( args... );
    }


    template <typename... Args>
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    typename const_slice_t<Args...>::type slice( Args... args ) const {
#else
    // C++14 will allow auto return type
    auto slice( Args... args ) const {
#endif
        return const_slicer_t( *this ).apply( args... );
    }

private:
    // -- Private methods

    template <int Dim, typename Int, typename... Ints>
    constexpr idx_t index_part( Int idx, Ints... next_idx ) const {
        return idx * strides_[Dim] + index_part<Dim + 1>( next_idx... );
    }

    template <int Dim, typename Int>
    constexpr idx_t index_part( Int last_idx ) const {
        return last_idx * strides_[Dim];
    }

    template <typename... Ints>
    constexpr idx_t index( Ints... idx ) const {
        return index_part<0>( idx... );
    }

#if ATLAS_ARRAYVIEW_BOUNDS_CHECKING
    template <typename... Ints>
    void check_bounds( Ints... idx ) const {
        static_assert( sizeof...( idx ) == Rank, "Expected number of indices is different from rank of array" );
        return check_bounds_part<0>( idx... );
    }
#else
    template <typename... Ints>
    void check_bounds( Ints... idx ) const {
        static_assert( sizeof...( idx ) == Rank, "Expected number of indices is different from rank of array" );
    }
#endif

    template <typename... Ints>
    void check_bounds_force( Ints... idx ) const {
        static_assert( sizeof...( idx ) == Rank, "Expected number of indices is different from rank of array" );
        return check_bounds_part<0>( idx... );
    }

    template <int Dim, typename Int, typename... Ints>
    void check_bounds_part( Int idx, Ints... next_idx ) const {
        if ( idx_t( idx ) >= shape_[Dim] ) {
            throw_OutOfRange( "ArrayView", array_dim<Dim>(), idx, shape_[Dim] );
        }
        check_bounds_part<Dim + 1>( next_idx... );
    }

    template <int Dim, typename Int>
    void check_bounds_part( Int last_idx ) const {
        if ( idx_t( last_idx ) >= shape_[Dim] ) {
            throw_OutOfRange( "ArrayView", array_dim<Dim>(), last_idx, shape_[Dim] );
        }
    }

    // -- Private data

    value_type* data_;
    size_t size_;
    std::array<idx_t, Rank> shape_;
    std::array<idx_t, Rank> strides_;
};

//------------------------------------------------------------------------------------------------------

#undef ENABLE_IF_NON_CONST
#undef ENABLE_IF_CONST_WITH_NON_CONST

}  // namespace array
}  // namespace atlas