SharedData.h

Go to the documentation of this file.

/*

Copyright (C) 2006-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_DATA_H
#define UTILS__MEMORY__SHARED_DATA_H

namespace Utils {
namespace Memory {


class SharedData
{
public:
    QAtomic ref;

    inline                  SharedData() : ref(0) { }
    inline                  SharedData(const SharedData &) : ref(0) { }
    virtual SharedData *    copy() const = 0;
    virtual                 ~SharedData() {}

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



class SharedDataPointer
{
public:
    inline void detach() { if (d && d->ref != 1) detach_helper(); }
    inline SharedData &operator*() { detach(); return *d; }
    inline const SharedData &operator*() const { return *d; }
    inline SharedData *operator->() { detach(); return d; }
    inline const SharedData *operator->() const { return d; }
    inline operator SharedData *() { detach(); return d; }
    inline operator const SharedData *() const { return d; }
    inline SharedData *data() { detach(); return d; }
    inline const SharedData *data() const { return d; }
    inline const SharedData *constData() const { return d; }

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

    inline SharedDataPointer() : d (0) {}
    inline ~SharedDataPointer() { if (d && !d->ref.deref()) delete d; }

    explicit SharedDataPointer(SharedData *data);
    inline SharedDataPointer(const SharedDataPointer &o) : d(o.d) { if (d) d->ref.ref(); }
    inline SharedDataPointer & operator= (const SharedDataPointer &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 SharedDataPointer & operator= (SharedData *o) {
        if (o != d) {
            SharedData *x = o;
            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();

    SharedData *d;
};

inline SharedDataPointer::SharedDataPointer (SharedData *adata) : d(adata)
{ if (d) d->ref.ref(); }

inline void SharedDataPointer::detach_helper()
{
    SharedData *x = d->copy();
    x->ref.ref();
    x = qAtomicSetPtr(&d, x);
    if (!x->ref.deref())
        delete x;
}

// This macros facilitate implicit sharing of private data:
#define Q_SHARED_DATA_COPY(Class) \
    Class *             copy() const    { return new Class (*this); }

#define Q_DECLARE_SHARED_DATA(Class) \
    inline Class*       d_func()        \
    { return static_cast <Class *> (d_ptr.data()); } \
    inline const Class* d_func() const  \
    { return static_cast <const Class *> (d_ptr.data()); }

#define Q_SD(Class) Class * const d = d_func()

} // namespace Memory
} // namespace Utils

#endif // UTILS__MEMORY__SHARED_DATA_H

Copyright © 2006 Peter Dimov.
Powered by Doxygen.