CLHEP VERSION Reference Documentation
   
CLHEP Home Page     CLHEP Documentation     CLHEP Bug Reports

Matrix/CLHEP/Matrix/Pile.h
Go to the documentation of this file.
1 // -*- C++ -*-
2 // CLASSDOC OFF
3 // ---------------------------------------------------------------------------
4 // CLASSDOC ON
5 //
6 // This file is a part of the CLHEP - a Class Library for High Energy Physics.
7 //
8 // This software written by Nobu Katayama and Mike Smyth, Cornell University.
9 //
10 // This file contains an attempt to make the template "pile". A pile is
11 // a finite size LIFO stack. When a element is pushed on that increases
12 // the stack beyond its maximum size, the oldest element is deleted from
13 // the stack. A subroutine can be used on that oldest element first.
14 
15 // The orginal use of this stack was to store old double arrays. When
16 // a new array is needed, we can simply pull one off the pile. However,
17 // we don't want to keep too many old array's around, after a while we just
18 // want to start getting rid of them. When the pile gets too large, or
19 // when the pile is destroyed, we want to call subroutines to get rid of
20 // some of these arrays.
21 
22 // Unfortunately, in version 2.2 of g++ templates don't seem to work unless
23 // they are declared inline. So this class has ridiculously long inline
24 // functions. Also, g++ doesn't seem to allow multiple arguements to
25 // templates, so the size of the pile is hardwired in. To change the size,
26 // change the value of the const int sz.
27 
28 // A pile is easy to use. Just declare pile<X> X_pile. To add a X to the
29 // pile, say X_pile.push(X item). To get an item from the pile, first
30 // check that the pile is not empty, and then say item=X_pile.pop(). It
31 // is an error to try and pop from an empty pile. To check if a pile is
32 // empty, say X_pile.is_empty(). If this is TRUE, then the pile is empty.
33 // Otherwise it is FALSE. The subroutine called when the stack begins to
34 // overflow is set by X_pile.destroy(void (*function)(X)), or it can be
35 // set in the construction pile<X> X_pile(void (*function)(X)). It is
36 // okay to not supply a function, in that case nothing is done when an
37 // item falls off the bottom of the pile. It is simply lost.
38 
39 #ifndef _PILE_H
40 #define _PILE_H
41 
42 #include <iostream>
43 #include "CLHEP/Matrix/defs.h"
44 
50 namespace CLHEP {
51 
52 template<class T>
53 class HepPile
54 {
55 public:
56  // Destructor
57  // (defined first in templated class due to a bug in VxWorks)
59  {
60  while(bottom != top)
61  {
62 #if 1
63  destroy(stack[bottom]);
64 #else
65  delete [] stack[bottom];
66 #endif
67  next(&bottom);
68  }
69  }
70 
71  HepPile(void (*f)(T)=0): top(0), bottom(0) { destroy_fun = f;}
72 
73  void set_destroy(void (*f)(T)) { destroy_fun = f;}
74  void push(T item)
75  {
76  stack[top]=item;
77  next(&top);
78  if (top==bottom)
79  {
80 #if 1
81  destroy(stack[bottom]);
82 #else
83  delete [] stack[bottom];
84 #endif
85  next(&bottom);
86  }
87  }
88  bool is_empty() const { return top == bottom ?true :false;}
89  T pop()
90  {
91  if (is_empty())
92  {
93  std::cerr << "Attempt to pop empty pile.\n--- Exiting to system."
94  << std::endl;
95  exit(1);
96  }
97  previous(&top);
98  return stack[top];
99  }
100 
101 private:
102  enum {sz = 50};
103  T stack[sz+1];
104  int top,bottom;
105  void (*destroy_fun)(T);
106  void next(int *n) const {if (++(*n) >= sz+1) *n = 0;}
107  void previous(int *n) const {if (--(*n) < 0) *n = sz;}
108  void destroy(T t) { if (destroy_fun) (*destroy_fun)(t); }
109 };
110 
111 } // namespace CLHEP
112 
113 #ifdef ENABLE_BACKWARDS_COMPATIBILITY
114 // backwards compatibility will be enabled ONLY in CLHEP 1.9
115 using namespace CLHEP;
116 #endif
117 
118 #endif /*_PILE_H */
CLHEP::HepPile::HepPile
HepPile(void(*f)(T)=0)
Definition: Matrix/CLHEP/Matrix/Pile.h:71
CLHEP::HepPile::push
void push(T item)
Definition: Matrix/CLHEP/Matrix/Pile.h:74
CLHEP::HepPile::~HepPile
~HepPile()
Definition: Matrix/CLHEP/Matrix/Pile.h:58
CLHEP::HepPile::set_destroy
void set_destroy(void(*f)(T))
Definition: Matrix/CLHEP/Matrix/Pile.h:73
CLHEP::detail::n
n
Definition: Ranlux64Engine.cc:85
CLHEP::HepPile::is_empty
bool is_empty() const
Definition: Matrix/CLHEP/Matrix/Pile.h:88
f
void f(void g())
Definition: excDblThrow.cc:38
CLHEP::HepPile::pop
T pop()
Definition: Matrix/CLHEP/Matrix/Pile.h:89
CLHEP
Definition: ClhepVersion.h:13
void
We should separate methods that force the load of the Rotation class For practical that implies that methods like and that as in the ThreeVector class we separate the cc files Also again we have the rotation methods returning HepLorentzVector &rather than void
Definition: minorMergeIssues.doc:148
exit
it has advantages For I leave the ZMthrows but substitute I replaced ZMthrow with ZMthrowA in this package when will issue its message and exit(-1). Also
CLHEP::HepPile
Definition: Matrix/CLHEP/Matrix/Pile.h:53