home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / cool / ge_cool.lha / GE_COOL2.1 / src / Stack / Base_Stack.C next >
Encoding:
C/C++ Source or Header  |  1992-04-22  |  7.3 KB  |  218 lines
  1. //
  2. // Copyright (C) 1991 Texas Instruments Incorporated.
  3. //
  4. // Permission is granted to any individual or institution to use, copy, modify,
  5. // and distribute this software, provided that this complete copyright and
  6. // permission notice is maintained, intact, in all copies and supporting
  7. // documentation.
  8. //
  9. // Texas Instruments Incorporated provides this software "as is" without
  10. // express or implied warranty.
  11. //
  12. // Created: MBN 08/29/89 -- Initial design and implementation
  13. // Updated: MJF 03/12/90 -- Added group names to RAISE
  14. //
  15. // The CoolStack class is  publicly  derived from the  Generic class and is used to
  16. // implement non-type specific functionality for the parameterized CoolStack class.
  17. // In  this manner, code common  to  all instances  of the  CoolStack  class can be
  18. // shared to reduce code replication.  The  CoolStack class  implements a one
  19. // dimensional vector of a user-specified type.  This  is accomplished by using
  20. // the parameterized type  capability of C++.  The  stack will grow dynamically
  21. // as necessary  with   the amount  of  growth determined  by  the value  of an
  22. // allocation size slot.  Fixed length stacks are also supported by setting the
  23. // value of the allocation size slot to zero.
  24. //
  25.  
  26. #ifndef BASE_STACKH                // If no definition for CoolStack
  27. #include <cool/Base_Stack.h>            // Include definition file
  28. #endif
  29.  
  30. // long set_length(long, char*) -- Change number of elements in this stack
  31. // Input:                          Integer number of elements and
  32. //                                 character string of type
  33. // Output:                         Number of elements
  34.  
  35. long CoolStack::set_length (long n, const char* Type) {
  36. #if ERROR_CHECKING
  37.   if (n < 0) {                    // If index out of range
  38.     //RAISE (Error, SYM(CoolStack), SYM(Negative_Length),
  39.     printf ("CoolStack<%s>::set_length(): Negative length %d.\n", Type, n);
  40.     abort ();
  41.   }
  42. #endif
  43.   if (n <= size)                // If not greater than size
  44.     this->number_elements = n;            // Set new length
  45.   else
  46.     this->number_elements = size;        // Else set to maximum possible
  47.   return this->number_elements;            // Return value
  48. }
  49.  
  50.  
  51. // void set_growth_ratio(float, char*) -- Set growth percentage of this stack
  52. // Input:                                 Float ratio and character string type
  53. // Output:                                None
  54.  
  55. void CoolStack::set_growth_ratio (float ratio, const char* Type) {
  56. #if ERROR_CHECKING
  57.   if (ratio <= 0.0) {                // If non-positive growth
  58.     //RAISE (Error, SYM(CoolStack), SYM(Negative_Ratio),
  59.     printf ("CoolStack<%s>::set_growth_ratio(): Negative growth ratio %f.\n",
  60.         Type, ratio);
  61.     abort ();
  62.   }
  63. #endif
  64.   this->growth_ratio = ratio;            // Adjust instance ration
  65. } 
  66.  
  67.  
  68. // void set_alloc_size(int, char*) -- Set the default allocation size 
  69. // Input:                             Integer size and character string type
  70. // Output:                            None
  71.  
  72. void CoolStack::set_alloc_size (int size, const char* Type) {
  73. #if ERROR_CHECKING
  74.   if (size < 0) {                    // If index out of range
  75.     //RAISE (Error, SYM(CoolStack), SYM(Negative_Size),
  76.     printf ("CoolStack<%s>::set_alloc_size(): Negative growth size %d.\n",
  77.         Type, size);
  78.     abort ();
  79.   }
  80. #endif
  81.   this->alloc_size_s = size;            // Set growth size
  82. }
  83.  
  84.  
  85. // CoolStack () -- Empty constructor for the CoolStack class
  86. // Input:            None
  87. // Output:           None
  88.  
  89. CoolStack::CoolStack () {
  90.   this->size = 0;                // Initialize size
  91.   this->number_elements = 0;            // Initialize element count
  92.   if (alloc_size_s == 0)            // If no size specified
  93.     alloc_size_s = STACK_MEM_BLK_SZ;        // Set the default size 
  94.   this->growth_ratio = 0.0;            // Intialize growth ratio
  95. }
  96.  
  97.  
  98. // CoolStack (long) -- constructor that specifies number of elements
  99. // Input:          Integer number of elements
  100. // Output:         None
  101.  
  102. CoolStack::CoolStack (long n) {
  103.   this->size = n;                // Element capacity
  104.   this->number_elements = 0;            // No elements
  105.   if (alloc_size_s == 0)            // If no allocation size
  106.     alloc_size_s = STACK_MEM_BLK_SZ;        // Set default size
  107.   this->growth_ratio = 0.0;            // Initialize growth ratio 
  108. }
  109.  
  110.  
  111. // CoolStack (CoolStack&) -- constructor for reference to another stack
  112. // Input:                        CoolStack reference
  113. // Output:                       None
  114.  
  115. CoolStack::CoolStack (const CoolStack& s) {
  116.   if (alloc_size_s == 0)            // If no allocation size
  117.     alloc_size_s = STACK_MEM_BLK_SZ;        // Default
  118.   this->growth_ratio = s.growth_ratio;        // New growth ratio
  119.   this->size = s.size;                // New size
  120.   this->number_elements = s.number_elements;    // New number of elements
  121. }
  122.  
  123.  
  124. // ~CoolStack -- Destructor for CoolStack class that frees up storage
  125. // Input:          None
  126. // Output:         None
  127.  
  128. CoolStack::~CoolStack () {
  129. }
  130.  
  131.  
  132. // CoolStack& operator= (CoolStack&) -- Assigns this stack to another stack
  133. // Input:                       Reference to a stack
  134. // Output:                      Reference to modified this
  135.  
  136. CoolStack& CoolStack::operator= (const CoolStack& s) {
  137.   this->number_elements = s.number_elements;    // New number of elements
  138.   this->growth_ratio = s.growth_ratio;          // New growth ratio
  139.   return *this;                    // Return reference
  140. }
  141.  
  142.  
  143. // assign_error -- Error message for parameterized CoolStack<Type>::operator=()
  144. // Input:          Character string of type
  145. // Output:         None
  146.  
  147. void CoolStack::assign_error (const char* Type) {
  148.   //RAISE (Error, SYM(CoolStack), SYM(Static_Size),
  149.   printf ("CoolStack<%s>::operator=(): Static-size stack.\n", Type);
  150.   abort ();
  151. }
  152.  
  153.  
  154. // top_error -- Error message for parameterized CoolStack<Type>::top()
  155. // Input:       Character string of type
  156. // Output:      None
  157.  
  158. void CoolStack::top_error (const char* Type) {
  159.   //RAISE (Error, SYM(CoolStack), SYM(No_Elements),
  160.   printf ("CoolStack<%s>::top(): No elements in stack.\n", Type);
  161.   abort ();
  162. }
  163.  
  164.  
  165. // pop_error -- Error message for parameterized CoolStack<Type>::pop()
  166. // Input:       Character string of type
  167. // Output:      None
  168.  
  169. void CoolStack::pop_error (const char* Type) {
  170.   //RAISE (Error, SYM(CoolStack), SYM(No_Elements),
  171.   printf ("CoolStack<%s>::pop(): No elements in stack.\n", Type);
  172.   abort ();
  173. }
  174.  
  175.  
  176. // bracket_error -- Error message for parameterized CoolStack<Type>::operator[]()
  177. // Input:           Character string of type and index
  178. // Output:          None
  179.  
  180. void CoolStack::bracket_error (const char* Type, long n) {
  181.   //RAISE (Error, SYM(CoolStack), SYM(Out_Of_Range),
  182.   printf ("CoolStack<%s>::operator[](): Index %d out of range.\n", Type, n);
  183.   abort ();
  184. }
  185.  
  186.  
  187. // push_error -- Error message for parameterized CoolStack<Type>::push()
  188. // Input:        Character string of type
  189. // Output:       None
  190.  
  191. void CoolStack::push_error (const char* Type) {
  192.   //RAISE (Error, SYM(CoolStack), SYM(Static_Size),
  193.   printf ("CoolStack<%s>::push(): Static-size stack.\n", Type);
  194.   abort ();
  195. }
  196.  
  197.  
  198. // popn_error -- Error message for parameterized CoolStack<Type>::popn()
  199. // Input:        Character string of type and index
  200. // Output:       None
  201.  
  202. void CoolStack::popn_error (const char* Type, long n) {
  203.   //RAISE (Error, SYM(CoolStack), SYM(Static_Size),
  204.   printf ("CoolStack<%s>::popn(): Negative stack index %d.\n", Type, n);
  205.   abort ();
  206. }
  207.  
  208.  
  209. // resize_error -- Error message for parameterized CoolStack<Type>::resize()
  210. // Input:          Character string of type and size
  211. // Output:         None
  212.  
  213. void CoolStack::resize_error (const char* Type, long new_size) {
  214.   //RAISE (Error, SYM(CoolStack), SYM(Negative_Size),
  215.   printf ("CoolStack<%s>::resize(): Negative resize %d.\n", Type, new_size);
  216.   abort ();
  217. }
  218.