kturtle/src/value.cpp

   1 /*
   2     Copyright (C) 2003 by Walter Schreppers
   3     Copyright (C) 2004 by Cies Breijs
   4
   5     This program is free software; you can redistribute it and/or
   6     modify it under the terms of version 2 of the GNU General Public
   7     License as published by the Free Software Foundation.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17  */
  18
  19 #include <kdebug.h>
  20 #include <klocale.h>
  21
  22 #include "value.h"
  23
  24
  25 Value::Value()
  26 {
  27         init();
  28 }
  29
  30 Value::Value(const Value& n)
  31 {
  32         *this = n;
  33 }
  34
  35
  36
  37 int Value::Type() const
  38 {
  39         return type;
  40 }
  41
  42 void Value::setType(int newType)
  43 {
  44         if (type == newType) return; // dont change values when type is not changing
  45         else if (newType == boolValue)
  46         {
  47                 init();
  48                 type = newType;
  49                 m_string = i18n("false");
  50         }
  51         else if (newType == numberValue)
  52         {
  53                 init();
  54                 type = newType;
  55         }
  56         else if (newType == stringValue)
  57         {
  58                 init();
  59                 type = newType;
  60         }
  61         else if (newType == emptyValue) init();
  62 }
  63
  64
  65 bool Value::Bool() const
  66 {
  67         if (type == boolValue) return m_bool;
  68         else if (type == numberValue) return (m_double - 0.5 > 0);
  69         return false;
  70 }
  71
  72 void Value::setBool(bool b)
  73 {
  74         type = boolValue;
  75         m_bool = b;
  76         if (m_bool)
  77         {
  78                 m_double = 1;
  79                 m_string = i18n("true");
  80         }
  81         else
  82         {
  83                 m_double = 0;
  84                 m_string = i18n("false");
  85         }
  86 }
  87
  88
  89 double Value::Number() const
  90 {
  91         if (type == boolValue)
  92         {
  93                 if (m_bool) return 1;
  94                 else return 0;
  95         }
  96         else if (type == numberValue) return m_double;
  97         return 0; // stringValue, emptyValue
  98 }
  99
 100 void Value::setNumber(double d)
 101 {
 102         type = numberValue;
 103         m_double = d;
 104         m_string.setNum(d);
 105 }
 106
 107 bool Value::setNumber(const QString &s)
 108 {
 109         type = numberValue;
 110         bool ok = true;
 111         double num = s.toDouble(&ok);
 112         if (ok)
 113         {
 114                 m_double = num;
 115                 m_string.setNum(num);
 116                 return true;
 117         }
 118         return false;
 119 }
 120
 121
 122 QString Value::String() const
 123 {
 124         if (type == boolValue)
 125         {
 126                 if (m_bool) return QString( i18n("true") );
 127                 else return QString( i18n("false") );
 128         }
 129         else if (type == numberValue)
 130         {
 131                 QString s;
 132                 s.setNum(m_double);
 133                 return s;
 134         }
 135         return m_string; // stringValue, emptyValue
 136 }
 137
 138 void Value::setString(double d)
 139 {
 140         type = stringValue;
 141         m_double = d;
 142         m_string.setNum(d);
 143 }
 144
 145 void Value::setString(const QString &s)
 146 {
 147         type = stringValue;
 148         m_string = s;
 149 }
 150
 151
 152
 153 Value& Value::operator=(const Value& n)
 154 {
 155         if (this != &n)
 156         {
 157                 if (type == n.type)
 158                 {
 159                         type = n.Type();
 160                         m_bool = n.Bool();
 161                         m_double = n.Number();
 162                         m_string = n.String();
 163                 }
 164                 else if (n.Type() == boolValue)
 165                 {
 166                         setBool( n.Bool() );
 167                 }
 168                 else if (n.Type() == numberValue)
 169                 {
 170                         setNumber( n.Number() );
 171                 }
 172                 else if (n.Type() == stringValue)
 173                 {
 174                         setString( n.String() );
 175                 }
 176                 else if (n.Type() == emptyValue)
 177                 {
 178                         init();
 179                 }
 180         }
 181         return *this;
 182 }
 183
 184
 185 Value& Value::operator=(const QString& s)
 186 {
 187         setString(s);
 188         return *this;
 189 }
 190
 191 Value& Value::operator=(double n)
 192 {
 193         setNumber(n);
 194         return *this;
 195 }
 196
 197
 198
 199 Value& Value::operator+(const Value& n)
 200 {
 201         if (type == numberValue && n.Type() == numberValue)
 202         {
 203                 m_double += n.Number();
 204         }
 205         else
 206         {
 207                 type = stringValue;
 208                 m_string = String() + n.String();
 209         }
 210         return *this;
 211 }
 212
 213
 214 Value& Value::operator-(const Value& n)
 215 {
 216         if (type == numberValue && n.Type() == numberValue)
 217         {
 218                 m_double -= n.Number();
 219         }
 220         else
 221         {
 222                 kdDebug(0)<<"Value::operator; cannot subtract strings"<<endl;
 223         }
 224         return *this;
 225 }
 226
 227
 228 Value& Value::operator*(const Value& n)
 229 {
 230         if (type == numberValue && n.Type() == numberValue)
 231         {
 232                 m_double *= n.Number();
 233         }
 234         else
 235         {
 236                 kdDebug(0)<<"Value::operator; cannot multiply strings"<<endl;
 237         }
 238         return *this;
 239 }
 240
 241
 242 Value& Value::operator/(const Value& n)
 243 {
 244         if (type == numberValue && n.Type() == numberValue)
 245         {
 246                 m_double /= n.Number();
 247         }
 248         else
 249         {
 250                 kdDebug(0)<<"Value::operator; cannot divide strings"<<endl;
 251         }
 252         return *this;
 253 }
 254
 255
 256
 257 bool Value::operator==(const Value& n) const
 258 {
 259         if (type == boolValue && n.Type() == boolValue)     return m_bool == n.Bool();
 260         if (type == numberValue && n.Type() == numberValue) return m_double == n.Number();
 261         if (type == stringValue && n.Type() == stringValue) return m_string == n.String();
 262         if (type == emptyValue && n.Type() == emptyValue)   return true;
 263         return false;
 264 }
 265
 266
 267 bool Value::operator!=(const Value& n) const
 268 {
 269         if (type == boolValue && n.Type() == boolValue)     return m_bool != n.Bool();
 270         if (type == numberValue && n.Type() == numberValue) return m_double != n.Number();
 271         if (type == stringValue && n.Type() == stringValue) return m_string != n.String();
 272         // if (type == emptyValue && n.Type() == emptyValue)   return false;
 273         return false;
 274 }
 275
 276
 277 bool Value::operator<(const Value& n) const
 278 {
 279         if (type == boolValue && n.Type() == boolValue)     return m_bool < n.Bool();
 280         if (type == numberValue && n.Type() == numberValue) return m_double < n.Number();
 281         if (type == stringValue && n.Type() == stringValue) return m_string.length() < n.String().length();
 282         // if (type == emptyValue && n.Type() == emptyValue)   return false;
 283         return false;
 284 }
 285
 286
 287 bool Value::operator<=(const Value& n) const
 288 {
 289         if (type == boolValue && n.Type() == boolValue)     return m_bool <= n.Bool();
 290         if (type == numberValue && n.Type() == numberValue) return m_double <= n.Number();
 291         if (type == stringValue && n.Type() == stringValue) return m_string.length() <= n.String().length();
 292         if (type == emptyValue && n.Type() == emptyValue)   return true;
 293         return false;
 294 }
 295
 296
 297 bool Value::operator>(const Value& n) const
 298 {
 299         if (type == boolValue && n.Type() == boolValue)     return m_bool > n.Bool();
 300         if (type == numberValue && n.Type() == numberValue) return m_double > n.Number();
 301         if (type == stringValue && n.Type() == stringValue) return m_string.length() > n.String().length();
 302         // if (type == emptyValue && n.Type() == emptyValue)   return false;
 303         return false;
 304 }
 305
 306
 307 bool Value::operator>=(const Value& n) const
 308 {
 309         if (type == boolValue   && n.Type() == boolValue)   return m_bool >= n.Bool();
 310         if (type == numberValue && n.Type() == numberValue) return m_double >= n.Number();
 311         if (type == stringValue && n.Type() == stringValue) return m_string.length() >= n.String().length();
 312         if (type == emptyValue  && n.Type() == emptyValue)  return true;
 313         return false;
 314 }
 315
 316
 317
 318 // private
 319
 320 void Value::init()
 321 {
 322         type = emptyValue; // init'ed values are empty by default
 323         m_bool = false;
 324         m_double = 0;
 325         m_string = "";
 326 }
 327
 328