size.h

#ifndef SIZE_H
#define SIZE_H

#include <QSize>
#include "Kernel_global.h"

namespace Ilwis {

template <typename T=quint32> class KERNELSHARED_EXPORT Size
{
public:
    Size() : _xsize(0), _ysize(0), _zsize(0) {}
    Size(T x, T y, T z) : _xsize(x), _ysize(y), _zsize(z) {}
    Size(const Size& sz) : _xsize(sz.xsize()), _ysize(sz.ysize()), _zsize(sz.zsize()) {}
    Size(const QSize& sz) : _xsize(sz.width()), _ysize(sz.height()), _zsize(1) {}
    Size& operator+=(const Size& sz){
        if ( !isValid() ) {
            *this = Size();
            return *this;
        }

        _xsize += sz.xsize();
        _ysize += sz.ysize();
        _zsize += sz.zsize();
        check();
        return *this;
    }

    Size& operator-=(const Size& sz){
        if ( !isValid() ) {
            *this = Size();
            return *this;
        }

        _xsize -= sz.xsize();
        _ysize -= sz.ysize();
        _zsize -= sz.zsize();
        check();
        return *this;
    }

    Size& operator*=(double f){
        if ( !isValid() || f == rUNDEF || f < 0) {
            *this = Size();
            return *this;
        }

        _xsize *= f;
        _ysize *= f;
        _zsize *= f;
        check();
        return *this;
    }

    QSize toQSize() const{
        return QSize(xsize(), ysize());
    }
    T xsize() const{
        return _xsize;
    }
    T ysize() const{
        return _ysize;
    }
    T zsize() const{
        return _zsize;
    }
    void xsize(T x){
        _xsize = x;
    }

    void ysize(T y){
        _ysize = y;
    }

    void zsize(T z){
        _zsize = z;
    }

    quint64 linearSize() const{
        if (!isValid())
            return 0;
        return (quint64)xsize() * (quint64)ysize() * (quint64)zsize();
    }

    bool contains(T x, T y, T z=0) const{
        return x <= xsize() && y <= ysize() && z <= zsize();
    }

    bool isValid() const{
        if ( isNumericalUndef(_xsize) || isNumericalUndef(_ysize) || isNumericalUndef(_zsize)) // should not be possible but better safe then sorry
            return false;

        return _xsize >0 && _ysize > 0 && _zsize > 0;
    }
    bool isNull() const{
        return _xsize == 0 && _ysize == 0 && _zsize == 0;
    }
private:
    void check(){
        {
            if ( _xsize < 0)
                xsize(0);
            if ( _ysize < 0)
                ysize(0);
            if (_zsize < 0)
                zsize(0);
        }
    }

    T _xsize;
    T _ysize;
    T _zsize;
    
};

//bool operator==(const Size& sz1, const Size& sz2) {
//    return sz1.xsize() == sz2.xsize() && sz1.ysize() == sz2.ysize() && sz1.zsize() == sz2.zsize();
//}

//bool operator!=(const Size& sz1, const Size& sz2) {
//    return ! operator==(sz1, sz2);
//}

template<typename T> Ilwis::Size<T> operator+(const Ilwis::Size<T>& sz1, const Ilwis::Size<T>& sz2){
    if((!sz1.isNull() && !sz1.isValid()) || (!sz2.isNull() && !sz2.isValid())){
        return Size<T>();
    }
    return Size<T>(sz1.xsize() + sz2.xsize(), sz1.ysize() + sz2.ysize(), sz1.zsize() + sz2.zsize());
}

template<typename T> Ilwis::Size<T> operator-(const Ilwis::Size<T>& sz1, const Ilwis::Size<T>& sz2){
    if((!sz1.isNull() && !sz1.isValid()) || (!sz2.isNull() && !sz2.isValid())){
        return Size<T>();
    }

    return Size<T>(sz1.xsize() - sz2.xsize(), sz1.ysize() - sz2.ysize(), sz1.zsize() - sz2.zsize());
}

template<typename T> bool operator==(const Ilwis::Size<T>& sz1, const Ilwis::Size<T>& sz2){
    if ( !sz1.isValid() && !sz2.isValid())
        return true;

    return sz1.xsize() == sz2.xsize() && sz1.ysize() == sz2.ysize() && sz1.zsize() == sz2.zsize();
}

template<typename T> bool operator!=(const Ilwis::Size<T>& sz1, const Ilwis::Size<T>& sz2){
    return !operator ==(sz1, sz2);
}
}
Q_DECLARE_METATYPE(Ilwis::Size<quint32>)
Q_DECLARE_METATYPE(Ilwis::Size<double>)

#endif // SIZE_H