home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c221 / 6.ddi / MWHC.006 / A1 < prev    next >
Encoding:
Text File  |  1992-06-07  |  3.8 KB  |  113 lines
  1. #ifndef __RWGORDVEC_H__
  2. #define __RWGORDVEC_H__
  3. pragma push_align_members(64);
  4.  
  5. /*
  6.  * GOrderedVector(val): <generic.h> style Ordered Vector of type val
  7.  *
  8.  * $Header:   E:/vcs/rw/gordvec.h_v   1.0   04 Mar 1992 18:57:56   KEFFER  $
  9.  *
  10.  ****************************************************************************
  11.  *
  12.  * Rogue Wave 
  13.  * P.O. Box 2328
  14.  * Corvallis, OR 97339
  15.  * Voice: (503) 754-3010    FAX: (503) 757-6650
  16.  *
  17.  * Copyright (C) 1989, 1990, 1991, 1992. This software is subject to copyright 
  18.  * protection under the laws of the United States and other countries.
  19.  *
  20.  
  21.  *
  22.  * To use this class you must declare and implement the 
  23.  * base class GVector(val), as well as the ordered collection itself.
  24.  *
  25.  * Example: To declare and implement an ordered vector of doubles:
  26.  *
  27.  *   #include <rw/gordvec.h>
  28.  *   
  29.  *   declare(GVector,double)        // Declare the base class
  30.  *   declare(GOrderedVector,double)    // Declare the ordered vector
  31.  *
  32.  *   // In one and only one .cpp file you must put the following:
  33.  *   implement(GVector,double)        // Implement the base class
  34.  *   implement(GOrderedVector,double)    // Implement the ordered vector
  35.  *
  36.  *   // To use:
  37.  *   void func(){
  38.  *     GOrderedVector(double) ord;
  39.  *     ord.insert(22.1);
  40.  *     ord.insert(5.0);        // etc.
  41.  *   }
  42.  *
  43.  ***************************************************************************
  44.  *
  45.  * $Log:   E:/vcs/rw/gordvec.h_v  $
  46.  * 
  47.  *    Rev 1.0   04 Mar 1992 18:57:56   KEFFER
  48.  * Initial revision.
  49.  *
  50.  */
  51.  
  52. #include "rw/tooldefs.h"
  53. #include "rw/gvector.h"
  54.  
  55. #define GOrderedVector(val) name2(val,GOrderedVector)
  56.  
  57. #define GOrderedVectordeclare(val)                                \
  58. class RWExport GOrderedVector(val) : private GVector(val) {                    \
  59.   unsigned        _nitems; /* Number of slots in use */                    \
  60. public:                                                \
  61.   GOrderedVector(val)(unsigned capac=RWDEFAULT_CAPACITY) : GVector(val)(capac)            \
  62.     {_nitems=0;}                                        \
  63.   val            operator()(int i) const { return array[i];}                \
  64.   val&            operator()(int i)       { return array[i];}                \
  65.   val            operator[](int i) const                            \
  66.     { if (i<0 || i>=_nitems) callerror(GVector,val,1,"GOrderedVector index out of range.");    \
  67.       return array[i]; }                                    \
  68.   val&            operator[](int i)                             \
  69.     { if (i<0 || i>=_nitems) callerror(GVector,val,1,"GOrderedVector index out of range.");    \
  70.       return array[i]; }                                    \
  71.   void            clear()            {_nitems=0;}                    \
  72.   unsigned        entries() const        {return _nitems;}                \
  73.   int            index(val) const;                            \
  74.   void            insert(val item)    {insertAt(_nitems, item);}            \
  75.   void            insertAt(int indx, val item);                        \
  76.   RWBoolean        isEmpty() const        {return _nitems==0;}                \
  77.   unsigned        length() const        {return _nitems;}                \
  78.   void            removeAt(int);                                \
  79.   void            resize(unsigned N);                            \
  80. };
  81.  
  82. #define GOrderedVectorimplement(val)                                \
  83. int GOrderedVector(val)::index(val item) const                            \
  84. {                                                \
  85.   for(int i=0; i<_nitems; i++) if (array[i]==item) return i;                    \
  86.   return -1;                                            \
  87. }                                                \
  88.                                                 \
  89. void GOrderedVector(val)::insertAt(int ipt, val item)                        \
  90. {                                                \
  91.   if(_nitems>=GVector(val)::length())        /* Check for overflow */            \
  92.     resize(_nitems + RWDEFAULT_RESIZE);                                \
  93.                                                   \
  94.   for(register i=(int)_nitems; i>ipt; i--)    /* Slide right (could be very expensive) */    \
  95.     array[i] = array[i-1];                                    \
  96.                                                 \
  97.   _nitems++;                                            \
  98.   array[ipt] = item;                                        \
  99. }                                                \
  100.                                                 \
  101. void GOrderedVector(val)::removeAt(int ipt)                            \
  102. {                                                \
  103.   /* Slide left (could be very expensive): */                            \
  104.   for(register i=ipt; i<_nitems-1; i++) array[i] = array[i+1];                    \
  105.   _nitems--;                                            \
  106. }                                                \
  107.                                                 \
  108. void GOrderedVector(val)::resize(unsigned N)                            \
  109. {  if(N>_nitems) GVector(val)::resize(N); }
  110.  
  111. pragma pop_align_members();
  112. #endif
  113.