refcounter_decls.h

/*
 *  Copyright (C) 2006  Helmut Grohne
 *
 *  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 LIBMUTH_REFCOUNTER_DECLS_H
#define LIBMUTH_REFCOUNTER_DECLS_H

#include <set>
#include <stdexcept>
#include "lock.h"
#include "condition.h"

class WeakRefBase;
template<class RC> class WeakReference;

class RefCounter {
        private:
                Lock datalock;
                Condition cond;
                int refcount;
                std::set<WeakRefBase*> notifier;
                void addWeakRef(WeakRefBase &wr);
                void removeWeakRef(WeakRefBase &wr);
                void notifyall();
                friend class WeakRefBase;
                template<class RC> friend class WeakReference;
        protected:
                RefCounter();
        public:
                void incref();
                void decref();
                virtual ~RefCounter();
};

template<class RC> class WeakReference;

template<class RC> class Reference {
        private:
                RC *object;
                friend class WeakReference<RC>;
        public:
                Reference(RC *obj);
                Reference(const Reference &other);
                Reference<RC> &operator=(RC *obj);
                Reference<RC> &operator=(const Reference &other);
                bool operator==(const Reference &other) const;
                bool operator!=(const Reference &other) const;
                RC &operator*() const;
                RC *operator->() const;
                ~Reference();
};

class WeakRefBase {
                friend class RefCounter;
        protected:
                mutable Lock datalock;
                virtual void notify() = 0;
                WeakRefBase();
                virtual ~WeakRefBase() {}
};

class NullPointerException : public std::runtime_error {
        public:
                NullPointerException() : std::runtime_error("NullPointer") {}
};

template<class RC> class WeakReference : private WeakRefBase {
        private:
                RC *object;
                void notify();
                friend class Reference<RC>;
        public:
                WeakReference();
                WeakReference(const WeakReference &other);
                WeakReference(const Reference<RC> &other);
                WeakReference(RC *obj);
                WeakReference &operator=(const WeakReference &other);
                WeakReference &operator=(const Reference<RC> &other);
                bool operator==(const WeakReference &other) const;
                bool operator==(const Reference<RC> &other) const;
                bool operator!=(const WeakReference &other) const;
                bool operator!=(const Reference<RC> &other) const;
                Reference<RC> operator*() const;
                ~WeakReference();
};

#endif

---