GyotoSmartPointer.h

Go to the documentation of this file.

/*
    Copyright 2011-2014, 2016, 2020 Thibaut Paumard

    This file is part of Gyoto.

    Gyoto 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, either version 3 of the License, or
    (at your option) any later version.

    Gyoto 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 Gyoto.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef __GyotoSmartPointer_H_
#define __GyotoSmartPointer_H_

#include "GyotoUtils.h"
#ifdef HAVE_PTHREAD
#include <pthread.h>
#endif

namespace Gyoto {
  class SmartPointee;
  class FactoryMessenger;
  template <class T> class SmartPointer;
}

#include <GyotoError.h>
#include <stddef.h>
#include <iostream>
#include <typeinfo>
#include <string>
#include <vector>

class Gyoto::SmartPointee
{
 private:
  int refCount; 

# ifdef HAVE_PTHREAD

  pthread_mutex_t mutex_; 
#endif

 public:
  SmartPointee () ;
  virtual ~SmartPointee() ;
  SmartPointee (const   SmartPointee&) ; 
  void incRefCount () ; 
  int decRefCount () ;  
  int getRefCount () ;  

  typedef Gyoto::SmartPointer<Gyoto::SmartPointee>
    Subcontractor_t(Gyoto::FactoryMessenger*, std::vector<std::string> const &);

};


template< class T >
class Gyoto::SmartPointer
{
 private:

  T *obj;

 private:
  void decRef ()
  {
    if (obj && obj->decRefCount() == 0) {
#     if GYOTO_DEBUG_ENABLED
      GYOTO_DEBUG_EXPR(obj);
#     endif
      delete obj;
      obj = NULL;
    }
  }
  
 public:
  SmartPointer (T *orig = NULL) : obj(orig)
  {
    if (obj)
      obj->incRefCount();
  } 

  SmartPointer (const SmartPointer< T > &orig)
    {
      obj = orig.obj;
      if (obj)
        obj->incRefCount ();
    }

  template<class U>
    SmartPointer(const SmartPointer<U>& orig)
    {
      obj = dynamic_cast<T*>(const_cast<U*>(orig()));
      if (obj)
        obj->incRefCount ();
    }

  T& operator* ()
    {
      if (!obj)
        Gyoto::throwError("Null Gyoto::SmartPointer dereference in operator*");
      return *obj;
    }

  const T& operator* () const
    {
      if (!obj)
        Gyoto::throwError("Null Gyoto::SmartPointer dereference in operator*");
      return *obj;
    }

  T* operator-> ()
    {
      if (!obj)
        Gyoto::throwError("Null Gyoto::SmartPointer dereference in operator->");
      return obj;
    }

  T* operator-> () const
    {
      if (!obj)
        Gyoto::throwError("Null Gyoto::SmartPointer dereference in operator->");
      return obj;
    }

  bool operator== (const SmartPointer< T >&right) { return obj == right.obj; }
  
  bool operator!= (const SmartPointer< T >&right) { return obj != right.obj; }
  
  SmartPointer< T > &operator= (SmartPointer< T > &right)
    {
      if (this == &right)
        return *this;
      
      if (right.obj)
        right.obj->incRefCount ();
      
      decRef ();
      
      obj = right.obj;
      
      return *this;
    }

  SmartPointer< T > &operator= (T* right)
    {
      if (obj == right)
        return *this;
      
      decRef ();
      
      obj = right;

      if (obj) obj->incRefCount();
      
      return *this;
    }

  //  template<class U> operator U() { return obj; }
  operator T*() const { return obj; }

#if 0
  operator const T*() { return obj; }

  operator bool () const { return obj != NULL; }

  bool operator! () const { return obj == NULL; }
#endif

  ~SmartPointer< T > () { decRef(); }

 public:
  //  const T* address() const { return obj; }
  const T* operator()() const { return obj; }

};

#endif