home *** CD-ROM | disk | FTP | other *** search
/ Borland Programmer's Resource / Borland_Programmers_Resource_CD_1995.iso / code / bcpp / file19 / vector.mth < prev   
Encoding:
Text File  |  1995-05-19  |  8.8 KB  |  301 lines
  1. //////////////////////////////////////////////////////////////////
  2. // vector.mth: Template methods for fixed-length shared vectors.
  3. // Copyright(c) 1993 Azarona Software. All rights reserved.
  4. //////////////////////////////////////////////////////////////////
  5. #include "placenew.h"
  6.  
  7. template<class TYPE>
  8. void *VecRep<TYPE>::operator new(size_t n, unsigned d)
  9. // The new operator overloaded for VecRep, so
  10. // that the vector elements are stored immediately
  11. // after the reference count. Here, n is sizeof(VecRep)
  12. // and d is the number of elements to be allocated in the
  13. // vector. If allocation fails or d == 0, we reference 
  14. // null_rep, the null VecRep object.
  15. {
  16.   // Compute what pointer to object should be.
  17.   // Note: One element already accounted for in n.
  18.   void *p = (d == 0) ? 0 : new char[n+(d-1)*sizeof(TYPE)];
  19.   if (p == 0) { // If pointer is null, bind to null_rep
  20.      p = &null_rep;
  21.      null_rep.refcnt++;
  22.   }
  23.   return p;
  24. }
  25.  
  26. template<class TYPE>
  27. void VecRep<TYPE>::operator delete(void *p)
  28. // The delete operator is overloaded to delete
  29. // all of the vector data, as well as the
  30. // refcnt and alloclen fields.
  31. {
  32.   // Since null_rep is allocated statically,
  33.   // p should never point to null_rep.
  34.   // However, it might under the following conditions:
  35.   // (1) A vector is declared in the static segment,
  36.   // (2) the allocation of dynamic memory for the
  37.   // vector fails, (3) the null_rep object hasn't
  38.   // been constructed yet. This condition occurs
  39.   // very rarely, but it can happen.
  40.   if (p != &null_rep) delete[] (char *)p;
  41. }
  42.  
  43. template<class TYPE>
  44. VecRep<TYPE>::VecRep(unsigned d)
  45. // Constructor to initialize a shared vector rep.
  46. {
  47.   if (this != &null_rep) {
  48.      // We only want to do the following if we're
  49.      // not referencing null_rep.
  50.      alloclen = d;
  51.      refcnt = 1;
  52.      // We must call the placement constructor for
  53.      // all but the first element
  54.      TYPE *q = data + 1;
  55.      for(unsigned i = 1; i<d; i++, q++) new(q) TYPE;
  56.   }
  57. }
  58.  
  59.  
  60. template<class TYPE>
  61. void VecRep<TYPE>::~VecRep()
  62. // Destructor to explicitly destroy all elements 
  63. // of the vector, except the first. Note that this
  64. // effectively keeps null_rep's only element from 
  65. // being destroyed too many times.
  66. {
  67.   TYPE *q = data + 1;
  68.   for(unsigned i = 1; i<alloclen; i++, q++) q->TYPE::~TYPE();
  69. }
  70.  
  71.  
  72. template<class TYPE>
  73. void Vector<TYPE>::Bind(const Vector<TYPE> &v)
  74. // This function binds us to the same data that
  75. // v is bound to, thus sharing v's data.
  76. // ASSUMES vector not already bound.
  77. {
  78.   rep = v.rep;
  79.   rep->refcnt++;
  80. }
  81.  
  82. template<class TYPE>
  83. void Vector<TYPE>::Unbind()
  84. // Unbinds this vector from the shared data. The data 
  85. // is disposed of properly if reference count goes to 0.
  86. // WARNING: This function should only be called by the
  87. // destructor, or be immediately followed by a call to
  88. // Bind(). That's because our internal pointers might
  89. // be left pointing to freed memory.
  90. {
  91.   rep->refcnt--;
  92.   // Note: delete handles the possibility of trying to
  93.   // delete null_rep.
  94.   if (rep->refcnt == 0) delete rep;
  95. }
  96.  
  97. template<class TYPE>
  98. void Vector<TYPE>::NewBinding(const Vector<TYPE> &v)
  99. // Unbinds this vector from the data it shares, and
  100. // then binds it to the data shared by v.
  101. {
  102.   // Check for already sharing the same data
  103.   if (rep == v.rep) return;
  104.   Unbind();
  105.   Bind(v);
  106. }
  107.  
  108. template<class TYPE>
  109. int Vector<TYPE>::Alloc(unsigned n)
  110. // Allocates a block of n elements for this vector.
  111. // If n == 0 or allocation fails, we bind to the null rep.
  112. // ASSUMES TYPE has a default constructor.
  113. // NOTE: This vector better not be bound at this time!
  114. // Returns 0 if we've bound to null_rep, else 1.
  115. {
  116.   // You might not think we need this if statement. 
  117.   // Couldn't we do the new() even if n = 0? The
  118.   // answer is no, things get all fouled up, cause
  119.   // multiple reps that are actually null get created
  120.   // but we want only one, and it should be static.
  121.   if (n) {
  122.      rep = new(n) VecRep<TYPE>(n);
  123.   }
  124.   else {
  125.     rep = &VecRep<TYPE>::null_rep;
  126.     rep->refcnt++;
  127.   }
  128.   start = rep->data;
  129.   if (rep != &VecRep<TYPE>::null_rep) {
  130.      len = n;
  131.      stride = 1;
  132.      return 1;
  133.   }
  134.   else {
  135.      len = 0;
  136.      stride = 1;
  137.      return 0;
  138.   }
  139. }
  140.  
  141. template<class TYPE>
  142. Vector<TYPE>::Vector(unsigned n, const TYPE *s) 
  143. // Constructor to allocate space for a n element vector,
  144. // and, if s != 0, to copy low-level C array into it.
  145. // If n == 0 or allocation fails, we bind to null rep, 
  146. // and do no copying.
  147. { 
  148.   if (Alloc(n) && s) CopyN(s, n); 
  149. }
  150.  
  151. template<class TYPE>
  152. Vector<TYPE>::Vector(const Vector<TYPE> &v)
  153. // Copy constructor that shares all of the vector v. 
  154. {
  155.   Bind(v);
  156.   len = v.len;
  157.   stride = v.stride;
  158.   start = v.start;
  159. }
  160.  
  161. template<class TYPE>
  162. Vector<TYPE>::Vector(const Vector<TYPE> &v, SliceType styp, 
  163.                      unsigned n, unsigned str, unsigned ofs)
  164. // Constructor used to share or copy a slice of an existing
  165. // vector. If styp = SHARED, then the new vector of
  166. // length n shares its data with the old vector with the
  167. // desired stride and offset. Otherwise, a copy is made 
  168. // with a length of n, stride of 1, and offset of 0.
  169. // If n == 0, it means use v.len for the length.
  170. // If copying and allocation fails, no copy takes place.
  171. {
  172.   len = (n) ? n : v.len;
  173. #ifndef NO_RANGE_CHECK
  174.   // NOTE: This range check code here not shown in book!
  175.   // Keep offset in range, and compute number of
  176.   // elements available, given offset.
  177.   unsigned vlen = v.len;
  178.   if (ofs >= vlen) ofs = vlen ? (vlen-1) : 0;
  179.   unsigned elemavl = vlen - ofs;
  180.   // Keep new stride in range, determine desired length
  181.   // and keep it in range too. Note that elemavl is 
  182.   // rounded up so that it covers whole strides.
  183.   if (str == 0) str = 1;
  184.   if (str > elemavl) str = elemavl;
  185.   elemavl += str - (elemavl % str); // Round up to whole strides
  186.   if (len * str > elemavl) len = elemavl / str;
  187. #endif
  188.   if (styp == SHARED) {
  189.      // Share existing data in v, accumulating offset
  190.      // and stride as needed. Note how stride and
  191.      // starting offset are computed in units of the 
  192.      // elements of the real underlying vector.
  193.      Bind(v);
  194.      start = v.start + ofs * v.stride;
  195.      stride = str * v.stride;
  196.   }
  197.   else {
  198.     // Allocate data, then copy the desired slice of the
  199.     // source vector into the destination vector.
  200.     // Note clever recursive call to constructor.
  201.     if (Alloc(len)) Copy(Vector<TYPE>(v, SHARED, len, str, ofs));
  202.   }
  203. }
  204.  
  205. #ifndef NO_RANGE_CHECK
  206.  
  207. template<class TYPE>
  208. unsigned Vector<TYPE>::CheckIndx(unsigned i) const
  209. // Check for index being in bounds. If not in
  210. // bounds, call the error handler.
  211. {
  212.   if (i >= len) i = HandleRangeErr(i, len);
  213.   return i;
  214. }
  215.  
  216. #endif
  217.  
  218. template<class TYPE>
  219. void Vector<TYPE>::CopyN(const TYPE *src, unsigned n)
  220. // Copies as much data as possible from src
  221. // into this vector, truncating if need be.
  222. {
  223.   unsigned tlen = len;
  224.   if (tlen > n) tlen = n;
  225.   VecPtr<TYPE> dest(start, stride);
  226.   for (unsigned i=0; i<tlen; i++) {
  227.       *dest = src[i];
  228.       dest++;
  229.   }
  230.   len = tlen; // We have a new logical length!
  231. }
  232.  
  233. template<class TYPE>
  234. void Vector<TYPE>::Copy(const Vector<TYPE> &v)
  235. // Copies as much data as possible from v into this
  236. // vector, truncating if need be.
  237. {
  238.   unsigned tlen = len;
  239.   unsigned vlen = v.len;
  240.   if (tlen > vlen) tlen = vlen;
  241.   VecPtr<const TYPE> src(v.start, v.stride);
  242.   VecPtr<TYPE> dest(start, stride);
  243.   for (unsigned i=0; i<tlen; i++) {
  244.       *dest = *src;
  245.       src++;
  246.       dest++;
  247.   }
  248.   len = tlen; // We have a new logical length!
  249. }
  250.  
  251.  
  252. template<class TYPE>
  253. Vector<TYPE> Vector<TYPE>::Clone() const
  254. // Return a clone of this vector. This clone will
  255. // be unique, (with vector rep refcnt = 1), and
  256. // will have a stride of 1.
  257. // Note: If allocation fails, a null vector is returned.
  258. {
  259.   Vector<TYPE> temp(len);
  260.   temp.Copy(*this);
  261.   return temp;
  262. }
  263.  
  264. template<class TYPE>
  265. int Vector<TYPE>::EnsureUnique()
  266. // Ensures that this vector uniquely owns its vector
  267. // rep, (ie. the reference count is 1).
  268. // Might have to copy vector rep data to ensure this.
  269. // Returns 1 if can make unique, 0 if can't (allocation
  270. // for copy failed.)
  271. {
  272.   if (!IsUnique()) {            // Need to copy to make unique
  273.      Vector<TYPE> &c = Clone(); // Attempt to copy
  274.      if (c.IsNull()) return 0;  // Couldn't copy
  275.      Share(c);                  // Share with copy
  276.   }
  277.   return 1;
  278. }
  279.  
  280.  
  281. template<class TYPE>
  282. void Vector<TYPE>::Share(const Vector<TYPE> &v)
  283. // Shares with the elements in vector v. 
  284. {
  285.   NewBinding(v);
  286.   len = v.len;
  287.   stride = v.stride;
  288.   start = v.start;
  289. }
  290.  
  291. template<class TYPE>
  292. void Vector<TYPE>::SetElements(const TYPE &x)
  293. // Sets every element of this vector to x.
  294. {
  295.   VecPtr<TYPE> cursor(start, stride);
  296.   for (unsigned i = 0; i<len; i++) {
  297.       *cursor = x;
  298.       cursor++;
  299.   }
  300. }
  301.