DataCont/interface/RefArray.h

//--------------------------------------------------------------------------------------------------
// $Id: RefArray.h,v 1.18 2009/03/06 13:52:54 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 new reference to object.

  // 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 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 idx.

  return fUIDs.UncheckedAt(idx);
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
Bool_t mithep::RefArray<ArrayElement>::HasObject(const ArrayElement *obj) const
{
  // check whether RefArray 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.19
Committed:	Thu Mar 12 18:19:48 2009 UTC (16 years, 1 month ago) by loizides
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_008pre2
Changes since 1.18:	+2 -1 lines
Log Message:	Proper resetting of the cached entry in BaseCollection.
#	User	Rev	Content
1	loizides	1.1	//--------------------------------------------------------------------------------------------------
2	loizides	1.19	// $Id: RefArray.h,v 1.18 2009/03/06 13:52:54 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			// Add new reference to object.
78
79			// check if the object can belong here and assign or get its uid
80			if (ae->TestBit(kHasUUID)) {
81	loizides	1.8	Fatal("Add", "Object can not be added as it has not UUID!");
82	loizides	1.1	return;
83			}
84
85	bendavid	1.7	UInt_t uid = 0;
86			TProcessID *pid = 0;
87	loizides	1.1	if (ae->TestBit(kIsReferenced)) {
88			uid = ae->GetUniqueID();
89	loizides	1.9	pid = TProcessID::GetProcessWithUID(uid, const_cast<ArrayElement*>(ae));
90	loizides	1.1	} else {
91	bendavid	1.7	pid = TProcessID::GetSessionProcessID();
92	loizides	1.9	uid = TProcessID::AssignID(const_cast<ArrayElement*>(ae));
93	loizides	1.1	}
94
95	loizides	1.8	// If RefArray contains one and only one PID reference, then only add another if the added object
96			// has a different PID. When this occurs all of the extra spaces which had been left empty get
97			// filled in with the original PID
98	loizides	1.18	if (fPIDs.Entries()==1) {
99	bendavid	1.7	if (pid != fPIDs.At(0)->Pid() ) {
100	loizides	1.18	while (fPIDs.Entries()<Entries())
101	bendavid	1.15	fPIDs.GetNew()->SetPid(fPIDs.At(0)->Pid());
102	bendavid	1.7
103	bendavid	1.15	fPIDs.GetNew()->SetPid(pid);
104	bendavid	1.7	}
105			}
106			else
107	bendavid	1.15	fPIDs.GetNew()->SetPid(pid);
108	bendavid	1.7
109			fUIDs.Add(uid);
110	loizides	1.1	}
111
112			//--------------------------------------------------------------------------------------------------
113	bendavid	1.15	template<class ArrayElement>
114			inline ArrayElement *mithep::RefArray<ArrayElement>::At(UInt_t idx)
115	loizides	1.1	{
116			// Return entry at given index.
117
118	loizides	1.18	if (idx<Entries())
119	loizides	1.1	return static_cast<ArrayElement*>(GetObject(idx));
120
121	loizides	1.18	Fatal("At", "Given index (%u) is larger than array size (%u)", idx, Entries());
122	loizides	1.1	return 0;
123			}
124
125			//--------------------------------------------------------------------------------------------------
126	bendavid	1.15	template<class ArrayElement>
127			inline const ArrayElement *mithep::RefArray<ArrayElement>::At(UInt_t idx) const
128	loizides	1.1	{
129			// Return entry at given index.
130
131	loizides	1.18	if (idx<Entries())
132	loizides	1.1	return static_cast<const ArrayElement*>(GetObject(idx));
133
134	loizides	1.18	Fatal("At", "Given index (%u) is larger than array size (%u)", idx, Entries());
135	loizides	1.1	return 0;
136			}
137
138			//--------------------------------------------------------------------------------------------------
139	bendavid	1.15	template<class ArrayElement>
140			TObject *mithep::RefArray<ArrayElement>::GetObject(UInt_t idx) const
141	loizides	1.1	{
142			// Return entry at given index. Code adapted from TRef::GetObject().
143	loizides	1.8
144	bendavid	1.12	TProcessID *pid = GetPID(idx);
145	loizides	1.1
146	bendavid	1.7	if (!pid) {
147	loizides	1.8	Fatal("GetObject","Process id pointer is null!");
148	loizides	1.1	return 0;
149			}
150
151	bendavid	1.7	if (!TProcessID::IsValid(pid)) {
152	loizides	1.8	Fatal("GetObject","Process id is invalid!");
153	loizides	1.1	return 0;
154			}
155	loizides	1.8
156	loizides	1.1	UInt_t uid = GetUID(idx);
157	loizides	1.16	return RefResolver::GetObjectWithID(uid,pid);
158	loizides	1.1	}
159
160			//--------------------------------------------------------------------------------------------------
161	bendavid	1.15	template<class ArrayElement>
162			inline TProcessID *mithep::RefArray<ArrayElement>::GetPID(UInt_t idx) const
163	bendavid	1.12	{
164			// Return pid corresponding to idx.
165
166			TProcessID *pid = 0;
167	loizides	1.18	if (fPIDs.Entries()>1)
168	bendavid	1.15	pid = fPIDs.UncheckedAt(idx)->Pid();
169	bendavid	1.12	else
170	bendavid	1.15	pid = fPIDs.UncheckedAt(0)->Pid();
171	bendavid	1.12
172			return pid;
173			}
174
175			//--------------------------------------------------------------------------------------------------
176	bendavid	1.15	template<class ArrayElement>
177			inline UInt_t mithep::RefArray<ArrayElement>::GetUID(UInt_t idx) const
178	loizides	1.1	{
179			// Return uid corresponding to idx.
180
181	bendavid	1.15	return fUIDs.UncheckedAt(idx);
182	loizides	1.1	}
183
184			//--------------------------------------------------------------------------------------------------
185	bendavid	1.15	template<class ArrayElement>
186			Bool_t mithep::RefArray<ArrayElement>::HasObject(const ArrayElement *obj) const
187	bendavid	1.12	{
188			// check whether RefArray contains a given object
189
190			if (!obj->TestBit(kIsReferenced))
191			return kFALSE;
192
193			UInt_t oUid = obj->GetUniqueID();
194			TProcessID oPid = TProcessID::GetProcessWithUID(oUid, const_cast<ArrayElement>(obj));
195
196	loizides	1.18	for (UInt_t i=0; i<Entries(); ++i) {
197	bendavid	1.12	if ( (GetUID(i)&0xffffff)==(oUid&0xffffff) && GetPID(i)->GetUniqueID()==oPid->GetUniqueID())
198			return kTRUE;
199			}
200
201			return kFALSE;
202			}
203
204			//--------------------------------------------------------------------------------------------------
205	bendavid	1.15	template<class ArrayElement>
206			TObject *mithep::RefArray<ArrayElement>::ObjAt(UInt_t idx)
207	loizides	1.10	{
208			// Return object at given index.
209
210	loizides	1.18	if (idx<Entries())
211	loizides	1.10	return GetObject(idx);
212
213	loizides	1.18	Fatal("ObjAt", "Given index (%u) is larger than array size (%u)", idx, Entries());
214	loizides	1.10	return 0;
215			}
216
217			//--------------------------------------------------------------------------------------------------
218	bendavid	1.15	template<class ArrayElement>
219			const TObject *mithep::RefArray<ArrayElement>::ObjAt(UInt_t idx) const
220	loizides	1.10	{
221			// Return object at given index.
222
223	loizides	1.18	if (idx<Entries())
224	loizides	1.10	return static_cast<const TObject*>(GetObject(idx));
225
226	loizides	1.18	Fatal("ObjAt", "Given index (%u) is larger than array size (%u)", idx, Entries());
227	loizides	1.10	return 0;
228			}
229
230			//--------------------------------------------------------------------------------------------------
231	bendavid	1.15	template<class ArrayElement>
232			inline void mithep::RefArray<ArrayElement>::Reset()
233	loizides	1.1	{
234	loizides	1.16	// Reset the array.
235
236	loizides	1.8	fUIDs.Reset();
237			fPIDs.Reset();
238	loizides	1.19	BaseCollection::Clear();
239	loizides	1.1	}
240
241			//--------------------------------------------------------------------------------------------------
242	bendavid	1.15	template<class ArrayElement>
243			inline ArrayElement *mithep::RefArray<ArrayElement>::UncheckedAt(UInt_t idx)
244	loizides	1.1	{
245			// Return entry at given index.
246
247	loizides	1.8	return static_cast<ArrayElement*>(GetObject(idx));
248	loizides	1.1	}
249
250	bendavid	1.7	//--------------------------------------------------------------------------------------------------
251	bendavid	1.15	template<class ArrayElement>
252			inline const ArrayElement *mithep::RefArray<ArrayElement>::UncheckedAt(UInt_t idx) const
253	bendavid	1.7	{
254	loizides	1.8	// Return entry at given index.
255
256			return static_cast<const ArrayElement*>(GetObject(idx));
257	loizides	1.1	}
258
259			//--------------------------------------------------------------------------------------------------
260	bendavid	1.15	template<class ArrayElement>
261			inline const ArrayElement *mithep::RefArray<ArrayElement>::operator[](UInt_t idx) const
262	loizides	1.1	{
263			// Return entry at given index.
264
265	loizides	1.8	return At(idx);
266	loizides	1.1	}
267
268			//--------------------------------------------------------------------------------------------------
269	bendavid	1.15	template<class ArrayElement>
270			inline ArrayElement *mithep::RefArray<ArrayElement>::operator[](UInt_t idx)
271	loizides	1.1	{
272			// Return entry at given index.
273
274	loizides	1.8	return At(idx);
275	loizides	1.1	}
276			#endif