Heed::ActivePtr< X, C > Class Template Reference

Active pointer or automatic container or controlling pointer. More...

#include <AbsPtr.h>

Public Member Functions
X *	operator-> (void) const
X &	operator* (void) const
X *	getver (void) const
X *	get (void) const
void	put (const X *fptr)
void	pass (X *fptr)
X *	extract (void)
void	clear (void)
void	pilfer (const ActivePtr< X, C > &f)
void	print (std::ostream &file, int l=1) const
	ActivePtr (void)
	ActivePtr (const X *fptr, Clone)
	ActivePtr (const ActivePtr< X, C > &f)
	ActivePtr (const ActivePtr< X, C > &f, Pilfer)
	ActivePtr (X *fptr, Pass)
ActivePtr &	operator= (const ActivePtr< X, C > &f)
virtual ActivePtr *	copy () const
virtual	~ActivePtr ()

Detailed Description

template<class X, class C = StandardCopyDefinition<X>>
class Heed::ActivePtr< X, C >

Active pointer or automatic container or controlling pointer.

Definition at line 199 of file AbsPtr.h.

Constructor & Destructor Documentation

ActivePtr() [1/5]

template<class X , class C = StandardCopyDefinition<X>>

Heed::ActivePtr< X, C >::ActivePtr ( void  )

inline

Definition at line 317 of file AbsPtr.h.

: ptr(NULL) {}

Referenced by Heed::ActivePtr< X, C >::copy().

ActivePtr() [2/5]

template<class X , class C = StandardCopyDefinition<X>>

Heed::ActivePtr< X, C >::ActivePtr ( const X *  fptr, Clone    )

inline

Definition at line 319 of file AbsPtr.h.

      : ptr(fptr != NULL ? C::copy(fptr) : ((X*)NULL))
#ifndef DEBUG_ACTIVEPTR
  {
  }  // normal case

ActivePtr() [3/5]

template<class X , class C = StandardCopyDefinition<X>>

Heed::ActivePtr< X, C >::ActivePtr ( const ActivePtr< X, C > &  f )

inline

Definition at line 334 of file AbsPtr.h.

      : ptr(f.ptr != NULL ? C::copy(f.ptr) : f.ptr)
#ifndef DEBUG_ACTIVEPTR
  {
  }

ActivePtr() [4/5]

template<class X , class C = StandardCopyDefinition<X>>

Heed::ActivePtr< X, C >::ActivePtr ( const ActivePtr< X, C > &  f, Pilfer    )

inline

Attention: actually not const

Definition at line 346 of file AbsPtr.h.

      : ptr(f.ptr) {  //!Attention: actually not const
#ifdef DEBUG_ACTIVEPTR
    mcout << "ActivePtr(const ActivePtr<X,C>& f, Pilfer) is run\n";
#endif
    f.ptr = NULL;
  }  // debug

ActivePtr() [5/5]

template<class X , class C = StandardCopyDefinition<X>>

Heed::ActivePtr< X, C >::ActivePtr ( X *  fptr, Pass    )

inline

Definition at line 355 of file AbsPtr.h.

: ptr(fptr) {}

~ActivePtr()

template<class X , class C = StandardCopyDefinition<X>>

virtual Heed::ActivePtr< X, C >::~ActivePtr ( )

inlinevirtual

Definition at line 366 of file AbsPtr.h.

                       { 
    // unfortunately it should be virtual
    // in order to avoid some rare (not met in practice but
    // in principle possible) problems with ActivePtrReg.
    // Therefore (if there is a virtual member)
    // we can also include virtual copy (see above),
    // although there is no obvious application for it
    // (multiple indirection depth, but for what?).
    if (ptr != NULL) {
      delete ptr;
      ptr = NULL;
    }
  }

Member Function Documentation

clear()

template<class X , class C = StandardCopyDefinition<X>>

void Heed::ActivePtr< X, C >::clear ( void  )

inline

Definition at line 281 of file AbsPtr.h.

                          {
#ifdef DEBUG_ACTIVEPTR
    mcout << "ActivePtr::clear is called, ptr =" << ptr << '\n';
#endif
    if (ptr) {
      delete ptr;
      ptr = NULL;
    }
  }

Referenced by Heed::operator>>().

copy()

template<class X , class C = StandardCopyDefinition<X>>

virtual ActivePtr * Heed::ActivePtr< X, C >::copy ( ) const

inlinevirtual

Definition at line 365 of file AbsPtr.h.

{ return new ActivePtr(*this); }

extract()

template<class X , class C = StandardCopyDefinition<X>>

X * Heed::ActivePtr< X, C >::extract ( void  )

inline

Definition at line 276 of file AbsPtr.h.

                          {
    X* ret = ptr;
    ptr = NULL;
    return ret;
  }

Referenced by Heed::exchange().

get()

template<class X , class C = StandardCopyDefinition<X>>

X * Heed::ActivePtr< X, C >::get ( void  ) const

inline

Definition at line 215 of file AbsPtr.h.

{ return ptr; }

Referenced by Heed::ExAtomPhotoAbsCS::ExAtomPhotoAbsCS(), and Heed::operator<<().

getver()

template<class X , class C >

X * Heed::ActivePtr< X, C >::getver ( void  ) const

inline

Definition at line 465 of file AbsPtr.h.

                                            {
#ifdef SKIP_CHECKS_NULL
  return ptr;
#else
  if (ptr) return ptr;
  mcerr << "Error in X* ActivePtr<X,C>::getver(void) const: "
        << " ptr == NULL\n";
  mcerr << "Type of X is (in internal notations) " << typeid(X).name() << '\n';
  spexit(mcerr);
  return ptr;
#endif
}

operator*()

template<class X , class C >

X & Heed::ActivePtr< X, C >::operator* ( void  ) const

inline

Definition at line 452 of file AbsPtr.h.

                                               {
#ifdef SKIP_CHECKS_NULL
  return *ptr;
#else
  if (ptr) return *ptr;
  mcerr << "Error in X& ActivePtr<X,C>::operator*(void) const: "
        << " ptr == NULL\n";
  mcerr << "Type of X is (in internal notations) " << typeid(X).name() << '\n';
  spexit(mcerr);
  return *ptr;
#endif
}

operator->()

template<class X , class C >

X * Heed::ActivePtr< X, C >::operator-> ( void  ) const

inline

Definition at line 438 of file AbsPtr.h.

                                                {
#ifdef SKIP_CHECKS_NULL
  return ptr;
#else
  if (ptr) return ptr;
  mcerr << "Error in X* ActivePtr<X,C>::operator->(void) const: "
        << " ptr == NULL\n";
  mcerr << "Type of X is (in internal notations) " << typeid(X).name() << '\n';
  // mcerr<<"Type of ptr is "<<typeid(ptr).name()<<'\n';
  spexit(mcerr);
  return ptr;
#endif
}

operator=()

template<class X , class C = StandardCopyDefinition<X>>

ActivePtr & Heed::ActivePtr< X, C >::operator= ( const ActivePtr< X, C > &  f )

inline

Definition at line 357 of file AbsPtr.h.

                                                        {
#ifdef DEBUG_ACTIVEPTR
    mcout << "inline ActivePtr& operator=(const ActivePtr<X,C>& f)\n";
#endif
    if (this != &f) put(f.ptr);
    return *this;
  }

pass()

template<class X , class C = StandardCopyDefinition<X>>

void Heed::ActivePtr< X, C >::pass ( X *  fptr )

inline

Definition at line 247 of file AbsPtr.h.

                            {
    // delete old owned object and
    // pass address of object fptr to ownership of this
    // without copying.
    // At fptr==NULL old object is deleted and new one is not copyed.
    // In general this is dengerous operation.
    // In particular if object pointed by fptr is direct or indirect part
    // of object pointed by ptr, it will be destroyed, which would probably
    // cause error.
    // But it is more efficient since does not require copying.
 
    if (ptr) {
      if (fptr) {
        mcerr << "ERROR in ActivePtr::pass(X* fptr):\n";
        mcerr << "Both the destination and source pointers are not empty\n";
        // if f belongs to *ptr, deletion of *ptr would lead to
        // deletion of f. In order to avoid this unexpected behaviour,
        // we interprete non-zero ptr as error.
        // The user should clear ptr first and then use this function.
        spexit(mcerr);
      } else {
        delete ptr;
      }
    }
    ptr = fptr;
  }

Referenced by Heed::exchange(), Heed::circumf::get_components(), Heed::plane::get_components(), Heed::polyline::get_components(), Heed::polyline_pl::get_components(), Heed::rectangle::get_components(), Heed::spquadr::get_components(), Heed::straight::get_components(), Heed::splane::get_components(), Heed::ulsvolume::get_components(), Heed::trajestep::get_components(), Heed::basis::get_components(), Heed::fixsyscoor::get_components(), and Heed::sh_manip_absvol::get_components().

pilfer()

template<class X , class C = StandardCopyDefinition<X>>

void Heed::ActivePtr< X, C >::pilfer ( const ActivePtr< X, C > &  f )

inline

Attention: actually not const

Definition at line 291 of file AbsPtr.h.

                                               {
      //!Attention: actually not const
#ifdef DEBUG_ACTIVEPTR
    mcout << "ActivePtr::pilfer is called\n";
#endif
    if (this != &f) {
      if (ptr) {
        if (f.ptr) {
          mcerr << "ERROR in ActivePtr::pilfer(...):\n";
          mcerr << "Both the destination and source pointers are not empty\n";
          // if f belongs to *ptr, deletion of *ptr would lead to
          // deletion of f. In order to avoid this unexpected behaviour,
          // we interprete non-zero ptr as error.
          // The user should clear ptr first and then use this function.
          spexit(mcerr);
        } else {
          delete ptr;
        }
      }
      ptr = f.ptr;
      f.ptr = NULL;
    }
    return;
  }

print()

template<class X , class C >

void Heed::ActivePtr< X, C >::print	(	std::ostream &	file,
		int	l = 1
	)		const

Definition at line 391 of file AbsPtr.h.

                                                         {
  Ifile << "ActivePtr<X,C>: ";
  if (ptr == NULL)
    file << " ptr==NULL. \n";  // optimized to provide automatic reading
  else {
    file << " ptr!=NULL: ";
    file << noindent;
    ptr->print(file, l);
    file << yesindent;
  }
}

put()

template<class X , class C = StandardCopyDefinition<X>>

void Heed::ActivePtr< X, C >::put ( const X *  fptr )

inline

Definition at line 225 of file AbsPtr.h.

                                 {
    // delete old owned object and copy object fptr to ownership of this.
    // At fptr == NULL old object is deleted and new one is not copied.
#ifdef DEBUG_ACTIVEPTR
    mcout << "inline void put(const X* fptr)\n";
    Iprintn(mcout, ptr);
    mcout << "Type of X is (in internal notations) " << typeid(X).name()
          << '\n';
    mcout << "Type of *fptr is (in internal notations) " << typeid(*fptr).name()
          << '\n';
#endif
    // Initialization of copy should go ahead, since
    // object *fptr could be dependant or part of *this,
    // and could be deleted prior to copying  at the reverse order.
    X* ptr_temp = (fptr != NULL ? C::copy(fptr) : (X*)(NULL));
    if (ptr) delete ptr;
    ptr = ptr_temp;
#ifdef DEBUG_ACTIVEPTR
    mcout << "finishing inline void put(const X* fptr):\n";
    Iprintn(mcout, ptr);
#endif
  }

Referenced by Heed::ActivePtr< X, C >::operator=(), and Heed::operator>>().

---

The documentation for this class was generated from the following file:

• AbsPtr.h