Heed::RegPassivePtr Class Reference

#include <AbsPtr.h>

Inheritance diagram for Heed::RegPassivePtr:

Public Member Functions
	RegPassivePtr (void)
	RegPassivePtr (char fs_ban_del, char fs_ban_sub, char fs_ban_cop=0)
	RegPassivePtr (const RegPassivePtr &f)
RegPassivePtr &	operator= (const RegPassivePtr &f)
CountPP_ns::CountPassivePtr *	book (void) const
void	clear_pointers (void) const
virtual RegPassivePtr *	copy () const
virtual	~RegPassivePtr ()
virtual void	print (std::ostream &file, int l=1) const
void	set_s_ban_del (char fs_ban_del)
char	get_s_ban_del (void) const
void	set_s_ban_sub (char fs_ban_sub)
char	get_s_ban_sub (void) const
void	set_s_ban_cop (char fs_ban_cop)
char	get_s_ban_cop (void) const
void	set_s_allow_del_at_zero_count (char fs_allow_del_at_zero_count)
char	get_s_allow_del_at_zero_count (void) const
long	get_total_number_of_references (void) const

Static Public Member Functions
static void	set_s_ban_del_ignore (char fs_ban_del_ignore)
static char	get_s_ban_del_ignore (void)
static void	set_s_print_adr_cpp (char fs_print_adr_cpp)
static char	get_s_print_adr_cpp (void)

Friends
class	CountPP_ns::CountPassivePtr
std::ostream &	operator<< (std::ostream &file, const RegPassivePtr &f)

Detailed Description

Definition at line 254 of file AbsPtr.h.

Constructor & Destructor Documentation

RegPassivePtr() [1/3]

Heed::RegPassivePtr::RegPassivePtr ( void  )

inline

Definition at line 346 of file AbsPtr.h.

      :
#ifdef USE_BIT_OPERA
        control_word(0),
#elif defined USE_BIT_FIELDS
        conparam(),
#else
        s_ban_del(0),
        s_ban_sub(0),
        s_ban_cop(0),
#ifdef USE_DELETE_AT_ZERO_COUNT
        s_allow_del_at_zero_count(0),
#endif
#endif
        cpp(NULL) {
  }

Referenced by copy().

RegPassivePtr() [2/3]

Heed::RegPassivePtr::RegPassivePtr ( char  fs_ban_del, char  fs_ban_sub, char  fs_ban_cop = 0  )

inline

Definition at line 363 of file AbsPtr.h.

      :
#else
  inline RegPassivePtr(int fs_ban_del, int fs_ban_sub, int fs_ban_cop = 0)
      :
#endif
#ifdef USE_BIT_OPERA
        control_word(0),
#elif defined(USE_BIT_FIELDS)
        conparam(fs_ban_del, fs_ban_sub, fs_ban_cop),
#else
  s_ban_del(fs_ban_del), s_ban_sub(fs_ban_sub), s_ban_cop(fs_ban_cop),
#ifdef USE_DELETE_AT_ZERO_COUNT
      s_allow_del_at_zero_count(0),
#endif
#endif
        cpp(NULL) {
#ifdef USE_BIT_OPERA
    set_s_ban_del(fs_ban_del);
    set_s_ban_sub(fs_ban_sub);
    set_s_ban_cop(fs_ban_cop);
#endif
  }

RegPassivePtr() [3/3]

Heed::RegPassivePtr::RegPassivePtr

(

const RegPassivePtr &

f

)

Definition at line 16 of file AbsPtr.cpp.

    :
#ifdef USE_BIT_OPERA
      control_word(f.control_word),
#elif defined(USE_BIT_FIELDS)
      conparam(f.conparam),
#else
      s_ban_del(f.s_ban_del),
      s_ban_sub(f.s_ban_sub),
      s_ban_cop(f.s_ban_cop),
#ifdef USE_DELETE_AT_ZERO_COUNT
      s_allow_del_at_zero_count(f.s_allow_del_at_zero_count),
#endif
#endif
      cpp(NULL) {
// mcout<<"RegPassivePtr::RegPassivePtr(...) is started\n";
#ifdef USE_BIT_OPERA
  if (f.get_s_ban_cop() == 2) {
#elif defined(USE_BIT_FIELDS)
  if (f.conparam.s_ban_cop == 2) {
#else
  if (f.s_ban_cop == 2) {
#endif
    mcerr << "Error in "
          << "RegPassivePtr::RegPassivePtr(const RegPassivePtr& f):\n"
          << "attempt to copy object whose s_ban_cop == 2.\n";
    spexit(mcerr);
  }
#ifdef USE_BIT_OPERA
  else if (f.get_s_ban_cop() == 1 && f.cpp->get_number_of_booked() > 0) {
#elif defined(USE_BIT_FIELDS)
  else if (f.conparam.s_ban_cop == 1 && f.cpp->get_number_of_booked() > 0) {
#else
  else if (f.s_ban_cop == 1 && f.cpp->get_number_of_booked() > 0) {
#endif
    mcerr << "Error in "
          << "RegPassivePtr::RegPassivePtr(const RegPassivePtr& f):\n"
          << "attempt to copy referred object whose s_ban_cop == 1.\n"
          << "f.cpp->get_number_of_booked()=" << f.cpp->get_number_of_booked()
          << '\n';
    spexit(mcerr);
  }
}

~RegPassivePtr()

Heed::RegPassivePtr::~RegPassivePtr ( )

virtual

Definition at line 231 of file AbsPtr.cpp.

                              {
  // mcout<<"~RegPassivePtr(): *this="<<(*this)<<'\n';
  if (cpp != NULL) {
    cpp->change_rpp(NULL);
    if (cpp->get_number_of_booked() == 0) {
      delete cpp;
      cpp = NULL;
    } else {
#ifdef USE_BIT_OPERA
      if (s_ban_del_ignore == 0 && get_s_ban_del() == 1)
#elif defined(USE_BIT_FIELDS)
      if (s_ban_del_ignore == 0 && conparam.s_ban_del == 1)
#else
      if (s_ban_del_ignore == 0 && s_ban_del == 1)
#endif
      {
        mcerr << "Error in RegPassivePtr::~RegPassivePtr() "
              << "s_ban_del == 1, but there are pointers to this class.\n";
        mcerr << "cpp->number_of_registered=" << cpp->get_number_of_booked()
              << '\n';
        s_ban_del_ignore = 1;
        spexit(mcerr);
      }
    }
  }
}

Member Function Documentation

book()

CountPP_ns::CountPassivePtr * Heed::RegPassivePtr::book ( void  ) const

inline

Definition at line 394 of file AbsPtr.h.

                                                     {
    if (!cpp) cpp = new CountPP_ns::CountPassivePtr(this);
    cpp->book();
    return cpp;
  }

Referenced by Heed::PassivePtr< X >::put().

clear_pointers()

void Heed::RegPassivePtr::clear_pointers ( void  ) const

inline

Definition at line 400 of file AbsPtr.h.

                                         { 
    // all pointers addressing this are cleared;
    if (cpp) cpp->change_rpp(NULL);
  }

Referenced by operator=().

copy()

virtual RegPassivePtr * Heed::RegPassivePtr::copy ( ) const

inlinevirtual

Reimplemented in Heed::DynLinArr< T >, Heed::DynLinArr< long >, Heed::DynLinArr< D >, Heed::DynArr< T >, and Heed::DynArr< D >.

Definition at line 405 of file AbsPtr.h.

{ return new RegPassivePtr(*this); }

get_s_allow_del_at_zero_count()

char Heed::RegPassivePtr::get_s_allow_del_at_zero_count ( void  ) const

inline

Definition at line 763 of file AbsPtr.h.

  {
    if ((control_word & eb_s_allow_del_at_zero_count) != 0)
      return 1;
    else
      return 0;
  }
#elif defined(USE_BIT_FIELDS)
  {
    return conparam.s_allow_del_at_zero_count;
  }
#else
  { return s_allow_del_at_zero_count; }

Referenced by Heed::PassivePtr< X >::move_pointer(), operator=(), Heed::PassivePtr< X >::put(), and Heed::PassivePtr< X >::~PassivePtr().

get_s_ban_cop()

char Heed::RegPassivePtr::get_s_ban_cop ( void  ) const

inline

Definition at line 707 of file AbsPtr.h.

  {
    if ((control_word & eb_s_ban_cop2) == 0) {
      if ((control_word & eb_s_ban_cop1) == 0)
        return 0;
      else
        return 1;
    } else {
      return 2;
    }
  }
#elif defined USE_BIT_FIELDS
  {
    return conparam.s_ban_cop;
  }
#else
  { return s_ban_cop; }

Referenced by operator=(), and RegPassivePtr().

get_s_ban_del()

char Heed::RegPassivePtr::get_s_ban_del ( void  ) const

inline

Definition at line 567 of file AbsPtr.h.

  {
    if ((control_word & eb_s_ban_del) != 0)
      return 1;
    else
      return 0;
  }
#elif defined(USE_BIT_FIELDS)
  {
    return conparam.s_ban_del;
  }
#else
  { return s_ban_del; }

Referenced by operator=(), and ~RegPassivePtr().

get_s_ban_del_ignore()

static char Heed::RegPassivePtr::get_s_ban_del_ignore ( void  )

inlinestatic

Definition at line 604 of file AbsPtr.h.

  {
    return s_ban_del_ignore;
  }

get_s_ban_sub()

char Heed::RegPassivePtr::get_s_ban_sub ( void  ) const

inline

Definition at line 647 of file AbsPtr.h.

  {
    if ((control_word & eb_s_ban_sub2) == 0) {
      if ((control_word & eb_s_ban_sub1) == 0)
        return 0;
      else
        return 1;
    } else {
      // Iprintn(mcout, (control_word & eb_s_ban_sub1) );
      // Iprintn(mcout, (control_word & eb_s_ban_sub2) );
      return 2;
    }
  }
#elif defined(USE_BIT_FIELDS)
  {
    return conparam.s_ban_sub;
  }
#else
  { return s_ban_sub; }

Referenced by operator=().

get_s_print_adr_cpp()

static char Heed::RegPassivePtr::get_s_print_adr_cpp ( void  )

inlinestatic

Definition at line 802 of file AbsPtr.h.

  {
    return s_print_adr_cpp;
  }

get_total_number_of_references()

long Heed::RegPassivePtr::get_total_number_of_references

(

void

)

const

Definition at line 222 of file AbsPtr.cpp.

                                                             {
  if (cpp == NULL)
    return 0;
  else
    return cpp->get_number_of_booked();
}

operator=()

RegPassivePtr & Heed::RegPassivePtr::operator=

(

const RegPassivePtr &

f

)

Definition at line 60 of file AbsPtr.cpp.

                                                              {
// mcout<<"RegPassivePtr::operator= is started\n";
#ifdef USE_BIT_OPERA
  if (f.get_s_ban_cop() == 2) {
#elif defined(USE_BIT_FIELDS)
  if (f.conparam.s_ban_cop == 2) {
#else
  if (f.s_ban_cop == 2) {
#endif
    mcerr << "Error in "
          << "RegPassivePtr& RegPassivePtr::operator=(const RegPassivePtr& "
             "f):\n"
          << "attempt to copy object whose s_ban_cop == 2.\n";
    spexit(mcerr);
#ifdef USE_BIT_OPERA
  } else if (f.get_s_ban_cop() == 1 && f.cpp->get_number_of_booked() > 0) {
#elif defined(USE_BIT_FIELDS)
  } else if (f.conparam.s_ban_cop == 1 && f.cpp->get_number_of_booked() > 0) {
#else
  } else if (f.s_ban_cop == 1 && f.cpp->get_number_of_booked() > 0) {
#endif
    mcerr << "Error in "
          << "RegPassivePtr& RegPassivePtr::operator=(const "
             "RegPassivePtr& f):\n"
          << "attempt to copy referred object whose s_ban_cop == 1.\n"
          << "f.cpp->get_number_of_booked()=" << f.cpp->get_number_of_booked()
          << '\n';
    spexit(mcerr);
  }
#ifdef USE_BIT_OPERA
  set_s_ban_cop(f.get_s_ban_cop());
#ifdef USE_DELETE_AT_ZERO_COUNT
  set_s_allow_del_at_zero_count(f.get_s_allow_del_at_zero_count());
#endif
  set_s_ban_del(f.get_s_ban_del());
  if (get_s_ban_sub() == 1)
#elif defined(USE_BIT_FIELDS)
  conparam.s_ban_cop = f.conparam.s_ban_cop;
#ifdef USE_DELETE_AT_ZERO_COUNT
  conparam.s_allow_del_at_zero_count = f.conparam.s_allow_del_at_zero_count;
#endif
  conparam.s_ban_del = f.conparam.s_ban_del;
  if (conparam.s_ban_sub == 1)
#else
  s_ban_cop = f.s_ban_cop;
#ifdef USE_DELETE_AT_ZERO_COUNT
  s_allow_del_at_zero_count = f.s_allow_del_at_zero_count;
#endif
  s_ban_del = f.s_ban_del;
  if (s_ban_sub == 1)
#endif
  {
    if (this == &f &&  // self-assignment
        cpp != NULL && cpp->get_number_of_booked() > 0) {
      mcerr << "Error in "
            << "RegPassivePtr& RegPassivePtr::operator=(const RegPassivePtr& "
               "f):\n"
            << "self-assignment, s_ban_sub == 1, but the object is addressed.\n"
            << "This can lead to loss of pointers to copied object, not only "
               "to this one.\n";
      spexit(mcerr);
    }
    clear_pointers();
  }
#ifdef USE_BIT_OPERA
  else if (get_s_ban_sub() == 2 && cpp != NULL &&
           cpp->get_number_of_booked() > 0)
#elif defined(USE_BIT_FIELDS)
  else if (conparam.s_ban_sub == 2 && cpp != NULL &&
           cpp->get_number_of_booked() > 0)
#else
  else if (s_ban_sub == 2 && cpp != NULL && cpp->get_number_of_booked() > 0)
#endif
  {
    mcerr << "Error in "
          << "RegPassivePtr& RegPassivePtr::operator=(const RegPassivePtr& "
             "f):\n"
          << "s_ban_sub == 2, but the object is addressed.\n";
    spexit(mcerr);
  }
#ifdef USE_BIT_OPERA
  set_s_ban_sub(f.get_s_ban_sub());
#elif defined(USE_BIT_FIELDS)
  conparam.s_ban_sub = f.conparam.s_ban_sub;
#else
  s_ban_sub = f.s_ban_sub;
#endif
  return *this;
}

print()

void Heed::RegPassivePtr::print ( std::ostream &  file, int  l = 1  ) const

virtual

Definition at line 152 of file AbsPtr.cpp.

                                                       {
  if (l > 0) file << (*this);
}

Referenced by Heed::print_adr_DynLinArr(), and Heed::print_DynLinArr().

set_s_allow_del_at_zero_count()

void Heed::RegPassivePtr::set_s_allow_del_at_zero_count ( char  fs_allow_del_at_zero_count )

inline

Definition at line 733 of file AbsPtr.h.

  {
#ifdef USE_BIT_OPERA
    if (fs_allow_del_at_zero_count == 0)
      clear_bit(control_word, eb_s_allow_del_at_zero_count);
    else if (fs_allow_del_at_zero_count == 1)
      rise_bit(control_word, eb_s_allow_del_at_zero_count);
#else
    if (fs_allow_del_at_zero_count == 0 || fs_allow_del_at_zero_count == 1) {
#ifdef USE_BIT_FIELDS
      conparam.s_allow_del_at_zero_count = fs_allow_del_at_zero_count;
#else
      s_allow_del_at_zero_count = fs_allow_del_at_zero_count;
#endif
    }
#endif
    else {
      mcerr << "ERROR in inline void set_s_allow_del_at_zero_count(int "
               "fs_allow_del_at_zero_count):\n";
      mcerr << "s_allow_del_at_zero_count is outside limits, "
               "s_allow_del_at_zero_count=" << int(fs_allow_del_at_zero_count)
            << '\n';
      spexit(mcerr);
    }
  }

Referenced by operator=().

set_s_ban_cop()

void Heed::RegPassivePtr::set_s_ban_cop ( char  fs_ban_cop )

inline

Definition at line 673 of file AbsPtr.h.

  {
#ifdef USE_BIT_OPERA
    if (fs_ban_cop == 0) {
      clear_bit(control_word, eb_s_ban_cop1);
      clear_bit(control_word, eb_s_ban_cop2);
    } else if (fs_ban_cop == 1) {
      rise_bit(control_word, eb_s_ban_cop1);
      clear_bit(control_word, eb_s_ban_cop2);
    } else if (fs_ban_cop == 2) {
      clear_bit(control_word, eb_s_ban_cop1);
      rise_bit(control_word, eb_s_ban_cop2);
    }
#else
    if (fs_ban_cop >= 0 && fs_ban_cop <= 2) {
#ifdef USE_BIT_FIELDS
      conparam.s_ban_cop = fs_ban_cop;
#else
      s_ban_cop = fs_ban_cop;
#endif
    }
#endif
    else {
      mcerr << "ERROR in inline void set_s_ban_cop(int fs_ban_cop):\n";
      mcerr << "s_ban_cop is outside limits, s_ban_cop=" << int(fs_ban_cop)
            << '\n';
      spexit(mcerr);
    }
  }

Referenced by operator=(), and RegPassivePtr().

set_s_ban_del()

void Heed::RegPassivePtr::set_s_ban_del ( char  fs_ban_del )

inline

Definition at line 539 of file AbsPtr.h.

  {
#ifdef USE_BIT_OPERA
    if (fs_ban_del == 0)
      clear_bit(control_word, eb_s_ban_del);
    else if (fs_ban_del == 1)
      rise_bit(control_word, eb_s_ban_del);
#else
    if (fs_ban_del == 0 || fs_ban_del == 1) {
#ifdef USE_BIT_FIELDS
      conparam.s_ban_del = fs_ban_del;
#else
      s_ban_del = fs_ban_del;
#endif
    }
#endif
    else {
      mcerr << "ERROR in inline void set_s_ban_del(int fs_ban_del):\n";
      mcerr << "s_ban_del is outside limits, s_ban_del=" << int(fs_ban_del)
            << '\n';
      spexit(mcerr);
    }
  }

Referenced by operator=(), and RegPassivePtr().

set_s_ban_del_ignore()

static void Heed::RegPassivePtr::set_s_ban_del_ignore ( char  fs_ban_del_ignore )

inlinestatic

Definition at line 587 of file AbsPtr.h.

  {
    if (fs_ban_del_ignore == 0 || fs_ban_del_ignore == 1) {
      s_ban_del_ignore = fs_ban_del_ignore;
    } else {
      mcerr << "ERROR in inline void set_s_ban_del_ignore(int "
               "fs_ban_del_ignore ):\n";
      mcerr << "s_ban_del_ignore is outside limits, s_ban_del_ignore="
            << int(fs_ban_del_ignore) << '\n';
      spexit(mcerr);
    }
  }

set_s_ban_sub()

void Heed::RegPassivePtr::set_s_ban_sub ( char  fs_ban_sub )

inline

Definition at line 613 of file AbsPtr.h.

  {
#ifdef USE_BIT_OPERA
    if (fs_ban_sub == 0) {
      clear_bit(control_word, eb_s_ban_sub1);
      clear_bit(control_word, eb_s_ban_sub2);
    } else if (fs_ban_sub == 1) {
      rise_bit(control_word, eb_s_ban_sub1);
      clear_bit(control_word, eb_s_ban_sub2);
    } else if (fs_ban_sub == 2) {
      clear_bit(control_word, eb_s_ban_sub1);
      rise_bit(control_word, eb_s_ban_sub2);
    }
#else
    if (fs_ban_sub >= 0 && fs_ban_sub <= 2) {
#ifdef USE_BIT_FIELDS
      conparam.s_ban_sub = fs_ban_sub;
#else
      s_ban_sub = fs_ban_sub;
#endif
    }
#endif
    else {
      mcerr << "ERROR in inline void set_s_ban_sub(int fs_ban_sub):\n";
      mcerr << "s_ban_sub is outside limits, s_ban_sub=" << int(fs_ban_sub)
            << '\n';
      spexit(mcerr);
    }
  }

Referenced by operator=(), and RegPassivePtr().

set_s_print_adr_cpp()

static void Heed::RegPassivePtr::set_s_print_adr_cpp ( char  fs_print_adr_cpp )

inlinestatic

Definition at line 785 of file AbsPtr.h.

  {
    if (fs_print_adr_cpp == 0 || fs_print_adr_cpp == 1) {
      s_print_adr_cpp = fs_print_adr_cpp;
    } else {
      mcerr << "ERROR in inline void set_s_print_adr_cpp(int fs_print_adr_cpp "
               "):\n";
      mcerr << "s_print_adr_cpp is outside limits, s_print_adr_cpp="
            << int(fs_print_adr_cpp) << '\n';
      spexit(mcerr);
    }
  }

Friends And Related Function Documentation

CountPP_ns::CountPassivePtr

friend class CountPP_ns::CountPassivePtr

friend

Definition at line 256 of file AbsPtr.h.

operator<<

std::ostream & operator<< ( std::ostream &  file, const RegPassivePtr &  f  )

friend

Definition at line 156 of file AbsPtr.cpp.

                                                                 {
#ifdef USE_BIT_OPERA
#ifdef USE_CHAR_GETSETTERS_PARAMETERS
  Ifile << "RegPassivePtr<X>: s_ban_del/sub/cop=" << int(f.get_s_ban_del())
        << "/" << int(f.get_s_ban_sub()) << "/" << int(f.get_s_ban_cop());
#else
  Ifile << "RegPassivePtr<X>: s_ban_del/sub/cop=" << f.get_s_ban_del() << "/"
        << f.get_s_ban_sub() << "/" << f.get_s_ban_cop();
#endif
#elif defined USE_BIT_FIELDS
  Ifile << "RegPassivePtr<X>: s_ban_del/sub/cop=" << f.conparam.s_ban_del << "/"
        << f.conparam.s_ban_sub << "/" << f.conparam.s_ban_cop;
#else
#ifdef USE_CHAR_CONTROL_VARIABLES
  Ifile << "RegPassivePtr<X>: s_ban_del/sub/cop=" << int(f.s_ban_del) << "/"
        << int(f.s_ban_sub) << "/" << int(f.s_ban_cop);
#else
  Ifile << "RegPassivePtr<X>: s_ban_del/sub/cop=" << f.s_ban_del << "/"
        << f.s_ban_sub << "/" << f.s_ban_cop;
#endif
#endif
  /*
    Ifile<<"RegPassivePtr<X>: s_ban_del="<<f.s_ban_del
         <<" s_ban_sub="<<f.s_ban_sub
         <<" s_ban_cop="<<f.s_ban_cop;
           */
  if (RegPassivePtr::s_print_adr_cpp == 0) {
    if (f.cpp == NULL) {
      file << " cpp=NULL\n";
    } else {
      file << " cpp!=NULL\n";
    }
  } else {
    file << " cpp=" << f.cpp << '\n';
  }
  if (f.cpp != NULL) {
    indn.n += 2;
    Ifile << "cpp->number_of_registered=" << f.cpp->get_number_of_booked()
          << '\n';
    indn.n -= 2;
  }
#ifdef USE_DELETE_AT_ZERO_COUNT
  indn.n += 2;
#ifdef USE_BIT_OPERA
  Ifile << "s_allow_del_at_zero_count="
#ifdef USE_CHAR_GETSETTERS_PARAMETERS
        << int(f.get_s_allow_del_at_zero_count()) << '\n';
#else
        << f.get_s_allow_del_at_zero_count() << '\n';
#endif
#elif defined(USE_BIT_FIELDS)
  Ifile << "s_allow_del_at_zero_count=" << f.conparam.s_allow_del_at_zero_count
        << '\n';
#else
#ifdef USE_CHAR_CONTROL_VARIABLES
  Ifile << "s_allow_del_at_zero_count=" << int(f.s_allow_del_at_zero_count)
        << '\n';
#else
  Ifile << "s_allow_del_at_zero_count=" << f.s_allow_del_at_zero_count << '\n';
#endif
#endif
  indn.n -= 2;
#endif
  return file;
}

---

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

• AbsPtr.h
• AbsPtr.cpp