QBaseType.hh

Go to the documentation of this file.

#ifndef _Q_BASETYPE_HH_
#define _Q_BASETYPE_HH_
 
#include "QObject.hh"
 
Q_BEGIN_NAMESPACE
 
template<class T> class QBaseType : public QObject {
 
    public:
        void Clear();
 
        QBaseType() { Clear(); }
 
        QBaseType(const QBaseType<T>& bt)
        { 
            this->operator=(bt); 
        }
 
        QBaseType(const T& value) 
        { 
            this->operator=(value); 
        }
 
        QBaseType<T>& operator=(const T& value)
        {
            fValue = value; 
            Validate(); 
            return *this;
        }
 
        bool operator==(const T& value) const
        {
            return fValue == value;
        }
        bool operator!=(const T& value) const
        {
            return fValue != value;
        }
 
        bool operator<(const T& value) const
        {
            return fValue < value;
        }
 
        bool operator<=(const T& value) const
        {
            return fValue <= value;
        }
 
        bool operator>=(const T& value) const
        {
            return fValue >= value;
        }
 
        bool operator>(const T& value) const
        {
            return fValue > value;
        }
 
        QBaseType<T>& operator+=(const T& value) 
        {
            this->operator=(fValue+value);
            return *this;
        }
 
        QBaseType<T>& operator-=(const T& value) 
        {
            this->operator=(fValue-value);
            return *this;
        }
 
        QBaseType<T>& operator*=(const T& value) 
        {
            this->operator=(fValue*value);
            return *this;
        }
 
        QBaseType<T>& operator/=(const T& value) 
        {
            this->operator=(fValue/value);
            return *this;
        }
 
        operator T () const { return  fValue; }
 
        void Dump(std::ostream& ob) const { ob<<fValue; }
 
        bool Fill(Diana::QObject* obj) const
        {
            QBaseType<T>* bt = dynamic_cast<QBaseType<T>* >(obj);
            if(bt) {
                *bt = *this; 
            }
            return bt != NULL;
        }
 
        QObject* Duplicate() const {
            QBaseType<T> * obj = new QBaseType<T>;
            return obj;
        }
 
    private:
        T fValue;
        ClassDef(QBaseType,2);
 
};
 
 
template <class T> void QBaseType<T>::Clear() {};
 
template <> inline void QBaseType<int>::Clear() 
{
    fValue = Q_INT_DEFAULT;
}
template <> inline void QBaseType<float>::Clear() 
{
    fValue = Q_FLOAT_DEFAULT;
}
 
template <> inline void QBaseType<double>::Clear() 
{
    fValue = Q_DOUBLE_DEFAULT;
}
 
template <> inline void QBaseType<Long64_t>::Clear() 
{
    fValue = Q_INT_DEFAULT;
}
 
 
typedef QBaseType<int> QInt;
typedef QBaseType<float> QFloat;
typedef QBaseType<double> QDouble;
typedef QBaseType<Long64_t> QLong64;
 
typedef QBaseType<ULong64_t> QULong64;
 
Q_END_NAMESPACE
 
/* the cast operator replaces them, however cint seems not able to call it
 * so we should do a manual cast
template<class T> bool operator>(const T& b,const Diana::QBaseType<T> & qb)
{
    return qb < b;
}
 
template<class T> bool operator<(const T& b,const Diana::QBaseType<T> & qb)
{
        return qb > b;
}
 
template<class T> bool operator==(const T& b,const Diana::QBaseType<T> & qb)
{
        return qb == b;
}
*/
 
#endif