object.h

/*
 *  Copyright (c) 2001-2003    National Research Council
 *
 *  All rights reserved.
 *
 *  This material is confidential and proprietary information of
 *  National Research Council Canada ("Confidential Information").
 *  This Confidential Information may only be used and reproduced
 *  in accordance with the terms of the license agreement.
 *
 */

#ifndef __INCLUDED__SCOPIRA_TOOL_OBJECT_H__
#define __INCLUDED__SCOPIRA_TOOL_OBJECT_H__

#include <assert.h>

#include <scopira/tool/mutex.h>
#include <scopira/tool/export.h>

// THIS FILE HAS BEEN FULLY DOCUMENTED

namespace scopira
{
  namespace tool
  {
    class object;       // obj for short

    template <class T> class count_ptr;
    template <class T> class count2_ptr;
    //typedef count_ptr<object> objauto; //this is dangerous, dont use it (as it slices t_object's into simple object)

    // forward decl
    class oflow_i;
    class oobjflow_i;
    class iobjflow_i;
  }
}

class scopira::tool::object
{
  private:

  mutable volatile int dm_refcount;      // current ref count, mutal and transient
  mutable mutex dm_refcount_mutex;
#ifndef NDEBUG
  volatile int dm_object_magic;          // magic key for object class
  volatile bool dm_use_debug_ref_counter;   // when created, was the ref counter debug thing available?
#endif

  public:

    SCOPIRA_EXPORT virtual ~object();

    //
    // reference stuff
    //

    SCOPIRA_EXPORT int add_ref(void) const;

    SCOPIRA_EXPORT bool sub_ref(void) const;

    SCOPIRA_EXPORT void auto_ref(void) const;

    SCOPIRA_EXPORT int current_ref(void) const;

    //
    // serialization stuff
    //

    SCOPIRA_EXPORT virtual scopira::tool::oflow_i & print(scopira::tool::oflow_i &o) const;

    SCOPIRA_EXPORT virtual bool load(scopira::tool::iobjflow_i& in);
    SCOPIRA_EXPORT virtual void save(scopira::tool::oobjflow_i& out) const;

#ifndef NDEBUG

    bool is_alive_object(void) const { return this && (dm_object_magic == -236944); }
    bool is_dead_object(void) const { return dm_object_magic == 5529022; }
#endif

  protected:
    SCOPIRA_EXPORT object(void);

    SCOPIRA_EXPORT explicit object(bool neverusecounter);

  private:
    object(const object &o);

    void operator = (const object &rhs);
};

template <class T> class scopira::tool::count_ptr
{
  public:
    typedef T data_type;

  protected:
    T *dm_ptr;

  public:
    count_ptr(void)
      : dm_ptr(0) { }
    count_ptr(T *o)
      : dm_ptr(o) { if (o) o->add_ref(); }
    count_ptr(const count_ptr<T> &o)
      : dm_ptr(o.dm_ptr) { if (dm_ptr) dm_ptr->add_ref(); }
    template <class Y> count_ptr(const count_ptr<Y> &o)
      : dm_ptr(o.get()) { if (dm_ptr) dm_ptr->add_ref(); }
    ~count_ptr()
      { if (dm_ptr) dm_ptr->sub_ref(); }

    void set(T* o)
      { if (o) o->add_ref(); if (dm_ptr) dm_ptr->sub_ref(); dm_ptr = o; }
    count_ptr & operator = (T *o)
      { set(o); return *this; }

    count_ptr & operator = (const count_ptr<T> &o)
      { set(o.dm_ptr); return *this; }
    bool operator == (const count_ptr<T> &rhs) const { return dm_ptr == rhs.dm_ptr; }
    bool operator == (const T* rhs) const { return dm_ptr == rhs; }
    bool operator != (const count_ptr<T> &rhs) const { return dm_ptr != rhs.dm_ptr; }
    bool operator != (const T* rhs) const { return dm_ptr != rhs; }
    bool operator < (const count_ptr<T> &rhs) const { return dm_ptr < rhs.dm_ptr; }

    scopira::tool::oflow_i & print(scopira::tool::oflow_i &o) const
       { if (dm_ptr) dm_ptr->print(o); /*else o<<"(null)";*/ return o; }

    // do save and load like the above?

    T* get(void) const { return dm_ptr; }

    T& ref(void) const
      { assert("[NULL pointer dereferenced in count_ptr]" && dm_ptr); return *dm_ptr; }
    //T& ref(void)
      //{ assert(dm_ptr); return *dm_ptr; }

    T* operator ->(void) const
      { assert("[NULL pointer dereferenced in count_ptr]" && dm_ptr); return dm_ptr; }
    //T* operator ->(void)
      //{ assert(dm_ptr); return dm_ptr; }

    T & operator *(void) const
      { assert("[NULL pointer dereferenced in count_ptr]" && dm_ptr); return *dm_ptr; }

    bool is_null(void) const { return dm_ptr == 0; }
};

template <class T> class scopira::tool::count2_ptr
{
  protected:
    T* dm_ptr;
    bool dm_doref;

  public:
    typedef T ptr_type;

    /*count2_ptr(bool doref)
      : dm_ptr(0), dm_doref(doref) { }*/
    count2_ptr(bool doref, T* o)
      : dm_ptr(o), dm_doref(doref) { if (doref && o) o->add_ref(); }
    count2_ptr(const count_ptr<T>& o)
      : dm_ptr(o.dm_ptr), dm_doref(o.dm_doref) { if (dm_doref && dm_ptr) dm_ptr->add_ref(); }
    ~count2_ptr()
      { if (dm_doref && dm_ptr) dm_ptr->sub_ref(); }

    void set(T* o)
      { if (dm_doref && o) o->add_ref(); if (dm_doref && dm_ptr) dm_ptr->sub_ref(); dm_ptr = o; }
    count2_ptr& operator=(T* o)
      { set(o); return *this; }

    count2_ptr& operator=(const count2_ptr<T>& o)
      { set(o.dm_ptr); return *this; }
    bool operator == (const count2_ptr<T>& rhs) const { return dm_ptr == rhs.dm_ptr; }
    bool operator == (const T* rhs) const { return dm_ptr == rhs; }
    bool operator != (const count2_ptr<T>& rhs) const { return dm_ptr != rhs.dm_ptr; }
    bool operator != (const T* rhs) const { return dm_ptr != rhs; }
    bool operator < (const count2_ptr<T>& rhs) const { return dm_ptr < rhs.dm_ptr; }

     oflow_i& print(oflow_i& o) const
       { if (dm_ptr) dm_ptr->print(o); return o; }

    // do save and load like the above?

    T* get(void) const { return dm_ptr; }

    operator T*(void) const { return dm_ptr; }
    //T* get(void)
      //{ return dm_ptr; }

    T& ref(void) const
      { assert("[NULL pointer dereferenced in count_ptr]" && dm_ptr); return *dm_ptr; }
    //T& ref(void)
      //{ assert(dm_ptr); return *dm_ptr; }

    T* operator ->(void) const
      { assert("[NULL pointer dereferenced in count_ptr]" && dm_ptr); return dm_ptr; }
    //T* operator ->(void)
      //{ assert(dm_ptr); return dm_ptr; }

    T & operator *(void) const
      { assert("[NULL pointer dereferenced in count_ptr]" && dm_ptr); return *dm_ptr; }

    bool is_null(void) const { return dm_ptr == 0; }
};

SCOPIRA_EXPORT scopira::tool::oflow_i & operator << (scopira::tool::oflow_i &o, const scopira::tool::object &vl);

SCOPIRA_EXPORT scopira::tool::oflow_i & operator << (scopira::tool::oflow_i &o, const scopira::tool::object *vl);

template <class C>
  inline scopira::tool::oflow_i & operator << (scopira::tool::oflow_i &o, const scopira::tool::count_ptr<C> &ptr)
{
  return o << ptr.get();
}



//
// *** DEBUG ROUTINES
//

#ifndef NDEBUG
namespace scopira
{
  namespace tool
  {
    class objrefcounter;
  }
}

class scopira::tool::objrefcounter
{
  protected:
    static int dm_ref;
    static int dm_peak;
    static int dm_tot;
    static int dm_baddel;
    static int dm_real;
    
  public:
    SCOPIRA_EXPORT objrefcounter(void);
    SCOPIRA_EXPORT ~objrefcounter();

  public:
    void foo(void) const { }
    
  private:
    friend class object;

    static bool has_counter(void);
    static void add_ref(void);
    static void sub_ref(void);
    static void bad_del(void);
    static void add_real(void);
    static void sub_real(void);

    static void output(void);
};

// NDEBUG
#endif

#endif