MultiBuffer.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* MultiBuffer.h                                               (C) 2000-2011 */
/*                                                                           */
/* Classe template d'un tableau avec tampon.                                 */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_UTILS_MULTIBUFFER_H
#define ARCANE_UTILS_MULTIBUFFER_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/ArrayView.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_BEGIN_NAMESPACE
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<class T>
class MultiBufferT
{
 public:
 
  typedef UniqueArray<T> BufferType;
 
 public:
 
  MultiBufferT()
  : m_buffer_size(1000), m_current_buffer_size(0), m_nb_in_buffer(0),m_current_buffer(0)
    {
    }
  MultiBufferT(Integer buf_size)
  : m_buffer_size(buf_size), m_current_buffer_size(0), m_nb_in_buffer(0),m_current_buffer(0)
    {
    }
  MultiBufferT(const MultiBufferT<T>& ref)
  : m_buffer_size(ref.m_buffer_size), m_current_buffer_size(0), m_nb_in_buffer(0), m_current_buffer(0)
    {
    }
  ~MultiBufferT()
    {
      _freeAllocatedBuffers();
    }
 public:
  void operator=(const MultiBufferT<T>& ref)
    {
      if (&ref==this)
        return;
      clear();
      m_buffer_size = ref.m_buffer_size;
    }
 public:
  T* allocOne()
    {
      if (!m_current_buffer)
        _allocateCurrentBuffer();
      T* v = &(*m_current_buffer)[m_nb_in_buffer];
      ++m_nb_in_buffer;
      if (m_nb_in_buffer==m_current_buffer_size)
        m_current_buffer = 0; // Indique que le tampon actuel est plein
      return v;
    }

  ArrayView<T> allocMany(Integer n)
    {
      // Si le nombre d'éléments souhaités est supérieure à la taille
      // du tampon, alloue spécifiquement un tampon de la bonne taille
      if (n>m_current_buffer_size){
        BufferType* bt = new BufferType(n);
        m_allocated_buffers.add(bt);
        return *bt;
      }
      if (!m_current_buffer)
        _allocateCurrentBuffer();
      // Si le tampon actuel n'est pas assez grand pour contenir les
      // \a n éléments souhaités, en alloue un autre
      if ((m_nb_in_buffer+n)>=m_current_buffer_size)
        _allocateCurrentBuffer();
      T* v = &(*m_current_buffer)[m_nb_in_buffer];
      m_nb_in_buffer += n;
      if (m_nb_in_buffer==m_current_buffer_size)
        m_current_buffer = 0; // Indique que le tampon actuel est plein
      return ArrayView<T>(n,v);
    }
  void clear()
    {
      m_nb_in_buffer = 0;
      m_current_buffer = 0;
      m_current_buffer_size = 0;
      _freeAllocatedBuffers();
 
    }
  Integer nbAllocatedBuffer() { return m_allocated_buffers.size(); }
  Integer bufferSize() const { return m_current_buffer_size; }
 
 protected:
  void _freeAllocatedBuffers()
    {
      for( Integer i=0, s=m_allocated_buffers.size(); i<s; ++i )
        delete m_allocated_buffers[i];
      m_allocated_buffers.clear();
    }
 private:
  Integer m_buffer_size; 
  Integer m_current_buffer_size; 
  Integer m_nb_in_buffer; 
  BufferType* m_current_buffer; 
  UniqueArray< BufferType* > m_allocated_buffers; 
 private:
  void _allocateCurrentBuffer()
    {
      m_current_buffer = new BufferType(m_buffer_size);
      m_current_buffer_size = m_buffer_size;
      m_allocated_buffers.add(m_current_buffer);
      m_nb_in_buffer = 0;
    }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_END_NAMESPACE
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif