/home/neoflo/smb4k/SERVEUR/Millie/trunk/src/DataBuffer.hpp

Aller à la documentation de ce fichier.

/******************************************************************************
 *       __    _    _   _       _       _   _____                             *
 *       | \  / |  | | | |     | |     | |  | ___|                            *
 *       |  \/  |  | | | |     | |     | |  | |_                              *
 *       |      |  | | | |     | |     | |  |  _|                             *
 *       | |\/| |  | | | |__   | |__   | |  | |__                             *
 *       |_|  |_|  |_| |____|  |____|  |_|  |____|                            *
 * __________________________________________________________________________ *
 *                 Multifunctional Library For Image Processing               *
 *                                                                            *
 *                                                                            *
 *                                                                            *
 *      (c) Copyright 2007 by Humbert Florent                                 *
 *                                                                            *
 *      This program is free software; you can redistribute it and/or modify  *
 *      it under the terms of the GNU General Public License as published by  *
 *      the Free Software Foundation; only version 2 of the License.          *
 *                                                                            *
 *      This program is distributed in the hope that it will be useful,       *
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *      GNU General Public License for more details.                          *
 *                                                                            *
 *      You should have received a copy of the GNU General Public License     *
 *      along with this program; if not, write to the Free Software           *
 *      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA             *
 *      02111-1307, USA.                                                      *
 ******************************************************************************/

#ifndef _DATABUFFER_HPP_
#define _DATABUFFER_HPP_

#include <iostream>
#include "MillieExceptions.hpp"

namespace Millie
{

  template <typename T>
  class DataBuffer
  {
    protected:
      T* _tab;
      int    _size;
      int    _realsize;

    public:
      DataBuffer(int size = 0)
      {
        _tab = NULL;

        if(size<0)
          throw IllegalArgument("DataBuffer::Size");

        /*sinon, _tab vaut toujours NULL*/
        if(size!=0)
          _tab = new T[size];

        _size = size;
        _realsize = size;
      }



      DataBuffer(const DataBuffer<T>& d)
      {
        _tab = NULL;

        _size = d.getSize();
        _realsize = d.getSize();

        /*sinon _tab est NULL*/
        if(_size != 0)
          _tab = new T[_size];

        /* si _tab est NULL, c'est que la taille est nulle, on ne rentre pas dans
          la boucle
          */
        for(int i = 0; i< _size;i++)
          _tab[i] = d._tab[i];
      }

      virtual ~DataBuffer()
      {
        delete[] _tab;
        _tab = NULL;
      }

      void resize(int taille)
      {
        if(taille<0)
          throw IllegalArgument("DataBuffer Resize");


        _size = taille;

        if(taille> _realsize)
        {
          delete[] _tab;
          _tab = NULL;
          /*la taille ne peut pas être nulle à cet instant !*/
          _tab = new T[taille];
          _realsize = taille;
        }

      }

      DataBuffer& operator=(const DataBuffer<T>& d)
      {
        _size = d.getSize();

        /*optimisation*/
        if(_realsize < d.getSize())
        {
          _realsize = d.getSize();

          T * tempo = _tab;
          /*d.getSize() ne peut pas être nulle*/
          tempo = new T[d.getSize()];

          for(int i = 0; i< _size;i++)
            tempo[i] = d._tab[i];

          delete[] _tab;

          _tab = tempo;
        }
        else
        {

          /*si la taille est nulle, on ne rentre pas dans la boucle*/
          for(int i = 0; i< _size;i++)
            _tab[i] = d._tab[i];
        }

        return *this;
      }

      int  getSize() const
      {
        return _size;
      }

      T * getDataBuffer()
      {
        return _tab;
      }

      T operator[](int position) const
      {
#ifndef _MILLIE_DANGEROUS_OPTIMIZATIONS_
        if(position<0 || position> getSize())
        {
          //*(int*) 0 = 1;
          throw OutOfRange("hors zone");

        }
#endif
        return _tab[position];
      }

      T& operator[](int position)
      {
#ifndef _MILLIE_DANGEROUS_OPTIMIZATIONS_
        if(position<0 || position> getSize())
        {
          //*(int*) 0 = 1;
          throw OutOfRange("hors zone");
        }
#endif
        return _tab[position];
      }

  };


}

#endif

---