[u/mrichter/AliRoot.git] / STEER / AliDCSArray.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * 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.                  *
 **************************************************************************/

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
// This class represents the value(s) of a the LHC DPs at a given timestamp   //
// The variuos measurement that occurred at the same timestamp are associated //
// to the same timestamp.                                                     //  
//                                                                            //
////////////////////////////////////////////////////////////////////////////////


#include "AliDCSArray.h"

#include "TTimeStamp.h"
#include <TString.h>

ClassImp(AliDCSArray)
	
AliDCSArray::AliDCSArray() :
		TObject(),
		fType(kInvalid),
		fnentries(0),
		fBool(0x0),
		fChar(0x0),
		fInt(0x0),
		fUInt(0x0),
		fFloat(0x0),
		fString(0x0),
		fTimeStamp(0)
{
	//
	// default constructor
	//
}

//--------------------------------------------------------------------------
AliDCSArray::AliDCSArray(Int_t nentries, Bool_t* value, TTimeStamp* timeStamp) : 
	TObject(),
	fType(kBool),
	fnentries(nentries),
	fBool(new Bool_t[fnentries]),
	fChar(0x0),
	fInt(0x0),
	fUInt(0x0),
	fFloat(0x0),
	fString(0x0),
	fTimeStamp(timeStamp)
{
	//
	// constructor for Bool
	//
	
	for (Int_t i = 0; i<fnentries; i++){
		fBool[i] = value[i];
	}
}

//--------------------------------------------------------------------------
AliDCSArray::AliDCSArray(Int_t nentries, Char_t* value, TTimeStamp* timeStamp) :
	TObject(),
	fType(kChar),
	fnentries(nentries),
	fBool(0x0),
	fChar(new Char_t[fnentries]),
	fInt(0x0),
	fUInt(0x0),
	fFloat(0x0),
	fString(0x0),
	fTimeStamp(timeStamp)
{
	//
	// constructor for Char
	//
	for (Int_t i = 0; i<fnentries; i++){
		fChar[i] = value[i];
	}
}

//-------------------------------------------------------------------------
AliDCSArray::AliDCSArray(Int_t nentries, Int_t* value, TTimeStamp* timeStamp) :
	TObject(),
	fType(kInt),
	fnentries(nentries),
	fBool(0x0),
	fChar(0x0),
	fInt(new Int_t[fnentries]),
	fUInt(0x0),
	fFloat(0x0),
	fString(0x0),
	fTimeStamp(timeStamp)
{
	//
	// constructor for Int
	//
	for (Int_t i = 0; i<fnentries; i++){
		fInt[i] = value[i];
	}
}

//-------------------------------------------------------------------------
AliDCSArray::AliDCSArray(Int_t nentries, UInt_t* value, TTimeStamp* timeStamp) :
	TObject(),
	fType(kUInt),
	fnentries(nentries),
	fBool(0x0),
	fChar(0x0),
	fInt(0x0),
	fUInt(new UInt_t[fnentries]),
	fFloat(0x0),
	fString(0x0),
	fTimeStamp(timeStamp)
{
	//
	// constructor for UInt
	//

	for (Int_t i = 0; i<fnentries; i++){
		fUInt[i] = value[i];
	}
}

//-------------------------------------------------------------------------
AliDCSArray::AliDCSArray(Int_t nentries, Float_t* value, TTimeStamp* timeStamp) :
	TObject(),
	fType(kFloat),
	fnentries(nentries),
	fBool(0x0),
	fChar(0x0),
	fInt(0x0),
	fUInt(0x0),
	fFloat(new Float_t[fnentries]),
	fString(0x0),
	fTimeStamp(timeStamp)
{
	//
	// constructor for Float
	//

	for (Int_t i = 0; i<fnentries; i++){
		fFloat[i] = value[i];
	}
}

//------------------------------------------------------------------------
AliDCSArray::AliDCSArray(Int_t nentries, TString* value, TTimeStamp* timeStamp) :
	TObject(),
	fType(kString),
	fnentries(nentries),
	fBool(0x0),
	fChar(0x0),
	fInt(0x0),
	fUInt(0x0),
	fFloat(0x0),
	fString(new TString[fnentries]),
	fTimeStamp(timeStamp)
{
	//
	// constructor for String
	//

	for (Int_t i = 0; i<fnentries; i++){
		fString[i] = value[i];
	}
}

//-----------------------------------------------------------------------
AliDCSArray::AliDCSArray(const AliDCSArray& c) :
	TObject(c),
	fType(c.fType),
	fnentries(c.fnentries),
	fBool(0x0),
	fChar(0x0),
	fInt(0x0),
	fUInt(0x0),
	fFloat(0x0),
	fString(0x0),
	fTimeStamp(c.fTimeStamp)
{
	//
	// copy constructor
	//
	
	if (fType == kBool && c.fBool){
		fBool = new Bool_t[fnentries];
		memcpy(fBool,c.fBool,fnentries*sizeof(Bool_t));
	} 
	if (fType == kChar && c.fChar){
		fChar = new Char_t[fnentries];
		memcpy(fChar,c.fChar,fnentries*sizeof(Char_t));
	} 
 	if (fType == kUInt && c.fUInt){
		fUInt = new UInt_t[fnentries];
		memcpy(fUInt,c.fUInt,fnentries*sizeof(UInt_t));
	} 
 	if (fType == kInt && c.fInt){
		fInt = new Int_t[fnentries];
		memcpy(fInt,c.fInt,fnentries*sizeof(Int_t));
	} 
 	if (fType == kFloat && c.fFloat){
		fFloat = new Float_t[fnentries];
		memcpy(fFloat,c.fFloat,fnentries*sizeof(Float_t));
	} 
 	if (fType == kString && c.fString){
		fString = new TString[fnentries];
		memcpy(fString,c.fString,fnentries*sizeof(TString));
	} 

}

//-----------------------------------------------------------------------
AliDCSArray::~AliDCSArray()
{
	//
	// destructor
	//

	if (fBool){
		fBool = 0x0;
		delete fBool;
	}
	if (fChar){
		fChar = 0x0;
		delete fChar;
	}
	if (fUInt){
		fUInt = 0x0;
		delete fUInt;
	}
	if (fInt){
		fInt = 0x0;
		delete fInt;
	}
	if (fFloat){
		fFloat = 0x0;
		delete fFloat;
	}
	if (fString){
		fString = 0x0;
		delete fString;
	}
	if (fTimeStamp){
		fTimeStamp = 0x0;
		delete fTimeStamp;
	}
}

//-----------------------------------------------------------------------
AliDCSArray &AliDCSArray::operator=(const AliDCSArray &c)
{
	//
	// operator = 
	//
	
	if(&c == this) return *this;
	if (fType == kBool && c.fBool){
		fBool = new Bool_t[fnentries];
		memcpy(fBool,c.fBool,fnentries*sizeof(Bool_t));
	} 
	if (fType == kChar && c.fChar){
		fChar = new Char_t[fnentries];
		memcpy(fChar,c.fChar,fnentries*sizeof(Char_t));
	} 
 	if (fType == kUInt && c.fUInt){
		fUInt = new UInt_t[fnentries];
		memcpy(fUInt,c.fUInt,fnentries*sizeof(UInt_t));
	} 
 	if (fType == kInt && c.fInt){
		fInt = new Int_t[fnentries];
		memcpy(fInt,c.fInt,fnentries*sizeof(Int_t));
	} 
 	if (fType == kFloat && c.fFloat){
		fFloat = new Float_t[fnentries];
		memcpy(fFloat,c.fFloat,fnentries*sizeof(Float_t));
	} 
 	if (fType == kString && c.fString){
		fString = new TString[fnentries];
		memcpy(fString,c.fString,fnentries*sizeof(TString));
	} 
	
	return *this;
}

//-----------------------------------------------------------------------
void AliDCSArray::Init()
{
	//
	// init helper, that initializes everything to 0
	//
	
	fType = kInvalid;
	
	fnentries = 0;
	fBool = 0x0;
	fChar = 0x0;
	fInt = 0x0;
	fUInt = 0x0;
	fFloat = 0x0;
	fString = 0x0;
	
	fTimeStamp = 0x0;
}
Commit	Line	Data
d96c6484	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	////////////////////////////////////////////////////////////////////////////////
	17	// //
	18	// This class represents the value(s) of a the LHC DPs at a given timestamp //
	19	// The variuos measurement that occurred at the same timestamp are associated //
	20	// to the same timestamp. //
	21	// //
	22	////////////////////////////////////////////////////////////////////////////////
	23
	24
	25	#include "AliDCSArray.h"
	26
	27	#include "TTimeStamp.h"
	28	#include <TString.h>
	29
	30	ClassImp(AliDCSArray)
	31
	32	AliDCSArray::AliDCSArray() :
	33	TObject(),
	34	fType(kInvalid),
	35	fnentries(0),
	36	fBool(0x0),
	37	fChar(0x0),
	38	fInt(0x0),
	39	fUInt(0x0),
	40	fFloat(0x0),
	41	fString(0x0),
	42	fTimeStamp(0)
	43	{
	44	//
	45	// default constructor
	46	//
	47	}
	48
	49	//--------------------------------------------------------------------------
	50	AliDCSArray::AliDCSArray(Int_t nentries, Bool_t* value, TTimeStamp* timeStamp) :
	51	TObject(),
	52	fType(kBool),
	53	fnentries(nentries),
	54	fBool(new Bool_t[fnentries]),
	55	fChar(0x0),
	56	fInt(0x0),
	57	fUInt(0x0),
	58	fFloat(0x0),
	59	fString(0x0),
	60	fTimeStamp(timeStamp)
	61	{
	62	//
	63	// constructor for Bool
	64	//
65
66	for (Int_t i = 0; i<fnentries; i++){
67	fBool[i] = value[i];
68	}
69	}
70
71	//--------------------------------------------------------------------------
72	AliDCSArray::AliDCSArray(Int_t nentries, Char_t* value, TTimeStamp* timeStamp) :
73	TObject(),
74	fType(kChar),
75	fnentries(nentries),
76	fBool(0x0),
77	fChar(new Char_t[fnentries]),
78	fInt(0x0),
79	fUInt(0x0),
80	fFloat(0x0),
81	fString(0x0),
82	fTimeStamp(timeStamp)
83	{
84	//
85	// constructor for Char
86	//
87	for (Int_t i = 0; i<fnentries; i++){
88	fChar[i] = value[i];
89	}
90	}
91
92	//-------------------------------------------------------------------------
93	AliDCSArray::AliDCSArray(Int_t nentries, Int_t* value, TTimeStamp* timeStamp) :
94	TObject(),
95	fType(kInt),
96	fnentries(nentries),
97	fBool(0x0),
98	fChar(0x0),
99	fInt(new Int_t[fnentries]),
100	fUInt(0x0),
101	fFloat(0x0),
102	fString(0x0),
103	fTimeStamp(timeStamp)
104	{
105	//
106	// constructor for Int
107	//
108	for (Int_t i = 0; i<fnentries; i++){
109	fInt[i] = value[i];
110	}
111	}
112
113	//-------------------------------------------------------------------------
114	AliDCSArray::AliDCSArray(Int_t nentries, UInt_t* value, TTimeStamp* timeStamp) :
115	TObject(),
116	fType(kUInt),
117	fnentries(nentries),
118	fBool(0x0),
119	fChar(0x0),
120	fInt(0x0),
121	fUInt(new UInt_t[fnentries]),
122	fFloat(0x0),
123	fString(0x0),
124	fTimeStamp(timeStamp)
125	{
126	//
127	// constructor for UInt
128	//
129
130	for (Int_t i = 0; i<fnentries; i++){
131	fUInt[i] = value[i];
132	}
133	}
134
135	//-------------------------------------------------------------------------
136	AliDCSArray::AliDCSArray(Int_t nentries, Float_t* value, TTimeStamp* timeStamp) :
137	TObject(),
138	fType(kFloat),
139	fnentries(nentries),
140	fBool(0x0),
141	fChar(0x0),
142	fInt(0x0),
143	fUInt(0x0),
144	fFloat(new Float_t[fnentries]),
145	fString(0x0),
146	fTimeStamp(timeStamp)
147	{
148	//
149	// constructor for Float
150	//
151
152	for (Int_t i = 0; i<fnentries; i++){
153	fFloat[i] = value[i];
154	}
155	}
156
157	//------------------------------------------------------------------------
158	AliDCSArray::AliDCSArray(Int_t nentries, TString* value, TTimeStamp* timeStamp) :
159	TObject(),
160	fType(kString),
161	fnentries(nentries),
162	fBool(0x0),
163	fChar(0x0),
164	fInt(0x0),
165	fUInt(0x0),
166	fFloat(0x0),
167	fString(new TString[fnentries]),
168	fTimeStamp(timeStamp)
169	{
170	//
171	// constructor for String
172	//
173
174	for (Int_t i = 0; i<fnentries; i++){
175	fString[i] = value[i];
176	}
177	}
178
179	//-----------------------------------------------------------------------
180	AliDCSArray::AliDCSArray(const AliDCSArray& c) :
181	TObject(c),
182	fType(c.fType),
183	fnentries(c.fnentries),
184	fBool(0x0),
185	fChar(0x0),
186	fInt(0x0),
187	fUInt(0x0),
188	fFloat(0x0),
189	fString(0x0),
190	fTimeStamp(c.fTimeStamp)
191	{
192	//
193	// copy constructor
194	//
195
196	if (fType == kBool && c.fBool){
197	fBool = new Bool_t[fnentries];
198	memcpy(fBool,c.fBool,fnentries*sizeof(Bool_t));
199	}
200	if (fType == kChar && c.fChar){
201	fChar = new Char_t[fnentries];
202	memcpy(fChar,c.fChar,fnentries*sizeof(Char_t));
203	}
204	if (fType == kUInt && c.fUInt){
205	fUInt = new UInt_t[fnentries];
206	memcpy(fUInt,c.fUInt,fnentries*sizeof(UInt_t));
207	}
208	if (fType == kInt && c.fInt){
209	fInt = new Int_t[fnentries];
210	memcpy(fInt,c.fInt,fnentries*sizeof(Int_t));
211	}
212	if (fType == kFloat && c.fFloat){
213	fFloat = new Float_t[fnentries];
214	memcpy(fFloat,c.fFloat,fnentries*sizeof(Float_t));
215	}
216	if (fType == kString && c.fString){
217	fString = new TString[fnentries];
218	memcpy(fString,c.fString,fnentries*sizeof(TString));
219	}
220
221	}
222
223	//-----------------------------------------------------------------------
224	AliDCSArray::~AliDCSArray()
225	{
226	//
227	// destructor
228	//
229
230	if (fBool){
231	fBool = 0x0;
232	delete fBool;
233	}
234	if (fChar){
235	fChar = 0x0;
236	delete fChar;
237	}
238	if (fUInt){
239	fUInt = 0x0;
240	delete fUInt;
241	}
242	if (fInt){
243	fInt = 0x0;
244	delete fInt;
245	}
246	if (fFloat){
247	fFloat = 0x0;
248	delete fFloat;
249	}
250	if (fString){
251	fString = 0x0;
252	delete fString;
253	}
254	if (fTimeStamp){
255	fTimeStamp = 0x0;
256	delete fTimeStamp;
257	}
258	}
259
260	//-----------------------------------------------------------------------
261	AliDCSArray &AliDCSArray::operator=(const AliDCSArray &c)
262	{
263	//
264	// operator =
265	//
266
267	if(&c == this) return *this;
268	if (fType == kBool && c.fBool){
269	fBool = new Bool_t[fnentries];
270	memcpy(fBool,c.fBool,fnentries*sizeof(Bool_t));
271	}
272	if (fType == kChar && c.fChar){
273	fChar = new Char_t[fnentries];
274	memcpy(fChar,c.fChar,fnentries*sizeof(Char_t));
275	}
276	if (fType == kUInt && c.fUInt){
277	fUInt = new UInt_t[fnentries];
278	memcpy(fUInt,c.fUInt,fnentries*sizeof(UInt_t));
279	}
280	if (fType == kInt && c.fInt){
281	fInt = new Int_t[fnentries];
282	memcpy(fInt,c.fInt,fnentries*sizeof(Int_t));
283	}
284	if (fType == kFloat && c.fFloat){
285	fFloat = new Float_t[fnentries];
286	memcpy(fFloat,c.fFloat,fnentries*sizeof(Float_t));
287	}
288	if (fType == kString && c.fString){
289	fString = new TString[fnentries];
290	memcpy(fString,c.fString,fnentries*sizeof(TString));
291	}
292
293	return *this;
294	}
295
296	//-----------------------------------------------------------------------
297	void AliDCSArray::Init()
298	{
299	//
300	// init helper, that initializes everything to 0
301	//
302
303	fType = kInvalid;
304
305	fnentries = 0;
306	fBool = 0x0;
307	fChar = 0x0;
308	fInt = 0x0;
309	fUInt = 0x0;
310	fFloat = 0x0;
311	fString = 0x0;
312
313	fTimeStamp = 0x0;
314	}