ReferenceTo.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2004 - 2025 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Util/units/ReferenceTo.h
 
#ifndef __psrchive_util_units_ReferenceTo_h
#define __psrchive_util_units_ReferenceTo_h
 
// #define _DEBUG 1
#include "debug.h"
#include "ReferenceAble.h"
#include "Error.h"
 
#include <typeinfo>
#include <string>
 
namespace Reference {

  template<class Type, bool active = true> class To {
 
  public:
    
    constexpr To () = default;
    
    To (const To&);
    
    ~To ();
    
    To& operator = (const To&);

    To (Type* ptr);

    To& operator = (Type *);
    
    Type& operator * () const { return *get(); }
    
    Type* operator -> () const { return get(); }
    
    bool operator == (const Type* ptr) const;

    bool operator != (const Type* ptr) const;


    bool is_equal_to (const Type* ptr) const;

    operator Type* () const { return get(); }

    bool operator ! () const;
    
    operator bool () const;

    void set (Type*);

    Type* get () const;
    
    Type* release ();
    
    const Type* ptr () const;

    Type* ptr ();

    std::string name () const;
 
  private:

    void hook (const Able*);

    void unhook (bool auto_delete = true);

    Able::Handle* the_handle = nullptr;
 
  };
}
 
template<class Type, bool active>
bool Reference::To<Type,active>::operator == (const Type* ptr) const
{
  DEBUG("Reference::To<"+name()+">::operator ==");
  return is_equal_to(ptr);
}
 
template<class Type, bool active>
bool Reference::To<Type,active>::operator != (const Type* ptr) const
{
  DEBUG("Reference::To<"+name()+">::operator !=");
  return !is_equal_to(ptr);
}
 
template<class Type, bool active>
bool Reference::To<Type,active>::is_equal_to (const Type* ptr) const
{
  if (!ptr)
    return !the_handle || the_handle->pointer == nullptr;
  else
    return the_handle && the_handle->pointer == ptr;
}
 
template<class Type, bool active>
void Reference::To<Type,active>::unhook (bool auto_delete)
{
  DEBUG("Reference::To<"+name()+">::unhook handle=" << the_handle << " auto_delete=" << auto_delete);
 
  if (!the_handle)
    return;
 
  Able::Handle* temp = the_handle;
 
  the_handle = 0;
 
  // thread-safe handle detachment
  temp->decrement (active, auto_delete);
}
 
template<class Type, bool active>
void Reference::To<Type,active>::hook (const Able* pointer)
{
  DEBUG("Reference::To<"+name()+">::handle Able*="<< pointer);
 
  if (!pointer)
    the_handle = 0;
  else
    the_handle = pointer->__reference (active);
}
 
template<class Type, bool active>
std::string Reference::To<Type,active>::name () const
{
#ifdef _DEBUG
  return "T";
#else
  return typeid(Type).name();
#endif
}
 
template<class Type, bool active>
Reference::To<Type,active>::To (Type* ref_pointer)
{
  DEBUG("Reference::To<"+name()+">::To (Type*="<< (void*)ref_pointer <<")");
 
  the_handle = 0;
  hook (ref_pointer);
}
 
template<class Type, bool active>
Reference::To<Type,active>::~To ()
{ 
  DEBUG("Reference::To<"+name()+">::~To");
 
  unhook ();
}
 
template<class Type, bool active>
bool Reference::To<Type,active>::operator ! () const
{
  DEBUG("Reference::To<"+name()+">::operator !");
 
  return !the_handle || the_handle->pointer == 0;
}
 
template<class Type, bool active>
Reference::To<Type,active>::operator bool () const
{
  DEBUG("Reference::To<"+name()+">::operator bool");
 
  return the_handle && the_handle->pointer;
}
 
// copy constructor
template<class Type, bool active>
Reference::To<Type,active>::To (const To& another_reference)
{
  DEBUG("Reference::To<"+name()+">::To (To<Type>)");
 
  // thread-safe copy
  the_handle = 0;
  Able::Handle::copy (the_handle, another_reference.the_handle, active);
}
 
 
// operator = copy assignment operator
template<class Type, bool active>
Reference::To<Type,active>&
Reference::To<Type,active>::operator = (const To& oref)
{
  DEBUG("Reference::To<"+name()+">::operator = (To<Type>)");
 
  if (the_handle == oref.the_handle)
    return *this;
 
  unhook ();
 
  // thread-safe copy
  Able::Handle::copy (the_handle, oref.the_handle, active);
 
  return *this;
}
 
// operator = assignment operator
template<class Type, bool active>
Reference::To<Type,active>& 
Reference::To<Type,active>::operator = (Type* ref_pointer)
{
  DEBUG("Reference::To<"+name()+">::operator = (Type*=" << (void*)ref_pointer <<")");
  set (ref_pointer);
  return *this;
}
 
// operator = assignment operator
template<class Type, bool active>
void Reference::To<Type,active>::set (Type* ref_pointer)
{
  DEBUG("Reference::To<"+name()+">::set (Type*=" << (void*)ref_pointer <<")");
 
  if (the_handle && the_handle->pointer == ref_pointer)
    return;
 
  unhook ();
  hook (ref_pointer);
}
 
template<class Type, bool active>
Type* Reference::To<Type,active>::get () const
{
  DEBUG("Reference::To<"+name()+">::get");
 
  if (!the_handle || the_handle->pointer == 0)
    throw Error (InvalidPointer, "Reference::To<"+name()+">::get");
 
  return reinterpret_cast<Type*>( the_handle->pointer );
}
 
 
template<class Type, bool active>
Type* Reference::To<Type,active>::release ()
{
  DEBUG("Reference::To<"+name()+">::release");
 
  if (!the_handle || the_handle->pointer == 0)
    throw Error (InvalidPointer, "Reference::To<"+name()+">::release");
 
  Type* copy = reinterpret_cast<Type*>( the_handle->pointer );
 
  unhook (false);
 
  return copy;
}

template<class Type, bool active>
const Type* Reference::To<Type,active>::ptr () const
{
  if (the_handle)
    return reinterpret_cast<const Type*>( the_handle->pointer );
  else
    return 0;
}

template<class Type, bool active>
Type* Reference::To<Type,active>::ptr ()
{
  if (the_handle && the_handle->pointer)
    return reinterpret_cast<Type*>( the_handle->pointer );
  else
    return 0;
}
 
template<class Type, bool active>
void swap (Reference::To<Type,active>& ref1, Reference::To<Type,active>& ref2)
{
  DEBUG("swap (Reference::To<Type>, ditto)");
 
  Type* ref1_ptr = ref1.release();
  Type* ref2_ptr = ref2.release();
 
  ref1 = ref2_ptr;
  ref2 = ref1_ptr;
}

template<class Type1, bool active1, class Type2, bool active2>
bool operator == (const Reference::To<Type1,active1>& ref1,
                  const Reference::To<Type2,active2>& ref2)
{
  DEBUG("operator == (Reference::To<Type>&, Reference::To<Type2>&)");
 
  if (!ref1)
    return !ref2;
 
  if (!ref2)
    return false;
 
  return ref1.ptr() == ref2.ptr();
}

template<class Type1, bool active1, class Type2, bool active2>
bool operator != (const Reference::To<Type1,active1>& ref1,
                  const Reference::To<Type2,active2>& ref2)
{
  DEBUG("operator != (Reference::To<Type>&, Reference::To<Type2>&)");
 
  if (!ref1)
    return ref2;
 
  if (!ref2)
    return true;
 
  return ref1.ptr() != ref2.ptr();
}
 

template<class Type, bool active, class Type2>
bool operator == (const Reference::To<Type,active>& ref, const Type2* instance)
{
  DEBUG("operator == (Reference::To<Type>&, Type*)");
  return ref.is_equal_to(instance);
}

template<class Type, bool active, class Type2>
bool operator == (const Type2* instance, const Reference::To<Type,active>& ref)
{
  DEBUG("operator == (T2*, Reference::To<T1>&)");
  return ref.is_equal_to(instance);
}
 
template<typename C, typename P, bool A>
C* dynamic_kast (Reference::To<P,A>& p)
{
  return dynamic_cast<C*> (p.ptr());
}
 
template<typename P, bool A>
P* const_kast (Reference::To<const P,A>& p)
{
  return const_cast<P*> (p.ptr());
}
 
#endif // #ifndef __psrchive_util_units_ReferenceTo_h