unumber.hpp

/* ==================================================== ======== ======= *
 *
 *  unumber.hpp
 *  Ubit Project
 *  Part of the Ubit Toolkit: A Brick Construction Game Model for Creating GUIs
 *  (C) 1999-2006 / Eric Lecolinet / ENST Paris / http://www.enst.fr/~elc/ubit
 *
 * ***********************************************************************
 * COPYRIGHT NOTICE : 
 * THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY AND WITHOUT EVEN THE 
 * IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 
 * 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.
 * SEE FILES 'COPYRIGHT' AND 'COPYING' FOR MORE DETAILS.
 * ***********************************************************************
 * ==================================================== [(c)Elc] ======= *
 * ==================================================== ======== ======= */

#ifndef _unumber_hpp_
#define _unumber_hpp_
#include <iostream>
#include <ubit/ubrick.hpp>
//pragma ident  "@(#)unumber.hpp        ubit:05.05.00"
namespace ubit {

/* ==================================================== ===== ======= */
class UNumber: public UBrick {
public:
  //UBIT_CLASS(UNumber, UBrick)

  UNumber(UMask b_modes = 0) {}
    
  virtual int    intValue()    const = 0;
  virtual float  floatValue()  const = 0;
  virtual double doubleValue() const = 0;
  virtual UStr   toString()    const = 0;

  virtual UNumber& onChange(UCall&);

  virtual void changed(bool = true);
};
  
/* ==================================================== ===== ======= */
class UInteger : public UNumber {
public:
  UBIT_CLASS(UInteger, UNumber)

  UInteger(int v = 0) : value(v) {}
  UInteger(const UInteger& v) : value(v.value) {}
  //UInteger(const char*);  // ambigu
  UInteger(const UStr&);
  UInteger(const std::string&);

  operator int() const {return value;}

  friend std::istream& operator>>(std::istream&, UInteger&);

  int    intValue()    const {return value;}
  float  floatValue()  const {return float(value);}
  double doubleValue() const {return double(value);}
  UStr   toString()    const;

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  UInteger& operator=(int v)              {return setImpl(v);}
  UInteger& operator=(const UInteger& v)  {return setImpl(v.value);}

  UInteger& operator=(const char* s)      {return setImpl(s);}
  UInteger& operator=(const UStr& s);
  UInteger& operator=(const std::string& s);

  friend std::ostream& operator<<(std::ostream&, const UInteger&);

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  bool operator==(int v)             const {return value == v;}
  bool operator==(double v)          const {return value == v;}
  bool operator==(const UInteger& v) const {return value == v.value;}

  bool operator!=(int v)             const {return value != v;}
  bool operator!=(double v)          const {return value != v;}
  bool operator!=(const UInteger& v) const {return value != v.value;}

  bool operator<(int v)              const {return value < v;}
  bool operator<(double v)           const {return value < v;}
  bool operator<(const UInteger& v)  const {return value < v.value;}

  bool operator<=(int v)             const {return value <= v;}
  bool operator<=(double v)          const {return value <= v;}
  bool operator<=(const UInteger& v) const {return value <= v.value;}

  bool operator>(int v)              const {return value > v;}
  bool operator>(double v)           const {return value > v;}
  bool operator>(const UInteger& v)  const {return value > v.value;}

  bool operator>=(int v)             const {return value >= v;}
  bool operator>=(double v)          const {return value >= v;}
  bool operator>=(const UInteger& v) const {return value >= v.value;}
  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  UInteger& operator++() {return setImpl(value+1);}
  UInteger  operator++(int);
  UInteger& operator--() {return setImpl(value-1);}
  UInteger  operator--(int);

  UInteger& operator+=(int v) {return setImpl(value+v);}
  UInteger& operator+=(const UInteger& v) {return setImpl(value+v.value);}
  UInteger& operator-=(int v) {return setImpl(value-v);}
  UInteger& operator-=(const UInteger& v) {return setImpl(value-v.value);}
  UInteger& operator*=(int v) {return setImpl(value*v);}
  UInteger& operator*=(const UInteger& v) {return setImpl(value*v.value);}
  UInteger& operator/=(int v) {return setImpl(value/v);}
  UInteger& operator/=(const UInteger& v) {return setImpl(value/v.value);}
  
  // - - - Impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  virtual UInteger& setImpl(int, bool call_callbacks = true);
  virtual UInteger& setImpl(const char*, bool call_callbacks = true);
  
private:
  friend class UFloat;
  friend class UDouble;
  int value;
};

/* ==================================================== ===== ======= */
class UFloat : public UNumber {
public:
  UBIT_CLASS(UFloat, UNumber)

  UFloat(float v = 0.0)     : value(v) {}
  UFloat(const UFloat& v)   : value(v.value) {}
  UFloat(const UInteger& v) : value(v.value) {}
  //UFloat(const char*);  ambigu
  UFloat(const UStr&);
  UFloat(const std::string&);

  operator float() const {return value;}

  friend std::ostream& operator<<(std::ostream&, const UFloat&);

  int    intValue()    const {return int(value);}
  float  floatValue()  const {return value;}
  double doubleValue() const {return double(value);}
  UStr   toString()    const;
  
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  UFloat& operator=(float v)           {return setImpl(v);}
  UFloat& operator=(const UFloat& v)   {return setImpl(v.value);}
  UFloat& operator=(const UInteger& v) {return setImpl(v.value);}
  UFloat& operator=(const char* s)     {return setImpl(s);}
  UFloat& operator=(const UStr& s);
  UFloat& operator=(const std::string& s);

  friend std::istream& operator>>(std::istream&, UFloat&);

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  bool operator==(float v)          const {return value == v;}
  bool operator==(double v)         const {return value == v;}
  bool operator==(const UFloat& v)  const {return value == v.value;}

  bool operator!=(float v)          const {return value != v;}
  bool operator!=(double v)         const {return value != v;}
  bool operator!=(const UFloat& v)  const {return value != v.value;}

  bool operator<(float v)           const {return value < v;}
  bool operator<(double v)          const {return value < v;}
  bool operator<(const UFloat& v)   const {return value < v.value;}

  bool operator<=(float v)          const {return value <= v;}
  bool operator<=(double v)         const {return value <= v;}
  bool operator<=(const UFloat& v)  const {return value <= v.value;}

  bool operator>(float v)           const {return value > v;}
  bool operator>(double v)          const {return value > v;}
  bool operator>(const UFloat& v)   const {return value > v.value;}

  bool operator>=(float v)          const {return value >= v;}
  bool operator>=(double v)         const {return value >= v;}
  bool operator>=(const UFloat& v)  const {return value >= v.value;}

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  UFloat& operator++() {return setImpl(value+1);}
  UFloat  operator++(int);
  UFloat& operator--() {return setImpl(value-1);}
  UFloat  operator--(int);

  UFloat& operator+=(int v) {return setImpl(value+v);}
  UFloat& operator+=(const UFloat& v) {return setImpl(value+v.value);}
  UFloat& operator-=(int v) {return setImpl(value-v);}
  UFloat& operator-=(const UFloat& v) {return setImpl(value-v.value);}
  UFloat& operator*=(int v) {return setImpl(value*v);}
  UFloat& operator*=(const UFloat& v) {return setImpl(value*v.value);}
  UFloat& operator/=(int v) {return setImpl(value/v);}
  UFloat& operator/=(const UFloat& v) {return setImpl(value/v.value);}

  // - - - Impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  virtual UFloat& setImpl(float, bool call_callbacks = true);
  virtual UFloat& setImpl(const char*, bool call_callbacks = true);
  
private:
  friend class UInteger;
  friend class UDouble;
  float value;
};

/* ==================================================== ===== ======= */
class UDouble : public UNumber {
public:
  UBIT_CLASS(UDouble, UNumber)

  UDouble(double v = 0.0)    : value(v) {}
  UDouble(const UDouble& v)  : value(v.value) {}
  UDouble(const UFloat& v)   : value(v.value) {}
  UDouble(const UInteger& v) : value(v.value) {}
  //UDouble(const char*);  //ambigu
  UDouble(const UStr&);
  UDouble(const std::string&);

  operator double() const {return value;}

  friend std::ostream& operator<<(std::ostream&, const UDouble&);

  int    intValue()    const {return int(value);}
  float  floatValue()  const {return float(value);}
  double doubleValue() const {return value;}
  UStr   toString()    const;

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  UDouble& operator=(double v)           {return setImpl(v);}
  UDouble& operator=(const UDouble& v)   {return setImpl(v.value);}
  UDouble& operator=(const UFloat& v)    {return setImpl(v.value);}
  UDouble& operator=(const UInteger& v)  {return setImpl(v.value);}

  UDouble& operator=(const char* s)      {return setImpl(s);}
  UDouble& operator=(const UStr& s);
  UDouble& operator=(const std::string& s);

  friend std::istream& operator>>(std::istream&, UDouble&);

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  bool operator==(float v)          const {return value == v;}
  bool operator==(double v)         const {return value == v;}
  bool operator==(const UDouble& v) const {return value == v.value;}

  bool operator!=(float v)          const {return value != v;}
  bool operator!=(double v)         const {return value != v;}
  bool operator!=(const UDouble& v) const {return value != v.value;}

  bool operator<(float v)           const {return value < v;}
  bool operator<(double v)          const {return value < v;}
  bool operator<(const UDouble& v)  const {return value < v.value;}

  bool operator<=(float v)          const {return value <= v;}
  bool operator<=(double v)         const {return value <= v;}
  bool operator<=(const UDouble& v) const {return value <= v.value;}

  bool operator>(float v)           const {return value > v;}
  bool operator>(double v)          const {return value > v;}
  bool operator>(const UDouble& v)  const {return value > v.value;}

  bool operator>=(float v)          const {return value >= v;}
  bool operator>=(double v)         const {return value >= v;}
  bool operator>=(const UDouble& v) const {return value >= v.value;}
  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  UDouble& operator++() {return setImpl(value+1);}
  UDouble  operator++(int);
  UDouble& operator--() {return setImpl(value-1);}
  UDouble  operator--(int);

  UDouble& operator+=(int v) {return setImpl(value+v);}
  UDouble& operator+=(const UDouble& v) {return setImpl(value+v.value);}
  UDouble& operator-=(int v) {return setImpl(value-v);}
  UDouble& operator-=(const UDouble& v) {return setImpl(value-v.value);}
  UDouble& operator*=(int v) {return setImpl(value*v);}
  UDouble& operator*=(const UDouble& v) {return setImpl(value*v.value);}
  UDouble& operator/=(int v) {return setImpl(value/v);}
  UDouble& operator/=(const UDouble& v) {return setImpl(value/v.value);}

  // - - - Impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  virtual UDouble& setImpl(double, bool call_callbacks = true);
  virtual UDouble& setImpl(const char*, bool call_callbacks = true);

private:
  friend class UInteger;
  friend class UFloat;
  double value;
};

}
#endif
/* ==================================================== [TheEnd] ======= */
/* ==================================================== [(c)Elc] ======= */

---