---

Ref.h

Go to the documentation of this file.

/* SimData: Data Infrastructure for Simulations
 * Copyright (C) 2002 Mark Rose <tm2@stm.lbl.gov>
 * 
 * This file is part of SimData.
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */


#ifndef __SIMDATA_REF_H__
#define __SIMDATA_REF_H__

#include <cassert>
#include <list>
#include <vector>

#include <SimData/Namespace.h>
#include <SimData/Export.h>
#include <SimData/Exception.h>
#include <SimData/Log.h>


NAMESPACE_SIMDATA


class Referenced;
class ReferencePointer;
class LinkBase;


SIMDATA_EXCEPTION(ConversionError);


template<class T>
class Ref {
public:
        typedef std::vector< Ref<T> > vector;
        typedef std::list< Ref<T> > list;

        /* TODO add Python bindings
        // SWIG python specific comparisons
        bool __eq__(const Ref& other);
        bool __ne__(const Ref& other); 
        */
        

        Ref(): _reference(0) {
        }


        Ref(T* ptr): _reference(ptr) {
                if (ptr) ptr->_ref();
        }

        Ref(LinkBase const & r): _reference(0) {
                _rebind(r._get());
        }

        template <typename Q>
        Ref(Ref<Q> const & r): _reference(0) {
                Q *rp = r.get();
                if (rp != 0) {
                        //rp->_ref();
                        //_reference = static_cast<T*>(rp);
                        _rebind(rp);
                }
        }

        Ref(Ref const & r): _reference(r._reference) {
                if (_reference != 0) _reference->_ref();
        }

        ~Ref() {
                if (_reference) _reference->_deref();
        }

        inline bool unique() const {
                if (_reference == 0) return true;
                return (_reference->_count() == 1);
        }

        inline int count() const {
                if (_reference == 0) return 1;
                return _reference->_count();
        }

#ifndef SWIG

        template <class Q>
        Ref const & operator=(Ref<Q> const & r) {
                _rebind(r.get());
                return *this;
        }

        Ref const & operator=(Ref const & r) {
                _rebind(r.get());
                return *this;
        }

        LinkBase const & operator=(LinkBase const & r) {
                _rebind(r._get());
                return r;
        }

        template <class Q>
        inline Q *operator=(Q *ptr) {
                _rebind(ptr);
                return ptr;
        }

        inline void *operator=(void *ptr) {
                assert(ptr==0);
                if (_reference != 0) _reference->_deref();
                _reference = 0;
                return ptr;
        }
#endif // SWIG


        inline T* get() const {
                return _reference;
        }

        inline T* operator->() const {
                return _reference;
        }

        inline T & operator*() const {
                return *_reference;
        }

#ifndef SWIG

        inline bool operator!() const {
                return _reference == 0;
        }
#endif // SWIG

        inline bool valid() const {
                return _reference != 0;
        }
        
        template <class Q>
        inline bool operator==(Ref<Q> const & p) const {
                return _reference == p.get();
        }

        inline bool operator==(Referenced const * p) const {
                return _reference == p;
        }

        template <class Q>
        inline bool operator!=(Ref<Q> const & p) const {
                return _reference != p.get();
        }

        inline bool operator!=(Referenced const * p) const {
                return _reference != p;
        }


protected:
        template <class Q>
        void _rebind(Q* ptr) {
                if (ptr) ptr->_ref();
                if (_reference != 0) _reference->_deref();
                _reference = dynamic_cast<T*>(ptr);
                if (_reference == 0 && ptr != 0) {
                        SIMDATA_LOG(LOG_ALL, LOG_ERROR, "simdata::Ref() assignment: incompatible types (dynamic cast failed).");
                        throw ConversionError();
                }
        }

        T* _reference;
};


class SIMDATA_EXPORT Referenced {

template <class T> friend class Ref;
friend class ReferencePointer;

public:
        Referenced(): __count(0) {}

protected:
        virtual ~Referenced() {
                if (__count != 0) {
                        SIMDATA_LOG(LOG_ALL, LOG_ERROR, "simdata::Referenced(" << std::hex << int(this) << ") deleted with non-zero reference count (" << __count << "): memory corruption possible.");
                }
        }

private:
        inline void _ref() const { ++__count; }

        inline void _deref() const { 
                if (--__count <= 0) {
                        delete this;
                }
        }
        inline unsigned _count() const { return __count; }

        mutable unsigned __count;

        Referenced(Referenced const &); //: __count(0) {}

#ifndef SWIG
        inline Referenced& operator=(Referenced const &);// { return *this; }
#endif // SWIG

};


NAMESPACE_SIMDATA_END


#endif //__SIMDATA_OBJECT_H__

---

SimData version pre-0.4.0. For more information on SimData, visit the SimData Homepage. Generated on Tue Oct 14 12:06:39 2003, using Doxygen 1.2.18.