MultiArray2.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2022 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* MultiArray2.h                                               (C) 2000-2015 */
/*                                                                           */
/* Tableau 2D à taille multiple.                                             */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_UTILS_MULTIARRAY2_H
#define ARCANE_UTILS_MULTIARRAY2_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Array.h"
#include "arcane/utils/MultiArray2View.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_BEGIN_NAMESPACE
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename DataType>
class MultiArray2
{
 public:
  typedef typename UniqueArray<DataType>::ConstReferenceType ConstReferenceType;
 public:
  MultiArray2() {}
  MultiArray2(IntegerConstArrayView sizes)
  {
    _resize(sizes);
  }
 private:
  MultiArray2(const MultiArray2<DataType>& rhs);
  void operator=(const MultiArray2<DataType>& rhs);
 protected:
  MultiArray2(const MultiArray2<DataType>& rhs,bool do_clone)
  : m_buffer(do_clone ? rhs.m_buffer.clone() : rhs.m_buffer),
    m_indexes(do_clone ? rhs.m_indexes.clone() : rhs.m_indexes),
    m_sizes(do_clone ? rhs.m_sizes.clone() : rhs.m_sizes)
  {
  }
  MultiArray2(ConstMultiArray2View<DataType> aview)
  : m_buffer(aview.m_buffer), m_indexes(aview.m_indexes), m_sizes(aview.m_sizes)
  {
  }
 public:
  ArrayView<DataType> operator[](Integer i)
  {
    return ArrayView<DataType>(m_sizes[i],m_buffer.data() + (m_indexes[i]));
  }
  ConstArrayView<DataType> operator[](Integer i) const
  {
    return ConstArrayView<DataType>(m_sizes[i],m_buffer.data()+ (m_indexes[i]));
  }
 public:
  Integer totalNbElement() const { return m_buffer.size(); }
  void clear()
  {
    m_buffer.clear();
    m_indexes.clear();
    m_sizes.clear();
  }
  MultiArray2<DataType> clone()
  {
    MultiArray2<DataType> new_array;
    new_array.m_buffer = m_buffer.clone();
    new_array.m_indexes = m_indexes.clone();
    new_array.m_sizes = m_sizes.clone();
    return new_array;
  }
  void fill(const DataType& v)
  {
    m_buffer.fill(v);
  }
  DataType& at(Integer i,Integer j)
  {
    return m_buffer[m_indexes[i]+j];
  }
  void setAt(Integer i,Integer j,ConstReferenceType v)
  {
    return m_buffer.setAt(m_indexes[i]+j,v);
  }
 public:
  Integer dim1Size() const { return m_indexes.size(); }
  
  IntegerConstArrayView dim2Sizes() const { return m_sizes; }
 
  operator MultiArray2View<DataType>()
  {
    return view();
  }
 
  operator ConstMultiArray2View<DataType>() const
  {
    return constView();
  }
 
  MultiArray2View<DataType> view()
  {
    return MultiArray2View<DataType>(m_buffer,m_indexes,m_sizes);
  }
 
  ConstMultiArray2View<DataType> constView() const
  {
    return ConstMultiArray2View<DataType>(m_buffer,m_indexes,m_sizes);
  }
 
  ArrayView<DataType> viewAsArray()
  {
    return m_buffer.view();
  }
 
  ConstArrayView<DataType> viewAsArray() const
  {
    return m_buffer.constView();
  }
 
  void resize(IntegerConstArrayView new_sizes)
  {
    if (new_sizes.size()==0){
      clear();
    }
    else
      _resize(new_sizes);
  }
 protected:
  ConstArrayView<DataType> _value(Integer i) const
  {
    return ConstArrayView<DataType>(m_sizes[i],m_buffer.data()+ m_indexes[i]);
  }
 protected:
  void _resize(IntegerConstArrayView ar)
  {
    Integer size1 = ar.size();
    // Calcule le nombre d'éléments total
    Integer total_size = 0;
    for( Integer i=0; i<size1; ++i )
      total_size += ar[i];
 
    // Si on ne change pas le nombre total d'élément, vérifie
    // si le resize est nécessaire
    if (total_size==totalNbElement() && size1==m_indexes.size()){
      bool is_same = true;
      for( Integer i=0; i<size1; ++i )
        if (m_sizes[i]!=ar[i]){
          is_same = false;
          break;
        }
      if (is_same)
        return;
    }
    //_setTotalNbElement(total_size);
 
    // Alloue le tampon correspondant.
    //T* anew_buffer = new T[total_size+1];
    Integer old_size1 = m_indexes.size();
 
    SharedArray<DataType> new_buffer(total_size);
      
    // Recopie dans le nouveau tableau les valeurs de l'ancien.
    if (old_size1>size1)
      old_size1 = size1;
    Integer index = 0;
    for( Integer i=0; i<old_size1; ++i ){
      Integer size2 = ar[i];
      Integer old_size2 = m_sizes[i];
      if (old_size2>size2)
        old_size2 = size2;
      ConstArrayView<DataType> cav(_value(i));
      for( Integer j=0; j<old_size2; ++j )
        new_buffer[index+j] = cav[j];
      index += size2;
    }
    m_buffer = new_buffer;
 
    m_indexes.resize(size1);
    m_sizes.resize(size1);
    for( Integer i2=0, index2=0; i2<size1; ++i2 ){
      Integer size2 = ar[i2];
      m_indexes[i2] = index2;
      m_sizes[i2] = size2;
      index2 += size2;
    }
  }
 
 protected:
 
  void _copy(const MultiArray2<DataType>& rhs,bool do_clone)
  {
    m_buffer = do_clone ? rhs.m_buffer.clone() : rhs.m_buffer;
    m_indexes = do_clone ? rhs.m_indexes.clone() : rhs.m_indexes;
    m_sizes = do_clone ? rhs.m_sizes.clone() : rhs.m_sizes;
  }
  void _copy(ConstMultiArray2View<DataType> aview)
  {
    m_buffer = aview.m_buffer;
    m_indexes = aview.m_indexes;
    m_sizes = aview.m_sizes;
  }
 
 private:
  SharedArray<DataType> m_buffer;
  SharedArray<Integer> m_indexes;
  SharedArray<Integer> m_sizes;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename DataType>
class SharedMultiArray2
: public MultiArray2<DataType>
{
 public:
 
  SharedMultiArray2() {}
  SharedMultiArray2(IntegerConstArrayView sizes)
  : MultiArray2<DataType>(sizes){}
  SharedMultiArray2(ConstMultiArray2View<DataType> view)
  : MultiArray2<DataType>(view){}
  SharedMultiArray2(const SharedMultiArray2<DataType>& rhs)
  : MultiArray2<DataType>(rhs,false){}
  SharedMultiArray2(const UniqueMultiArray2<DataType>& rhs);
 
 public:
 
  void operator=(const SharedMultiArray2<DataType>& rhs)
  {
    this->_copy(rhs,false);
  }
  void operator=(ConstMultiArray2View<DataType> view)
  {
    this->_copy(view);
  }
  void operator=(const UniqueMultiArray2<DataType>& rhs);
 
 public:
 
  SharedMultiArray2<DataType> clone() const
  {
    return SharedMultiArray2<DataType>(this->constView());
  }
 
 private:
 
  void operator=(const MultiArray2<DataType>& rhs);
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename DataType>
class UniqueMultiArray2
: public MultiArray2<DataType>
{
 public:
 
  UniqueMultiArray2() {}
  UniqueMultiArray2(IntegerConstArrayView sizes)
  : MultiArray2<DataType>(sizes){}
  UniqueMultiArray2(ConstMultiArray2View<DataType> view)
  : MultiArray2<DataType>(view){}
  UniqueMultiArray2(const SharedMultiArray2<DataType>& rhs)
  : MultiArray2<DataType>(rhs,true){}
  UniqueMultiArray2(const UniqueMultiArray2<DataType>& rhs)
  : MultiArray2<DataType>(rhs,true){}
 
 public:
 
  void operator=(const SharedMultiArray2<DataType>& rhs)
  {
    this->_copy(rhs,true);
  }
  void operator=(ConstMultiArray2View<DataType> view)
  {
    this->_copy(view);
  }
  void operator=(const UniqueMultiArray2<DataType>& rhs)
  {
    this->_copy(rhs,true);
  }
 
 public:
 
  UniqueMultiArray2<DataType> clone() const
  {
    return UniqueMultiArray2<DataType>(this->constView());
  }
 
 private:
 
  void operator=(const MultiArray2<DataType>& rhs);
 
 private:
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template<typename DataType> SharedMultiArray2<DataType>::
SharedMultiArray2(const UniqueMultiArray2<DataType>& rhs)
: MultiArray2<DataType>(rhs,true){}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template<typename DataType> void SharedMultiArray2<DataType>::
operator=(const UniqueMultiArray2<DataType>& rhs)
{
  this->_copy(rhs,true);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_END_NAMESPACE
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif