FXPolicies.h

Go to the documentation of this file.

/********************************************************************************
*                                                                               *
*                                Policy classes                                 *
*                                                                               *
*********************************************************************************
*        Copyright (C) 2003 by Niall Douglas.   All Rights Reserved.            *
*       NOTE THAT I DO NOT PERMIT ANY OF MY CODE TO BE PROMOTED TO THE GPL      *
*********************************************************************************
* This code is free software; you can redistribute it and/or modify it under    *
* the terms of the GNU Library General Public License v2.1 as published by the  *
* Free Software Foundation EXCEPT that clause 3 does not apply ie; you may not  *
* "upgrade" this code to the GPL without my prior written permission.           *
* Please consult the file "License_Addendum2.txt" accompanying this file.       *
*                                                                               *
* This code 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.                          *
*********************************************************************************
* $Id:                                                                          *
********************************************************************************/

#ifndef FXPOLICIES_H
#define FXPOLICIES_H

#include "FXException.h"

namespace FX {

class QMtxHold;

namespace Pol {

class None0
{
protected:
    None0() { }
    ~None0() { }
};
template<class type> class None1
{
protected:
    None1() { }
    ~None1() { }
};

template<class type> class deepCopy
{
protected:
    type *data;
public:
    deepCopy(type *d) : data(d) { }
    deepCopy(const deepCopy &o) : data(o.data->copy()) { FXERRHM(data); }
    deepCopy &operator=(const deepCopy &o)
    {
        FXDELETE(data);
        FXERRHM(data=o.data->copy());
        return *this;
    }
    ~deepCopy() { FXDELETE(data); }
    friend type *PtrPtr(deepCopy &p) { return p.data; }
    friend const type *PtrPtr(const deepCopy &p) { return p.data; }
    friend type *&PtrRef(deepCopy &p) { return p.data; }
    friend const type *PtrRef(const deepCopy &p) { return p.data; }
};

template<class type> class refCounted
{
protected:
    type *data;
public:
    refCounted(type *d) : data(d) { ++data->refCount(); }
    refCounted(const refCounted &o) : data(o.data) { ++data->refCount(); }
    refCounted &operator=(const refCounted &o)
    {
        if(!--data->refCount()) FXDELETE(data);
        data=o.data;
        ++data->refCount();
        return *this;
    }
    ~refCounted()
    {
        if(!--data->refCount()) FXDELETE(data);
    }
    friend type *PtrPtr(refCounted &p) { return p.data; }
    friend const type *PtrPtr(const refCounted &p) { return p.data; }
    friend type *&PtrRef(refCounted &p) { return p.data; }
    friend const type *PtrRef(const refCounted &p) { return p.data; }
};

template<class type> class destructiveCopyNoDelete
{
protected:
    mutable type *data;
    destructiveCopyNoDelete &operator=(const destructiveCopyNoDelete &o);   // implementation needs to be replaced
public:
    destructiveCopyNoDelete(type *d) : data(d) { }
    destructiveCopyNoDelete(const destructiveCopyNoDelete &o) : data(o.data) { o.data=0; }
    friend type *PtrPtr(destructiveCopyNoDelete &p) { return p.data; }
    friend const type *PtrPtr(const destructiveCopyNoDelete &p) { return p.data; }
    friend type *&PtrRef(destructiveCopyNoDelete &p) { return p.data; }
    friend const type *PtrRef(const destructiveCopyNoDelete &p) { return p.data; }
};

template<class type> class destructiveCopy : public destructiveCopyNoDelete<type>
{
public:
    destructiveCopy(type *d) : destructiveCopyNoDelete<type>(d) { }
    ~destructiveCopy() { FXDELETE(destructiveCopyNoDelete<type>::data); }
    destructiveCopy &operator=(const destructiveCopy &o)
    {
        FXDELETE(destructiveCopyNoDelete<type>::data);
        destructiveCopyNoDelete<type>::data=o.data;
        o.data=0;
        return *this;
    }
};

template<class type> class noCopyNoDelete
{
protected:
    type *data;
public:
    noCopyNoDelete(type *d) : data(d) { }
    friend type *PtrPtr(noCopyNoDelete &p) { return p.data; }
    friend const type *PtrPtr(const noCopyNoDelete &p) { return p.data; }
    friend type *&PtrRef(noCopyNoDelete &p) { return p.data; }
    friend const type *PtrRef(const noCopyNoDelete &p) { return p.data; }
};

template<class type> class noCopy : public noCopyNoDelete<type>
{
public:
    noCopy(type *d) : noCopyNoDelete<type>(d) { }
    ~noCopy() { FXDELETE(noCopyNoDelete<type>::data); }
};

template<class type> struct itMove
{
    template<class L, class I> void move(L &list, I to, I &from) const
    {
        list.splice(to, list, from);
        from=--to;
    }
};
template<class type> struct itSwap
{
    template<class L, class I> void swap(L &list, I &a, I &b) const
    {
        I _a=a, _b=b; ++_a; ++_b;
        if(_b==a)
        {
            list.splice(b, list, a);
            a=--_a; b=--_a;
        }
        else if(_a==b)
        {
            list.splice(a, list, b);
            b=--_b; a=--_b;
        }
        else
        {
            list.splice(b, list, a);
            list.splice(_a, list, b);
            a=--_a; b=--_b;
        }
    }
};
template<class type> struct itCompare
{
    template<class L, class I> bool compare(L &list, I &a, I &b) const
    {
        return *a<*b;
    }
};
template<class type> struct itRevCompare
{
    template<class L, class I> bool compare(L &list, I &a, I &b) const
    {
        return *a>*b;
    }
};

} // namespace

} // namespace

#endif

---

(C) 2002-2009 Niall Douglas. Some parts (C) to assorted authors.