home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / oath.lha / oath / src / stringTable.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-29  |  6.8 KB  |  262 lines
  1. //***************************************************************************
  2. //             OATH :: Object-oriented Abstract Type Hierarchy
  3. //***************************************************************************
  4. //
  5. //  Copyright (C) 1991, 1990  Texas Instruments Incorporated
  6. //  Permission is granted to any individual or institution
  7. //  to use, copy, modify, and distribute this software,
  8. //  provided that this complete copyright and permission notice
  9. //  is maintained, intact, in all copies and supporting documentation.
  10. //
  11. //  Texas Instruments Incorporated provides this software "as is"
  12. //  without express or implied warranty.
  13. //
  14. //***************************************************************************
  15. //  stringToken (stringTokenA, stringTokenG)
  16. //  stringTable (stringTableA, stringTableG)
  17. //
  18. //  History:
  19. //    07/91  Brian M Kennedy  import, export, typeRegister
  20. //    06/91  Brian M Kennedy  New macros & format; remove printDiagnostic
  21. //    10/90  Brian M Kennedy  Major Rewrite
  22. //    02/90  Brian M Kennedy  Original
  23. //
  24. //***************************************************************************
  25.  
  26. #include "copyright.h"
  27.  
  28. #include <oath/stringTable.h>
  29.  
  30. #define OATH_STRING_TOKEN_BUCKETS 255
  31.  
  32. #include <iostream.h>
  33.  
  34. /////////////////////////////////////////////////////////////////////////////
  35. /////////////////////////////////////////////////////////////////////////////
  36. // stringToken Outlines
  37.  
  38. OUTLINES(stringToken, token)
  39.  
  40.     stringTableA stringTokenG::
  41. StringTokens = stringTableA::make(OATH_STRING_TOKEN_BUCKETS);
  42.  
  43. // Constructors //////////
  44.  
  45.     stringTokenG::
  46. stringTokenG (const minStringG* IString)
  47.    :tokenG(), String(IString)
  48.    {ref();
  49.        {if(!String.isConst())
  50.         String = String.makeCopy(TRUE);
  51.     HashCache = String.hash();
  52.     StringTokens.guts()->insertAssoc(this, Nil);
  53.        }
  54.     deref();
  55.    }
  56.  
  57.     stringTokenG::
  58. ~stringTokenG ()
  59.    {ref();
  60.        {// cannot yet remove from existence
  61.        }
  62.     deref();
  63.    }
  64.  
  65.  
  66. // oathCore Operations //////////
  67.  
  68.     void stringTokenG::
  69. export (exportP& X) const
  70.    {X.writeType(TypeName);
  71.     String.export(X);
  72.    }
  73.  
  74.     objA stringTokenG::
  75. import (importP& M)
  76.    {minStringA String = minStringA::isa(objA::import(M));
  77.     return stringTokenA::make(String);
  78.    }
  79.  
  80.  
  81. /////////////////////////////////////////////////////////////////////////////
  82. /////////////////////////////////////////////////////////////////////////////
  83. // stringTable Outlines
  84.  
  85. OUTLINES(stringTable, table)
  86.  
  87. // Constructors //////////
  88.  
  89.     stringTableG::
  90. stringTableG (unsigned int IBuckets, int IsConst)
  91.    :tableG(IsConst), Table(0), Count(0), Buckets(IBuckets)
  92.    {ref();
  93.         Table = (stNodeP**)(new stNodeP* [IBuckets]);
  94.     for(unsigned int I = 0; I < Buckets; I++)
  95.         Table[I] = 0;
  96.     deref();
  97.    }
  98.  
  99. // oathCore Operations //////////
  100.  
  101.     void stringTableG::
  102. export (exportP& X) const
  103.    {X.writeType(TypeName);
  104.     X.stream() << Buckets << ' ' << Count << (isConst() ? ' ' : '\0');
  105.     for(unsigned int I = 0; I < Buckets; ++I)
  106.         for(stNodeP* N = Table[I]; N; N = N->Next)
  107.         N->Obj.export(X);
  108.    }
  109.  
  110.     objA stringTableG::
  111. import (importP& M)
  112.    {int Buckets, Count;
  113.     M.stream() >> Buckets >> Count;
  114.     char MakeConst = M.stream().get();
  115.     stringTableA ST = stringTableA::make(Buckets);
  116.     for(int I = 0; I < Count; ++I)
  117.         ST << stringTokenA::isa(objA::import(M)).am();
  118.     if(MakeConst)
  119.         ST.guts()->forceConst();
  120.     return ST;
  121.    }
  122.  
  123.  
  124. // obj Operations //////////
  125.  
  126.     int stringTableG::
  127. isEqual (const objG* O) const
  128.    {ensure(is(O), "Not implemented.");
  129.     return TRUE;
  130.    }
  131.  
  132.     objA stringTableG::
  133. makeCopy (int) const        // ignores MakeConst argument
  134.    {bagA ST = makeEmpty();
  135.     applyX(callSelf, ST.guts());
  136.     return Nil;
  137.    }
  138.  
  139.  
  140. // bag Operations //////////
  141.  
  142.     int stringTableG::
  143. contains (const objG* O) const
  144.    {return O->isImplementedAs(stringTokenG::Type)
  145.            && Table[((stringTokenG*)O)->hash() % Buckets]
  146.           ->contains((stringTokenG*)O);
  147.    }
  148.  
  149.     int stringTableG::
  150. containsEqual (const objG* O) const
  151.    {return O->isImplementedAs(stringTokenG::Type)
  152.            && Table[((stringTokenG*)O)->hash() % Buckets]
  153.           ->contains((stringTokenG*)O);
  154.    }
  155.  
  156.     int stringTableG::
  157. canContain (const objG* O) const
  158.    {return O->isImplementedAs(stringTokenG::Type);}
  159.  
  160.     void stringTableG::
  161. insert (const objG* O)
  162.    {NOT_CONST();
  163.     if(O->isImplementedAs(stringTokenG::Type))
  164.        {int Hash = ((stringTokenG*)O)->hash() % Buckets;
  165.         Table[Hash] = new stNodeP((stringTokenG*)O, Nil, Table[Hash]);
  166.        }
  167.    }
  168.  
  169.     void stringTableG::
  170. append (const bagG* B)
  171.    {NOT_CONST();
  172.     B->applyX(callSelf, this);
  173.    }
  174.  
  175.     void stringTableG::
  176. apply (void (*F)(objA)) const
  177.    {for(unsigned int I = 0; I < Buckets; ++I)
  178.         for(stNodeP* N = Table[I]; N; N = N->Next)
  179.         F(N->Token);
  180.    }
  181.  
  182.     bagG* stringTableG::
  183. applyX (objA (*F)(objA), bagG* B) const
  184.    {for(unsigned int I = 0; I < Buckets; ++I)
  185.        {for(stNodeP* N = Table[I]; N; N = N->Next)
  186.        {objA R = F(N->Token);
  187.         B->insert(R.guts());
  188.        }
  189.        }
  190.     return B;
  191.    }
  192.  
  193.     bagG* stringTableG::
  194. applyX (bagA (*F)(objA), bagG* B) const
  195.    {if(B->isType(tableG::Type))
  196.        {tableG* T = (tableG*)B;
  197.         for(unsigned int I = 0; I < Buckets; ++I)
  198.            {for(stNodeP* N = Table[I]; N; N = N->Next)
  199.            {bagA R = F(N->Token);
  200.             T->insertAssoc(R.guts(), N->Obj.guts());
  201.            }
  202.        }
  203.        }
  204.     else
  205.        {for(unsigned int I = 0; I < Buckets; ++I)
  206.            {for(stNodeP* N = Table[I]; N; N = N->Next)
  207.            {bagA R = F(N->Token);
  208.             B->insert(R.guts());
  209.            }
  210.        }
  211.        }
  212.     return B;
  213.    }
  214.  
  215.     bagA stringTableG::
  216. makeEmpty () const
  217.    {return new stringTableG (Buckets);}
  218.  
  219.  
  220. // Table Operations //////////
  221.  
  222.     void stringTableG::
  223. insertAssoc (const objG* O, const objG* A)
  224.    {NOT_CONST();
  225.     if(O->isImplementedAs(stringTokenG::Type))
  226.        {int Hash = ((stringTokenG*)O)->hash() % Buckets;
  227.     Table[Hash] = new stNodeP((stringTokenG*)O, A, Table[Hash]);
  228.        }
  229.    }
  230.  
  231.     void stringTableG::
  232. reassoc (const objG* O, const objG* A)
  233.    {NOT_CONST();
  234.     if(O->isImplementedAs(stringTokenG::Type))
  235.        {int Hash = ((stringTokenG*)O)->hash() % Buckets;
  236.     if(!Table[Hash]->reassoc((stringTokenG*)O, A))
  237.         Table[Hash] = new stNodeP((stringTokenG*)O, A, Table[Hash]);
  238.        }
  239.    }
  240.  
  241.     const objG* stringTableG::
  242. remove (const objG* O)
  243.    {NOT_CONST();
  244.     if(O->isImplementedAs(stringTokenG::Type))
  245.        {unsigned int Hash = ((stringTokenG*)O)->hash() % Buckets;
  246.         return Table[Hash]->remove((stringTokenG*)O, Table[Hash]);
  247.        }
  248.     else
  249.         return Nil;
  250.    }
  251.  
  252.     const objG* stringTableG::
  253. assoc (const objG* O) const
  254.    {return O->isImplementedAs(stringTokenG::Type) 
  255.        ? Table[((stringTokenG*)O)->hash() % Buckets]
  256.          ->assoc((stringTokenG*)O)
  257.        : objG::Nil;
  258.    }
  259.  
  260.  
  261. //***************************************************************************
  262.