home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c017 / 34.ddi / CSTRM.ZIP / BINDER.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-27  |  21.9 KB  |  1,130 lines
  1. /*
  2.  
  3.     binder.cpp
  4.     8-27-91
  5.     Loose Data Binder
  6.  
  7.     Copyright 1991
  8.     John W. Small
  9.     All rights reserved
  10.  
  11.     PSW / Power SoftWare
  12.     P.O. Box 10072
  13.     McLean, Virginia 22102 8072 USA
  14.  
  15.     John Small
  16.     Voice: (703) 759-3838
  17.     CIS: 73757,2233
  18.  
  19. */
  20.  
  21.  
  22. #include <string.h>
  23. #include <binder.hpp>
  24.  
  25. int Streamable::debug = 0;
  26. int Streamable::refDebug = 0;
  27.  
  28. void Streamable::lserror(const char *msg, unsigned id)
  29. {
  30.     if (debug)
  31.         cerr << "Class id: " << setw(6) << id
  32.             <<  "   stream error - "
  33.             << msg << endl;
  34. }
  35.  
  36. void Streamable::serror(const char *msg)
  37. {
  38.     if (debug)
  39.         cerr << endl 
  40.             <<"Class id: " << setw(6) << id
  41.             << "    &instance:   "
  42.             << (void *) this << endl
  43.             <<  "Stream error - "
  44.             << msg << endl << endl;
  45. }
  46.  
  47. void Streamable::swarn(const char *msg)
  48. {
  49.     if (debug)
  50.         cerr << endl
  51.             << "Class id: " << setw(6) << id
  52.             << "    &instance:   "
  53.             << (void *) this << endl
  54.             <<  "Stream warning - "
  55.             << msg << endl;
  56. }
  57.  
  58.  
  59. #pragma argsused
  60. StreamablE Streamable::load(istream& is,
  61.     StreamablE InstancE)
  62.     { return InstancE; }
  63.  
  64. char Streamable::memberTermChar = '\n';
  65.  
  66. #pragma argsused
  67. Streamable::Streamable(StreamableClassRegistry& dummy,
  68.     unsigned id)
  69. {
  70.     this->id = id;
  71.     streamed = refCount = 0;
  72.     spos = 0L;
  73. }
  74.  
  75. void Streamable::registerClass(unsigned id,
  76.         StreamablE (*loader)(istream& is,
  77.         StreamablE InstancE))
  78. {
  79.     SCRegistry.registerClass(id,loader);
  80. }
  81.  
  82. void Streamable::restream()
  83.     { streamed = 0; spos = 0L; }
  84.  
  85. unsigned Streamable::unlink()
  86. {
  87.     if (refDebug)
  88.         cerr << endl
  89.             << "Class id: " << setw(6) << id
  90.             << "    &instance:   "
  91.             << (void *) this << endl
  92.             <<  "Unlinking, starting refCount: "
  93.             << refCount << endl;
  94.     return (refCount? refCount-- : refCount);
  95. }
  96.  
  97. StreamablE Streamable::link()
  98. {
  99.     refCount++;
  100.     if (refDebug)
  101.         cerr << endl
  102.             << "Class id: " << setw(6) << id
  103.             << "    &instance:   "
  104.             << (void *) this << endl
  105.             <<  "Adding link, new refCount: "
  106.             << refCount << endl;
  107.     return this;
  108. }
  109.  
  110.  
  111. ostream& endm(ostream& os)
  112. {
  113.     return os << Streamable::memberTermChar
  114.         << flush;
  115. }
  116.  
  117. istream& nextm(istream& is)
  118. {
  119.     is.get();
  120.     return is;
  121. }
  122.  
  123.  
  124. void Binder::construct(unsigned flags, unsigned maxNodes,
  125.     unsigned limit, unsigned delta)
  126. {
  127.     curNode = first = nodes = 0;
  128.     comparE = BDRcomparE0;
  129.  
  130. /*
  131.     The following relationships are maintained
  132.     during operation of a binder:
  133.  
  134.     1 <= delta <= lowLimit <= limit <= maxNodes
  135.         <= BDR_MAXNODES
  136.     lowThreshold = lowLimit - delta;
  137. */
  138.  
  139.     if (maxNodes > BDR_MAXNODES)
  140.         maxNodes = BDR_MAXNODES;
  141.     if (limit > maxNodes)
  142.         limit = maxNodes;
  143.     if (delta > limit)
  144.         delta = limit;
  145.     if (!delta)  {
  146.         delta = 1;
  147.         if (limit < delta)
  148.             limit = delta;
  149.         if (maxNodes < limit)
  150.             maxNodes = limit;
  151.     }
  152.     if ((linkS = new voiD[limit]) == voiDV0)
  153.         this->limit = lowLimit = lowThreshold
  154.             = this->delta = this->maxNodes
  155.             = this->flags = 0;
  156.     else  {
  157.         this->limit = limit;
  158.         this->delta = delta;
  159.         this->maxNodes = maxNodes;
  160.         lowLimit = limit;
  161.         lowThreshold = lowLimit - delta;
  162.         flags |= SORTED;
  163.         this->flags = flags;
  164.     }
  165. }
  166.  
  167. int Binder::Dfree(voiD D)
  168. {
  169.     if (D)  {
  170.         if (flags & STREAMABLE_NODES)  {
  171.             if (!((StreamablE)D)->unlink())
  172.                 delete (StreamablE) D;
  173.         }
  174.         else
  175.             delete D;
  176.         return 1;
  177.     }
  178.     else
  179.         return 0;
  180. }
  181.  
  182. void Binder::Dstore(ostream& os, const voiD D)
  183. {
  184.     if (D && (flags & STREAMABLE_NODES))
  185.         os << (StreamablE) D;
  186.     else
  187.         swarn("don't know how to store "
  188.             "binder node ");
  189. }
  190.  
  191. voiD Binder::Dload(istream& is)
  192. {
  193.     StreamablE InstancE = StreamablE0;
  194.  
  195.     if (flags & STREAMABLE_NODES)
  196.         is >> InstancE;
  197.     else
  198.         swarn("don't know how to load "
  199.             "binder node ");
  200.     return (voiD) InstancE;
  201. }
  202.  
  203.  
  204. voiD Binder::DinsQ(voiD D)
  205.     { return insQ(D); }
  206.  
  207.  
  208. ostream& Binder::store(ostream& os)
  209. {
  210.     unsigned i;
  211.  
  212.     os << maxNodes << endm << limit << endm
  213.         << delta << endm << nodes << endm
  214.         << curNode << endm << flags << endm
  215.         << FncPtrToID((GenericFnC)comparE) << endm;
  216.     if (!os)
  217.         serror("unable to store Binder ");
  218.     else for (i = 0; i < nodes; i++)
  219.         Dstore(os,atGet(i));
  220.     return os;
  221. }
  222.  
  223. StreamablE Binder::load(istream& is, StreamablE InstancE)
  224. {
  225.     unsigned i, maxNodes, limit, delta, nodes, curNode;
  226.     unsigned flags;
  227.     unsigned comparEID;
  228.  
  229.     is >> maxNodes >> nextm >> limit >> nextm
  230.         >> delta >> nextm >> nodes >> nextm
  231.         >> curNode >> nextm >> flags >> nextm
  232.         >> comparEID >> nextm;
  233.     if (!is)  {
  234.         lserror("unable to load binder header data",
  235.             CLASS_ID);
  236.         return StreamablE0;
  237.     }
  238.     if (!InstancE) if ((InstancE = (StreamablE)
  239.         new Binder(UNIQUE_STREAMABLE))
  240.         == StreamablE0)  {
  241.         lserror("unable to construct binder for"
  242.             " loading ",CLASS_ID);
  243.         return StreamablE0;
  244.     }
  245.     ((BindeR)InstancE)->construct(flags,maxNodes,
  246.         limit,delta);
  247.     for (i = 0; i < nodes; i++)
  248.         ((BindeR)InstancE)->DinsQ(((BindeR)InstancE)
  249.             ->Dload(is));
  250.     ((BindeR)InstancE)->setCurNode(curNode);
  251.     ((BindeR)InstancE)->flags = flags;
  252.     ((BindeR)InstancE)->setComparE((BDRcomparE)
  253.         IDtoFncPtr(comparEID));
  254.     return InstancE;
  255. }
  256.  
  257. void Binder::restream()
  258. {
  259.     Streamable::restream();
  260.     if (flags & STREAMABLE_NODES)
  261.         for (unsigned i = 0; i < nodes; i++)
  262.             ((StreamablE)atGet(i))->restream();
  263. }
  264.  
  265. Binder::Binder(voiDV argv, int argc, unsigned flags)
  266.     : Streamable(UNIQUE_STREAMABLE,CLASS_ID)
  267. {
  268.     construct(flags,BDR_MAXNODES,argc,BDR_DELTA);
  269.     if (argv) if (argc > 0)
  270.         while (argc--)
  271.             push(argv[argc]);
  272.     else
  273.         for (argc = 0; insQ(argv[argc]); argc++);
  274. }
  275.  
  276. voiDV Binder::vector()
  277. {
  278.     voiDV V = voiDV0;
  279.  
  280.     if (nodes) if ((V = new voiD[nodes+1]) != voiDV0)  {
  281.         for (unsigned i = 0; i < nodes; i++)
  282.             V[i] = atGet(i);
  283.         V[i] = voiD0;
  284.     }
  285.     return V;
  286. }
  287.  
  288. Binder::~Binder()
  289. {
  290.     if (flags & (ALL_FREE_DESTRUCT | STREAMABLE_NODES))
  291.         allFree();
  292.     else
  293.         allDel();
  294.     delete linkS;
  295. }
  296.  
  297. unsigned Binder::setLimit(unsigned newLimit)
  298. {
  299.     voiDV newLinkS;
  300.     unsigned i;
  301.  
  302.     if (newLimit < nodes)
  303.         newLimit = nodes;
  304.     else if (newLimit > maxNodes)
  305.         newLimit = maxNodes;
  306.     if (newLimit < delta)
  307.         newLimit = delta;
  308.     if (!linkS || !newLimit || newLimit == limit)
  309.         return 0;
  310.     if ((newLinkS = new voiD[newLimit]) == voiDV0)
  311.         return 0;
  312.     if ((i = limit - first) > nodes)
  313.         i = nodes;
  314.     memcpy(newLinkS,&linkS[first],sizeof(linkS[0])*i);
  315.     /* copy wrap around */
  316.     if (i < nodes)
  317.         memcpy(&newLinkS[i],linkS,
  318.             sizeof(linkS[0])*(nodes-i));
  319.     if (newLimit > limit)
  320.         if (newLimit - delta > limit)
  321.             lowLimit = newLimit - delta;
  322.         else
  323.             lowLimit = limit;
  324.     else
  325.         if (newLimit - delta > delta)
  326.             lowLimit = newLimit - delta;
  327.         else
  328.             lowLimit = delta;
  329.     lowThreshold = lowLimit - delta;
  330.     delete linkS;
  331.     linkS = newLinkS;
  332.     limit = newLimit;
  333.     first = 0;
  334.     return limit;
  335. }
  336.  
  337. unsigned Binder::setDelta(unsigned newDelta)
  338. {
  339.     return ((newDelta && newDelta <= lowLimit)?
  340.         delta = newDelta : 0);
  341. }
  342.  
  343. unsigned Binder::setMaxNodes(unsigned newMaxNodes)
  344. {
  345.     return ((newMaxNodes >= limit)?
  346.         (maxNodes = (newMaxNodes
  347.         > BDR_MAXNODES)? BDR_MAXNODES
  348.         : newMaxNodes) : 0);
  349. }
  350.  
  351. voiD Binder::atIns(unsigned n, const voiD D)
  352. {
  353.     voiDV newLinkS;
  354.     unsigned newLimit, i;
  355.  
  356.     if (!linkS || !D)
  357.         return voiD0;
  358.     if (nodes == limit)  {
  359.         if (limit == maxNodes)
  360.             return voiD0;
  361.         newLimit = (maxNodes - delta > limit)?
  362.             limit + delta : maxNodes;
  363.         if ((newLinkS = new voiD[newLimit]) 
  364.             == voiDV0) return voiD0;
  365.         if ((i = limit - first) > nodes)
  366.             i = nodes;
  367.         memcpy(newLinkS,&linkS[first],
  368.             sizeof(linkS[0])*i);
  369.         /* copy wrap around */
  370.         if (i < nodes)
  371.             memcpy(&newLinkS[i],linkS,
  372.                 sizeof(linkS[0])*(nodes-i));
  373.         /*
  374.             Compute next smaller linkS size
  375.             and threshold for shrinking.
  376.         */
  377.         lowLimit = limit;
  378.         lowThreshold = lowLimit - delta;
  379.         /* swap new for old */
  380.         delete linkS;
  381.         linkS = newLinkS;
  382.         limit = newLimit;
  383.         first = 0;
  384.     }
  385.     if (!n)  /* push */
  386.         linkS[first? --first
  387.             : (first = limit - 1)] = D;
  388.     else if (n >= nodes) /* insQ */
  389.         linkS[(first+(n=nodes))%limit] = D;
  390.     else  { /* insert interior */ 
  391.         i = (first + n) % limit;
  392.         if (i < first || !first)
  393.             /* move rear rightward */
  394.             memmove(&linkS[i+1],&linkS[i],
  395.                 sizeof(linkS[0])
  396.                 * (nodes-n));
  397.         else /* move front leftward */
  398.             memmove(&linkS[--first],&linkS[--i],
  399.                 sizeof(linkS[0])*(n+1));
  400.         linkS[i] = D;
  401.     }
  402.     nodes++;
  403.     if (n <= curNode)
  404.         curNode++;
  405.     flags &= ~SORTED;
  406.     return D;
  407. }
  408.  
  409. voiD Binder::atDel(unsigned n)
  410. {
  411.     voiDV newLinkS;
  412.     unsigned newLimit, i;
  413.     voiD D;
  414.  
  415.     if (!linkS || n >= nodes)
  416.         return voiD0;
  417.     D = linkS[(first+n)%limit];
  418.     if (!n)  {  /* pop */
  419.         if (++first >= limit)
  420.             first = 0;
  421.     }
  422.     else if (n != nodes-1)  {  /* del interior */
  423.         /* move front rightward */
  424.         memmove(&linkS[first+1],&linkS[first],
  425.             sizeof(linkS[0])*n);
  426.         first++;
  427.     }
  428.     if (--nodes == 0)
  429.         flags |= SORTED;
  430.     if (n < curNode)
  431.         curNode--;
  432.     else if (n == curNode)
  433.         curNode = nodes;
  434.     if (nodes < lowThreshold)  {
  435.         newLimit = lowLimit;
  436.         if ((newLinkS = new voiD[newLimit]) 
  437.             == voiDV0) return voiD0;
  438.         if ((i = limit - first) > nodes)
  439.             i = nodes;
  440.         memcpy(newLinkS,&linkS[first],
  441.             sizeof(linkS[0])*i);
  442.         /* copy wrap around */
  443.         if (i < nodes)
  444.             memcpy(&newLinkS[i],linkS,
  445.                 sizeof(linkS[0])*(nodes-i));
  446.         /*
  447.             Compute next smaller linkS size
  448.             and threshold for shrinking.
  449.         */
  450.         if (lowLimit - delta > delta)
  451.             lowLimit -= delta;
  452.         else
  453.             lowLimit = delta;
  454.         lowThreshold = lowLimit - delta;
  455.         /* swap new for old */
  456.         delete linkS;
  457.         linkS = newLinkS;
  458.         limit = newLimit;
  459.         first = 0;
  460.     }
  461.     return D;
  462. }
  463.  
  464. int Binder::allDel()
  465. {
  466.     if (!linkS)
  467.         return 0;
  468.     while (atDel(0))
  469.         /* null statement */;
  470.     return 1;
  471. }
  472.  
  473. int Binder::allFree()
  474. {
  475.     if (!linkS)
  476.         return 0;
  477.     while (atFree(0))
  478.         /* null statement */;
  479.     return 1;
  480. }
  481.  
  482. voiD Binder::atPut(unsigned n, const voiD D)
  483. {
  484.     return ((linkS && D && (n < nodes))?
  485.         flags &= ~SORTED,
  486.         linkS[(first+n)%limit] = D
  487.         : voiD0);
  488. }
  489.  
  490. voiD Binder::atGet(unsigned n)
  491. {
  492.     return ((linkS && (n < nodes))?
  493.         linkS[(first+n)%limit] : voiD0);
  494. }
  495.  
  496. voiD Binder::at(unsigned n, const voiD D)
  497. {
  498.     voiD oldD;
  499.     
  500.     if ((oldD = atGet(n)) != voiD0)
  501.         if (D)  {
  502.             linkS[(first+n)%limit] = D;
  503.             flags &= ~SORTED;
  504.         }
  505.     return oldD;
  506. }
  507.  
  508. unsigned Binder::index(const voiD D)
  509. {
  510.     unsigned i;
  511.  
  512.     if (linkS && D)
  513.         for (i = 0; i < nodes; i++)
  514.             if (D == linkS[(first+i)%limit])
  515.                 return i;
  516.     return BDR_NOTFOUND;
  517. }
  518.  
  519. int Binder::forEach(BDRforEachBlocK B, voiD M, voiD A)
  520. {
  521.     unsigned i;
  522.  
  523.     if (!linkS || !B || !nodes)
  524.         return 0;
  525.     for (i = 0; i < nodes; i++)
  526.         (*B)(linkS[(first+i)%limit],M,A);
  527.     return 1;
  528. }
  529.  
  530. unsigned Binder::firstThat(BDRdetectBlocK B, voiD M)
  531. {
  532.     unsigned i;
  533.  
  534.     if (linkS && B)
  535.         for (i = 0; i < nodes; i++)
  536.             if ((*B)(linkS[(first+i)%limit],M))
  537.                 return i;
  538.     return BDR_NOTFOUND;
  539. }
  540.  
  541. unsigned Binder::lastThat(BDRdetectBlocK B, voiD M)
  542. {
  543.     unsigned i;
  544.  
  545.     if (linkS && B && nodes)
  546.         for (i = nodes; i--; /* no reinit */)
  547.             if ((*B)(linkS[(first+i)%limit],M))
  548.                 return i;
  549.     return BDR_NOTFOUND;
  550. }
  551.  
  552. int Binder::collect(BDRcollectBlocK B, BindeR R,
  553.     voiD M, voiD A)
  554. {
  555.     unsigned i;
  556.  
  557.     if (!linkS || !B || !R)
  558.         return 0;
  559.     for (i = 0; i < nodes; i++)
  560.         (*B)(linkS[(first+i)%limit],R,M,A);
  561.     return 1;
  562. }
  563.  
  564.  
  565. /*  FlexList like primitives:  */
  566.  
  567. unsigned Binder::CurNode()
  568. {
  569.     return ((curNode < nodes)?
  570.         curNode : BDR_NOTFOUND);
  571. }
  572.  
  573. int  Binder::setCurNode(unsigned n)
  574. {
  575.     return ((curNode = ((n > nodes)? nodes : n))
  576.         < nodes);
  577. }
  578.  
  579. Binder& Binder::operator<<(Binder& (*manipulator)
  580.         (Binder& B))
  581. {
  582.     return (manipulator? (*manipulator)(*this)
  583.         : *this);
  584. }
  585.  
  586. voiD Binder::ins(const voiD D)
  587. {
  588.     if (atIns(curNode+1,D))  {
  589.         if (++curNode >= nodes)
  590.             curNode = nodes - 1;
  591.         return D;
  592.     }
  593.     return voiD0;
  594. }
  595.  
  596. voiD Binder::insSort(const voiD D)
  597. {
  598.     unsigned low, mid, high;
  599.     voiD ok;
  600.  
  601. /*
  602.     The current node is left undefined if
  603.     anything fails, otherwise it is set to the
  604.     newly inserted node.
  605. */
  606.  
  607.     curNode = nodes;
  608.     if (!linkS || !D || nodes >= maxNodes || !comparE)
  609.         return voiD0;
  610.     if (!(flags & SORTED))
  611.         if (!sort())
  612.             return voiD0;
  613.     low = 0;
  614.     high = nodes;
  615.     while (low < high)  {
  616.         mid = low + ((high - low) >> 1);
  617.         if ((*comparE)(D,
  618.             linkS[(first+mid)%limit]) <= 0)
  619.             high = mid;
  620.         else
  621.             low = mid + 1;
  622.     }
  623.     if ((ok = atIns(high,D)) != voiD0)
  624.         curNode = high;
  625.     /*  atIns() resets sorted to zero  */
  626.     flags |= SORTED;
  627.     return ok;
  628. }
  629.  
  630. voiD Binder::del()
  631. {
  632.     voiD D;
  633.     unsigned n;
  634.  
  635.     if ((D = atDel(n=curNode)) != voiD0)
  636.         if (n--)
  637.             curNode = n;
  638.     return D;
  639. }
  640.  
  641. voiD Binder::next()
  642. { 
  643.     if (linkS)  {
  644.         if (curNode >= nodes)
  645.             curNode = 0;
  646.         else
  647.             curNode++;
  648.         if (curNode < nodes)
  649.             return linkS[(first+curNode)%limit];
  650.     }
  651.     return voiD0;
  652. }
  653.  
  654. voiD Binder::prev()
  655. { 
  656.     if (linkS)  {
  657.         if (curNode)  {
  658.             if (curNode > nodes)
  659.                 curNode = nodes;
  660.             curNode--;
  661.         }
  662.         else
  663.             curNode = nodes;
  664.         if (curNode < nodes)
  665.             return linkS[(first+curNode)%limit];
  666.     }
  667.     return voiD0;
  668. }
  669.  
  670. voiD Binder::findFirst(const voiD K)
  671. {
  672.     unsigned low, mid, high;
  673.     voiD D;
  674.  
  675. /*
  676.     The current node is left undefined if
  677.     anything fails, otherwise it is set to the
  678.     newly found node.
  679. */
  680.  
  681.     curNode = nodes;
  682.     if (!linkS || !K || !comparE || !nodes)
  683.         return voiD0;
  684.     if (flags & SORTED)  {
  685.         low = 0;
  686.         high = nodes;
  687.         while (low < high)  {
  688.             mid = low + ((high - low) >> 1);
  689.             if ((*comparE)(K,linkS[(first+mid)
  690.                 %limit]) <= 0)
  691.                 high = mid;
  692.             else
  693.                 low = mid + 1;
  694.         }
  695.         if (high < nodes)
  696.             if (!(*comparE)(K,linkS[(first+
  697.                 high)%limit]))
  698.                 return linkS[(first+
  699.                 (curNode = high))%limit];
  700.     }
  701.     else  {  /*  linear search!  */
  702.         while ((D = next()) != voiD0)
  703.             if (!(*comparE)(K,D))
  704.                 return D;
  705.     }
  706.     return voiD0;
  707. }
  708.  
  709. voiD Binder::findNext(const voiD K)
  710. {
  711.  
  712. /*
  713.     For sorted binders you must first call findFirst()
  714.     to insure consistent results!
  715. */
  716.  
  717.     voiD D;
  718.  
  719. /*
  720.     The current node is left undefined if
  721.     anything fails, otherwise it is set to the
  722.     newly found node.
  723. */
  724.  
  725.     if (!linkS || !K || !comparE)  {
  726.         curNode = nodes;
  727.         return voiD0;
  728.     }
  729.     while ((D = next()) != voiD0)
  730.         if (!(*comparE)(K,D))
  731.             return D;
  732.         else if (flags & SORTED)  {
  733.             curNode = nodes;
  734.             break; /*  Look no further!  */
  735.         }
  736.     return voiD0;
  737. }
  738.  
  739. voiD Binder::findLast(const voiD K)
  740. {
  741.     unsigned low, mid, high;
  742.     voiD D;
  743.  
  744. /*
  745.     The current node is left undefined if
  746.     anything fails, otherwise it is set to the
  747.     newly found node.
  748. */
  749.  
  750.     curNode = nodes;
  751.     if (!linkS || !K || !comparE || !nodes)
  752.         return voiD0;
  753.     if (flags & SORTED)  {
  754.         low = 0;
  755.         high = nodes;
  756.         while (low < high)  {
  757.             mid = low + ((high - low) >> 1);
  758.             if ((*comparE)(K,linkS[(first+mid)
  759.                 %limit]) < 0)
  760.                 high = mid;
  761.             else
  762.                 low = mid + 1;
  763.         }
  764.         if (high < nodes)
  765.             if (!(*comparE)(K,linkS[(first+
  766.                 high)%limit]))
  767.                 return linkS[(first+
  768.                 (curNode = high))%limit];
  769.     }
  770.     else  {  /*  linear search!  */
  771.         while ((D = prev()) != voiD0)
  772.             if (!(*comparE)(K,D))
  773.                 return D;
  774.     }
  775.     return voiD0;
  776. }
  777.  
  778. voiD Binder::findPrev(const voiD K)
  779. {
  780.  
  781. /*
  782.     For sorted binders you must first call findLast()
  783.     to insure consistent results!
  784. */
  785.  
  786.     voiD D;
  787.  
  788. /*
  789.     The current node is left undefined if
  790.     anything fails, otherwise it is set to the
  791.     newly found node.
  792. */
  793.  
  794.     if (!linkS || !K || !comparE)  {
  795.         curNode = nodes;
  796.         return voiD0;
  797.     }
  798.     while ((D = prev()) != voiD0)
  799.         if (!(*comparE)(K,D))
  800.             return D;
  801.         else if (flags & SORTED)  {
  802.             curNode = nodes;
  803.             break; /*  Look no further!  */
  804.         }
  805.     return voiD0;
  806. }
  807.  
  808. int   Binder::sort(BDRcomparE comparE)
  809. {
  810.     unsigned low, mid, high;
  811.     unsigned d;
  812.     voiD D;
  813.  
  814. /*
  815.     The current node is always reset to undefined
  816.     regardless of the outcome of sort.
  817. */
  818.  
  819.     curNode = nodes;
  820.     if (flags & SORTED)  {
  821.         if (this->comparE == comparE || !comparE)
  822.             return 1;
  823.     }
  824.     else if (!this->comparE && !comparE)
  825.         return 0;
  826.     if (comparE)  {
  827.         this->comparE = comparE;
  828.         flags &= ~SORTED;
  829.     }
  830.     if (!nodes)
  831.         return (flags |= SORTED);
  832.     if (!linkS)
  833.         return 0;
  834.     if (first)  { /* form contiguous block at front */
  835.         d = (first + nodes) % limit;
  836.         if (d > first)
  837.             memmove(linkS,&linkS[first],
  838.                 sizeof(linkS[0])*nodes);
  839.         else if (d < first)
  840.             memmove(&linkS[d],&linkS[first],
  841.                 sizeof(linkS[0])
  842.                 *(limit-first));
  843.         /* else array is full/contiguous */
  844.         first = 0;
  845.     }
  846.     for (high = d = 1; d < nodes; high = ++d)  {
  847.         low = 0;
  848.         D = linkS[d];
  849.         while (low < high)  {
  850.             mid = low + ((high - low) >> 1);
  851.             if ((*this->comparE)(D,
  852.                 linkS[mid]) <= 0)
  853.                 high = mid;
  854.             else
  855.                 low = mid + 1;
  856.         }
  857.         if (high < d)  {
  858.             memmove(&linkS[high+1],&linkS[high],
  859.                 sizeof(linkS[0])*(d-high));
  860.             linkS[high] = D;
  861.         }
  862.     }
  863.     return (flags |= SORTED);
  864. }
  865.  
  866.  
  867.  
  868. StreamableClassRegistry SCRegistry;
  869.  
  870. int StreamableClassRegistry::debug;
  871.  
  872. void StreamableClassRegistry::error(char *msg, unsigned id)
  873. {
  874.     if (debug)
  875.         cerr
  876.         << "StreamClassRegistry error - "
  877.             << msg << id << endl;
  878. }
  879.  
  880. void StreamableClassRegistry::warn(char *msg, unsigned id)
  881. {
  882.     if (debug)
  883.         cerr
  884.         << "StreamClassRegistry warning - "
  885.         << msg << id << endl;
  886. }
  887.  
  888. void StreamableClassRegistry::registerClass(unsigned id,
  889.     StreamablE (*loader) (istream& is,
  890.     StreamablE InstancE))
  891. {
  892.     unsigned i;
  893.  
  894.     for (i = 0; i < ClassRecords.Nodes(); i++)
  895.         if (((SCRecorD)ClassRecords[i])->id
  896.             == id)
  897.             break;
  898.     if (i < ClassRecords.Nodes())
  899.         if (((SCRecorD)ClassRecords[i])->load
  900.             == loader)  {
  901.             warn("multiple registration of"
  902.                 " loader id: ",id);
  903.             return;
  904.         }
  905.         else  {
  906.             error("id conflict: ",id);
  907.             return;
  908.         }
  909.     SCRecorD R = new StreamableClassRecord(id,loader);
  910.     if (!R)
  911.         error("class record memory exhausted, id: ",
  912.             id);
  913.     else if (!ClassRecords.insQ(R))  {
  914.         error("class record can't be queued, id: ",
  915.             id);
  916.         delete R;
  917.     }
  918. }
  919.  
  920. void StreamableClassRegistry::forgetClasses()
  921. {
  922.     ClassRecords.allFree();
  923.     InstanceLinks.allDel();
  924. }
  925.  
  926. istream& StreamableClassRegistry::get(istream& is,
  927.     StreamablE& InstancE)
  928. {
  929.     unsigned id, streamed, i;
  930.     long spos;
  931.  
  932.     InstancE = StreamablE0;
  933.     if (!(is >> id >> nextm >> streamed >> nextm >>
  934.         spos >> nextm))
  935.         error("unable to read id, streamed, "
  936.             "spos ",0);
  937.     else if (streamed > 1)  {
  938.         // Link to previously loaded Instance
  939.         for (i = 0; i < InstanceLinks.Nodes(); i++)
  940.             if (((SCHRecorD)InstanceLinks[i])
  941.                 ->spos == spos)  {
  942.                 InstancE = ((SCHRecorD)
  943.                     InstanceLinks[i])
  944.                         ->InstancE;
  945.                 InstancE->link();
  946.                 break;
  947.             }
  948.         if (!InstancE)
  949.             error("unable to establish link to"
  950.                 " previously loaded class",
  951.                 id);
  952.     }
  953.     else  {  // load instance
  954.  
  955.  
  956. for (i = 0; i < ClassRecords.Nodes(); i++)
  957.     if (((SCRecorD)ClassRecords[i])->id == id)
  958.             break;
  959. if (i >= ClassRecords.Nodes())
  960.     error("attempted load of unknown class: ",id);
  961. else  {
  962.     if ((InstancE = (*((SCRecorD)
  963.         ClassRecords[i])->load)
  964.         (is,StreamablE0)) == StreamablE0)
  965.         error("unable to load class ",id);
  966.     else if (streamed == 1)  {
  967.         // 1st of many save in holding pen
  968.         SCHRecorD R = new
  969.             StreamableClassHoldingRecord
  970.                 (InstancE,spos);
  971.         if (!R)
  972.             error("class holding record"
  973.                 " memory exhausted,"
  974.                 " id: ",id);
  975.         else if (!InstanceLinks.insQ(R))  {
  976.             error("unable to hold class"
  977.                 " for multiple "
  978.                 "links ",id);
  979.             delete R;
  980.         }
  981.     }
  982. }
  983.  
  984.  
  985.  
  986.     }
  987.  
  988.     return is;
  989. }
  990.  
  991. ostream& StreamableClassRegistry::put(ostream& os,
  992.     StreamablE InstancE)
  993. {
  994.     unsigned id, i;
  995.     long tpos;
  996.  
  997.     if (!InstancE)
  998.         return os;
  999.     for (i = 0; i < ClassRecords.Nodes(); i++)
  1000.         if (((SCRecorD)ClassRecords[i])->id
  1001.             == InstancE->id)
  1002.             break;
  1003.     if (i >= ClassRecords.Nodes())  {
  1004.         error("attempted store of unknown class: ",
  1005.             InstancE->id);
  1006.         // Insert unknown class place holder
  1007.         os << ID_UnknownStreamable << endm;
  1008.         return os;
  1009.     }
  1010.     else  {
  1011.         if (!(os << InstancE->id << endm))
  1012.         {
  1013.             error("unable to insert id: ",
  1014.                 InstancE->id);
  1015.             return os;
  1016.         }
  1017.         if (!InstancE->spos)
  1018.             InstancE->spos = os.tellp();
  1019.         if (!(os << InstancE->streamed << endm
  1020.             << InstancE->spos << endm))
  1021.         {
  1022.             error("unable to insert streamed "
  1023.                 "and spos: ",InstancE->id);
  1024.             return os;
  1025.         }
  1026.         if (!InstancE->streamed)  {
  1027.             // first time - store instance!
  1028.             InstancE->store(os);
  1029.             InstancE->streamed = 2;
  1030.         }
  1031.         else
  1032.         {
  1033.             // go back to stored class and
  1034.             // indicate multiple links!
  1035.             tpos = os.tellp();
  1036.             os.seekp(InstancE->spos);
  1037.             os << "1";
  1038.             os.seekp(tpos);
  1039.         }
  1040.  
  1041.     }
  1042.     return os << flush;
  1043. }
  1044.  
  1045.  
  1046. StreamableFncPtrRegistry SFPRegistry;
  1047.  
  1048. int StreamableFncPtrRegistry::debug;
  1049.  
  1050. void StreamableFncPtrRegistry::error(char *msg, unsigned id)
  1051. {
  1052.     if (debug)
  1053.         cerr << "FncPtrRegistry error - "
  1054.             << msg << id << endl;
  1055. }
  1056.  
  1057. void StreamableFncPtrRegistry::warn(char *msg, unsigned id)
  1058. {
  1059.     if (debug)
  1060.         cerr << "FncPtrRegistry warning - "
  1061.             << msg << id << endl;
  1062.  
  1063. }
  1064.  
  1065. void StreamableFncPtrRegistry::registerFunction(unsigned id,
  1066.     GenericFnC fnC)
  1067. {
  1068.     unsigned i;
  1069.  
  1070.     for (i = 0; i < FncPtrRecords.Nodes(); i++)
  1071.         if (((SFPRecorD)FncPtrRecords[i])->id == id)
  1072.             break;
  1073.     if (i < FncPtrRecords.Nodes())
  1074.         if (((SFPRecorD)FncPtrRecords[i])->fnC
  1075.             == fnC)
  1076.         {
  1077.             warn("attempted multiple"
  1078.                 " registration"
  1079.                 " of function pointer: ",
  1080.                 id);
  1081.             return;
  1082.         }
  1083.         else {
  1084.             error("id conflict: ",id);
  1085.             return;
  1086.         }
  1087.     SFPRecorD R = new StreamableFncPtrRecord(id,fnC);
  1088.     if (!R)
  1089.         error("fncPtr memory exhausted, id: ",id);
  1090.     else if (!FncPtrRecords.insQ(R))  {
  1091.         error("fncPtr record can't be queued, id: ",
  1092.             id);
  1093.         delete R;
  1094.     }
  1095. }
  1096.  
  1097.  
  1098. GenericFnC StreamableFncPtrRegistry::FnC(unsigned id)
  1099. {
  1100.     unsigned i;
  1101.  
  1102.     for (i = 0; i < FncPtrRecords.Nodes(); i++)
  1103.         if (((SFPRecorD)FncPtrRecords[i])->id == id)
  1104.             break;
  1105.     if (i >= FncPtrRecords.Nodes())  {
  1106.         error("unknown fncPtr: ",id);
  1107.         return GenericFnC0;
  1108.     }
  1109.     else
  1110.         return ((SFPRecorD)FncPtrRecords[i])->fnC;
  1111. }
  1112.  
  1113. unsigned StreamableFncPtrRegistry::ID(GenericFnC fnC)
  1114. {
  1115.     unsigned i;
  1116.  
  1117.     for (i = 0; i < FncPtrRecords.Nodes(); i++)
  1118.         if (((SFPRecorD)FncPtrRecords[i])->fnC
  1119.             == fnC)
  1120.             break;
  1121.     if (i >= FncPtrRecords.Nodes())  {
  1122.         error("unknown fncPtr: ",
  1123.             ID_UnknownGenericFnC);
  1124.         return ID_UnknownGenericFnC;
  1125.     }
  1126.     else
  1127.         return ((SFPRecorD)FncPtrRecords[i])->id;
  1128. }
  1129.  
  1130.