value.h

Go to the documentation of this file.

/*************************************************************************************
 *  Copyright (C) 2007 by Aleix Pol <aleixpol@kde.org>                               *
 *                                                                                   *
 *  This program is free software; you can redistribute it and/or                    *
 *  modify it under the terms of the GNU General Public License                      *
 *  as published by the Free Software Foundation; either version 2                   *
 *  of the License, or (at your option) any later version.                           *
 *                                                                                   *
 *  This program 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.  See the                    *
 *  GNU General Public License for more details.                                     *
 *                                                                                   *
 *  You should have received a copy of the GNU General Public License                *
 *  along with this program; if not, write to the Free Software                      *
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA   *
 *************************************************************************************/

#ifndef VALUE_H
#define VALUE_H

#include "object.h"
#include "analitzaexport.h"

#include <cmath>

class QDomElement;

namespace Analitza
{

class ANALITZA_EXPORT Cn : public Object
{
    public:
        enum ValueFormat { Char=8, Real=7, Integer=3, Boolean=1 };
        Cn(const Cn& v) : Object(v), m_value(v.value()), m_format(v.m_format) { Q_ASSERT(m_type==Object::value); }

        explicit Cn(const double &b=0.) : Object(Object::value), m_value(b), m_format(Real) {}

        explicit Cn(int i) : Object(Object::value), m_value(i), m_format(Integer) {}

        explicit Cn(uint i) : Object(Object::value), m_value(i), m_format(Integer) {}

        explicit Cn(bool b) : Object(Object::value), m_value(b?1.:0.), m_format(Boolean) {}

        explicit Cn(const QChar& c) : Object(Object::value), m_char(c.unicode()), m_format(Char) {}

        bool setValue(const QDomElement& e);

        void setValue(const double& v);
        void setValue(int v);
        void setValue(uint v);
        void setValue(bool v);

        inline double value() const { return m_value; }
        inline double& rvalue() { return m_value; }

        int intValue() const { return static_cast<int>(std::floor(m_value)); }

        bool isBoolean() const { return m_format==Boolean; }

        bool isCharacter() const { return m_format==Char; }

        ValueFormat format() const { return m_format; }

        void setBoolean(bool b) { m_format= b ? Boolean : Real; }

        bool isTrue() const { Q_ASSERT(m_format==Boolean); return m_value!=0.; }

//      static double toNum(const QString& num, const QString& type, int base);
//      static enum ValueFormat whatValueFormat(const QDomElement&);

        bool isInteger() const { return std::floor(m_value)==m_value; }

        bool operator==(const Cn& d) const { return m_value==d.m_value; }

        bool operator<(const Cn& d) const { return m_value<d.m_value; }

        bool operator<(double d) const { return m_value<d; }

        bool operator<=(const Cn& d) const { return m_value<=d.m_value; }

        bool operator<=(double d) const { return m_value<=d; }

        Cn operator=(double d) { m_value=d; return *this; }

        QChar character() const { Q_ASSERT(m_format==Char); return QChar(m_char); }

        virtual QVariant accept(AbstractExpressionVisitor*) const;
        virtual bool isZero() const { return m_value==0.; }

        virtual bool matches(const Object* exp, QMap< QString, const Object* >* found) const;
        /*
        virtual Object* copy() const;

        static Cn pi();
        static Cn e();
        static Cn euler();
    private:
        union { double m_value; ushort m_char; };
        enum ValueFormat m_format;
};

}

#endif