DataCont/interface/RefArray.h

//--------------------------------------------------------------------------------------------------
// $Id: RefArray.h,v 1.19 2009/03/12 18:19:48 loizides Exp $
//
// RefArray
//
// Implementation of an efficient TRefArray using the FastArray.
//
// RefArray now supports objects from multiple PIDs, but only a single 
// PID will be stored as long as only objects from a single PID are added.
//
// Authors: C.Loizides, J.Bendavid
//--------------------------------------------------------------------------------------------------

#ifndef MITANA_DATACONT_REFARRAY_H
#define MITANA_DATACONT_REFARRAY_H

#include <TObject.h>
#include <TRefArray.h>
#include <TRefTable.h>
#include <TProcessID.h>
#include <TError.h>
#include "MitAna/DataCont/interface/RefResolver.h"
#include "MitAna/DataCont/interface/Collection.h"
#include "MitAna/DataCont/interface/FastArray.h"
#include "MitAna/DataCont/interface/FastArrayBasic.h"
#include "MitAna/DataCont/interface/ProcIDRef.h"

namespace mithep 
{
  template<class ArrayElement>
  class RefArray : public Collection<ArrayElement>
  {
    public:
      RefArray();

      void                      Add(const ArrayElement *ae);
      ArrayElement             *At(UInt_t idx);
      const ArrayElement       *At(UInt_t idx)               const;
      void                      Clear(Option_t */*opt*/="")        { fPIDs.Clear(); fUIDs.Clear(); }
      UInt_t                    Entries()                    const { return fUIDs.Entries();       }
      UInt_t                    GetEntries()                 const { return fUIDs.GetEntries();    }
      UInt_t                    GetSize()                    const { return fUIDs.GetSize();       }
      Bool_t                    HasObject(const ArrayElement *obj) const;
      Bool_t                    IsOwner()                    const { return kTRUE; }
      TObject                  *ObjAt(UInt_t idx);       
      const TObject            *ObjAt(UInt_t idx)            const;
      void                      Reset();
      void                      Trim()                             { fPIDs.Trim(); fUIDs.Trim();   }
      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:
      TObject                  *GetObject(UInt_t idx)        const;
      TProcessID               *GetPID(UInt_t idx)           const;
      UInt_t                    GetUID(UInt_t idx)           const;
    
      FastArray<ProcIDRef>      fPIDs; //||process ids of referenced objects
      FastArrayBasic<UInt_t>    fUIDs; //||unique ids of referenced objects

      ClassDef(RefArray, 1) // Implementation of our own TRefArray
  };
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
inline mithep::RefArray<ArrayElement>::RefArray()
{
  // Default constructor.
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
void mithep::RefArray<ArrayElement>::Add(const ArrayElement *ae)
{
  // Add reference to object.

  if (!ae)
    return;

  // check if the object can belong here and assign or get its uid
  if (ae->TestBit(kHasUUID)) {
    Fatal("Add", "Object can not be added as it has not UUID!");
    return;
  }

  UInt_t uid = 0;
  TProcessID *pid = 0;
  if (ae->TestBit(kIsReferenced)) {
    uid = ae->GetUniqueID();
    pid = TProcessID::GetProcessWithUID(uid, const_cast<ArrayElement*>(ae));
  } else {
    pid = TProcessID::GetSessionProcessID();
    uid = TProcessID::AssignID(const_cast<ArrayElement*>(ae));
  }

  // If RefArray contains one and only one PID reference, then only add another if the added object
  // has a different PID.  When this occurs all of the extra spaces which had been left empty get
  // filled in with the original PID
  if (fPIDs.Entries()==1) {
    if (pid != fPIDs.At(0)->Pid() ) {
      while (fPIDs.Entries()<Entries())
        fPIDs.GetNew()->SetPid(fPIDs.At(0)->Pid());
        
      fPIDs.GetNew()->SetPid(pid);
    }    
  }
  else
    fPIDs.GetNew()->SetPid(pid);
  
  fUIDs.Add(uid);
}

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

  if (idx<Entries())  
     return static_cast<ArrayElement*>(GetObject(idx));

  Fatal("At", "Given index (%u) is larger than array size (%u)", idx, Entries());
  return 0;
}

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

  if (idx<Entries())  
     return static_cast<const ArrayElement*>(GetObject(idx));

  Fatal("At", "Given index (%u) is larger than array size (%u)", idx, Entries());
  return 0;
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
TObject *mithep::RefArray<ArrayElement>::GetObject(UInt_t idx) const
{
  // Return entry at given index. Code adapted from TRef::GetObject().

  TProcessID *pid = GetPID(idx); 
  
  if (!pid) {
    Fatal("GetObject","Process id pointer is null!");
    return 0;
  }

  if (!TProcessID::IsValid(pid)) {
    Fatal("GetObject","Process id is invalid!");
    return 0;
  }

  UInt_t uid = GetUID(idx);
  return RefResolver::GetObjectWithID(uid,pid);
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
inline TProcessID *mithep::RefArray<ArrayElement>::GetPID(UInt_t idx) const
{
  // Return pid corresponding to given idx.

  TProcessID *pid = 0;
  if (fPIDs.Entries()>1)
    pid = fPIDs.UncheckedAt(idx)->Pid();
  else
    pid = fPIDs.UncheckedAt(0)->Pid();
    
  return pid;
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
inline UInt_t mithep::RefArray<ArrayElement>::GetUID(UInt_t idx) const
{
  // Return uid corresponding to given idx.

  return fUIDs.UncheckedAt(idx);
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
Bool_t mithep::RefArray<ArrayElement>::HasObject(const ArrayElement *obj) const
{
  // Check whether array contains a given object.

  if (!obj->TestBit(kIsReferenced))
    return kFALSE;
  
  UInt_t oUid = obj->GetUniqueID();
  TProcessID *oPid = TProcessID::GetProcessWithUID(oUid, const_cast<ArrayElement*>(obj));
  
  for (UInt_t i=0; i<Entries(); ++i) {
    if ( (GetUID(i)&0xffffff)==(oUid&0xffffff) && GetPID(i)->GetUniqueID()==oPid->GetUniqueID())
      return kTRUE;
  }
  
  return kFALSE;
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
TObject *mithep::RefArray<ArrayElement>::ObjAt(UInt_t idx)
{
  // Return object at given index.

  if (idx<Entries())  
     return GetObject(idx);

  Fatal("ObjAt", "Given index (%u) is larger than array size (%u)", idx, Entries());
  return 0;
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
const TObject *mithep::RefArray<ArrayElement>::ObjAt(UInt_t idx) const
{
  // Return object at given index.

  if (idx<Entries())  
    return static_cast<const TObject*>(GetObject(idx));

  Fatal("ObjAt", "Given index (%u) is larger than array size (%u)", idx, Entries());
  return 0;
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
inline void mithep::RefArray<ArrayElement>::Reset()
{
  // Reset the array.

  fUIDs.Reset();
  fPIDs.Reset();
  BaseCollection::Clear();
}

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

  return static_cast<ArrayElement*>(GetObject(idx));
}

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

  return static_cast<const ArrayElement*>(GetObject(idx));
}

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

  return At(idx);
}

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

  return At(idx);
}
#endif
Revision:	1.20
Committed:	Fri Mar 20 09:29:24 2009 UTC (16 years, 1 month ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.19:	+8 -5 lines
Log Message:	Cosmetics
#	User	Rev	Content
1	loizides	1.1	//--------------------------------------------------------------------------------------------------
2	loizides	1.20	// $Id: RefArray.h,v 1.19 2009/03/12 18:19:48 loizides Exp $
3	loizides	1.1	//
4			// RefArray
5			//
6	loizides	1.16	// Implementation of an efficient TRefArray using the FastArray.
7	bendavid	1.7	//
8	loizides	1.16	// RefArray now supports objects from multiple PIDs, but only a single
9			// PID will be stored as long as only objects from a single PID are added.
10	loizides	1.1	//
11			// Authors: C.Loizides, J.Bendavid
12			//--------------------------------------------------------------------------------------------------
13
14	loizides	1.17	#ifndef MITANA_DATACONT_REFARRAY_H
15			#define MITANA_DATACONT_REFARRAY_H
16	loizides	1.1
17			#include <TObject.h>
18			#include <TRefArray.h>
19			#include <TRefTable.h>
20			#include <TProcessID.h>
21			#include <TError.h>
22	loizides	1.16	#include "MitAna/DataCont/interface/RefResolver.h"
23	loizides	1.1	#include "MitAna/DataCont/interface/Collection.h"
24	bendavid	1.15	#include "MitAna/DataCont/interface/FastArray.h"
25			#include "MitAna/DataCont/interface/FastArrayBasic.h"
26	bendavid	1.7	#include "MitAna/DataCont/interface/ProcIDRef.h"
27	loizides	1.1
28			namespace mithep
29			{
30	bendavid	1.15	template<class ArrayElement>
31	loizides	1.16	class RefArray : public Collection<ArrayElement>
32	loizides	1.1	{
33			public:
34			RefArray();
35
36	loizides	1.9	void Add(const ArrayElement *ae);
37	loizides	1.1	ArrayElement *At(UInt_t idx);
38	loizides	1.8	const ArrayElement *At(UInt_t idx) const;
39	bendavid	1.15	void Clear(Option_t /opt*/="") { fPIDs.Clear(); fUIDs.Clear(); }
40	loizides	1.18	UInt_t Entries() const { return fUIDs.Entries(); }
41	loizides	1.16	UInt_t GetEntries() const { return fUIDs.GetEntries(); }
42			UInt_t GetSize() const { return fUIDs.GetSize(); }
43	bendavid	1.12	Bool_t HasObject(const ArrayElement *obj) const;
44	loizides	1.8	Bool_t IsOwner() const { return kTRUE; }
45	loizides	1.10	TObject *ObjAt(UInt_t idx);
46			const TObject *ObjAt(UInt_t idx) const;
47	bendavid	1.7	void Reset();
48	loizides	1.16	void Trim() { fPIDs.Trim(); fUIDs.Trim(); }
49	loizides	1.1	ArrayElement *UncheckedAt(UInt_t idx);
50	loizides	1.8	const ArrayElement *UncheckedAt(UInt_t idx) const;
51	loizides	1.1	ArrayElement *operator[](UInt_t idx);
52	loizides	1.8	const ArrayElement *operator[](UInt_t idx) const;
53	loizides	1.1
54			protected:
55	loizides	1.8	TObject *GetObject(UInt_t idx) const;
56	bendavid	1.12	TProcessID *GetPID(UInt_t idx) const;
57	loizides	1.8	UInt_t GetUID(UInt_t idx) const;
58	loizides	1.1
59	loizides	1.16	FastArray<ProcIDRef> fPIDs; //\|\|process ids of referenced objects
60			FastArrayBasic<UInt_t> fUIDs; //\|\|unique ids of referenced objects
61	loizides	1.1
62	loizides	1.16	ClassDef(RefArray, 1) // Implementation of our own TRefArray
63	loizides	1.1	};
64			}
65
66			//--------------------------------------------------------------------------------------------------
67	bendavid	1.15	template<class ArrayElement>
68			inline mithep::RefArray<ArrayElement>::RefArray()
69	loizides	1.1	{
70	loizides	1.8	// Default constructor.
71	loizides	1.1	}
72
73			//--------------------------------------------------------------------------------------------------
74	bendavid	1.15	template<class ArrayElement>
75			void mithep::RefArray<ArrayElement>::Add(const ArrayElement *ae)
76	loizides	1.1	{
77	loizides	1.20	// Add reference to object.
78
79			if (!ae)
80			return;
81	loizides	1.1
82			// check if the object can belong here and assign or get its uid
83			if (ae->TestBit(kHasUUID)) {
84	loizides	1.8	Fatal("Add", "Object can not be added as it has not UUID!");
85	loizides	1.1	return;
86			}
87
88	bendavid	1.7	UInt_t uid = 0;
89			TProcessID *pid = 0;
90	loizides	1.1	if (ae->TestBit(kIsReferenced)) {
91			uid = ae->GetUniqueID();
92	loizides	1.9	pid = TProcessID::GetProcessWithUID(uid, const_cast<ArrayElement*>(ae));
93	loizides	1.1	} else {
94	bendavid	1.7	pid = TProcessID::GetSessionProcessID();
95	loizides	1.9	uid = TProcessID::AssignID(const_cast<ArrayElement*>(ae));
96	loizides	1.1	}
97
98	loizides	1.8	// If RefArray contains one and only one PID reference, then only add another if the added object
99			// has a different PID. When this occurs all of the extra spaces which had been left empty get
100			// filled in with the original PID
101	loizides	1.18	if (fPIDs.Entries()==1) {
102	bendavid	1.7	if (pid != fPIDs.At(0)->Pid() ) {
103	loizides	1.18	while (fPIDs.Entries()<Entries())
104	bendavid	1.15	fPIDs.GetNew()->SetPid(fPIDs.At(0)->Pid());
105	bendavid	1.7
106	bendavid	1.15	fPIDs.GetNew()->SetPid(pid);
107	bendavid	1.7	}
108			}
109			else
110	bendavid	1.15	fPIDs.GetNew()->SetPid(pid);
111	bendavid	1.7
112			fUIDs.Add(uid);
113	loizides	1.1	}
114
115			//--------------------------------------------------------------------------------------------------
116	bendavid	1.15	template<class ArrayElement>
117			inline ArrayElement *mithep::RefArray<ArrayElement>::At(UInt_t idx)
118	loizides	1.1	{
119			// Return entry at given index.
120
121	loizides	1.18	if (idx<Entries())
122	loizides	1.1	return static_cast<ArrayElement*>(GetObject(idx));
123
124	loizides	1.18	Fatal("At", "Given index (%u) is larger than array size (%u)", idx, Entries());
125	loizides	1.1	return 0;
126			}
127
128			//--------------------------------------------------------------------------------------------------
129	bendavid	1.15	template<class ArrayElement>
130			inline const ArrayElement *mithep::RefArray<ArrayElement>::At(UInt_t idx) const
131	loizides	1.1	{
132			// Return entry at given index.
133
134	loizides	1.18	if (idx<Entries())
135	loizides	1.1	return static_cast<const ArrayElement*>(GetObject(idx));
136
137	loizides	1.18	Fatal("At", "Given index (%u) is larger than array size (%u)", idx, Entries());
138	loizides	1.1	return 0;
139			}
140
141			//--------------------------------------------------------------------------------------------------
142	bendavid	1.15	template<class ArrayElement>
143			TObject *mithep::RefArray<ArrayElement>::GetObject(UInt_t idx) const
144	loizides	1.1	{
145			// Return entry at given index. Code adapted from TRef::GetObject().
146	loizides	1.8
147	bendavid	1.12	TProcessID *pid = GetPID(idx);
148	loizides	1.1
149	bendavid	1.7	if (!pid) {
150	loizides	1.8	Fatal("GetObject","Process id pointer is null!");
151	loizides	1.1	return 0;
152			}
153
154	bendavid	1.7	if (!TProcessID::IsValid(pid)) {
155	loizides	1.8	Fatal("GetObject","Process id is invalid!");
156	loizides	1.1	return 0;
157			}
158	loizides	1.8
159	loizides	1.1	UInt_t uid = GetUID(idx);
160	loizides	1.16	return RefResolver::GetObjectWithID(uid,pid);
161	loizides	1.1	}
162
163			//--------------------------------------------------------------------------------------------------
164	bendavid	1.15	template<class ArrayElement>
165			inline TProcessID *mithep::RefArray<ArrayElement>::GetPID(UInt_t idx) const
166	bendavid	1.12	{
167	loizides	1.20	// Return pid corresponding to given idx.
168	bendavid	1.12
169			TProcessID *pid = 0;
170	loizides	1.18	if (fPIDs.Entries()>1)
171	bendavid	1.15	pid = fPIDs.UncheckedAt(idx)->Pid();
172	bendavid	1.12	else
173	bendavid	1.15	pid = fPIDs.UncheckedAt(0)->Pid();
174	bendavid	1.12
175			return pid;
176			}
177
178			//--------------------------------------------------------------------------------------------------
179	bendavid	1.15	template<class ArrayElement>
180			inline UInt_t mithep::RefArray<ArrayElement>::GetUID(UInt_t idx) const
181	loizides	1.1	{
182	loizides	1.20	// Return uid corresponding to given idx.
183	loizides	1.1
184	bendavid	1.15	return fUIDs.UncheckedAt(idx);
185	loizides	1.1	}
186
187			//--------------------------------------------------------------------------------------------------
188	bendavid	1.15	template<class ArrayElement>
189			Bool_t mithep::RefArray<ArrayElement>::HasObject(const ArrayElement *obj) const
190	bendavid	1.12	{
191	loizides	1.20	// Check whether array contains a given object.
192	bendavid	1.12
193			if (!obj->TestBit(kIsReferenced))
194			return kFALSE;
195
196			UInt_t oUid = obj->GetUniqueID();
197			TProcessID oPid = TProcessID::GetProcessWithUID(oUid, const_cast<ArrayElement>(obj));
198
199	loizides	1.18	for (UInt_t i=0; i<Entries(); ++i) {
200	bendavid	1.12	if ( (GetUID(i)&0xffffff)==(oUid&0xffffff) && GetPID(i)->GetUniqueID()==oPid->GetUniqueID())
201			return kTRUE;
202			}
203
204			return kFALSE;
205			}
206
207			//--------------------------------------------------------------------------------------------------
208	bendavid	1.15	template<class ArrayElement>
209			TObject *mithep::RefArray<ArrayElement>::ObjAt(UInt_t idx)
210	loizides	1.10	{
211			// Return object at given index.
212
213	loizides	1.18	if (idx<Entries())
214	loizides	1.10	return GetObject(idx);
215
216	loizides	1.18	Fatal("ObjAt", "Given index (%u) is larger than array size (%u)", idx, Entries());
217	loizides	1.10	return 0;
218			}
219
220			//--------------------------------------------------------------------------------------------------
221	bendavid	1.15	template<class ArrayElement>
222			const TObject *mithep::RefArray<ArrayElement>::ObjAt(UInt_t idx) const
223	loizides	1.10	{
224			// Return object at given index.
225
226	loizides	1.18	if (idx<Entries())
227	loizides	1.10	return static_cast<const TObject*>(GetObject(idx));
228
229	loizides	1.18	Fatal("ObjAt", "Given index (%u) is larger than array size (%u)", idx, Entries());
230	loizides	1.10	return 0;
231			}
232
233			//--------------------------------------------------------------------------------------------------
234	bendavid	1.15	template<class ArrayElement>
235			inline void mithep::RefArray<ArrayElement>::Reset()
236	loizides	1.1	{
237	loizides	1.16	// Reset the array.
238
239	loizides	1.8	fUIDs.Reset();
240			fPIDs.Reset();
241	loizides	1.19	BaseCollection::Clear();
242	loizides	1.1	}
243
244			//--------------------------------------------------------------------------------------------------
245	bendavid	1.15	template<class ArrayElement>
246			inline ArrayElement *mithep::RefArray<ArrayElement>::UncheckedAt(UInt_t idx)
247	loizides	1.1	{
248			// Return entry at given index.
249
250	loizides	1.8	return static_cast<ArrayElement*>(GetObject(idx));
251	loizides	1.1	}
252
253	bendavid	1.7	//--------------------------------------------------------------------------------------------------
254	bendavid	1.15	template<class ArrayElement>
255			inline const ArrayElement *mithep::RefArray<ArrayElement>::UncheckedAt(UInt_t idx) const
256	bendavid	1.7	{
257	loizides	1.8	// Return entry at given index.
258
259			return static_cast<const ArrayElement*>(GetObject(idx));
260	loizides	1.1	}
261
262			//--------------------------------------------------------------------------------------------------
263	bendavid	1.15	template<class ArrayElement>
264			inline const ArrayElement *mithep::RefArray<ArrayElement>::operator[](UInt_t idx) const
265	loizides	1.1	{
266			// Return entry at given index.
267
268	loizides	1.8	return At(idx);
269	loizides	1.1	}
270
271			//--------------------------------------------------------------------------------------------------
272	bendavid	1.15	template<class ArrayElement>
273			inline ArrayElement *mithep::RefArray<ArrayElement>::operator[](UInt_t idx)
274	loizides	1.1	{
275			// Return entry at given index.
276
277	loizides	1.8	return At(idx);
278	loizides	1.1	}
279			#endif