DataCont/interface/Ref.h

//--------------------------------------------------------------------------------------------------
// $Id: Ref.h,v 1.7 2010/09/19 23:46:08 bendavid Exp $
//
// Ref
//
// Templated implementation of our own TRef.
//
// Authors: J.Bendavid
//--------------------------------------------------------------------------------------------------

#ifndef MITANA_DATACONT_REF_H
#define MITANA_DATACONT_REF_H

#include <TObject.h>
#include <TRefTable.h>
#include <TProcessID.h>
#include <TError.h>
#include "MitAna/DataCont/interface/RefResolver.h"
#include "MitAna/DataCont/interface/ProcIDRef.h"
 
namespace mithep 
{
  template<class ArrayElement>
  class Ref
  {
    public:
      Ref() : fPID(0), fUID(0)    {}
      Ref(const ArrayElement *ae) { SetObject(ae); }
      virtual ~Ref()              {}

      Bool_t                       IsNull()        const { return fUID==0 ? kTRUE : kFALSE; }
      Bool_t                       IsValid()       const { return !IsNull();                }
      const ArrayElement          *Obj()           const;
      ArrayElement                *Obj();
      Bool_t                       RefsObject(const ArrayElement *ae) const;
      void                         SetObject(const ArrayElement *ae);
      
      void                         operator= (const ArrayElement *ae) { SetObject(ae);         }
      Bool_t                       operator==(const ArrayElement *ae) { return RefsObject(ae); }

    protected:
      TObject                     *GetObject()     const;

      ProcIDRef                    fPID;     //||process id corresponding to referenced object
      UInt_t                       fUID;     //unique id of the referenced object

    ClassDef(Ref, 1) // Templated implementation of our own TRef
  };
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
TObject *mithep::Ref<ArrayElement>::GetObject() const
{
  // Return pointer to object. Code adapted from TRef::GetObject().

  if (IsNull())
    return 0;
  
  TProcessID *pid = fPID.Pid(); 
  if (!pid) {
    Fatal("GetObject","Process id pointer is null!");
    return 0;
  }

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

  TObject *obj = RefResolver::GetObjectWithID(fUID,pid);
  if (!obj) {
    Fatal("Ref::GetObject","Null pointer for valid ref!");
  }
  
  return obj;
}

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

  return reinterpret_cast<const ArrayElement*>(GetObject());
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
ArrayElement *mithep::Ref<ArrayElement>::Obj()
{
  // Return entry at given index. Code adapted from TRef::GetObject().

  return reinterpret_cast<ArrayElement*>(GetObject());
}

//--------------------------------------------------------------------------------------------------
template<class ArrayElement>
Bool_t mithep::Ref<ArrayElement>::RefsObject(const ArrayElement *ae) const
{
  // Check whether Ref points to given object.

  if (IsNull())
    return kFALSE;

  const TObject *oe = reinterpret_cast<const TObject*>(ae);
  
  if (!oe->TestBit(kIsReferenced))
    return kFALSE;

  UInt_t oUid = oe->GetUniqueID();
  TProcessID *oPid = TProcessID::GetProcessWithUID(oUid, const_cast<TObject*>(oe));
  if (!oPid)
    return kFALSE;

  if ( (fUID&0xffffff)!=(oUid&0xffffff) || fPID.Pid()->GetUniqueID()!=oPid->GetUniqueID())
    return kFALSE;
  return kTRUE;
}

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

  if (!ae)
    return;

  const TObject *oe = reinterpret_cast<const TObject*>(ae);


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

  if (oe->TestBit(kIsReferenced)) {
    fUID = oe->GetUniqueID();
    fPID.SetPid(TProcessID::GetProcessWithUID(fUID, const_cast<TObject*>(oe)));
  } else {
    fPID.SetPid(TProcessID::GetSessionProcessID());
    fUID = TProcessID::AssignID(const_cast<TObject*>(oe));
  }
}
#endif
Revision:	1.8
Committed:	Wed Jul 25 03:08:40 2012 UTC (12 years, 9 months ago) by paus
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_032, Mit_031, Mit_030, Mit_029c, Mit_029b, Mit_030_pre1, Mit_029a, Mit_029, Mit_029_pre1, HEAD
Changes since 1.7:	+16 -11 lines
Log Message:	Preparing for version 029.
#	User	Rev	Content
1	bendavid	1.1	//--------------------------------------------------------------------------------------------------
2	paus	1.8	// $Id: Ref.h,v 1.7 2010/09/19 23:46:08 bendavid Exp $
3	bendavid	1.1	//
4			// Ref
5			//
6	loizides	1.6	// Templated implementation of our own TRef.
7	bendavid	1.1	//
8			// Authors: J.Bendavid
9			//--------------------------------------------------------------------------------------------------
10
11			#ifndef MITANA_DATACONT_REF_H
12			#define MITANA_DATACONT_REF_H
13
14			#include <TObject.h>
15			#include <TRefTable.h>
16			#include <TProcessID.h>
17			#include <TError.h>
18	loizides	1.3	#include "MitAna/DataCont/interface/RefResolver.h"
19	bendavid	1.1	#include "MitAna/DataCont/interface/ProcIDRef.h"
20
21			namespace mithep
22			{
23			template<class ArrayElement>
24			class Ref
25			{
26			public:
27	loizides	1.3	Ref() : fPID(0), fUID(0) {}
28	bendavid	1.1	Ref(const ArrayElement *ae) { SetObject(ae); }
29	loizides	1.3	virtual ~Ref() {}
30	bendavid	1.1
31			Bool_t IsNull() const { return fUID==0 ? kTRUE : kFALSE; }
32	loizides	1.4	Bool_t IsValid() const { return !IsNull(); }
33	bendavid	1.1	const ArrayElement *Obj() const;
34			ArrayElement *Obj();
35			Bool_t RefsObject(const ArrayElement *ae) const;
36			void SetObject(const ArrayElement *ae);
37
38	loizides	1.4	void operator= (const ArrayElement *ae) { SetObject(ae); }
39	bendavid	1.1	Bool_t operator==(const ArrayElement *ae) { return RefsObject(ae); }
40
41			protected:
42			TObject *GetObject() const;
43
44	loizides	1.3	ProcIDRef fPID; //\|\|process id corresponding to referenced object
45			UInt_t fUID; //unique id of the referenced object
46
47			ClassDef(Ref, 1) // Templated implementation of our own TRef
48	bendavid	1.1	};
49			}
50
51			//--------------------------------------------------------------------------------------------------
52			template<class ArrayElement>
53			TObject *mithep::Ref<ArrayElement>::GetObject() const
54			{
55	loizides	1.3	// Return pointer to object. Code adapted from TRef::GetObject().
56	bendavid	1.1
57			if (IsNull())
58			return 0;
59
60	loizides	1.3	TProcessID *pid = fPID.Pid();
61	bendavid	1.1	if (!pid) {
62			Fatal("GetObject","Process id pointer is null!");
63			return 0;
64			}
65
66			if (!TProcessID::IsValid(pid)) {
67			Fatal("GetObject","Process id is invalid!");
68			return 0;
69			}
70
71	bendavid	1.7	TObject *obj = RefResolver::GetObjectWithID(fUID,pid);
72			if (!obj) {
73			Fatal("Ref::GetObject","Null pointer for valid ref!");
74			}
75
76			return obj;
77	bendavid	1.1	}
78
79			//--------------------------------------------------------------------------------------------------
80			template<class ArrayElement>
81			const ArrayElement *mithep::Ref<ArrayElement>::Obj() const
82			{
83			// Return entry at given index. Code adapted from TRef::GetObject().
84
85	paus	1.8	return reinterpret_cast<const ArrayElement*>(GetObject());
86	bendavid	1.1	}
87
88			//--------------------------------------------------------------------------------------------------
89			template<class ArrayElement>
90			ArrayElement *mithep::Ref<ArrayElement>::Obj()
91			{
92			// Return entry at given index. Code adapted from TRef::GetObject().
93
94	paus	1.8	return reinterpret_cast<ArrayElement*>(GetObject());
95	bendavid	1.1	}
96
97			//--------------------------------------------------------------------------------------------------
98			template<class ArrayElement>
99			Bool_t mithep::Ref<ArrayElement>::RefsObject(const ArrayElement *ae) const
100			{
101	loizides	1.4	// Check whether Ref points to given object.
102	bendavid	1.1
103			if (IsNull())
104			return kFALSE;
105	paus	1.8
106			const TObject oe = reinterpret_cast<const TObject>(ae);
107	bendavid	1.1
108	paus	1.8	if (!oe->TestBit(kIsReferenced))
109	bendavid	1.1	return kFALSE;
110
111	paus	1.8	UInt_t oUid = oe->GetUniqueID();
112			TProcessID oPid = TProcessID::GetProcessWithUID(oUid, const_cast<TObject>(oe));
113	loizides	1.4	if (!oPid)
114			return kFALSE;
115	bendavid	1.1
116	loizides	1.4	if ( (fUID&0xffffff)!=(oUid&0xffffff) \|\| fPID.Pid()->GetUniqueID()!=oPid->GetUniqueID())
117	bendavid	1.1	return kFALSE;
118	loizides	1.4	return kTRUE;
119	bendavid	1.1	}
120
121			//--------------------------------------------------------------------------------------------------
122			template<class ArrayElement>
123			void mithep::Ref<ArrayElement>::SetObject(const ArrayElement *ae)
124			{
125	loizides	1.4	// Set reference to object.
126
127			if (!ae)
128			return;
129	bendavid	1.1
130	paus	1.8	const TObject oe = reinterpret_cast<const TObject>(ae);
131
132
133	bendavid	1.1	// check if the object can belong here and assign or get its uid
134	paus	1.8	if (oe->TestBit(kHasUUID)) {
135	loizides	1.5	Fatal("Add", "Object cannot be added as it has not UUID!");
136	bendavid	1.1	return;
137			}
138
139	paus	1.8	if (oe->TestBit(kIsReferenced)) {
140			fUID = oe->GetUniqueID();
141			fPID.SetPid(TProcessID::GetProcessWithUID(fUID, const_cast<TObject*>(oe)));
142	bendavid	1.1	} else {
143			fPID.SetPid(TProcessID::GetSessionProcessID());
144	paus	1.8	fUID = TProcessID::AssignID(const_cast<TObject*>(oe));
145	bendavid	1.1	}
146			}
147			#endif