home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / yacl-012.zip / base / integer.h < prev    next >
C/C++ Source or Header  |  1995-04-08  |  11KB  |  431 lines
  1.  
  2. #ifndef _integer_h_
  3. #define _integer_h_
  4.  
  5.  
  6.  
  7.  
  8.  
  9. /*
  10.  *
  11.  *          Copyright (C) 1994, M. A. Sridhar
  12.  *  
  13.  *
  14.  *     This software is Copyright M. A. Sridhar, 1994. You are free
  15.  *     to copy, modify or distribute this software  as you see fit,
  16.  *     and to use  it  for  any  purpose, provided   this copyright
  17.  *     notice and the following   disclaimer are included  with all
  18.  *     copies.
  19.  *
  20.  *                        DISCLAIMER
  21.  *
  22.  *     The author makes no warranties, either expressed or implied,
  23.  *     with respect  to  this  software, its  quality, performance,
  24.  *     merchantability, or fitness for any particular purpose. This
  25.  *     software is distributed  AS IS.  The  user of this  software
  26.  *     assumes all risks  as to its quality  and performance. In no
  27.  *     event shall the author be liable for any direct, indirect or
  28.  *     consequential damages, even if the  author has been  advised
  29.  *     as to the possibility of such damages.
  30.  *
  31.  */
  32.  
  33.  
  34.  
  35. // This class is intended to make an integer look like a first-class YACL
  36. // object, complete with notification capabilities. It supports all of the
  37. // usual integer operators as well as the protocol inherited from
  38. // CL_Object.
  39.  
  40.  
  41. #ifdef __GNUC__
  42. #pragma interface
  43. #endif
  44.  
  45. #include "base/object.h"
  46. #include "base/string.h"
  47.     
  48.  
  49.  
  50. class CL_EXPORT  CL_Integer: public CL_Object {
  51.  
  52. public:
  53.  
  54.     //
  55.     // ------------------------ Construction and destruction -----------------
  56.     //
  57.     CL_Integer (long l)
  58.         {_value = l;}
  59.  
  60.     CL_Integer ()
  61.         {_value = 0;}
  62.  
  63.     CL_Integer (const CL_Integer& i)
  64.         {_value = i.Value();};
  65.  
  66.  
  67.     ~CL_Integer();
  68.  
  69.  
  70.     //
  71.     // ------------------------- Conversions ------------------------------
  72.     //
  73.  
  74.     long Value() const {return _value;};
  75.  
  76.     operator long() const {return _value;};
  77.  
  78.     CL_String InRadix (short r) const;
  79.     // Return a String containing the radix-$r$ representation of this
  80.     // integer. The radix must be in the range 2..16; otherwise, the null
  81.     // string is returned. Also, for a non-decimal radix, this integer is
  82.     // treated as unsigned.
  83.     
  84.     //
  85.     // Comparison
  86.     //
  87.     bool operator<  (const CL_Object& o) const;
  88.  
  89.     bool operator<= (const CL_Object& o) const;
  90.  
  91.     bool operator>  (const CL_Object& o) const;
  92.  
  93.     bool operator>= (const CL_Object& o) const;
  94.  
  95.     bool operator== (const CL_Object& o) const;
  96.  
  97.     bool operator!= (const CL_Object& o) const;
  98.  
  99.  
  100.     
  101.     bool operator<  (const CL_Integer& o) const
  102.         {return _value < o.Value();};
  103.  
  104.     bool operator<= (const CL_Integer& o) const
  105.          {return _value <= o.Value();};
  106.  
  107.     bool operator>  (const CL_Integer& o) const
  108.          {return _value > o.Value();};
  109.  
  110.     bool operator>= (const CL_Integer& o) const
  111.          {return _value >= o.Value();};
  112.  
  113.     bool operator== (const CL_Integer& o) const
  114.          {return _value == o.Value();};
  115.  
  116.     bool operator!= (const CL_Integer& o) const
  117.          {return _value != o.Value();};
  118.  
  119.  
  120.  
  121.     bool operator<  (long o) const
  122.         {return _value < o;};
  123.  
  124.     bool operator<= (long o) const
  125.          {return _value <= o;};
  126.  
  127.     bool operator>  (long o) const
  128.          {return _value > o;};
  129.  
  130.     bool operator>= (long o) const
  131.          {return _value >= o;};
  132.  
  133.     bool operator== (long o) const
  134.          {return _value == o;};
  135.  
  136.     bool operator!= (long o) const
  137.          {return _value != o;};
  138.  
  139.  
  140.  
  141.     bool operator<  (int o) const
  142.         {return _value < o;};
  143.  
  144.     bool operator<= (int o) const
  145.          {return _value <= o;};
  146.  
  147.     bool operator>  (int o) const
  148.          {return _value > o;};
  149.  
  150.     bool operator>= (int o) const
  151.          {return _value >= o;};
  152.  
  153.     bool operator== (int o) const
  154.          {return _value == o;};
  155.  
  156.     bool operator!= (int o) const
  157.          {return _value != o;};
  158.  
  159.  
  160.  
  161.     short Compare (const CL_Object& o) const;
  162.  
  163.     short Compare (const CL_Integer& o) const;
  164.  
  165.     //
  166.     // Arithmetic operations:
  167.     //
  168.     CL_Integer operator+ (const CL_Integer& i) const
  169.         {return CL_Integer(_value+i.Value());};
  170.  
  171.     CL_Integer operator- (const CL_Integer& i) const
  172.         {return CL_Integer(_value-i.Value());};
  173.  
  174.     CL_Integer operator* (const CL_Integer& i) const
  175.         {return CL_Integer(_value*i.Value());};
  176.  
  177.     CL_Integer operator/ (const CL_Integer& i) const
  178.         {return CL_Integer(_value/i.Value());};
  179.  
  180.     CL_Integer operator% (const CL_Integer& i) const
  181.         {return CL_Integer(_value%i.Value());};
  182.  
  183.  
  184.     
  185.     CL_Integer operator+ (long i) const
  186.         {return CL_Integer(_value + i);};
  187.  
  188.     CL_Integer operator- (long i)  const
  189.         {return CL_Integer(_value - i);};
  190.  
  191.     CL_Integer operator* (long i)  const
  192.         {return CL_Integer(_value * i);};
  193.  
  194.     CL_Integer operator/ (long i)  const
  195.         {return CL_Integer(_value / i);};
  196.  
  197.     CL_Integer operator% (long i)  const
  198.         {return CL_Integer(_value % i);};
  199.  
  200.  
  201.     CL_Integer operator++ ();
  202.     // Prefix increment.
  203.  
  204.     CL_Integer operator++ (int);
  205.     // Postfix increment.
  206.  
  207.     CL_Integer operator-- ();
  208.     // Prefix decrement.
  209.  
  210.     CL_Integer operator-- (int);
  211.     // Postfix decrement.
  212.  
  213.  
  214.     //
  215.     // Bitwise operations:
  216.     //
  217.     CL_Integer operator| (const CL_Integer& i) const
  218.         {return CL_Integer(_value | i.Value());};
  219.  
  220.     CL_Integer operator& (const CL_Integer& i) const
  221.         {return CL_Integer(_value & i.Value());};
  222.  
  223.     CL_Integer operator<< (const CL_Integer& i) const
  224.         {return CL_Integer(_value << i.Value());};
  225.  
  226.     CL_Integer operator>> (const CL_Integer& i) const
  227.         {return CL_Integer(_value >> i.Value());};
  228.  
  229.     CL_Integer operator~ () const
  230.         {return CL_Integer(~_value);};
  231.  
  232.     CL_Integer operator^ (const CL_Integer& i) const
  233.         {return CL_Integer(_value ^ i.Value());};
  234.  
  235.  
  236.     
  237.     CL_Integer operator| (long i) const
  238.         {return CL_Integer(_value | i);};
  239.  
  240.     CL_Integer operator& (long i)  const
  241.         {return CL_Integer(_value & i);};
  242.  
  243.     CL_Integer operator<< (long i) const
  244.         {return CL_Integer(_value << i);};
  245.  
  246.     CL_Integer operator>> (long i)  const
  247.         {return CL_Integer(_value >> i);};
  248.  
  249.     CL_Integer operator^ (long i)  const
  250.         {return CL_Integer(_value ^ i);};
  251.  
  252.  
  253.     
  254.     //
  255.     // ------------------ Assignments of various kinds --------------------
  256.     //
  257.     virtual void operator= (const CL_Object&);
  258.  
  259.     virtual void operator= (const CL_String&);
  260.  
  261.     virtual CL_Integer& operator= (const CL_Integer&);
  262.     
  263.     virtual CL_Integer& operator= (long i);
  264.  
  265.     
  266.     CL_Integer& operator+= (const CL_Integer& i) 
  267.         {*this = _value + i.Value(); return *this;};
  268.  
  269.     CL_Integer& operator-= (const CL_Integer& i) 
  270.         {*this = _value - i.Value(); return *this;};
  271.  
  272.     CL_Integer& operator*= (const CL_Integer& i) 
  273.         {*this = _value * i.Value(); return *this;};
  274.  
  275.     CL_Integer& operator/= (const CL_Integer& i) 
  276.         {*this = _value / i.Value(); return *this;};
  277.  
  278.     CL_Integer& operator%= (const CL_Integer& i) 
  279.         {*this = _value % i.Value(); return *this;};
  280.  
  281.     CL_Integer& operator|= (const CL_Integer& i) 
  282.         {*this = _value | i.Value(); return *this;};
  283.  
  284.     CL_Integer& operator&= (const CL_Integer& i) 
  285.         {*this = _value & i.Value(); return *this;};
  286.  
  287.     CL_Integer& operator^= (const CL_Integer& i) 
  288.         {*this = _value ^ i.Value(); return *this;};
  289.  
  290.     CL_Integer& operator<<= (const CL_Integer& i) 
  291.         {*this = _value << i.Value(); return *this;};
  292.  
  293.     CL_Integer& operator>>= (const CL_Integer& i) 
  294.         {*this = _value >> i.Value(); return *this;};
  295.  
  296.  
  297.     CL_Integer& operator+= (long i) 
  298.         {*this = _value+i; return *this;};
  299.  
  300.     CL_Integer& operator-= (long i) 
  301.         {*this = _value-i; return *this;};
  302.  
  303.     CL_Integer& operator*= (long i) 
  304.         {*this = _value*i; return *this;};
  305.  
  306.     CL_Integer& operator/= (long i) 
  307.         {*this = _value/i; return *this;};
  308.  
  309.     CL_Integer& operator%= (long i) 
  310.         {*this = _value%i; return *this;};
  311.  
  312.     CL_Integer& operator|= (long i) 
  313.         {*this = _value | i; return *this;};
  314.  
  315.     CL_Integer& operator&= (long i) 
  316.         {*this = _value & i; return *this;};
  317.  
  318.     CL_Integer& operator^= (long i) 
  319.         {*this = _value ^ i; return *this;};
  320.  
  321.     CL_Integer& operator<<= (long i) 
  322.         {*this = _value << i; return *this;};
  323.  
  324.     CL_Integer& operator>>= (long i) 
  325.         {*this = _value >> i; return *this;};
  326.  
  327.  
  328.  
  329.     // --------------- Storage and retrieval ----------------------------
  330.  
  331.     long StorableFormWidth () const
  332.         { return sizeof (CL_ClassId) + sizeof  _value; };
  333.  
  334.     bool ReadFrom (const CL_Stream&);
  335.  
  336.     bool WriteTo  (CL_Stream&) const;
  337.  
  338.     CL_String AsString () const;
  339.  
  340.     void FromStream (istream& stream);
  341.     // Override the method inherited from {\small\tt CL_Object}. 
  342.  
  343.     // --------------------------- Basic methods -------------------
  344.     
  345.     CL_ClassId ClassId() const { return _CL_Integer_CLASSID;};
  346.     
  347.     const char* ClassName() const {return "CL_Integer";};
  348.  
  349.     CL_Object* Clone() const {return new CL_Integer (*this);};
  350.  
  351.     // ------------------ End public protocol ----------------------
  352.  
  353.     
  354.  
  355. protected:
  356.     long _value;
  357. };
  358.  
  359.  
  360.  
  361. inline short CL_Integer::Compare (const  CL_Integer& o) const
  362. {
  363.     return _value < o._value  ? -1 :  ((_value == o._value) ? 0 : 1);
  364. }
  365.  
  366. inline short CL_Integer::Compare (const  CL_Object& o) const
  367. {
  368.     return IsA (o) ? Compare ((const CL_Integer&) o)
  369.         : (this < (CL_Integer*) &o ? -1 :  1);
  370. }
  371.  
  372. inline bool CL_Integer::operator< (const CL_Object& o) const
  373. {
  374.     return IsA (o) && _value < ((CL_Integer&) o).Value();
  375. }
  376.  
  377.     
  378.  
  379. inline bool CL_Integer::operator<= (const CL_Object& o) const
  380. {
  381.     return IsA(o) && _value <= ((CL_Integer&) o).Value();
  382. }
  383.  
  384.     
  385.  
  386. inline bool CL_Integer::operator== (const CL_Object& o) const
  387. {
  388.     return IsA (o) && _value == ((CL_Integer&) o).Value();
  389. }
  390.  
  391.     
  392.  
  393. inline bool CL_Integer::operator>= (const CL_Object& o) const
  394. {
  395.     return IsA(o) && _value >= ((CL_Integer&) o).Value();
  396. }
  397.  
  398.     
  399.  
  400. inline bool CL_Integer::operator> (const CL_Object& o) const
  401. {
  402.     return IsA(o) && _value > ((CL_Integer&) o).Value();
  403. }
  404.  
  405.     
  406.  
  407. inline bool CL_Integer::operator!= (const CL_Object& o) const
  408. {
  409.     return !IsA(o) || _value != ((CL_Integer&) o).Value();
  410. }
  411.  
  412.  
  413. inline void CL_Integer::operator= (const CL_Object& s)
  414. {
  415.     if (CheckClassType (s, "CL_Integer::operator="))
  416.         *this = (const CL_Integer&) s;
  417. }
  418.  
  419.     
  420.  
  421. inline void CL_Integer::operator= (const CL_String& s)
  422. {
  423.     *this = s.AsLong ();
  424. }
  425.  
  426.  
  427.  
  428. #endif
  429.     
  430.  
  431.