xtensor_forward.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_FORWARD_HPP
#define XTENSOR_FORWARD_HPP
 
// This file contains forward declarations and
// alias types to solve the problem of circular
// includes. It should not contain anything else
// and should not bring additional dependencies to
// the files that include it. So:
// - do NOT define classes of metafunctions here
// - do NOT include other headers
//
// If you need to do so, something is probably
// going wrong (either your change, or xtensor
// needs to be refactored).
 
#include <memory>
#include <vector>
 
#include <xtl/xoptional_sequence.hpp>
 
#include "../core/xlayout.hpp"
#include "../core/xtensor_config.hpp"
 
namespace xt
{
    struct xtensor_expression_tag;
    struct xoptional_expression_tag;
 
    template <class C>
    struct xcontainer_inner_types;
 
    template <class D>
    class xcontainer;
 
    template <class T, class A>
    class uvector;
 
    template <class T, std::size_t N, class A, bool Init>
    class svector;
 
    template <
        class EC,
        layout_type L = XTENSOR_DEFAULT_LAYOUT,
        class SC = XTENSOR_DEFAULT_SHAPE_CONTAINER(typename EC::value_type, typename EC::allocator_type, std::allocator<typename EC::size_type>),
        class Tag = xtensor_expression_tag>
    class xarray_container;

    template <
        class T,
        layout_type L = XTENSOR_DEFAULT_LAYOUT,
        class A = XTENSOR_DEFAULT_ALLOCATOR(T),
        class SA = std::allocator<typename std::vector<T, A>::size_type>>
    using xarray = xarray_container<XTENSOR_DEFAULT_DATA_CONTAINER(T, A), L, XTENSOR_DEFAULT_SHAPE_CONTAINER(T, A, SA)>;
 
    template <
        class EC,
        layout_type L = XTENSOR_DEFAULT_LAYOUT,
        class SC = XTENSOR_DEFAULT_SHAPE_CONTAINER(typename EC::value_type, std::allocator<typename EC::size_type>, std::allocator<typename EC::size_type>),
        class Tag = xtensor_expression_tag>
    class xarray_adaptor;

    template <
        class T,
        layout_type L = XTENSOR_DEFAULT_LAYOUT,
        class A = XTENSOR_DEFAULT_ALLOCATOR(T),
        class BC = xtl::xdynamic_bitset<std::size_t>,
        class SA = std::allocator<typename std::vector<T, A>::size_type>>
    using xarray_optional = xarray_container<
        xtl::xoptional_vector<T, A, BC>,
        L,
        XTENSOR_DEFAULT_SHAPE_CONTAINER(T, A, SA),
        xoptional_expression_tag>;
 
    template <class EC, std::size_t N, layout_type L = XTENSOR_DEFAULT_LAYOUT, class Tag = xtensor_expression_tag>
    class xtensor_container;

    template <class T, std::size_t N, layout_type L = XTENSOR_DEFAULT_LAYOUT, class A = XTENSOR_DEFAULT_ALLOCATOR(T)>
    using xtensor = xtensor_container<XTENSOR_DEFAULT_DATA_CONTAINER(T, A), N, L>;
 
    template <class EC, std::size_t N, layout_type L = XTENSOR_DEFAULT_LAYOUT, class Tag = xtensor_expression_tag>
    class xtensor_adaptor;
 
    template <class EC, std::size_t N, layout_type L = XTENSOR_DEFAULT_LAYOUT, class Tag = xtensor_expression_tag>
    class xtensor_view;
 
    template <std::size_t... N>
    class fixed_shape;

    template <std::size_t... N>
    using xshape = fixed_shape<N...>;
 
    template <class ET, class S, layout_type L = XTENSOR_DEFAULT_LAYOUT, bool Sharable = true, class Tag = xtensor_expression_tag>
    class xfixed_container;
 
    template <class ET, class S, layout_type L = XTENSOR_DEFAULT_LAYOUT, bool Sharable = true, class Tag = xtensor_expression_tag>
    class xfixed_adaptor;

    template <class T, class FSH, layout_type L = XTENSOR_DEFAULT_LAYOUT, bool Sharable = true>
    using xtensor_fixed = xfixed_container<T, FSH, L, Sharable>;

    template <
        class T,
        std::size_t N,
        layout_type L = XTENSOR_DEFAULT_LAYOUT,
        class A = XTENSOR_DEFAULT_ALLOCATOR(T),
        class BC = xtl::xdynamic_bitset<std::size_t>>
    using xtensor_optional = xtensor_container<xtl::xoptional_vector<T, A, BC>, N, L, xoptional_expression_tag>;
 
    template <class CT, class... S>
    class xview;
 
    template <class F, class... CT>
    class xfunction;
}
 
#endif