home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / yacl-012.zip / base / object.cxx < prev    next >
C/C++ Source or Header  |  1995-04-06  |  7KB  |  344 lines
  1.  
  2.  
  3.  
  4.  
  5. /*
  6.  *
  7.  *          Copyright (C) 1994, M. A. Sridhar
  8.  *  
  9.  *
  10.  *     This software is Copyright M. A. Sridhar, 1994. You are free
  11.  *     to copy, modify or distribute this software  as you see fit,
  12.  *     and to use  it  for  any  purpose, provided   this copyright
  13.  *     notice and the following   disclaimer are included  with all
  14.  *     copies.
  15.  *
  16.  *                        DISCLAIMER
  17.  *
  18.  *     The author makes no warranties, either expressed or implied,
  19.  *     with respect  to  this  software, its  quality, performance,
  20.  *     merchantability, or fitness for any particular purpose. This
  21.  *     software is distributed  AS IS.  The  user of this  software
  22.  *     assumes all risks  as to its quality  and performance. In no
  23.  *     event shall the author be liable for any direct, indirect or
  24.  *     consequential damages, even if the  author has been  advised
  25.  *     as to the possibility of such damages.
  26.  *
  27.  */
  28.  
  29.  
  30.  
  31.  
  32.  
  33. #ifdef __GNUC__
  34. #pragma implementation
  35. #endif
  36.  
  37.  
  38. #include <iostream.h>
  39.  
  40. #include "base/clntset.h"
  41. #include "base/stream.h"
  42. #include "base/map.h"
  43.  
  44.  
  45. static CL_Map<long,long>* TheClassIdMap = NULL;
  46.  
  47. #ifdef DEBUG
  48. #include "base/memory.h"
  49. static CL_MemoryLeakChecker* check;
  50. #endif
  51.  
  52. CL_Map<long,long>& CL_Object::_ClassIdMap =
  53. TheClassIdMap ? *TheClassIdMap
  54. : *(TheClassIdMap = new CL_Map<long,long>);
  55.  
  56.  
  57. CL_ClassIdEntryMaker::CL_ClassIdEntryMaker (CL_ClassId id, CL_Creator func)
  58. {
  59.     if (!TheClassIdMap) {
  60. #ifdef DEBUG
  61.         check = new CL_MemoryLeakChecker (cout);
  62. #endif
  63.         TheClassIdMap = new CL_Map<long,long>;
  64.     }
  65.     TheClassIdMap->Add (id, (long) func);
  66. }
  67.  
  68.  
  69. CL_ClassIdEntryMaker::~CL_ClassIdEntryMaker ()
  70. {
  71.     if (TheClassIdMap) {
  72.         delete TheClassIdMap;
  73.         TheClassIdMap = NULL;
  74. #ifdef DEBUG
  75.         delete check;
  76. #endif
  77.     }
  78. }
  79.  
  80.  
  81. CL_String CL_Object::AsString() const
  82. {
  83.     NotImplemented ("CL_Object::AsString");
  84.     return "";
  85. }
  86.  
  87.  
  88. bool CL_Object::operator== (const CL_Object& o) const
  89. {
  90.     return this == &o;
  91. }
  92.  
  93.  
  94. bool CL_Object::operator< (const CL_Object& o) const
  95. {
  96. #if defined(__DOS__) || defined(__MS_WINDOWS__)
  97.     return ((ulong) (void huge *) this) < ((ulong) (void huge *) &o);
  98. #else
  99.     return ((ulong) this) < ((ulong) &o);
  100. #endif
  101. }
  102.  
  103.  
  104.  
  105. istream& operator>> (istream& s, CL_Object& o)
  106. {
  107.     o.FromStream (s);
  108.     return s;
  109. }
  110.  
  111.  
  112.  
  113. ostream& operator<< (ostream& s, const CL_Object& o)
  114. {
  115.     o.IntoStream (s);
  116.     return s;
  117. }
  118.  
  119.  
  120.  
  121.  
  122. void CL_Object::IntoStream (ostream& o) const
  123. {
  124.     CL_String s = AsString ();
  125.     o << s.AsPtr();
  126. }
  127.  
  128.  
  129. bool CL_Object::ReadClassId (const CL_Stream& s) const
  130. {
  131.     long id;
  132.     if (!s.Read (id))
  133.         return FALSE;
  134.     if (id != ClassId()) {
  135.         s.SeekTo (s.Offset() - sizeof id);
  136.         return FALSE;
  137.     }
  138.     return TRUE;
  139. }
  140.  
  141. bool CL_Object::ReadFrom  (const CL_Stream&)
  142. {
  143.     NotImplemented ("ReadFrom");
  144.     return FALSE;
  145. }
  146.  
  147.  
  148. bool CL_Object::WriteTo  (CL_Stream&) const
  149. {
  150.     NotImplemented ("WriteTo");
  151.     return FALSE;
  152. }
  153.  
  154.  
  155.  
  156.  
  157. bool CL_Object::CompareWith (const CL_Object& obj,
  158.                              CL_Object::ComparisonOperator op) const
  159. {
  160.     short result;
  161.     if (!IsA (obj))
  162.         result = (this < &obj ? -1 : 1);
  163.     else
  164.         result = Compare (obj);
  165.     switch (op) {
  166.     case CL_Object::OP_EQUAL:
  167.         return result == 0;
  168.         
  169.     case CL_Object::OP_LESSTHAN:
  170.         return result < 0;
  171.         
  172.     case CL_Object::OP_GTRTHAN:
  173.         return result > 0;
  174.         
  175.     case CL_Object::OP_LESSEQ:
  176.         return result <= 0;
  177.         
  178.     case CL_Object::OP_GTREQ:
  179.         return result >= 0;
  180.         
  181.     case CL_Object::OP_NOTEQUAL:
  182.         return result != 0;
  183.         
  184.     case CL_Object::OP_PREFIX:
  185.     case CL_Object::OP_CONTAINS:
  186.         return AsString().CompareWith (obj.AsString(), op);
  187.  
  188.     default:
  189.         CL_Error::Warning ("CL_Object::CompareWith: bad operator %d",
  190.                            (short) op);
  191.         break;
  192.     }
  193.     return FALSE;
  194. }
  195.  
  196.  
  197.  
  198. bool CL_Object::CompareWith (const CL_String& obj,
  199.                              CL_Object::ComparisonOperator op) const
  200. {
  201.     return AsString().CompareWith (obj, op);
  202. }
  203.  
  204.  
  205.  
  206.  
  207.  
  208.  
  209.  
  210.  
  211.  
  212.  
  213. // ---------------------- Dependency methods ------------------------
  214.  
  215. static long _NullValue = 0;
  216.  
  217. struct CL_DependStruct {
  218.     CL_ClientSet postChange;
  219.     CL_ClientSet preChange;
  220. };
  221.  
  222.     
  223.  
  224.  
  225. CL_Object::~CL_Object()
  226. {
  227.     if (_dependSet) {
  228.         delete  _dependSet;
  229.     }
  230. }
  231.  
  232.  
  233.  
  234.         
  235.  
  236. void CL_Object::Notify ()
  237. {
  238.     if (_dependSet) {
  239.         ( _dependSet)->postChange.NotifyAll (*this);
  240.     }
  241. }
  242.  
  243.  
  244.  
  245. void CL_Object::AddDependent (const CL_AbstractBinding& binding, long code)
  246. {
  247.     if (!_dependSet) {
  248.         _dependSet = new CL_DependStruct;
  249.         if (!_dependSet)
  250.             return; // No memory
  251.     }
  252.     ( _dependSet)->postChange.Add (binding, code);
  253. }
  254.  
  255.  
  256.  
  257.  
  258. void CL_Object::RemoveDependent (const CL_AbstractBinding& binding)
  259. {
  260.     if (_dependSet) {
  261.         ( _dependSet)->postChange.Remove (binding);
  262.     }
  263. }
  264.  
  265.  
  266.  
  267. bool CL_Object::HasDependent (const CL_AbstractBinding& o) const
  268. {
  269.     return _dependSet &&
  270.         ( _dependSet)->postChange.Includes (o);
  271. }
  272.  
  273. long& CL_Object::PostChangeCode (const CL_AbstractBinding& b) const
  274. {
  275.     if (_dependSet) {
  276.         CL_ClientSet* post_change =  &( _dependSet)->postChange;
  277.         return (post_change->CodeFor (b));
  278.     }
  279.     _NullValue = 0;
  280.     return _NullValue;
  281. }
  282.  
  283.  
  284.  
  285. // Pre-change notification methods
  286.  
  287.  
  288.  
  289. bool CL_Object::PrepareToChange ()
  290. {
  291.     if (_dependSet) {
  292.         return  ( _dependSet)->preChange.Permits
  293.             (*this);
  294.     }
  295.     return TRUE;
  296. }
  297.  
  298.  
  299.  
  300. void CL_Object::AddPreChangeDependent (const CL_AbstractBinding& binding,
  301.                                        long code)
  302. {
  303.     if (!_dependSet) {
  304.         _dependSet = new CL_DependStruct;
  305.         if (!_dependSet)
  306.             return; // No memory
  307.     }
  308.     ( _dependSet)->preChange.Add (binding, code);
  309. }
  310.  
  311.  
  312. // Remove a binding from our dependent list
  313. void CL_Object::RemovePreChangeDependent (const CL_AbstractBinding& b)
  314. {
  315.     if (_dependSet) {
  316.         ( _dependSet)->preChange.Remove (b);
  317.     }
  318. }
  319.  
  320.  
  321. // Is the given object dependent on us?
  322. bool CL_Object::HasPreChangeDependent (const CL_AbstractBinding& b) const
  323. {
  324.     return _dependSet &&
  325.         ( _dependSet)->preChange.Includes (b);
  326. }
  327.  
  328.  
  329. long& CL_Object::PreChangeCode (const CL_AbstractBinding& b) const
  330. {
  331.     if (_dependSet) {
  332.         CL_ClientSet* pre_change = &( _dependSet)->preChange;
  333.         return (pre_change->CodeFor (b));
  334.     }
  335.     _NullValue = 0;
  336.     return _NullValue;
  337. }
  338.  
  339.  
  340. #if defined(__GNUC__) && __GNUC_MINOR__ >= 6
  341. template class CL_Binding<CL_Object>;
  342. #endif
  343.  
  344.