datarange.h

Go to the documentation of this file.

 
#ifndef DATARANGE_H
#define DATARANGE_H
 
#include <QObject>
#include <QDBusArgument>
#include <QPair>
 
/* Datatype for storing integer ranges. */
typedef QPair<unsigned int, unsigned int> IntegerRange;
 
/* Datatype for storing list of integer ranges. */
typedef QList<IntegerRange> IntegerRangeList;
 
Q_DECLARE_METATYPE( IntegerRange )
Q_DECLARE_METATYPE( IntegerRangeList )
 
 
class DataRange : public QObject {
    Q_OBJECT;
public:
 
    DataRange() : QObject(), min(0), max(0), resolution(0) {}
 
    DataRange(const DataRange &other) :
        QObject(), min(other.min), max(other.max), resolution(other.resolution) {}
 
    DataRange(double min, double max, double resolution) :
        QObject(), min(min), max(max), resolution(resolution) {}
 
    double min;         
    double max;         
    double resolution;  
    DataRange& operator=(const DataRange& origin)
    {
        min = origin.min;
        max = origin.max;
        resolution = origin.resolution;
        return *this;
    }
 
    bool operator==(const DataRange& right) const
    {
        return (min == right.min &&
                max == right.max &&
                resolution == right.resolution);
    }
};
 
/* Datatype for list of data ranges */
typedef QList<DataRange> DataRangeList;
 
Q_DECLARE_METATYPE( DataRange )
Q_DECLARE_METATYPE( DataRangeList )
 
 
inline QDBusArgument &operator<<(QDBusArgument &argument, const DataRange &data)
{
    argument.beginStructure();
    argument << data.min << data.max << data.resolution;
    argument.endStructure();
    return argument;
}
 
inline const QDBusArgument &operator>>(const QDBusArgument &argument, DataRange &data)
{
    argument.beginStructure();
    argument >> data.min >> data.max >> data.resolution;
    argument.endStructure();
    return argument;
}
 
inline QDBusArgument &operator<<(QDBusArgument &argument, const DataRangeList &data)
{
    argument.beginArray(qMetaTypeId<DataRange>());
    foreach(const DataRange& range, data)
    {
        argument << range;
    }
    argument.endArray();
    return argument;
}
 
inline const QDBusArgument &operator>>(const QDBusArgument &argument, DataRangeList &data)
{
    argument.beginArray();
    data.clear();
    while ( !argument.atEnd() ) {
        DataRange element;
        argument >> element;
        data.append( element );
    }
    argument.endArray();
    return argument;
}
 
inline QDBusArgument &operator<<(QDBusArgument &argument, const IntegerRange &data)
{
    argument.beginStructure();
    argument << data.first << data.second;
    argument.endStructure();
    return argument;
}
 
inline const QDBusArgument &operator>>(const QDBusArgument &argument, IntegerRange &data)
{
    argument.beginStructure();
    argument >> data.first >> data.second;
    argument.endStructure();
    return argument;
}
 
inline QDBusArgument &operator<<(QDBusArgument &argument, const IntegerRangeList &data)
{
    argument.beginArray(qMetaTypeId<IntegerRange>());
    foreach(const IntegerRange& range, data)
    {
        argument << range;
    }
    argument.endArray();
    return argument;
}
 
inline const QDBusArgument &operator>>(const QDBusArgument &argument, IntegerRangeList &data)
{
    argument.beginArray();
    data.clear();
    while ( !argument.atEnd() ) {
        IntegerRange element;
        argument >> element;
        data.append( element );
    }
    argument.endArray();
    return argument;
}
 
class DataRangeRequest
{
public:
 
    int       id;     
    DataRange range;  
    DataRangeRequest(int newId) :
        id(newId) {};
 
    DataRangeRequest(int newId, const DataRange& newRange) :
        id(newId),
        range(newRange) {};
 
    bool operator==(const DataRangeRequest& right) const
    {
        return (id == right.id && range == right.range);
    }
};
 
class IntervalRequest {
public:
    int      id;     
    unsigned value;  
    IntervalRequest(int newId, unsigned newValue) :
        id(newId),
        value(newValue) {}
 
    bool operator==(const IntervalRequest& right) const
    {
        return (id == right.id && value == right.value);
    }
};
 
template<typename T, typename U>
inline bool isInRange(T ref, const U& container)
{
    foreach(const typename U::value_type& value, container)
    {
        if(ref >= value.first && ref <= value.second)
            return true;
    }
    return false;
}
 
#endif // DATARANGE_H