variable.h

Go to the documentation of this file.

#ifndef VARIABLE_H
#define VARIABLE_H

#include <QTextStream>
#include <QDateTime>
#include <QObject>
#include <QDebug>
#include <limits>
#include <ostream>

namespace LangmuirCore
{

// output QDateTime as qint64 mSecsSinceEpoch
// must be declared before template functions
inline QTextStream& operator<<(QTextStream& stream, const QDateTime& datetime);

/*
  The class is a template so that it may point to arbitray data types.  In order to
  add a new data type you must implement the following, with \b 'T' replaced by your
  new type:
    - template <> inline void Variable<T>::convert(const QString& token, T& result)
    - inline QTextStream& operator<<(QTextStream& stream, const T& variable)
  */
class Variable : public QObject
{
    Q_OBJECT
public:
    enum VariableModeFlag
    {
        Constant = 1 
    };
    Q_FLAGS(ModeFlag)
    Q_DECLARE_FLAGS(VariableMode, VariableModeFlag)

    Variable(
        const QString &key,
        VariableMode mode = 0,
        QObject *parent = 0);


    virtual void read(const QString& token) = 0;    

    virtual QString key() const = 0;

    virtual QString value() const = 0;

    virtual QString keyValue() const = 0;

    bool isConstant() const;

    const VariableMode& mode() const;

    friend QTextStream& operator<<(QTextStream& stream, const Variable &variable);

    friend QDebug operator<<(QDebug dbg, const Variable &variable);

    friend std::ostream& operator<<(std::ostream &stream, Variable &variable);

protected:

    QString m_key;

    VariableMode m_mode;

    virtual void write(QTextStream& stream) const = 0;

};
Q_DECLARE_OPERATORS_FOR_FLAGS(Variable::VariableMode)

template <class T>
class TypedVariable : public Variable
{
public:


    TypedVariable(
        const QString& key,
        T &value,
        VariableMode mode = 0,
        QObject *parent = 0);

    virtual void read(const QString& token);

    virtual QString key() const;

    virtual QString value() const;

    virtual QString keyValue() const;


    static void convert(const QString& token, T& result);

protected:
    T &m_value;

    virtual void write(QTextStream& stream) const;
};

inline Variable::Variable(
    const QString &key,
    VariableMode mode,
    QObject *parent)
    : QObject(parent),
      m_key(key),
      m_mode(mode)
{
}

template <class T> inline QString TypedVariable<T>::key() const
{
    return m_key;
}

template <class T> inline QString TypedVariable<T>::value() const
{
    QString result; QTextStream stream(&result);
    stream << m_value;
    stream.flush();
    return result;
}

template <> inline QString TypedVariable<float>::value() const
{
    QString result; QTextStream stream(&result);
    stream << qSetRealNumberPrecision(std::numeric_limits<float>::digits10)
           << scientific
           << m_value;
    stream.flush();
    return result;
}

template <> inline QString TypedVariable<qreal>::value() const
{
    QString result; QTextStream stream(&result);
    stream << qSetRealNumberPrecision(std::numeric_limits<qreal>::digits10)
           << scientific
           << m_value;
    stream.flush();
    return result;
}

template <> inline QString TypedVariable<bool>::value() const
{
    QString result; QTextStream stream(&result);
    if (m_value == true) { stream << "True"; }
    else { stream << "False"; }
    stream.flush();
    return result;
}

template <class T> inline QString TypedVariable<T>::keyValue() const
{
    QString result; QTextStream stream(&result);
    stream << left
           << qSetFieldWidth(30)
           << key();
    QString theValue = value();
    if (theValue.startsWith('-'))
    {
        stream << qSetFieldWidth(2)
               << '='
               << qSetFieldWidth(0)
               << theValue;
    }
    else
    {
        stream << qSetFieldWidth(3)
               << '='
               << qSetFieldWidth(0)
               << theValue;
    }
    stream.flush();
    return result;
}

template <> inline QString TypedVariable<QString>::keyValue() const
{
    QString result; QTextStream stream(&result);
    stream << left
           << qSetFieldWidth(30)
           << key();
    if (m_value.isEmpty())
    {
        stream << qSetFieldWidth(0)
               << '=';
    }
    else
    {
        stream << qSetFieldWidth(3)
               << '='
               << qSetFieldWidth(0)
               << value();
    }
    stream.flush();
    return result;
}

inline bool Variable::isConstant() const
{
    return m_mode.testFlag(Constant);
}

inline const Variable::VariableMode& Variable::mode() const
{
    return m_mode;
}

template <class T> inline TypedVariable<T>::TypedVariable(
    const QString& key,
    T &value,
    VariableMode mode,
    QObject *parent)
    : Variable(key,mode,parent),
      m_value(value)
{
}

template <class T> inline void TypedVariable<T>::read(const QString& token)
{
    if (m_mode.testFlag(Constant))
    {
        qDebug("langmuir: ignoring constant; key: %s, token: %s",
                 qPrintable(m_key),qPrintable(token));
        return;
    }
    convert(token,m_value);
}

template <class T> inline void TypedVariable<T>::write(QTextStream& stream) const
{
    stream << keyValue();
}

inline QTextStream& operator<<(QTextStream& stream, const Variable& variable)
{
    variable.write(stream);
    return stream;
}

inline QDebug operator<<(QDebug dbg, const Variable &variable)
{
    QString string; QTextStream stream(&string);
    stream << variable;
    stream.flush();
    dbg.nospace() << qPrintable(string);
    return dbg.space();
}

inline std::ostream& operator<<(std::ostream &stream, Variable &variable)
{
    stream << variable.keyValue().toStdString();
    return stream;
}

template <> inline void TypedVariable<QString>::convert(const QString& token, QString& result)
{
    result = token.trimmed();
}

template <> inline void TypedVariable<qreal>::convert(const QString& token, qreal& result)
{
    bool ok = false;
    result = token.toDouble(&ok);
    if (!ok) qFatal("langmuir: can not convert to double: %s", qPrintable(token));
}

template <> inline void TypedVariable<float>::convert(const QString& token, float& result)
{
    bool ok = false;
    result = token.toFloat(&ok);
    if (!ok) qFatal("langmuir: can not convert to double: %s", qPrintable(token));
}

template <> inline void TypedVariable<bool>::convert(const QString& token, bool& result)
{
    QString lower = token.trimmed().toLower();
    if (lower == "false")
    {
        result = false;
    }
    else if (lower == "true")
    {
        result = true;
    }
    else
    {
        bool ok = false;
        result = token.toInt(&ok);
        if (!ok) qFatal("langmuir: can not convert to bool: %s", qPrintable(token));
    }
}

template <> inline void TypedVariable<qint32>::convert(const QString& token, qint32& result)
{
    bool ok = false;
    result = token.toInt(&ok);
    if (!ok) qFatal("langmuir: can not convert to int: %s", qPrintable(token));
}

template <> inline void TypedVariable<quint32>::convert(const QString& token, quint32& result)
{
    bool ok = false;
    result = token.toUInt(&ok);
    if (!ok) qFatal("langmuir: can not convert to unsigned int: %s", qPrintable(token));
}

template <> inline void TypedVariable<qint64>::convert(const QString& token, qint64& result)
{
    bool ok = false;
    result = token.toLongLong(&ok);
    if (!ok) qFatal("langmuir: can not convert to long long int: %s", qPrintable(token));
}

template <> inline void TypedVariable<quint64>::convert(const QString& token, quint64& result)
{
    bool ok = false;
    result = token.toULongLong(&ok);
    if (!ok) qFatal("langmuir: can not convert to unsigned long long int: %s", qPrintable(token));
}

template <> inline void TypedVariable<QDateTime>::convert(const QString& token, QDateTime& result)
{
    bool ok = false;
    qint64 msecSinceEpoch = token.toLongLong(&ok);
    if (!ok) qFatal("langmuir: can not convert to QDateTime (expecting long long int): %s", qPrintable(token));
    result = QDateTime::fromMSecsSinceEpoch(msecSinceEpoch);
}

inline QTextStream& operator<<(QTextStream& stream, const QDateTime& datetime)
{
    stream << datetime.toMSecsSinceEpoch();
    return stream;
}

}

#endif // VARIABLE_H