VRS - The Virtual Rendering System

version 3.3

so.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2004 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * This  library  is  free  software; you can redistribute it and/or  modify it
 * under the terms of the GNU Lesser General Public  License  as  published  by
 * the  Free  Software  Foundation;  either  version 2.1 of the License, or (at
 * your option) any later version. This library  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
 * GNU Lesser General Public License for more details. You should have received
 * a copy of the GNU Lesser+ General Public License along with this library; if
 * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

// $Id: so.h 6649 2009-01-28 10:48:51Z Amir_Semmo $
// $Date: 2009-01-28 11:48:51 +0100 (Wed, 28 Jan 2009) $
// $Revision: 6649 $
// $State$
// $Author: Amir_Semmo $
//
// $Log$
// Revision 1.45  2006/03/17 16:40:01  buchholz
//  - static_cast for dereferencing added to provoke compiler errors
//    if SOs are used for Non-SO-Objects
//  - VRS_Cast removed from serialize-method to avoid lots of
//    unnecessary includes in header files
//
// Revision 1.44  2005/07/26 19:44:14  baumann
// fixed some GLX problems with glXGetProcAddress() and glXGetProcAddressARB()
//
// Revision 1.43  2005/01/03 01:43:08  klimetschek
// - modified win32 project layout, splitted vrs.vcproj into vrs_container, vrs_core, vrs_sg, vrs_image, vrs_opengl and vrs_io
// - removed vrs.vcproj
// minor things:
// - added all glutexamples to vrs4glut.sln
// - fixed some problems in glutexamples
// - removed all project references from all VS projects (using solution wide project dependencies instead)
//
// Revision 1.42  2004/11/05 13:58:09  basch
// Class comment changed (Doxygen style)
//
// Revision 1.41  2004/10/15 12:49:54  kirsch
// fix for VC6
//
// Revision 1.40  2004/10/06 16:49:28  baumann
// automatic conversions between SO<T> and WO<T> fixed for VS C++ .NET and GCC
//
// Revision 1.39  2004/10/05 14:38:22  baumann
// fix for the last fix :-)
//
// Revision 1.38  2004/10/05 14:22:05  baumann
// automatic conversion from SO<T> to WO<T> and back again added
//
// Revision 1.37  2004/05/18 06:38:09  baumann
// - memory leak detector added (in DEBUG mode only!)
// - tracking of source code locations of references added (in DEBUG mode only!)
//
// Revision 1.36  2004/03/17 07:10:25  baumann
// bug fix for WO<T>
//
// Revision 1.35  2004/03/12 16:28:39  baumann
// macros VRS_NAMESPACE_BEGIN/_END expanded and removed
//
// Revision 1.34  2004/03/03 14:24:26  kirsch
// added templated assignment operator to permit assignment from SO<Derived> to SO<Base> (gcc)
//
// Revision 1.33  2004/02/26 19:39:13  baumann
// - conversion from SO<T> to SO<S> simplified
// - conversion from WO<T> to WO<S> simplified
//
// Revision 1.32  2004/02/26 11:07:23  baumann
// WO<T>: weak object pointer added
//
// Revision 1.31  2004/01/29 10:39:21  wendland
// first serialization method now checks typeid
//
// Revision 1.30  2004/01/29 08:58:36  kirsch
// added compile fix for VC6.0
//
// Revision 1.29  2004/01/27 13:45:24  baumann
// templated members added
//
// Revision 1.28  2004/01/19 17:07:21  baumann
// moved VRS::Document from vrs/ to vrs/io/
//
// Revision 1.27  2004/01/19 13:14:41  baumann
// #include <vrs/io/document.h> added or removed
//
// Revision 1.26  2004/01/19 11:43:57  baumann
// serialization mechanism improved
//
// Revision 1.25  2004/01/19 07:28:03  baumann
// serialization mechanism improved
//
// Revision 1.24  2004/01/15 14:16:53  baumann
// serialization mechanism improved
//
// Revision 1.23  2004/01/13 16:51:16  baumann
// "SerializationManager& doc" replaced in serialization() function by "SerializationManager& manager"
//
// Revision 1.22  2004/01/13 15:47:35  baumann
// new global serialization() function added
//
// Revision 1.21  2003/12/07 11:15:26  kirsch
// removed unnecessary includes
// removed obsolete comment which still described VRS_STATIC_SO_WITH_CONSTRUCTION
//
// Revision 1.20  2003/02/14 12:43:34  baumann
// macro VRS_STATIC_SO_WITH_CONSTRUCTION removed again
//
// Revision 1.19  2003/02/14 11:16:22  baumann
// typo fixed for VRS_STATIC_SO_WITH_CONSTRUCTION
//
// Revision 1.18  2003/02/14 10:33:46  baumann
// - using reinterpret_cast<> instead of old C-style cast
// - VRS_STATIC_SO and VRS_STATIC_SO_WITH_CONSTRUCTION macros added
//
// Revision 1.17  2003/01/02 10:45:08  baumann
// implemented all methods inline due to a compiler/optimizer
// bug of Intel-C++-7.0 in release mode
//
// Revision 1.16  2002/12/02 22:03:32  baumann
// operator< added
//
// Revision 1.15  2002/08/06 16:24:01  baumann
// VRS_CORE_API removed for template classes
//
// Revision 1.14  2002/07/15 14:58:45  kirsch
// cast string without effect (in assert) to void (removes warning in gcc)
//
// Revision 1.13  2002/07/11 15:15:30  baumann
// code cleanup
// comments changed
// asserts added
//
// Revision 1.12  2002/04/29 06:26:05  kirsch
// removed inline from operator-() definition
//
// Revision 1.11  2002/04/04 11:30:02  baumann
// code clean up
//
// Revision 1.10  2002/02/24 16:39:16  kosta
// VRS_CLASSNAME macros now consider namespace prefixes
//
// Revision 1.9  2002/02/19 10:34:12  kosta
// undone all changes since 2002-02-15
//
// Revision 1.6  2002/02/05 07:48:25  kosta
// new persistency macros:
//     VRS_SERIALIZABLE(CLASS_NAME);
//     VRS_SERIALIZABLE_ABSTRACT_CLASS(CLASS_NAME);
//     VRS_SERIALIZABLE_NO_SO_CLASS(CLASS_NAME)
//
// Revision 1.5  2002/02/04 11:54:37  kosta
// persistency rewritten (for better namespace support)
//
// Revision 1.4  2002/01/15 16:25:54  kosta
// macros rewritten for a better namespace support
//
// Revision 1.3  2002/01/10 14:05:21  kosta
// VRS-name mechanism reworked to support different namespaces
//
// Revision 1.2  2001/11/13 16:36:31  kirsch
// changed line feed to unix style (removed control-M)
//
// Revision 1.1.1.1  2001/06/08 08:09:20  kirsch
// imported alpha-version by olli 
//

#ifndef VRS_SO_H
#define VRS_SO_H

#include <vrs/sharedobj.h>
#include <cassert>
#include <stdlib.h>

namespace VRS {

class SharedObj;
class WeakPointerBase;
template<class T> class SO;
template<class T> class WO;

template<class T>
class SO {

public:
    SO()                : m_obj(NULL)                {               }
    SO(T* obj)          : m_obj(obj)                 { ref(m_obj);   }
    SO(const SO& so)    : m_obj(so.m_obj)            { ref(m_obj);   }
    SO(const WO<T>& wo) : m_obj(static_cast<T*>(wo)) { ref(m_obj);   }
    ~SO()                                            { unref(m_obj); }
    SO& operator=(T* obj)          { if(m_obj != obj) { ref(obj); unref(m_obj); m_obj = obj; } return *this; }
    SO& operator=(const SO& so)    { return operator=(so.m_obj);                                             }
    SO& operator=(const WO<T>& wo) { return operator=(static_cast<T*>(wo));                                  }
#if !defined(_MSC_VER) || (_MSC_VER >= 1300) // all compilers except visual studio < 7.0
    template<class S>
    SO& operator=(const SO<S>& so) { return operator=(static_cast<S*>(so));                                  }
#endif // all compilers except visual studio < 7.0

    bool operator<(const T* obj) const { return (m_obj < obj);      }
    bool operator<(const SO& so) const { return (m_obj < so.m_obj); }
    friend bool operator<(const T* obj1, const SO& so2) { return (obj1 < so2.m_obj); }
    operator T*()   const { return m_obj; }
    T* operator->() const { assert(((void)"NULL pointer dereferenced", static_cast<const SharedObj*>(m_obj))); return m_obj;  }
    T& operator*()  const { assert(((void)"NULL pointer dereferenced", static_cast<const SharedObj*>(m_obj))); return *m_obj; }
    template<class S>
    operator SO<S>() { return SO<S>(m_obj); }
#if !defined(_MSC_VER) || (_MSC_VER >= 1300) // all compilers except visual studio < 7.0
    operator WO<T>() { return WO<T>(m_obj); }
#endif // all compilers except visual studio < 7.0

    // allows for accessing the type in template methods whose template parameter is an SO
    typedef T Type;

private:
    void ref(  const T* ptr) const { if(ptr) { reinterpret_cast<const SharedObj*>(ptr)->ref(this);   } } // use reinterpret_cast to type "const SharedObj*" to allow forward declaration of "T"
    void unref(const T* ptr) const { if(ptr) { reinterpret_cast<const SharedObj*>(ptr)->unref(this); } } // use reinterpret_cast to type "const SharedObj*" to allow forward declaration of "T"

private:
    T* m_obj;
};

class WeakPointerBase {
protected:
    WeakPointerBase()                           : m_obj(NULL)      {             }
    WeakPointerBase(const SharedObj* ptr)       : m_obj(ptr)       { reg(m_obj); }
    WeakPointerBase(const WeakPointerBase& wpb) : m_obj(wpb.m_obj) { reg(m_obj); }
    WeakPointerBase& operator=(const SharedObj* ptr)       { set(ptr);       return *this; }
    WeakPointerBase& operator=(const WeakPointerBase& wpb) { set(wpb.m_obj); return *this; }
    ~WeakPointerBase() { unreg(m_obj); }

protected:
    friend class SharedObj;
    void setToNULL(const SharedObj* who) const { assert(checkOwner(who)); m_obj = NULL; } // called by dtor of SharedObj

protected:
    void set(  const SharedObj* ptr) { if(ptr != m_obj) { reg(ptr); unreg(m_obj); m_obj = ptr; } }
    void reg(  const SharedObj* obj) { if(obj) { obj->registerWO(this);   } }
    void unreg(const SharedObj* obj) { if(obj) { obj->unregisterWO(this); } }

protected:
    mutable const SharedObj* m_obj;

private:
    bool checkOwner(const SharedObj* who) const {
        if(m_obj == who) { return true; }
        return false;
    }
}; // class WeakPointerBase

template<class T>
class WO : public WeakPointerBase {
public:
public:
    WO()                : WeakPointerBase() { }
    WO(T* obj)          : WeakPointerBase(reinterpret_cast<const SharedObj*>(obj)) { } // use reinterpret_cast to type "const SharedObj*" to allow forward declaration of "T"
    WO(const WO& wo)    : WeakPointerBase(wo) { }
    WO(const SO<T>& so) : WeakPointerBase(reinterpret_cast<const SharedObj*>(static_cast<const T*>(so))) { } // use reinterpret_cast to type "const SharedObj*" to allow forward declaration of "T"
    WO& operator=(T* obj)          { WeakPointerBase::set(reinterpret_cast<const SharedObj*>(obj)); return *this; } // use reinterpret_cast to type "const SharedObj*" to allow forward declaration of "T"
    WO& operator=(const WO& wo)    { WeakPointerBase::operator=(wo); return *this; }
    WO& operator=(const SO<T>& so) { WeakPointerBase::set(reinterpret_cast<const SharedObj*>(static_cast<const T*>(so))); return *this; } // use reinterpret_cast to type "const SharedObj*" to allow forward declaration of "T"
#if !defined(_MSC_VER) || (_MSC_VER >= 1300) // all compilers except visual studio < 7.0
    template<class S>
    WO& operator=(const WO<S>& wo) { return operator=(static_cast<S*>(wo)); }
#endif // all compilers except visual studio < 7.0

    bool operator<(const T* obj) const { return (m_obj < obj);      }
    bool operator<(const WO& wo) const { return (m_obj < wo.m_obj); }
    friend bool operator<(const T* obj1, const WO& wo2) { return (obj1 < wo2.m_obj); }
    operator T*()   const { return const_cast<T*>(reinterpret_cast<const T*>(m_obj)); }
    T* operator->() const { assert(((void)"NULL pointer dereferenced", m_obj)); return const_cast<T*>(reinterpret_cast<const T*>(m_obj));  }
    T& operator*()  const { assert(((void)"NULL pointer dereferenced", m_obj)); return *const_cast<T*>(reinterpret_cast<const T*>(m_obj)); }
    template<class S>
    operator WO<S>() { return WO<S>(const_cast<T*>(reinterpret_cast<const T*>(m_obj))); }
#if !defined(_MSC_VER) || (_MSC_VER >= 1300) // all compilers except visual studio < 7.0
    operator SO<T>() { return SO<T>(const_cast<T*>(reinterpret_cast<const T*>(m_obj))); }
#endif // all compilers except visual studio < 7.0

}; // class WO<T>

} // namespace VRS

//
// specialize the dynamic cast functions for SO and WO pointers
//
template<class S, class T>
inline T* VRS_CastImpl(const VRS::SO<S>& s, T* dummy) {
    return VRS_CastImpl(static_cast<S*>(s), dummy);
}

template<class S, class T>
inline T* VRS_GuardedCastImpl(const VRS::SO<S>& s, T* dummy) {
    return VRS_GuardedCastImpl(static_cast<S*>(s), dummy);
}

template<class S, class T>
inline T* VRS_CastImpl(const VRS::WO<S>& s, T* dummy) {
    return VRS_CastImpl(static_cast<S*>(s), dummy);
}

template<class S, class T>
inline T* VRS_GuardedCastImpl(const VRS::WO<S>& s, T* dummy) {
    return VRS_GuardedCastImpl(static_cast<S*>(s), dummy);
}

namespace VRS {

class SerializationManager;

template<class T>
inline void
serialization(
    SerializationManager& manager,
    const std::string& attributeName,
    SO<T>& attributeValue
) {
    SharedObj* ptr = const_cast<SharedObj*>(reinterpret_cast<const SharedObj*>((T*)attributeValue));
    manager.serialize(attributeName, ptr, typeid(T).name());
    attributeValue = reinterpret_cast<T*>(ptr);
}

template<class T>
inline void
serialization(
    SerializationManager& manager,
    const std::string& attributeName,
    WO<T>& attributeValue
) {
    SO<T> soValue = attributeValue;
    serialization(manager, attributeName, soValue);
    attributeValue = soValue;
}

template<typename T>
inline void
serialization(
    SerializationManager& manager,
    const std::string& attributeName,
    SO<T>& attributeValue,
    void* null
) {
    assert(null == NULL);
    serialization(manager, attributeName, attributeValue, SO<T>(NULL));
}

template<typename T>
inline void
serialization(
    SerializationManager& manager,
    const std::string& attributeName,
    WO<T>& attributeValue,
    void* null
) {
    assert(null == NULL);
    serialization(manager, attributeName, attributeValue, WO<T>(NULL));
}

} // namespace VRS

// use these macros for defining static SO-pointers
// but you should know what you do!!!
// example:
//    VRS_STATIC_SO(Array<int>, INT_ARRAY, ());
//    ...
//    INT_ARRAY()->append(42);

#define VRS_STATIC_SO(TYPE, NAME, ARGS)      \
    namespace {                              \
                                             \
        void NAME ##_cleanup();              \
                                             \
        TYPE* NAME(bool destruct = false) {  \
            static TYPE* pointer = NULL;     \
            if(!pointer && !destruct) {      \
                pointer = new TYPE ARGS;     \
                pointer->ref();              \
                ::atexit(NAME ##_cleanup);   \
            } else if(pointer && destruct) { \
                pointer->unref();            \
                pointer = NULL;              \
            }                                \
            return pointer;                  \
        }                                    \
                                             \
        void NAME ##_cleanup() {             \
            NAME(true);                      \
        }                                    \
                                             \
    } // namespace

#endif // VRS_SO_H

---

Generated on Tue May 21 06:00:19 2013 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact