You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
329 lines
6.5 KiB
329 lines
6.5 KiB
/*
|
|
Copyright (C) 2003 by Walter Schreppers
|
|
Copyright (C) 2004 by Cies Breijs
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of version 2 of the GNU General Public
|
|
License as published by the Free Software Foundation.
|
|
|
|
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.
|
|
*/
|
|
|
|
#include <kdebug.h>
|
|
#include <tdelocale.h>
|
|
|
|
#include "value.h"
|
|
|
|
|
|
Value::Value()
|
|
{
|
|
init();
|
|
}
|
|
|
|
Value::Value(const Value& n)
|
|
{
|
|
*this = n;
|
|
}
|
|
|
|
|
|
|
|
int Value::Type() const
|
|
{
|
|
return type;
|
|
}
|
|
|
|
void Value::setType(int newType)
|
|
{
|
|
if (type == newType) return; // dont change values when type is not changing
|
|
else if (newType == boolValue)
|
|
{
|
|
init();
|
|
type = newType;
|
|
m_string = i18n("false");
|
|
}
|
|
else if (newType == numberValue)
|
|
{
|
|
init();
|
|
type = newType;
|
|
}
|
|
else if (newType == stringValue)
|
|
{
|
|
init();
|
|
type = newType;
|
|
}
|
|
else if (newType == emptyValue) init();
|
|
}
|
|
|
|
|
|
bool Value::Bool() const
|
|
{
|
|
if (type == boolValue) return m_bool;
|
|
else if (type == numberValue) return (m_double - 0.5 > 0);
|
|
return false;
|
|
}
|
|
|
|
void Value::setBool(bool b)
|
|
{
|
|
type = boolValue;
|
|
m_bool = b;
|
|
if (m_bool)
|
|
{
|
|
m_double = 1;
|
|
m_string = i18n("true");
|
|
}
|
|
else
|
|
{
|
|
m_double = 0;
|
|
m_string = i18n("false");
|
|
}
|
|
}
|
|
|
|
|
|
double Value::Number() const
|
|
{
|
|
if (type == boolValue)
|
|
{
|
|
if (m_bool) return 1;
|
|
else return 0;
|
|
}
|
|
else if (type == numberValue) return m_double;
|
|
return 0; // stringValue, emptyValue
|
|
}
|
|
|
|
void Value::setNumber(double d)
|
|
{
|
|
type = numberValue;
|
|
m_double = d;
|
|
m_string.setNum(d);
|
|
}
|
|
|
|
bool Value::setNumber(const TQString &s)
|
|
{
|
|
type = numberValue;
|
|
bool ok = true;
|
|
double num = s.toDouble(&ok);
|
|
if (ok)
|
|
{
|
|
m_double = num;
|
|
m_string.setNum(num);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
TQString Value::String() const
|
|
{
|
|
if (type == boolValue)
|
|
{
|
|
if (m_bool) return TQString( i18n("true") );
|
|
else return TQString( i18n("false") );
|
|
}
|
|
else if (type == numberValue)
|
|
{
|
|
TQString s;
|
|
s.setNum(m_double);
|
|
return s;
|
|
}
|
|
return m_string; // stringValue, emptyValue
|
|
}
|
|
|
|
void Value::setString(double d)
|
|
{
|
|
type = stringValue;
|
|
m_double = d;
|
|
m_string.setNum(d);
|
|
}
|
|
|
|
void Value::setString(const TQString &s)
|
|
{
|
|
type = stringValue;
|
|
m_string = s;
|
|
}
|
|
|
|
|
|
|
|
Value& Value::operator=(const Value& n)
|
|
{
|
|
if (this != &n)
|
|
{
|
|
if (type == n.type)
|
|
{
|
|
type = n.Type();
|
|
m_bool = n.Bool();
|
|
m_double = n.Number();
|
|
m_string = n.String();
|
|
}
|
|
else if (n.Type() == boolValue)
|
|
{
|
|
setBool( n.Bool() );
|
|
}
|
|
else if (n.Type() == numberValue)
|
|
{
|
|
setNumber( n.Number() );
|
|
}
|
|
else if (n.Type() == stringValue)
|
|
{
|
|
setString( n.String() );
|
|
}
|
|
else if (n.Type() == emptyValue)
|
|
{
|
|
init();
|
|
}
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
|
|
Value& Value::operator=(const TQString& s)
|
|
{
|
|
setString(s);
|
|
return *this;
|
|
}
|
|
|
|
Value& Value::operator=(double n)
|
|
{
|
|
setNumber(n);
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
Value& Value::operator+(const Value& n)
|
|
{
|
|
if (type == numberValue && n.Type() == numberValue)
|
|
{
|
|
m_double += n.Number();
|
|
}
|
|
else
|
|
{
|
|
type = stringValue;
|
|
m_string = String() + n.String();
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
|
|
Value& Value::operator-(const Value& n)
|
|
{
|
|
if (type == numberValue && n.Type() == numberValue)
|
|
{
|
|
m_double -= n.Number();
|
|
}
|
|
else
|
|
{
|
|
kdDebug(0)<<"Value::operator; cannot subtract strings"<<endl;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
|
|
Value& Value::operator*(const Value& n)
|
|
{
|
|
if (type == numberValue && n.Type() == numberValue)
|
|
{
|
|
m_double *= n.Number();
|
|
}
|
|
else
|
|
{
|
|
kdDebug(0)<<"Value::operator; cannot multiply strings"<<endl;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
|
|
Value& Value::operator/(const Value& n)
|
|
{
|
|
if (type == numberValue && n.Type() == numberValue)
|
|
{
|
|
m_double /= n.Number();
|
|
}
|
|
else
|
|
{
|
|
kdDebug(0)<<"Value::operator; cannot divide strings"<<endl;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
bool Value::operator==(const Value& n) const
|
|
{
|
|
if (type == boolValue && n.Type() == boolValue) return m_bool == n.Bool();
|
|
if (type == numberValue && n.Type() == numberValue) return m_double == n.Number();
|
|
if (type == stringValue && n.Type() == stringValue) return m_string == n.String();
|
|
if (type == emptyValue && n.Type() == emptyValue) return true;
|
|
return false;
|
|
}
|
|
|
|
|
|
bool Value::operator!=(const Value& n) const
|
|
{
|
|
if (type == boolValue && n.Type() == boolValue) return m_bool != n.Bool();
|
|
if (type == numberValue && n.Type() == numberValue) return m_double != n.Number();
|
|
if (type == stringValue && n.Type() == stringValue) return m_string != n.String();
|
|
// if (type == emptyValue && n.Type() == emptyValue) return false;
|
|
return false;
|
|
}
|
|
|
|
|
|
bool Value::operator<(const Value& n) const
|
|
{
|
|
if (type == boolValue && n.Type() == boolValue) return m_bool < n.Bool();
|
|
if (type == numberValue && n.Type() == numberValue) return m_double < n.Number();
|
|
if (type == stringValue && n.Type() == stringValue) return m_string.length() < n.String().length();
|
|
// if (type == emptyValue && n.Type() == emptyValue) return false;
|
|
return false;
|
|
}
|
|
|
|
|
|
bool Value::operator<=(const Value& n) const
|
|
{
|
|
if (type == boolValue && n.Type() == boolValue) return m_bool <= n.Bool();
|
|
if (type == numberValue && n.Type() == numberValue) return m_double <= n.Number();
|
|
if (type == stringValue && n.Type() == stringValue) return m_string.length() <= n.String().length();
|
|
if (type == emptyValue && n.Type() == emptyValue) return true;
|
|
return false;
|
|
}
|
|
|
|
|
|
bool Value::operator>(const Value& n) const
|
|
{
|
|
if (type == boolValue && n.Type() == boolValue) return m_bool > n.Bool();
|
|
if (type == numberValue && n.Type() == numberValue) return m_double > n.Number();
|
|
if (type == stringValue && n.Type() == stringValue) return m_string.length() > n.String().length();
|
|
// if (type == emptyValue && n.Type() == emptyValue) return false;
|
|
return false;
|
|
}
|
|
|
|
|
|
bool Value::operator>=(const Value& n) const
|
|
{
|
|
if (type == boolValue && n.Type() == boolValue) return m_bool >= n.Bool();
|
|
if (type == numberValue && n.Type() == numberValue) return m_double >= n.Number();
|
|
if (type == stringValue && n.Type() == stringValue) return m_string.length() >= n.String().length();
|
|
if (type == emptyValue && n.Type() == emptyValue) return true;
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
// private
|
|
|
|
void Value::init()
|
|
{
|
|
type = emptyValue; // init'ed values are empty by default
|
|
m_bool = false;
|
|
m_double = 0;
|
|
m_string = "";
|
|
}
|
|
|
|
|