Span2.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2023 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Span2.h                                                     (C) 2000-2023 */
/*                                                                           */
/* Vue d'un tableau 2D dont les dimensions utilisent des Int64.              */
/*---------------------------------------------------------------------------*/
#ifndef ARCCORE_BASE_SPAN2_H
#define ARCCORE_BASE_SPAN2_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arccore/base/BaseTypes.h"
#include "arccore/base/TraceInfo.h"
#include "arccore/base/Array2View.h"
 
#include <type_traits>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arccore
{
 
namespace detail
{
// Pour indiquer que Span2<T>::view() retourne un Array2View
// et Span2<const T>::view() retourne un ConstArray2View.
template<typename T>
class View2TypeT
{
 public:
  using view_type = Array2View<T>;
};
template<typename T>
class View2TypeT<const T>
{
 public:
  using view_type = ConstArray2View<T>;
};
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename T,typename SizeType,SizeType Extent1,SizeType Extent2>
class Span2Impl
{
  using ThatClass = Span2Impl<T,SizeType,Extent1,Extent2>;
 
 public:
 
  using ElementType = T;
  using element_type = ElementType;
  using value_type = typename std::remove_cv<ElementType>::type;
  using index_type = SizeType;
  using difference_type = SizeType;
  using size_type = SizeType;
  using pointer = ElementType*;
  using const_pointer = typename std::add_const<ElementType*>::type;
  using reference = ElementType&;
  using const_reference = const ElementType&;
  using view_type = typename detail::View2TypeT<ElementType>::view_type;
 
  template<typename X>
  using is_same_const_type = std::enable_if_t<std::is_same_v<X,T> || std::is_same_v<std::add_const_t<X>,T>>;
 
 public:
 
  ARCCORE_HOST_DEVICE Span2Impl(pointer ptr,SizeType dim1_size,SizeType dim2_size)
  : m_ptr(ptr), m_dim1_size(dim1_size), m_dim2_size(dim2_size) {}
  ARCCORE_HOST_DEVICE Span2Impl() : m_ptr(nullptr), m_dim1_size(0), m_dim2_size(0) {}
  // Constructeur à partir d'un ConstArrayView. Cela n'est autorisé que
  // si T est const.
  template<typename X,typename = std::enable_if_t<std::is_same_v<X,value_type>> >
  Span2Impl(const ConstArray2View<X>& from)
  : m_ptr(from.data()), m_dim1_size(from.dim1Size()),m_dim2_size(from.dim2Size()) {}
  // Pour un Span<const T>, on a le droit de construire depuis un Span<T>
  template<typename X,typename = std::enable_if_t<std::is_same_v<X,value_type>> >
  ARCCORE_HOST_DEVICE Span2Impl(const Span2<X>& from)
  : m_ptr(from.data()), m_dim1_size(from.dim1Size()),m_dim2_size(from.dim2Size()) {}
 
 public:
 
  constexpr ARCCORE_HOST_DEVICE SizeType dim1Size() const { return m_dim1_size; }
  constexpr ARCCORE_HOST_DEVICE SizeType dim2Size() const { return m_dim2_size; }
  constexpr ARCCORE_HOST_DEVICE SizeType totalNbElement() const { return m_dim1_size*m_dim2_size; }
 
 public:
 
  constexpr ARCCORE_HOST_DEVICE SpanImpl<ElementType,SizeType> operator[](SizeType i) const
  {
    ARCCORE_CHECK_AT(i,m_dim1_size);
    return SpanImpl<ElementType,SizeType>(m_ptr + (m_dim2_size*i),m_dim2_size);
  }
 
  constexpr ARCCORE_HOST_DEVICE SpanImpl<ElementType,SizeType> operator()(SizeType i) const
  {
    ARCCORE_CHECK_AT(i,m_dim1_size);
    return SpanImpl<ElementType,SizeType>(m_ptr + (m_dim2_size*i),m_dim2_size);
  }
 
  constexpr ARCCORE_HOST_DEVICE reference operator()(SizeType i,SizeType j) const
  {
    ARCCORE_CHECK_AT2(i,j,m_dim1_size,m_dim2_size);
    return m_ptr[(m_dim2_size*i) + j];
  }
 
#ifdef ARCCORE_HAS_MULTI_SUBSCRIPT
  constexpr ARCCORE_HOST_DEVICE reference operator[](SizeType i,SizeType j) const
  {
    ARCCORE_CHECK_AT2(i,j,m_dim1_size,m_dim2_size);
    return m_ptr[(m_dim2_size*i) + j];
  }
#endif
 
  constexpr ARCCORE_HOST_DEVICE ElementType item(SizeType i,SizeType j) const
  {
    ARCCORE_CHECK_AT2(i,j,m_dim1_size,m_dim2_size);
    return m_ptr[(m_dim2_size*i) + j];
  }
 
  constexpr ARCCORE_HOST_DEVICE ElementType setItem(SizeType i,SizeType j,const ElementType& value)
  {
    ARCCORE_CHECK_AT2(i,j,m_dim1_size,m_dim2_size);
    m_ptr[(m_dim2_size*i) + j] = value;
  }
 
 public:
 
  constexpr view_type smallView()
  {
    Integer s1 = arccoreCheckArraySize(m_dim1_size);
    Integer s2 = arccoreCheckArraySize(m_dim2_size);
    return view_type(m_ptr,s1,s2);
  }
 
  constexpr ConstArrayView<value_type> constSmallView() const
  {
    Integer s1 = arccoreCheckArraySize(m_dim1_size);
    Integer s2 = arccoreCheckArraySize(m_dim2_size);
    return ConstArrayView<value_type>(m_ptr,s1,s2);
  }
 
 public:
 
  constexpr ElementType* unguardedBasePointer() { return m_ptr; }
 
  constexpr ARCCORE_HOST_DEVICE ElementType* data() { return m_ptr; }
 
  constexpr ARCCORE_HOST_DEVICE const ElementType* data() const { return m_ptr; }
 
 public:
 
  template<typename X,SizeType XExtent1,SizeType XExtent2, typename = std::enable_if_t<std::is_same_v<X,value_type>>>
  friend bool operator==(const ThatClass& lhs, const Span2Impl<X,SizeType,XExtent1,XExtent2>& rhs)
  {
    return impl::areEqual2D(rhs,lhs);
  }
  template<typename X,SizeType XExtent1,SizeType XExtent2, typename = std::enable_if_t<std::is_same_v<X,value_type>>>
  friend bool operator!=(const ThatClass& lhs, const Span2Impl<X,SizeType,XExtent1,XExtent2>& rhs)
  {
    return !impl::areEqual2D(rhs,lhs);
  }
  template<SizeType XExtent1,SizeType XExtent2>
  friend bool operator==(const ThatClass& lhs, const Span2Impl<T,SizeType,XExtent1,XExtent2>& rhs)
  {
    return impl::areEqual2D(rhs,lhs);
  }
  template<SizeType XExtent1,SizeType XExtent2>
  friend bool operator!=(const ThatClass& lhs, const Span2Impl<T,SizeType,XExtent1,XExtent2>& rhs)
  {
    return !impl::areEqual2D(rhs,lhs);
  }
 
 protected:
 
  ElementType* m_ptr;
  SizeType m_dim1_size;
  SizeType m_dim2_size;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<class T,Int32 Extent1,Int32 Extent2>
class SmallSpan2
: public Span2Impl<T,Int32,Extent1,Extent2>
{
  friend class Span2<T>;
 
 public:
 
  using ThatClass = SmallSpan2<T,Extent1,Extent2>;
  using BaseClass = Span2Impl<T,Int32,Extent1,Extent2>;
  using size_type = Int32;
  using value_type = typename BaseClass::value_type;
  using pointer = typename BaseClass::pointer;
  using BaseClass::operator();
  using BaseClass::operator[];
  using ElementType = typename BaseClass::ElementType;
 
 private:
 
  using BaseClass::m_ptr;
  using BaseClass::m_dim1_size;
  using BaseClass::m_dim2_size;
 
 public:
 
  ARCCORE_HOST_DEVICE SmallSpan2(pointer ptr,Int32 dim1_size,Int32 dim2_size)
  : BaseClass(ptr,dim1_size,dim2_size) {}
  ARCCORE_HOST_DEVICE SmallSpan2() : BaseClass() {}
  SmallSpan2(const Array2View<value_type>& from)
  : BaseClass(from.m_ptr,from.dim1Size(),from.dim2Size()) {}
  // Constructeur à partir d'un ConstArrayView. Cela n'est autorisé que
  // si T est const.
  template<typename X,typename = std::enable_if_t<std::is_same_v<X,value_type>> >
  SmallSpan2(const ConstArray2View<X>& from)
  : BaseClass(from.m_ptr,from.dim1Size(),from.dim2Size()) {}
  // Pour un Span<const T>, on a le droit de construire depuis un Span<T>
  template<typename X,typename = std::enable_if_t<std::is_same_v<X,value_type>> >
  ARCCORE_HOST_DEVICE SmallSpan2(const SmallSpan2<X>& from)
  : BaseClass(from.data(),from.dim1Size(),from.dim2Size()) {}
 
 public:
 
  ARCCORE_HOST_DEVICE SmallSpan<ElementType> operator[](Int32 i) const
  {
    ARCCORE_CHECK_AT(i,m_dim1_size);
    return SmallSpan<ElementType>(m_ptr + (m_dim2_size*i),m_dim2_size);
  }
 
  ARCCORE_HOST_DEVICE SmallSpan<ElementType> operator()(Int32 i) const
  {
    ARCCORE_CHECK_AT(i,m_dim1_size);
    return SmallSpan<ElementType>(m_ptr + (m_dim2_size*i),m_dim2_size);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<class T,Int64 Extent1,Int64 Extent2>
class Span2
: public Span2Impl<T,Int64,Extent1,Extent2>
{
 public:
 
  using ThatClass = Span2<T,Extent1,Extent2>;
  using BaseClass = Span2Impl<T,Int64,Extent1,Extent2>;
  using size_type = Int64;
  using value_type = typename BaseClass::value_type;
  using pointer = typename BaseClass::pointer;
  using BaseClass::operator();
  using BaseClass::operator[];
  using ElementType = typename BaseClass::ElementType;
 
 private:
 
  using BaseClass::m_ptr;
  using BaseClass::m_dim1_size;
  using BaseClass::m_dim2_size;
 
 public:
 
  ARCCORE_HOST_DEVICE Span2(pointer ptr,Int64 dim1_size,Int64 dim2_size)
  : BaseClass(ptr,dim1_size,dim2_size) {}
  ARCCORE_HOST_DEVICE Span2() : BaseClass() {}
  Span2(const Array2View<value_type>& from)
  : BaseClass(from.m_ptr,from.dim1Size(),from.dim2Size()) {}
  // Constructeur à partir d'un ConstArrayView. Cela n'est autorisé que
  // si T est const.
  template<typename X,typename = std::enable_if_t<std::is_same_v<X,value_type>> >
  Span2(const ConstArray2View<X>& from)
  : BaseClass(from.m_ptr,from.dim1Size(),from.dim2Size()) {}
 
  Span2(const SmallSpan2<T>& from)
  : BaseClass(from.m_ptr,from.dim1Size(),from.dim2Size()) {}
 
  // Pour un Span<const T>, on a le droit de construire depuis un Span<T>
  template<typename X,typename = std::enable_if_t<std::is_same_v<X,value_type>> >
  ARCCORE_HOST_DEVICE Span2(const Span2<X>& from)
  : BaseClass(from) {}
 
  // Pour un Span<const T>, on a le droit de construire depuis un Span<T>
  template<typename X,typename = std::enable_if_t<std::is_same_v<X,value_type>> >
  ARCCORE_HOST_DEVICE Span2(const SmallSpan2<X>& from)
  : BaseClass(from.data(), from.dim1Size(), from.dim2Size()) {}
 
 public:
 
  ARCCORE_HOST_DEVICE Span<ElementType> operator[](Int64 i) const
  {
    ARCCORE_CHECK_AT(i,m_dim1_size);
    return Span<ElementType>(m_ptr + (m_dim2_size*i),m_dim2_size);
  }
 
  ARCCORE_HOST_DEVICE Span<ElementType> operator()(Int64 i) const
  {
    ARCCORE_CHECK_AT(i,m_dim1_size);
    return Span<ElementType>(m_ptr + (m_dim2_size*i),m_dim2_size);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arccore
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif