Import Geant4 0.1.0 source tree

2016-06-08 15:09:25 +02:00
parent b97f8d0df7
commit aaa409b6ee
2922 changed files with 55107 additions and 81674 deletions
@@ -0,0 +1,378 @@
+#ifndef __tpordvec
+#define __tpordvec
+
+#ifndef G4USE_OLDSTL
+# include <vector>
+# include <set>
+# include <functional>
+#else
+# include <vector.h>
+# include <set.h>
+# include <function.h>
+#endif
+#include "rw/defs.h"
+
+#if defined(G4USE_NAMESPACE)
+using std::vector;
+using std::set;
+#endif
+
+
+template<class T> class RWTPtrOrderedVector : public vector<T*> {
+
+#ifdef G4USE_EXPLICIT_TYPES_IN_TEMPLATES
+  typedef T** iterator;
+  typedef T* const* const_iterator;
+#endif
+
+public:
+  RWTPtrOrderedVector(size_t capacity=RWDEFAULT_CAPACITY):
+    vector<T*>(capacity,(T*)0),rwsize(0){}
+
+  RWTPtrOrderedVector(const RWTPtrOrderedVector<T>& v):
+    vector<T*>(v),rwsize(v.rwsize){}
+
+  RWTPtrOrderedVector<T>& operator=(const RWTPtrOrderedVector<T>& v)
+    {
+      vector<T*>::operator=(v),
+      rwsize=v.rwsize;
+      return *this;
+    }
+
+  ~RWTPtrOrderedVector(){}
+
+  T*& operator()(size_t i) 
+    {
+      //if(i<0 || i>=rwsize)
+      //	RWTHROW(RWBoundsErr("RWTPtrOrderedVector ()",rwsize,i));
+      if(i<vector<T*>::size() && rwsize<=i) rwsize=i+1;
+      return vector<T*>::operator[](i); 
+    }
+
+  T* const& operator()(size_t i) const 
+    { 
+      if(i<0 || i>=rwsize)
+	RWTHROW(RWBoundsErr("RWTPtrOrderedVector const ()",rwsize,i));
+      return vector<T*>::operator[](i); 
+    }
+
+  T*& operator[](size_t i) 
+    {
+      if(i<0 || i>=rwsize)
+	RWTHROW(RWBoundsErr("RWTPtrOrderedVector []",rwsize,i));
+      //if(i<vector<T*>::size() && rwsize<=i) rwsize=i+1;
+      return vector<T*>::operator[](i); 
+    }
+
+  T* const& operator[](size_t i) const 
+    {      
+      if(i<0 || i>=rwsize)
+	RWTHROW(RWBoundsErr("RWTPtrOrderedVector const []",rwsize,i));
+       return vector<T*>::operator[](i); 
+    }
+
+
+  void clearAndDestroy();
+
+  void clear();
+
+  size_t index ( const T*) const;
+
+  void resize(size_t);
+
+  void insert ( T* a )
+    { 
+      if(rwsize<vector<T*>::size())
+	{
+	  vector<T*>::operator[](rwsize)=a;
+	  rwsize++;
+	}
+      else
+	{
+	  vector<T*>::push_back(a);
+	  rwsize=vector<T*>::size();
+	}
+    }
+
+  //
+  // insertAt should throw an exception of type RWBoundsErr if you try
+  // to insert out of range
+  //
+  void insertAt ( size_t, T*); 
+
+  size_t occurrencesOf(const T*) const;	
+
+  T* remove ( const T*);	
+
+  size_t removeAll ( const T* );	
+
+  T* removeAt ( size_t);
+
+  T* removeFirst ();
+
+  T* removeLast ();
+
+  T* find(const T*) const;															
+  size_t entries() const { return rwsize; }
+
+  void append ( T* a ) 
+    { 
+      insert( a );
+    }
+
+  size_t length() const { return rwsize; }
+
+  T*& at ( size_t i ) 
+    { 
+      if(i<0 || i>=rwsize)
+	RWTHROW(RWBoundsErr("RWTPtrOrderedVector at",rwsize,i));
+      return operator()(i); 
+    }
+
+  T*const& at ( size_t i ) const 
+    {       
+      if(i<0 || i>=rwsize)
+	RWTHROW(RWBoundsErr("RWTPtrOrderedVector const at",rwsize,i));
+      return operator()(i); 
+    }
+
+  RWBoolean contains ( const T* a) const;
+  
+  RWBoolean isEmpty()const {return rwsize==0;}
+  
+  T* first() const
+    {
+      if(!rwsize)
+	RWTHROW(RWBoundsErr("RWTPtrOrderedVector front",rwsize,0));
+      return vector<T*>::front();
+    }
+
+  T* last() const
+    {
+      if(rwsize)
+	return vector<T*>::operator[](rwsize-1);
+      else
+	return 0;
+    }
+
+  void prepend(T* const ptr)
+    {
+      vector<T*>::insert(vector<T*>::begin(),ptr);
+      rwsize++;
+    }
+
+private:
+
+  size_t rwsize;
+
+
+};
+
+
+template<class T > void RWTPtrOrderedVector<T>::clear() 
+{
+  //vector<T*>::erase(vector<T*>::begin(), vector<T*>::end());
+  rwsize=0;
+}
+
+template<class T > void RWTPtrOrderedVector<T>::clearAndDestroy() 
+{
+  int sz;
+  set<T*,greater<T*> > tmp;
+  for (sz=0;sz<rwsize;sz++)
+    {
+      T* current;
+      current=vector<T*>::operator[](sz);
+      if ( current )
+         tmp.insert(current);
+    }
+  typename set<T*,greater<T*> >::iterator it;
+  for(it=tmp.begin();it!=tmp.end();it++)
+    {
+      delete *it;
+    }
+  //vector<T*>::erase(vector<T*>::begin(), vector<T*>::end());
+  rwsize=0;
+}
+
+template<class T> size_t RWTPtrOrderedVector<T>::index( const T* a ) const
+{
+  const_iterator i;
+  size_t ptn = 0;
+  for (i = vector<T*>::begin();ptn<rwsize; i++,ptn++)
+    {
+      if (**i==*a) return ptn;  
+    }
+  return (ptn=~(size_t)0);
+}
+
+template<class T>
+size_t RWTPtrOrderedVector<T>::occurrencesOf( const T* a ) const  
+{
+  const_iterator i;
+  size_t ptn = 0;
+  size_t sz=0;
+  for (i = vector<T*>::begin();sz<rwsize; i++,sz++)
+    {
+      if (**i==*a) ptn++;
+    }
+  return ptn;
+}
+
+template<class T> 
+RWBoolean RWTPtrOrderedVector<T>::contains( const T* a ) const  
+{
+  const_iterator i;
+  size_t ptn=0;
+  for (i = vector<T*>::begin(); ptn<rwsize; i++,ptn++)
+    {
+      if (**i==*a) return true;
+    }
+  return false;
+}
+
+template<class T> T* RWTPtrOrderedVector<T>::remove( const T* a )  
+{
+  iterator i;
+  size_t ptn=0;
+  size_t rwsz=rwsize;
+  for (i = vector<T*>::begin();ptn<rwsz; i++,ptn++)
+    {
+      if (**i==*a) 
+	{
+	  T* tmp=*i;
+	  vector<T*>::erase(i);
+	  rwsize--;
+	  return tmp;
+	} 
+    }
+  return 0;
+}
+
+template<class T> 
+size_t RWTPtrOrderedVector<T>::removeAll( const T* a )  
+{
+  iterator i;
+  size_t ptn = 0;
+  size_t sz=0;
+  size_t rwsz=rwsize;  
+  for (i = vector<T*>::begin();sz<rwsz; i++,sz++)
+    {
+      if (**i==*a) 
+	{
+	  vector<T*>::erase(i);
+	  rwsize--;
+          i--;
+	  ptn++;
+	} 
+    }
+  return ptn;
+}
+// should throw exception if ...
+template<class T> 
+T* RWTPtrOrderedVector<T>::removeAt( size_t i )  
+{
+  if(i<0 || i>=rwsize)
+    RWTHROW(RWBoundsErr("RWTPtrOrderedVector removeAt",rwsize,i));
+  iterator it=vector<T*>::begin();
+  int j;
+  for(j=0;j<rwsize && j<i;j++) it++;
+  if(it!=vector<T*>::end())
+    {
+      T* tmp = operator[](i);
+      vector<T*>::erase(it);
+      rwsize--;
+      return tmp;
+    }
+  else
+    return 0;
+}
+
+template<class T>	
+T* RWTPtrOrderedVector<T>::find(const T* a) const 
+{
+  const_iterator i;
+  size_t ptn=0;
+  for (i = vector<T*>::begin(); ptn<rwsize; i++,ptn++)
+    {
+      if (**i==*a) 
+	{
+	  return *i;
+	} 
+    }
+  return 0;
+}															
+template<class T>	
+void RWTPtrOrderedVector<T>::resize(size_t N)
+{
+  if(N>vector<T*>::size())
+    {
+      int e=N-vector<T*>::size();
+      for(int i=0;i<e;i++)
+	vector<T*>::push_back(0);
+    }
+  else if(N>rwsize)
+    {
+      iterator it=vector<T*>::begin();
+      for(int i=0;i<N;i++,it++);
+      vector<T*>::erase(it,vector<T*>::end());
+    }
+}
+
+template<class T>	
+void RWTPtrOrderedVector<T>::insertAt ( size_t i, T* a ) 
+{
+  if(i<0 || i>rwsize)
+    RWTHROW(RWBoundsErr("RWTPtrOrderedVector insertAt",rwsize,i));
+  if(rwsize<vector<T*>::size())
+    {
+      for(int j=rwsize;j>i;j--)
+	vector<T*>::operator[](j)=vector<T*>::operator[](j-1);
+      vector<T*>::operator[](i)=a;
+      rwsize++;
+    }
+  else
+    {
+      iterator it=vector<T*>::begin();
+      for(int j=0;j<i;j++,it++);
+      vector<T*>::insert(it,a);
+      rwsize++;
+    }
+}
+
+template<class T>	
+T* RWTPtrOrderedVector<T>::removeFirst ()
+{
+  if(rwsize!=0)
+    {
+      T* tmp=vector<T*>::front();
+      vector<T*>::erase(vector<T*>::begin());
+      rwsize--;
+      return tmp;
+    }
+  else
+    return 0;
+}
+
+template<class T>
+T* RWTPtrOrderedVector<T>::removeLast ()
+{
+  if(rwsize==0) return (T*) 0;
+  
+  rwsize--;
+  T* tmp=vector<T*>::operator[](rwsize);
+  vector<T*>::operator[](rwsize)=0;
+
+  return tmp;
+}
+
+
+#endif
+
+
+
+
+
+
+
+