SharedPointer.h

Go to the documentation of this file.

/*

Copyright (C) 2005-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko 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.

Calitko 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 Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/
/****************************************************************************
**
** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** This file may be used under the terms of the GNU General Public
** License version 2.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of
** this file.  Please review the following information to ensure GNU
** General Public Licensing requirements will be met:
** http://www.trolltech.com/products/qt/opensource.html
**
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://www.trolltech.com/products/qt/licensing.html or contact the
** sales department at sales@trolltech.com.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/

#ifndef UTILS__MEMORY__SHARED_POINTER_H
#define UTILS__MEMORY__SHARED_POINTER_H

namespace Utils {
namespace Memory {


template <typename T>
class SharedPointer
{
public:
    inline void detach() { if (d && d->ref != 1) detach_helper(); }
    inline T &operator*() { detach(); return *(d->data); }
    inline const T &operator*() const { return *(d->data); }
    inline T *operator->() { detach(); return d->data; }
    inline const T *operator->() const { return d->data; }
    inline operator T *() { detach(); return d->data; }
    inline operator const T *() const { return d->data; }
    inline T *data() { detach(); return d->data; }
    inline const T *data() const { return d->data; }
    inline const T *constData() const { return d->data; }

    inline bool operator==(const SharedPointer &other) const { return d == other.d; }
    inline bool operator!=(const SharedPointer &other) const { return d != other.d; }

    inline SharedPointer() { d = 0; }
    explicit SharedPointer(T *data);
    inline ~SharedPointer() { if (d && !d->ref.deref()) delete d; }

    inline SharedPointer(const SharedPointer &o) : d(o.d) { if (d) d->ref.ref(); }
    inline SharedPointer & operator= (const SharedPointer &o) {
        if (o.d != d) {
            SharedData *x = o.d;
            if (x) x->ref.ref();
            x = qAtomicSetPtr(&d, x);
            if (x && !x->ref.deref())
                delete x;
        }
        return *this;
    }

    inline bool operator!() const { return !d; }

private:
    void detach_helper();

    class SharedData
    {
    public:
        QAtomic ref;
        T       *data;

        inline                  SharedData (T *adata) : ref(0) { data = adata; }
        inline                  SharedData(const SharedData &other)
                                  : ref(0) { data = other.data->copy(); }
                                ~SharedData() { delete data; }

    private:
        // using the operator= would lead to corruption in the ref-counting
        SharedData &operator= (const SharedData &);
    };

    SharedData *d;
};

template <typename T>
inline SharedPointer <T>::SharedPointer (T *adata) : d(0)
{ d = new SharedData (adata); d->ref.ref(); }

template <typename T>
inline void SharedPointer <T>::detach_helper()
{
    SharedData *x = new SharedData (d);
    x->ref.ref();
    x = qAtomicSetPtr(&d, x);
    if (!x->ref.deref())
        delete x;
}

} // namespace Memory
} // namespace Utils

#endif // UTILS__MEMORY__SHARED_POINTER_H

Copyright © 2006 Peter Dimov.
Powered by Doxygen.