xaccessible.hpp

/***************************************************************************
 * Copyright (c) Johan Mabille, Sylvain Corlay and Wolf Vollprecht          *
 * Copyright (c) QuantStack                                                 *
 *                                                                          *
 * Distributed under the terms of the BSD 3-Clause License.                 *
 *                                                                          *
 * The full license is in the file LICENSE, distributed with this software. *
 ****************************************************************************/
 
#ifndef XTENSOR_ACCESSIBLE_HPP
#define XTENSOR_ACCESSIBLE_HPP
 
#include "../core/xstrides.hpp"
#include "../core/xtensor_forward.hpp"
#include "../utils/xexception.hpp"
 
namespace xt
{
    template <class D>
    class xconst_accessible
    {
    public:
 
        using derived_type = D;
        using inner_types = xcontainer_inner_types<D>;
        using reference = typename inner_types::reference;
        using const_reference = typename inner_types::const_reference;
        using size_type = typename inner_types::size_type;
 
        size_type size() const noexcept(noexcept(derived_cast().shape()));
        size_type dimension() const noexcept;
        size_type shape(size_type index) const;
 
        template <class... Args>
        const_reference at(Args... args) const;
 
        template <class S>
        disable_integral_t<S, const_reference> operator[](const S& index) const;
        template <class I>
        const_reference operator[](std::initializer_list<I> index) const;
        const_reference operator[](size_type i) const;
 
        template <class... Args>
        const_reference periodic(Args... args) const;
 
        template <class... Args>
        bool in_bounds(Args... args) const;
 
        const_reference front() const;
        const_reference back() const;
 
    protected:
 
        xconst_accessible() = default;
        ~xconst_accessible() = default;
 
        xconst_accessible(const xconst_accessible&) = default;
        xconst_accessible& operator=(const xconst_accessible&) = default;
 
        xconst_accessible(xconst_accessible&&) = default;
        xconst_accessible& operator=(xconst_accessible&&) = default;
 
    private:
 
        const derived_type& derived_cast() const noexcept;
    };

    template <class D>
    class xaccessible : public xconst_accessible<D>
    {
    public:
 
        using base_type = xconst_accessible<D>;
        using derived_type = typename base_type::derived_type;
        using reference = typename base_type::reference;
        using size_type = typename base_type::size_type;
 
        template <class... Args>
        reference at(Args... args);
 
        template <class S>
        disable_integral_t<S, reference> operator[](const S& index);
        template <class I>
        reference operator[](std::initializer_list<I> index);
        reference operator[](size_type i);
 
        template <class... Args>
        reference periodic(Args... args);
 
        reference front();
        reference back();
 
        using base_type::at;
        using base_type::operator[];
        using base_type::back;
        using base_type::front;
        using base_type::periodic;
 
    protected:
 
        xaccessible() = default;
        ~xaccessible() = default;
 
        xaccessible(const xaccessible&) = default;
        xaccessible& operator=(const xaccessible&) = default;
 
        xaccessible(xaccessible&&) = default;
        xaccessible& operator=(xaccessible&&) = default;
 
    private:
 
        derived_type& derived_cast() noexcept;
    };
 
    /************************************
     * xconst_accessible implementation *
     ************************************/

    template <class D>
    inline auto xconst_accessible<D>::size() const noexcept(noexcept(derived_cast().shape())) -> size_type
    {
        return compute_size(derived_cast().shape());
    }

    template <class D>
    inline auto xconst_accessible<D>::dimension() const noexcept -> size_type
    {
        return derived_cast().shape().size();
    }

    template <class D>
    inline auto xconst_accessible<D>::shape(size_type index) const -> size_type
    {
        return derived_cast().shape()[index];
    }

    template <class D>
    template <class... Args>
    inline auto xconst_accessible<D>::at(Args... args) const -> const_reference
    {
        check_access(derived_cast().shape(), args...);
        return derived_cast().operator()(args...);
    }

    template <class D>
    template <class S>
    inline auto xconst_accessible<D>::operator[](const S& index) const
        -> disable_integral_t<S, const_reference>
    {
        return derived_cast().element(index.cbegin(), index.cend());
    }
 
    template <class D>
    template <class I>
    inline auto xconst_accessible<D>::operator[](std::initializer_list<I> index) const -> const_reference
    {
        return derived_cast().element(index.begin(), index.end());
    }
 
    template <class D>
    inline auto xconst_accessible<D>::operator[](size_type i) const -> const_reference
    {
        return derived_cast().operator()(i);
    }

    template <class D>
    template <class... Args>
    inline auto xconst_accessible<D>::periodic(Args... args) const -> const_reference
    {
        normalize_periodic(derived_cast().shape(), args...);
        return derived_cast()(static_cast<size_type>(args)...);
    }

    template <class D>
    inline auto xconst_accessible<D>::front() const -> const_reference
    {
        return *derived_cast().begin();
    }

    template <class D>
    inline auto xconst_accessible<D>::back() const -> const_reference
    {
        return *std::prev(derived_cast().end());
    }

    template <class D>
    template <class... Args>
    inline bool xconst_accessible<D>::in_bounds(Args... args) const
    {
        return check_in_bounds(derived_cast().shape(), args...);
    }
 
    template <class D>
    inline auto xconst_accessible<D>::derived_cast() const noexcept -> const derived_type&
    {
        return *static_cast<const derived_type*>(this);
    }
 
    /******************************
     * xaccessible implementation *
     ******************************/

    template <class D>
    template <class... Args>
    inline auto xaccessible<D>::at(Args... args) -> reference
    {
        check_access(derived_cast().shape(), args...);
        return derived_cast().operator()(args...);
    }

    template <class D>
    template <class S>
    inline auto xaccessible<D>::operator[](const S& index) -> disable_integral_t<S, reference>
    {
        return derived_cast().element(index.cbegin(), index.cend());
    }
 
    template <class D>
    template <class I>
    inline auto xaccessible<D>::operator[](std::initializer_list<I> index) -> reference
    {
        return derived_cast().element(index.begin(), index.end());
    }
 
    template <class D>
    inline auto xaccessible<D>::operator[](size_type i) -> reference
    {
        return derived_cast().operator()(i);
    }

    template <class D>
    template <class... Args>
    inline auto xaccessible<D>::periodic(Args... args) -> reference
    {
        normalize_periodic(derived_cast().shape(), args...);
        return derived_cast()(args...);
    }

    template <class D>
    inline auto xaccessible<D>::front() -> reference
    {
        return *derived_cast().begin();
    }

    template <class D>
    inline auto xaccessible<D>::back() -> reference
    {
        return *std::prev(derived_cast().end());
    }
 
    template <class D>
    inline auto xaccessible<D>::derived_cast() noexcept -> derived_type&
    {
        return *static_cast<derived_type*>(this);
    }
 
}
 
#endif