DataCont/interface/Array.h

//--------------------------------------------------------------------------------------------------
// $Id: Array.h,v 1.5 2008/12/01 17:17:20 bendavid Exp $
//
// Array
//
// Implementation of Collection interface using TClonesArray class. 
//
// Authors: C.Loizides
//--------------------------------------------------------------------------------------------------

#ifndef MITANA_DATACONT_ARRAY_H
#define MITANA_DATACONT_ARRAY_H

#include <TClonesArray.h>
#include "MitAna/DataCont/interface/Collection.h"

namespace mithep 
{
  template<class ArrayElement>
  class Array : public Collection<ArrayElement> 
  {
    public:
      Array(UInt_t size=0, const char *name=0);
      ~Array() {}

      ArrayElement        *AddNew();
      ArrayElement        *Allocate();
      const TClonesArray  &Arr()                                const { return fArray; }
      TClonesArray        &Arr()                                      { return fArray; }
      ArrayElement        *At(UInt_t idx);
      const ArrayElement  *At(UInt_t idx)                       const;
      void                 Clear(Option_t */*opt*/="")                { fArray.~TClonesArray(); }
      UInt_t               Entries()                            const { return fNumEntries; }
      UInt_t               GetEntries()                         const { return fNumEntries; }
      const char          *GetName()                            const { return fArray.GetName(); }
      UInt_t               GetSize()                            const { return fArray.GetSize(); }
      Bool_t               HasObject(const ArrayElement *obj)   const;
      Bool_t               IsOwner()                            const { return kTRUE; }
      TIterator           *Iterator(Bool_t dir = kIterForward)  const;
      Bool_t               MustClear()                          const { return this->TestBit(14); }
      Bool_t               MustDelete()                         const { return this->TestBit(15); }
      void                 Print(Option_t *opt="")              const;
      void                 Reset();
      void                 SetMustClearBit()                          { this->SetBit(14); }
      void                 SetMustDeleteBit()                         { this->SetBit(15); }
      void                 SetName(const char *name)                  { fArray.SetName(name); }
      void                 Trim()                                     { fArray.Compress(); }
      ArrayElement        *UncheckedAt(UInt_t idx);                 
      const ArrayElement  *UncheckedAt(UInt_t idx)              const;
      ArrayElement        *operator[](UInt_t idx);
      const ArrayElement  *operator[](UInt_t idx)               const;

    protected:
      TClonesArray         fArray;        //array for storage
      UInt_t               fNumEntries;   //number of entries in the array

    private:
      Array(const Array &a);

    ClassDefT(Array,1) // Wrapper around TClonesArray class
  };
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
inline mithep::Array<ArrayElement>::Array(UInt_t size, const char *name) : 
  fArray(ArrayElement::Class_Name(),size), 
  fNumEntries(0)
{
   // Default constructor.

  fArray.BypassStreamer(kTRUE);

  if (name) 
    fArray.SetName(name);

  ArrayElement test;
  if (test.MustClear())
    SetMustClearBit();
  if (test.MustDelete())
    SetMustDeleteBit();
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
inline ArrayElement *mithep::Array<ArrayElement>::AddNew()
{
  // Add new entry and return pointer to it.

  return new(Allocate()) ArrayElement(); 
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
inline ArrayElement *mithep::Array<ArrayElement>::Allocate()
{
   // Allocate a slot in the array, *only* to be used in placement new operator.
   
   return static_cast<ArrayElement*>(fArray[fNumEntries++]);
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
inline ArrayElement *mithep::Array<ArrayElement>::At(UInt_t idx)
{
  // Return entry at given index.

  if (idx<fNumEntries)
    return static_cast<ArrayElement*>(fArray.UncheckedAt(idx));

  ArrayElement tmp;
  TObject::Fatal("At","Index too large: (%ud < %ud violated) for %s containing %s",
                 idx, fNumEntries, GetName(), tmp.GetName()); 
  return 0;
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
inline const ArrayElement *mithep::Array<ArrayElement>::At(UInt_t idx) const
{
  // Return entry at given index.

  if (idx<fNumEntries)
    return static_cast<const ArrayElement*>(fArray.UncheckedAt(idx));

  ArrayElement tmp;
  TObject::Fatal("At","Index too large: (%ud < %ud violated) for %s containing %s",
                 idx, fNumEntries, GetName(), tmp.GetName()); 
  return 0;
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
inline TIterator *mithep::Array<ArrayElement>::Iterator(Bool_t dir) const 
{ 
  // Return ROOT collection iterator.

  return fArray.MakeIterator(dir); 
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
inline Bool_t mithep::Array<ArrayElement>::HasObject(const ArrayElement *obj) const
{
  // Check whether object is in array.

  return fArray.FindObject(obj);
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
void mithep::Array<ArrayElement>::Print(Option_t *opt) const
{
  // Print out elements of array.

  printf("%s: Contains %d (out of %d) objs of name %s\n",
         GetName(), GetEntries(), GetSize(), ArrayElement::Class_Name());

  if (opt && opt[0]=='l') {
    const UInt_t N = GetEntries();
    for (UInt_t i=0; i<N; ++i) {
      printf("%4d: ",i);
      At(i)->Print(opt);
    }
  }
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
inline void mithep::Array<ArrayElement>::Reset()
{
  // ROOT implementation for clearing the array.

  if (MustDelete())
    fArray.Delete();   //will call destructor for every element
  else if (MustClear())
    fArray.Clear("C"); //will call clear for every element
  else 
    fArray.Clear();

  fNumEntries = 0;
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
inline ArrayElement *mithep::Array<ArrayElement>::UncheckedAt(UInt_t idx)
{
  // Return entry at given index.

  return static_cast<ArrayElement*>(fArray.UncheckedAt(idx));
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
inline const ArrayElement *mithep::Array<ArrayElement>::UncheckedAt(UInt_t idx) const
{
  // Return entry at given index.

  return static_cast<const ArrayElement*>(fArray.UncheckedAt(idx));
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
inline const ArrayElement *mithep::Array<ArrayElement>::operator[](UInt_t idx) const
{
  // Return entry at given index.

  return At(idx);
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
inline ArrayElement *mithep::Array<ArrayElement>::operator[](UInt_t idx)
{
  // Return entry at given index.

  return At(idx);
}
#endif
Revision:	1.6
Committed:	Mon Dec 8 15:26:11 2008 UTC (16 years, 4 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.5:	+7 -5 lines
Log Message:	Check for l option before listing.
#	User	Rev	Content
1	loizides	1.1	//--------------------------------------------------------------------------------------------------
2	loizides	1.6	// $Id: Array.h,v 1.5 2008/12/01 17:17:20 bendavid Exp $
3	loizides	1.1	//
4			// Array
5			//
6			// Implementation of Collection interface using TClonesArray class.
7			//
8			// Authors: C.Loizides
9			//--------------------------------------------------------------------------------------------------
10
11	loizides	1.2	#ifndef MITANA_DATACONT_ARRAY_H
12			#define MITANA_DATACONT_ARRAY_H
13	loizides	1.1
14			#include <TClonesArray.h>
15			#include "MitAna/DataCont/interface/Collection.h"
16
17			namespace mithep
18			{
19			template<class ArrayElement>
20			class Array : public Collection<ArrayElement>
21			{
22			public:
23			Array(UInt_t size=0, const char *name=0);
24			~Array() {}
25
26			ArrayElement *AddNew();
27			ArrayElement *Allocate();
28			const TClonesArray &Arr() const { return fArray; }
29			TClonesArray &Arr() { return fArray; }
30			ArrayElement *At(UInt_t idx);
31			const ArrayElement *At(UInt_t idx) const;
32			void Clear(Option_t /opt*/="") { fArray.~TClonesArray(); }
33			UInt_t Entries() const { return fNumEntries; }
34			UInt_t GetEntries() const { return fNumEntries; }
35			const char *GetName() const { return fArray.GetName(); }
36	loizides	1.4	UInt_t GetSize() const { return fArray.GetSize(); }
37	bendavid	1.5	Bool_t HasObject(const ArrayElement *obj) const;
38	loizides	1.1	Bool_t IsOwner() const { return kTRUE; }
39			TIterator *Iterator(Bool_t dir = kIterForward) const;
40			Bool_t MustClear() const { return this->TestBit(14); }
41			Bool_t MustDelete() const { return this->TestBit(15); }
42	loizides	1.4	void Print(Option_t *opt="") const;
43	loizides	1.1	void Reset();
44			void SetMustClearBit() { this->SetBit(14); }
45			void SetMustDeleteBit() { this->SetBit(15); }
46			void SetName(const char *name) { fArray.SetName(name); }
47	loizides	1.4	void Trim() { fArray.Compress(); }
48	loizides	1.1	ArrayElement *UncheckedAt(UInt_t idx);
49			const ArrayElement *UncheckedAt(UInt_t idx) const;
50			ArrayElement *operator[](UInt_t idx);
51			const ArrayElement *operator[](UInt_t idx) const;
52
53			protected:
54			TClonesArray fArray; //array for storage
55			UInt_t fNumEntries; //number of entries in the array
56
57			private:
58			Array(const Array &a);
59
60			ClassDefT(Array,1) // Wrapper around TClonesArray class
61			};
62			}
63
64			//--------------------------------------------------------------------------------------------------
65			template<class ArrayElement>
66			inline mithep::Array<ArrayElement>::Array(UInt_t size, const char *name) :
67			fArray(ArrayElement::Class_Name(),size),
68			fNumEntries(0)
69			{
70			// Default constructor.
71
72			fArray.BypassStreamer(kTRUE);
73
74			if (name)
75			fArray.SetName(name);
76
77			ArrayElement test;
78			if (test.MustClear())
79			SetMustClearBit();
80			if (test.MustDelete())
81			SetMustDeleteBit();
82			}
83
84			//--------------------------------------------------------------------------------------------------
85			template<class ArrayElement>
86			inline ArrayElement *mithep::Array<ArrayElement>::AddNew()
87			{
88			// Add new entry and return pointer to it.
89
90			return new(Allocate()) ArrayElement();
91			}
92
93			//--------------------------------------------------------------------------------------------------
94			template<class ArrayElement>
95			inline ArrayElement *mithep::Array<ArrayElement>::Allocate()
96			{
97			// Allocate a slot in the array, only to be used in placement new operator.
98
99			return static_cast<ArrayElement*>(fArray[fNumEntries++]);
100			}
101
102			//--------------------------------------------------------------------------------------------------
103			template<class ArrayElement>
104			inline ArrayElement *mithep::Array<ArrayElement>::At(UInt_t idx)
105			{
106			// Return entry at given index.
107
108			if (idx<fNumEntries)
109			return static_cast<ArrayElement*>(fArray.UncheckedAt(idx));
110
111			ArrayElement tmp;
112	loizides	1.3	TObject::Fatal("At","Index too large: (%ud < %ud violated) for %s containing %s",
113	loizides	1.4	idx, fNumEntries, GetName(), tmp.GetName());
114	loizides	1.1	return 0;
115			}
116
117			//--------------------------------------------------------------------------------------------------
118			template<class ArrayElement>
119			inline const ArrayElement *mithep::Array<ArrayElement>::At(UInt_t idx) const
120			{
121			// Return entry at given index.
122
123			if (idx<fNumEntries)
124			return static_cast<const ArrayElement*>(fArray.UncheckedAt(idx));
125
126			ArrayElement tmp;
127	loizides	1.3	TObject::Fatal("At","Index too large: (%ud < %ud violated) for %s containing %s",
128	loizides	1.4	idx, fNumEntries, GetName(), tmp.GetName());
129	loizides	1.1	return 0;
130			}
131
132			//--------------------------------------------------------------------------------------------------
133			template<class ArrayElement>
134			inline TIterator *mithep::Array<ArrayElement>::Iterator(Bool_t dir) const
135			{
136			// Return ROOT collection iterator.
137
138			return fArray.MakeIterator(dir);
139			}
140
141			//--------------------------------------------------------------------------------------------------
142			template<class ArrayElement>
143	bendavid	1.5	inline Bool_t mithep::Array<ArrayElement>::HasObject(const ArrayElement *obj) const
144			{
145			// Check whether object is in array.
146
147			return fArray.FindObject(obj);
148			}
149
150			//--------------------------------------------------------------------------------------------------
151			template<class ArrayElement>
152	loizides	1.4	void mithep::Array<ArrayElement>::Print(Option_t *opt) const
153	loizides	1.1	{
154	loizides	1.4	// Print out elements of array.
155	loizides	1.1
156	loizides	1.4	printf("%s: Contains %d (out of %d) objs of name %s\n",
157			GetName(), GetEntries(), GetSize(), ArrayElement::Class_Name());
158	loizides	1.1
159	loizides	1.6	if (opt && opt[0]=='l') {
160			const UInt_t N = GetEntries();
161			for (UInt_t i=0; i<N; ++i) {
162			printf("%4d: ",i);
163			At(i)->Print(opt);
164			}
165	loizides	1.4	}
166	loizides	1.1	}
167
168			//--------------------------------------------------------------------------------------------------
169			template<class ArrayElement>
170			inline void mithep::Array<ArrayElement>::Reset()
171			{
172			// ROOT implementation for clearing the array.
173
174	loizides	1.4	if (MustDelete())
175	loizides	1.1	fArray.Delete(); //will call destructor for every element
176	loizides	1.4	else if (MustClear())
177	loizides	1.1	fArray.Clear("C"); //will call clear for every element
178			else
179			fArray.Clear();
180
181			fNumEntries = 0;
182			}
183
184			//--------------------------------------------------------------------------------------------------
185			template<class ArrayElement>
186			inline ArrayElement *mithep::Array<ArrayElement>::UncheckedAt(UInt_t idx)
187			{
188			// Return entry at given index.
189
190			return static_cast<ArrayElement*>(fArray.UncheckedAt(idx));
191			}
192
193			//--------------------------------------------------------------------------------------------------
194			template<class ArrayElement>
195			inline const ArrayElement *mithep::Array<ArrayElement>::UncheckedAt(UInt_t idx) const
196			{
197			// Return entry at given index.
198
199			return static_cast<const ArrayElement*>(fArray.UncheckedAt(idx));
200			}
201	loizides	1.4
202			//--------------------------------------------------------------------------------------------------
203			template<class ArrayElement>
204			inline const ArrayElement *mithep::Array<ArrayElement>::operator[](UInt_t idx) const
205			{
206			// Return entry at given index.
207
208			return At(idx);
209			}
210
211			//--------------------------------------------------------------------------------------------------
212			template<class ArrayElement>
213			inline ArrayElement *mithep::Array<ArrayElement>::operator[](UInt_t idx)
214			{
215			// Return entry at given index.
216
217			return At(idx);
218			}
219	loizides	1.1	#endif