RefPtr.h

Go to the documentation of this file.

/* =====================================================================================
 
                      The UQ Toolkit (UQTk) version 3.1.5
                          Copyright (2024) NTESS
                        https://www.sandia.gov/UQToolkit/
                        https://github.com/sandialabs/UQTk
 
     Copyright 2024 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
     Under the terms of Contract DE-NA0003525 with NTESS, the U.S. Government
     retains certain rights in this software.
 
     This file is part of The UQ Toolkit (UQTk)
 
     UQTk is open source software: you can redistribute it and/or modify
     it under the terms of BSD 3-Clause License
 
     UQTk 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
     BSD 3 Clause License for more details.
 
     You should have received a copy of the BSD 3 Clause License
     along with UQTk. If not, see https://choosealicense.com/licenses/bsd-3-clause/.
 
     Questions? Contact the UQTk Developers at https://github.com/sandialabs/UQTk/discussions
     Sandia National Laboratories, Livermore, CA, USA
===================================================================================== */
//                               -*- C++ -*-
 
#ifndef _utility_ref_RefPtr_
#define _utility_ref_RefPtr_
 
#include "MyException.h"
#include <typeinfo>  // for dynamic_cast
#include <unistd.h>
#include <stddef.h>
 
template <class T>
class RefPtr {
public:
  typedef T Type;
  
  RefPtr() : ptr_(NULL) {}
  
  RefPtr(T* p) : ptr_(p) {
    grab();
  }
  
  RefPtr(const RefPtr<T>& p) : ptr_(p.ptr_) {
    grab();
  }
  
  template <class Other>
  RefPtr(RefPtr<Other> p) : ptr_(static_cast<T*>(p.pointee())) {
    grab();
  }
  
  ~RefPtr() {
    release();
  }
  
  RefPtr<T>& operator=(T* p) {
    if(p != ptr_) {
      release();  // release the old pointer
      ptr_ = p;   // assign our value to this one
      grab();     // grab this pointer
    }
    return *this;
  }
  
  RefPtr<T>& operator=(const RefPtr<T>& p) {
    if(p.ptr_ != ptr_) {
      release();
      ptr_ = p.ptr_;
      grab();
    }
    return *this;
  }
  
  template <class Other>
  RefPtr<T>& cast(Other* p) {
    if(p != ptr_) {
      release();
      
      //std::cout << "DEBUG: Dynamic cast from type " << typeid(p).name()
      //        << " to " << typeid(T).name() << std::endl; 
      
      ptr_ = dynamic_cast<T*>(p);
      if(p != NULL && ptr_ == NULL) {
        throw MyException
          (std::string("RefPtr::cast(Other):  Failed dynamic cast from ")
           + std::string(typeid(Other).name()) + std::string(" to ") +
           std::string(typeid(Type).name()));
        
      }
      grab();
    }
    return *this;
  }
  
  template <class Other>
  RefPtr<T>& cast(RefPtr<Other> p) {
    if(p.ptr_ != ptr_) {
      release();
      
      //std::cout << "DEBUG: Dynamic cast from type " 
      //        << typeid(p.pointee()).name()
      //        << " to " << typeid(T).name() << std::endl; 
      
      ptr_ = dynamic_cast<T*>(p.pointee());
      if(p != NULL && ptr_ == NULL) {
        throw MyException
          (std::string("RefPtr::cast(Other):  Failed dynamic cast from ")
           + std::string(typeid(Other).name()) + std::string(" to ") +
           std::string(typeid(Type).name()));
      }
      grab();
    }
    return *this;
  }
  
  T* operator->() const {
    if(ptr_ == NULL) {
      std::cerr << "RefPtr<" << typeid(T).name() 
                << ">::operator->() const invoked on a null pointer\n";
      throw MyException("RefPtr::operator->() const");
    }
    return ptr_;
  }
  
  T& operator*() const {
    if(ptr_ == NULL) {
      std::cerr << "RefPtr<" << typeid(T).name()
                << ">::operator*() const invoked on a null pointer\n";
      throw MyException("RefPtr::operator*() const");
    } 
    return *ptr_;
  }
  
  T* pointee() {
    return ptr_;
  }
  
  const T* pointee() const {
    return ptr_;
  }
  
  bool operator==(const T* p) const {
    return ptr_ == p;
  }
  
  bool operator==(const RefPtr<T>& p) const {
    return ptr_ == p.pointee();
  }
  
  bool operator!=(const T* p) const {
    return ptr_ != p;
  }
  
  bool operator!=(const RefPtr<T>& p) const {
    return ptr_ != p.ptr_;
  }
  
  inline bool operator<(const RefPtr<T>& p) const {
    return ptr_ < p.ptr_;
  }
  
  template <class Other>
  bool operator<(const RefPtr<Other>& p) const {
    return ptr_ < p.pointee();
  }
  
private:
  T* ptr_;
  
  inline void grab() {
    if(ptr_ != NULL) 
      ptr_->reference_grab();
  }
  
  inline void release() {
    if(ptr_ != NULL) {
      if(ptr_->reference_release() == 0)
        delete ptr_;
    }
  }
};
 
#endif //_utility_ref_RefPtr_