[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTScalars.cxx

// $Id: $
/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        *
 * All rights reserved.                                                   *
 *                                                                        *
 * Primary Authors:                                                       *
 *   Artur Szostak <artursz@iafrica.com>                                  *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

///  @file   AliHLTScalars.cxx
///  @author Artur Szostak <artursz@iafrica.com>
///  @date   28 Sep 2010
///  @brief  Implementation of the HLT scalars class.
///
/// This implements the scalars class for the HLT, which is a collection of
/// named scalar values. Searching for a named scalar is optimised by using
/// using a hash map.

#include "AliHLTScalars.h"
#include "TString.h"
#include "AliLog.h"
#include "TIterator.h"
#include "Riostream.h"
#include <cassert>

ClassImp(AliHLTScalars);
ClassImp(AliHLTScalars::AliScalar);


AliHLTScalars::AliHLTScalars() :
	TObject(),
	fScalars(AliHLTScalars::AliScalar::Class(), 128),
	fMap(TCollection::kInitHashTableCapacity, 2)
{
	// Default constructor.
	
	fMap.SetOwner(kFALSE);
}


AliHLTScalars::AliHLTScalars(const AliHLTScalars& obj) :
	TObject(obj),
	fScalars(obj.fScalars),
	fMap(obj.fMap.GetSize(), obj.fMap.GetRehashLevel())
{
	// Copy constructor performs a deep copy.

	fMap.SetOwner(kFALSE);
	fMap.AddAll(&fScalars);
}


AliHLTScalars::AliHLTScalars(const TClass* cl, Int_t initSize) :
	TObject(),
	fScalars(cl, initSize),
	fMap(TCollection::kInitHashTableCapacity, 2)
{
	// Constructor to be able to specify a custom class for the fScalars TClonesArray object.

	fMap.SetOwner(kFALSE);
}


AliHLTScalars::~AliHLTScalars()
{
	// Default destructor.
	
	Clear();
}


bool AliHLTScalars::Add(const char* name, const char* description, Double_t value)
{
	// Adds a new scalar.

	AliScalar* scalar = static_cast<AliScalar*>( fMap.FindObject(name) );
	bool exists = scalar != NULL;
	if (not exists)
	{
		scalar = new (fScalars[fScalars.GetEntriesFast()]) AliScalar(name, description, value);
		fMap.Add(scalar);
	}
	else
	{
		scalar->Value(value);
	}
	return exists;
}


bool AliHLTScalars::Remove(const char* name)
{
	// Removes a scalar from the list.

	TNamed x(name, "");
	TObject* scalar = fMap.Remove(&x);
	bool existed = scalar != NULL;
	if (existed)
	{
		fScalars.Remove(scalar);
		fScalars.Compress();
	}
	return existed;
}


const AliHLTScalars::AliScalar& AliHLTScalars::GetScalar(const char* name) const
{
	// Fetch the named scalar object.

	const TObject* scalar = fMap.FindObject(name);
	if (scalar != NULL)
	{
		return *static_cast<const AliScalar*>(scalar);
	}
	else
	{
		static AliHLTScalars::AliScalar sentinel;
		return sentinel;
	}
}


AliHLTScalars::AliScalar& AliHLTScalars::GetScalar(const char* name)
{
	// Fetch the named scalar object for editing.

	TObject* scalar = fMap.FindObject(name);
	if (scalar == NULL)
	{
		scalar = new (fScalars[fScalars.GetEntriesFast()]) AliScalar(name, "", 0);
		fMap.Add(scalar);
	}
	return *static_cast<AliScalar*>(scalar);
}


const AliHLTScalars::AliScalar& AliHLTScalars::GetScalarN(UInt_t n) const
{
	// Fetch the n'th scalar object.

	if (n < NumberOfScalars())
	{
		const TObject* scalar = fScalars.UncheckedAt(Int_t(n));
		return *static_cast<const AliScalar*>(scalar);
	}
	else
	{
		static AliHLTScalars::AliScalar sentinel;
		return sentinel;
	}
}


AliHLTScalars::AliScalar& AliHLTScalars::GetScalarN(UInt_t n)
{
	// Fetch the n'th scalar object for editing.

	TObject* scalar = NULL;
	if (n < NumberOfScalars())
	{
		scalar = fScalars.UncheckedAt(Int_t(n));
	}
	else
	{
		// We have to create all missing scalars since there cannot
		// be gaps in the TClonesArray. This can cause segfaults during
		// ROOT I/O of the class otherwise.
		for (UInt_t i = NumberOfScalars(); i <= n; ++i)
		{
			// Make sure the the name of the scalar is not taken.
			// If it is then find an unused name.
			TString nameToUse = Form("Scalar%d", i);
			if (FindObject(nameToUse.Data()) != NULL)
			{
				UInt_t m = 0;
				do
				{
					nameToUse = Form("Scalar%d_%d", i, m++);
				}
				while (FindObject(nameToUse.Data()) != NULL);
			}
			scalar = new (fScalars[i]) AliScalar(nameToUse.Data(), "", 0);
			fMap.Add(scalar);
		}
	}
	return *static_cast<AliScalar*>(scalar);
}


void AliHLTScalars::Reset()
{
	// Sets all the scalar values and rates to zero.
	
	for (Int_t i = 0; i < fScalars.GetEntriesFast(); ++i)
	{
		AliScalar* scalar = static_cast<AliScalar*>( fScalars.UncheckedAt(i) );
		scalar->Value(0);
	}
}


void AliHLTScalars::Clear(Option_t* option)
{
	// Clears the array of scalars.

	fMap.Clear();
	fScalars.Delete(option);
}


void AliHLTScalars::Copy(TObject& object) const
{
	// Performs a deep copy.
	
	if (object.IsA() != AliHLTScalars::Class())
	{
		AliError(Form("Cannot copy to an object of type '%s'.", object.ClassName()));
		return;
	}
	AliHLTScalars* obj = static_cast<AliHLTScalars*>(&object);
	obj->operator = (*this);
}


void AliHLTScalars::Print(Option_t* option) const
{
	// Prints the HLT trigger scalars.

	TIter next(&fScalars);
	const AliScalar* scalar = NULL;

	TString opt = option;
	if (opt == "compact")
	{
		scalar = static_cast<const AliScalar*>(next());
		if (scalar != NULL) cout << scalar->Value();
		while ((scalar = static_cast<const AliScalar*>(next())) != NULL)
		{
			cout << ", " << scalar->Value();
		}
		cout << endl;
		return;
	}
	
	// Calculate the maximum field width required to keep things aligned.
	int fieldwidth = 0;
	while ((scalar = static_cast<const AliScalar*>(next())) != NULL)
	{
		int length = strlen(scalar->Name()) + strlen(scalar->Description()) + 3;
		if (length > fieldwidth) fieldwidth = length;
	}
	if (fieldwidth > 80) fieldwidth = 80;
	
	cout << "HLT scalars:" << endl;
	next.Reset();
	while ((scalar = static_cast<const AliScalar*>(next())) != NULL)
	{
		TString str = scalar->Description();
		str += " (";
		str += scalar->Name();
		str += ")";
		cout << setw(fieldwidth) << str.Data() << setw(0)
		     << " = " << scalar->Value() << setw(0)
		     << endl;
	}
	if (fScalars.GetSize() == 0) cout << "(none)" << endl;
}


AliHLTScalars& AliHLTScalars::operator = (const AliHLTScalars& obj)
{
	// Performs a deep copy.
	
	if (this == &obj) return *this;
	Clear();  // Remove existing scalars.
	TObject::operator = (obj);
	for (Int_t i = 0; i < obj.fScalars.GetEntriesFast(); ++i)
	{
		const AliScalar* x = static_cast<const AliScalar*>(obj.fScalars.UncheckedAt(i));
		new (fScalars[i]) AliScalar(*x);
	}
	fMap.AddAll(&fScalars);
	return *this;
}


Bool_t AliHLTScalars::IsEqual(const TObject *obj) const
{
	// Checks if two sets of scalar lists have the same scalars.

	assert(obj != NULL);
	if (obj->IsA()->GetBaseClass(AliHLTScalars::Class()) == NULL)
	{
		AliError(Form("Cannot compare object of type '%s'' with an object of type '%s'.",
			      this->ClassName(), obj->ClassName()
			));
		return kFALSE;
	}
	const AliHLTScalars* rhs = static_cast<const AliHLTScalars*>(obj);
	if (fScalars.GetEntriesFast() != rhs->fScalars.GetEntriesFast()) return kFALSE;
	TIter next(&fScalars);
	const AliScalar* scalar = NULL;
	while ((scalar = static_cast<const AliScalar*>(next())) != NULL)
	{
		if (rhs->fScalars.FindObject(scalar->Name()) == NULL) return kFALSE;
	}
	return kTRUE;
}


bool AliHLTScalars::operator == (const AliHLTScalars& obj) const
{
	// Compares two scalar lists to see that they have the same scalar values.

	if (fScalars.GetEntriesFast() != obj.fScalars.GetEntriesFast()) return false;
	TIter next(&fScalars);
	const AliScalar* a = NULL;
	while ((a = static_cast<const AliScalar*>(next())) != NULL)
	{
		const AliScalar* b = static_cast<const AliScalar*>(
				obj.fScalars.FindObject(a->Name())
			);
		if (b == NULL) return false;
		if (a->Value() != b->Value()) return false;
	}
	return true;
}


void AliHLTScalars::AliScalar::Copy(TObject& object) const
{
	// Performs a deep copy.
	
	if (object.IsA() != AliHLTScalars::AliScalar::Class())
	{
		AliError(Form("Cannot copy to an object of type '%s'.", object.ClassName()));
		return;
	}
	AliHLTScalars::AliScalar* obj = static_cast<AliHLTScalars::AliScalar*>(&object);
	*obj = *this;
}
Commit	Line	Data
9cb24db9	1	// $Id: $
	2	/**************************************************************************
	3	* This file is property of and copyright by the ALICE HLT Project *
	4	* All rights reserved. *
	5	* *
	6	* Primary Authors: *
	7	* Artur Szostak <artursz@iafrica.com> *
	8	* *
	9	* Permission to use, copy, modify and distribute this software and its *
	10	* documentation strictly for non-commercial purposes is hereby granted *
	11	* without fee, provided that the above copyright notice appears in all *
	12	* copies and that both the copyright notice and this permission notice *
	13	* appear in the supporting documentation. The authors make no claims *
	14	* about the suitability of this software for any purpose. It is *
	15	* provided "as is" without express or implied warranty. *
	16	**************************************************************************/
	17
	18	/// @file AliHLTScalars.cxx
	19	/// @author Artur Szostak <artursz@iafrica.com>
	20	/// @date 28 Sep 2010
	21	/// @brief Implementation of the HLT scalars class.
	22	///
	23	/// This implements the scalars class for the HLT, which is a collection of
	24	/// named scalar values. Searching for a named scalar is optimised by using
	25	/// using a hash map.
	26
	27	#include "AliHLTScalars.h"
	28	#include "TString.h"
	29	#include "AliLog.h"
	30	#include "TIterator.h"
	31	#include "Riostream.h"
	32	#include <cassert>
	33
	34	ClassImp(AliHLTScalars);
	35	ClassImp(AliHLTScalars::AliScalar);
	36
	37
	38	AliHLTScalars::AliHLTScalars() :
	39	TObject(),
	40	fScalars(AliHLTScalars::AliScalar::Class(), 128),
	41	fMap(TCollection::kInitHashTableCapacity, 2)
	42	{
	43	// Default constructor.
	44
	45	fMap.SetOwner(kFALSE);
	46	}
	47
	48
	49	AliHLTScalars::AliHLTScalars(const AliHLTScalars& obj) :
	50	TObject(obj),
	51	fScalars(obj.fScalars),
	52	fMap(obj.fMap.GetSize(), obj.fMap.GetRehashLevel())
	53	{
	54	// Copy constructor performs a deep copy.
	55
	56	fMap.SetOwner(kFALSE);
	57	fMap.AddAll(&fScalars);
	58	}
	59
	60
	61	AliHLTScalars::AliHLTScalars(const TClass* cl, Int_t initSize) :
	62	TObject(),
	63	fScalars(cl, initSize),
	64	fMap(TCollection::kInitHashTableCapacity, 2)
65	{
66	// Constructor to be able to specify a custom class for the fScalars TClonesArray object.
67
68	fMap.SetOwner(kFALSE);
69	}
70
71
72	AliHLTScalars::~AliHLTScalars()
73	{
74	// Default destructor.
75
76	Clear();
77	}
78
79
80	bool AliHLTScalars::Add(const char* name, const char* description, Double_t value)
81	{
82	// Adds a new scalar.
83
84	AliScalar* scalar = static_cast<AliScalar*>( fMap.FindObject(name) );
85	bool exists = scalar != NULL;
86	if (not exists)
87	{
88	scalar = new (fScalars[fScalars.GetEntriesFast()]) AliScalar(name, description, value);
89	fMap.Add(scalar);
90	}
91	else
92	{
93	scalar->Value(value);
94	}
95	return exists;
96	}
97
98
99	bool AliHLTScalars::Remove(const char* name)
100	{
101	// Removes a scalar from the list.
102
103	TNamed x(name, "");
104	TObject* scalar = fMap.Remove(&x);
105	bool existed = scalar != NULL;
106	if (existed)
107	{
108	fScalars.Remove(scalar);
109	fScalars.Compress();
110	}
111	return existed;
112	}
113
114
115	const AliHLTScalars::AliScalar& AliHLTScalars::GetScalar(const char* name) const
116	{
117	// Fetch the named scalar object.
118
119	const TObject* scalar = fMap.FindObject(name);
120	if (scalar != NULL)
121	{
122	return static_cast<const AliScalar>(scalar);
123	}
124	else
125	{
126	static AliHLTScalars::AliScalar sentinel;
127	return sentinel;
128	}
129	}
130
131
132	AliHLTScalars::AliScalar& AliHLTScalars::GetScalar(const char* name)
133	{
134	// Fetch the named scalar object for editing.
135
136	TObject* scalar = fMap.FindObject(name);
137	if (scalar == NULL)
138	{
139	scalar = new (fScalars[fScalars.GetEntriesFast()]) AliScalar(name, "", 0);
140	fMap.Add(scalar);
141	}
142	return static_cast<AliScalar>(scalar);
143	}
144
145
146	const AliHLTScalars::AliScalar& AliHLTScalars::GetScalarN(UInt_t n) const
147	{
148	// Fetch the n'th scalar object.
149
150	if (n < NumberOfScalars())
151	{
152	const TObject* scalar = fScalars.UncheckedAt(Int_t(n));
153	return static_cast<const AliScalar>(scalar);
154	}
155	else
156	{
157	static AliHLTScalars::AliScalar sentinel;
158	return sentinel;
159	}
160	}
161
162
163	AliHLTScalars::AliScalar& AliHLTScalars::GetScalarN(UInt_t n)
164	{
165	// Fetch the n'th scalar object for editing.
166
167	TObject* scalar = NULL;
168	if (n < NumberOfScalars())
169	{
170	scalar = fScalars.UncheckedAt(Int_t(n));
171	}
172	else
173	{
174	// We have to create all missing scalars since there cannot
175	// be gaps in the TClonesArray. This can cause segfaults during
176	// ROOT I/O of the class otherwise.
177	for (UInt_t i = NumberOfScalars(); i <= n; ++i)
178	{
179	// Make sure the the name of the scalar is not taken.
180	// If it is then find an unused name.
181	TString nameToUse = Form("Scalar%d", i);
182	if (FindObject(nameToUse.Data()) != NULL)
183	{
184	UInt_t m = 0;
185	do
186	{
187	nameToUse = Form("Scalar%d_%d", i, m++);
188	}
189	while (FindObject(nameToUse.Data()) != NULL);
190	}
191	scalar = new (fScalars[i]) AliScalar(nameToUse.Data(), "", 0);
192	fMap.Add(scalar);
193	}
194	}
195	return static_cast<AliScalar>(scalar);
196	}
197
198
199	void AliHLTScalars::Reset()
200	{
201	// Sets all the scalar values and rates to zero.
202
203	for (Int_t i = 0; i < fScalars.GetEntriesFast(); ++i)
204	{
205	AliScalar* scalar = static_cast<AliScalar*>( fScalars.UncheckedAt(i) );
206	scalar->Value(0);
207	}
208	}
209
210
211	void AliHLTScalars::Clear(Option_t* option)
212	{
213	// Clears the array of scalars.
214
215	fMap.Clear();
216	fScalars.Delete(option);
217	}
218
219
220	void AliHLTScalars::Copy(TObject& object) const
221	{
222	// Performs a deep copy.
223
224	if (object.IsA() != AliHLTScalars::Class())
225	{
226	AliError(Form("Cannot copy to an object of type '%s'.", object.ClassName()));
227	return;
228	}
229	AliHLTScalars* obj = static_cast<AliHLTScalars*>(&object);
230	obj->operator = (*this);
231	}
232
233
234	void AliHLTScalars::Print(Option_t* option) const
235	{
236	// Prints the HLT trigger scalars.
237
238	TIter next(&fScalars);
239	const AliScalar* scalar = NULL;
240
241	TString opt = option;
242	if (opt == "compact")
243	{
244	scalar = static_cast<const AliScalar*>(next());
245	if (scalar != NULL) cout << scalar->Value();
246	while ((scalar = static_cast<const AliScalar*>(next())) != NULL)
247	{
248	cout << ", " << scalar->Value();
249	}
250	cout << endl;
251	return;
252	}
253
254	// Calculate the maximum field width required to keep things aligned.
255	int fieldwidth = 0;
256	while ((scalar = static_cast<const AliScalar*>(next())) != NULL)
257	{
258	int length = strlen(scalar->Name()) + strlen(scalar->Description()) + 3;
259	if (length > fieldwidth) fieldwidth = length;
260	}
261	if (fieldwidth > 80) fieldwidth = 80;
262
263	cout << "HLT scalars:" << endl;
264	next.Reset();
265	while ((scalar = static_cast<const AliScalar*>(next())) != NULL)
266	{
267	TString str = scalar->Description();
268	str += " (";
269	str += scalar->Name();
270	str += ")";
271	cout << setw(fieldwidth) << str.Data() << setw(0)
272	<< " = " << scalar->Value() << setw(0)
273	<< endl;
274	}
275	if (fScalars.GetSize() == 0) cout << "(none)" << endl;
276	}
277
278
279	AliHLTScalars& AliHLTScalars::operator = (const AliHLTScalars& obj)
280	{
281	// Performs a deep copy.
282
283	if (this == &obj) return *this;
284	Clear(); // Remove existing scalars.
285	TObject::operator = (obj);
286	for (Int_t i = 0; i < obj.fScalars.GetEntriesFast(); ++i)
287	{
288	const AliScalar* x = static_cast<const AliScalar*>(obj.fScalars.UncheckedAt(i));
289	new (fScalars[i]) AliScalar(*x);
290	}
291	fMap.AddAll(&fScalars);
292	return *this;
293	}
294
295
296	Bool_t AliHLTScalars::IsEqual(const TObject *obj) const
297	{
298	// Checks if two sets of scalar lists have the same scalars.
299
300	assert(obj != NULL);
301	if (obj->IsA()->GetBaseClass(AliHLTScalars::Class()) == NULL)
302	{
303	AliError(Form("Cannot compare object of type '%s'' with an object of type '%s'.",
304	this->ClassName(), obj->ClassName()
305	));
306	return kFALSE;
307	}
308	const AliHLTScalars* rhs = static_cast<const AliHLTScalars*>(obj);
309	if (fScalars.GetEntriesFast() != rhs->fScalars.GetEntriesFast()) return kFALSE;
310	TIter next(&fScalars);
311	const AliScalar* scalar = NULL;
312	while ((scalar = static_cast<const AliScalar*>(next())) != NULL)
313	{
314	if (rhs->fScalars.FindObject(scalar->Name()) == NULL) return kFALSE;
315	}
316	return kTRUE;
317	}
318
319
320	bool AliHLTScalars::operator == (const AliHLTScalars& obj) const
321	{
322	// Compares two scalar lists to see that they have the same scalar values.
323
324	if (fScalars.GetEntriesFast() != obj.fScalars.GetEntriesFast()) return false;
325	TIter next(&fScalars);
326	const AliScalar* a = NULL;
327	while ((a = static_cast<const AliScalar*>(next())) != NULL)
328	{
329	const AliScalar* b = static_cast<const AliScalar*>(
330	obj.fScalars.FindObject(a->Name())
331	);
332	if (b == NULL) return false;
333	if (a->Value() != b->Value()) return false;
334	}
335	return true;
336	}
337
338
339	void AliHLTScalars::AliScalar::Copy(TObject& object) const
340	{
341	// Performs a deep copy.
342
343	if (object.IsA() != AliHLTScalars::AliScalar::Class())
344	{
345	AliError(Form("Cannot copy to an object of type '%s'.", object.ClassName()));
346	return;
347	}
348	AliHLTScalars::AliScalar* obj = static_cast<AliHLTScalars::AliScalar*>(&object);
349	obj = this;
350	}