src/MEDMEM/MEDMEM_PointerOf.hxx

Go to the documentation of this file.

// Copyright (C) 2007-2011  CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//

# if ! defined( __PointerOf_HXX__ )
# define __PointerOf_HXX__

#include <cstdlib>
#include <cstring>
#include "MEDMEM_Utilities.hxx"
#include "MEDMEM_Exception.hxx"

namespace MEDMEM {

template <typename T> class PointerOf
{
protected :
        T* _pointer ;
        bool _done ;

public :
        PointerOf() ;
        ~PointerOf() ;
        PointerOf( const int &size ) ;
        PointerOf( const T *pointer ) ;
        PointerOf( const int &size, const T *pointer ) ;
        PointerOf( const PointerOf<T> & pointerOf ) ;
        operator T*() ;
        operator const T*() const ;
        void set( const int &size ) ;
        void set( const T *pointer ) ;
        void set( const int &size, const T *pointer ) ;
        void setShallowAndOwnership( const T *pointer );
        PointerOf<T>& operator=( const PointerOf<T> &pointer ) ;
} ;

// ------------------------------------------------------------ //
//                                                              //
//                      Implementation                          //
//                                                              //
// ------------------------------------------------------------ //

template <typename T> PointerOf<T>::PointerOf() : _pointer(0), _done(false)
{
}

template <typename T> PointerOf<T>::PointerOf(const PointerOf<T> & pointerOf) :
  _pointer((T*)(const T* const)pointerOf), _done(false)
{
  const char* LOC = "PointerOf<T>::PointerOf(const PointerOf<T> & pointerOf)";
  BEGIN_OF_MED(LOC);
        MESSAGE_MED("Warning ! No Propriety Transfer");
  END_OF_MED(LOC);
}

//template <typename T> PointerOf<T>::PointerOf( const int &size, const PointerOf<T> & pointerOf) : 
//  _pointer((size,(T*)pointerOf))
//{
//}

template <typename T> PointerOf<T>::PointerOf( const int &size )
{
        if (size < 0)
        {
                _pointer=(T*)NULL;
                _done=false;
        }
        else
        {
                _pointer = new T[ size ] ;
                _done=true;
        }
}

template <typename T> PointerOf<T>::PointerOf( const T* pointer ) : _pointer( (T*)pointer ), _done(false)
{
}

template <typename T> PointerOf<T>::PointerOf( const int &size, const T* pointer)
{
  if (size < 0)
    throw MEDEXCEPTION("PointerOf( const int,const T*) : array size < 0");

  _pointer = new T[ size ] ;
  memcpy(_pointer,pointer,size*sizeof(T));
  _done=true;
}

template <typename T> PointerOf<T>::~PointerOf()
{
        if ( _pointer )
        {
                if( _done )
                {
                        MESSAGE_MED("PointerOf<T>::~PointerOf() --> deleting _pointer") ;
                        delete [] _pointer ;
                        _done = false ;
                }
                else
                {
                        MESSAGE_MED("_pointer is only nullified") ;
                }
                _pointer = 0 ;
        }
}

template <typename T> PointerOf<T>& PointerOf<T>::operator=( const PointerOf<T> &pointer )
{
  const char* LOC = "PointerOf<T>::operator=( const PointerOf<T> &pointer )";
  BEGIN_OF_MED(LOC);
        if ( &pointer != this )
        {
                this->set( pointer._pointer ) ;
        }
  END_OF_MED(LOC);
        return *this ;
}

template <typename T> PointerOf<T>::operator T*()
{
        return _pointer ;
}


template <typename T> PointerOf<T>::operator const T*() const
{
        return _pointer ;
}

template <typename T> void PointerOf<T>::set( const int &size )
{
        if ( _pointer && _done )
        {
                delete [] _pointer ;
                _pointer=0 ;
        }
        // if (size < 0) TODO: analyse why it does not work
        if (size <= 0)
        {
                _pointer=(T*)NULL;
        }
        else
        {
                _pointer = new T[ size ] ;
        }
        _done = true ;
        return ;
}

template <typename T> void PointerOf<T>::set( const T *pointer )
{
        MESSAGE_MED( "BEGIN PointerOf<T>::set( const T *pointer )" ) ;
        SCRUTE_MED(pointer) ;
        SCRUTE_MED(_done) ;
        if ( _pointer && _done )
        {
                MESSAGE_MED("PointerOf<T>::set --> deleting _pointer") ;
                delete [] _pointer ;
                _pointer=0 ;
                _done=false ;
        }
        _pointer=(T*)pointer ;
        _done=false ;
        MESSAGE_MED( "END PointerOf<T>::set( const T *pointer )" ) ;
        return ;
}

template <typename T> void PointerOf<T>::set( const int &size, const T *pointer)
{
  if ( _pointer && _done )
    {
      delete [] _pointer ;
      _pointer = NULL ;
    }
  if (size < 0)
    throw MEDEXCEPTION("PointerOf( const int,const T*) : array size < 0");

  _pointer = new T[ size ] ;
  memcpy(_pointer,pointer,size*sizeof(T));
  _done=true;

  return ;
}

template <typename T> void PointerOf<T>::setShallowAndOwnership( const T *pointer )
{
  if ( _pointer && _done )
    delete [] _pointer;
  _pointer=(T*)pointer;
  _done=true;
}

}//End namespace MEDMEM

# endif         /* # if ! defined( __PointerOf_HXX__ ) */