ROOT  6.07/01
Reference Guide
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
TArrayL64.cxx
Go to the documentation of this file.
1 // @(#)root/cont:$Id$
2 // Author: Fons Rademakers 20/11/06
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2006, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 /** \class TArrayL64
13 \ingroup Containers
14 Array of long64s (64 bits per element).
15 */
16 
17 #include "TArrayL64.h"
18 #include "TBuffer.h"
19 
20 
22 
23 ////////////////////////////////////////////////////////////////////////////////
24 /// Default TArrayL64 ctor.
25 
27 {
28  fArray = 0;
29 }
30 
31 ////////////////////////////////////////////////////////////////////////////////
32 /// Create TArrayL64 object and set array size to n long64s.
33 
35 {
36  fArray = 0;
37  if (n > 0) Set(n);
38 }
39 
40 ////////////////////////////////////////////////////////////////////////////////
41 /// Create TArrayL object and initialize it with values of array.
42 
44 {
45  fArray = 0;
46  Set(n, array);
47 }
48 
49 ////////////////////////////////////////////////////////////////////////////////
50 /// Copy constructor.
51 
52 TArrayL64::TArrayL64(const TArrayL64 &array) : TArray(array)
53 {
54  fArray = 0;
55  Set(array.fN, array.fArray);
56 }
57 
58 ////////////////////////////////////////////////////////////////////////////////
59 /// TArrayL64 assignment operator.
60 
62 {
63  if (this != &rhs)
64  Set(rhs.fN, rhs.fArray);
65  return *this;
66 }
67 
68 ////////////////////////////////////////////////////////////////////////////////
69 /// Delete TArrayL64 object.
70 
72 {
73  delete [] fArray;
74  fArray = 0;
75 }
76 
77 ////////////////////////////////////////////////////////////////////////////////
78 /// Adopt array arr into TArrayL64, i.e. don't copy arr but use it directly
79 /// in TArrayL64. User may not delete arr, TArrayL64 dtor will do it.
80 
82 {
83  if (fArray)
84  delete [] fArray;
85 
86  fN = n;
87  fArray = arr;
88 }
89 
90 ////////////////////////////////////////////////////////////////////////////////
91 /// Add long64 c at position i. Check for out of bounds.
92 
94 {
95  if (!BoundsOk("TArrayL64::AddAt", i)) return;
96  fArray[i] = c;
97 }
98 
99 ////////////////////////////////////////////////////////////////////////////////
100 /// Set size of this array to n long64s.
101 /// A new array is created, the old contents copied to the new array,
102 /// then the old array is deleted.
103 /// This function should not be called if the array was declared via Adopt.
104 
106 {
107  if (n < 0) return;
108  if (n != fN) {
109  Long64_t *temp = fArray;
110  if (n != 0) {
111  fArray = new Long64_t[n];
112  if (n < fN) memcpy(fArray,temp, n*sizeof(Long64_t));
113  else {
114  memcpy(fArray,temp,fN*sizeof(Long64_t));
115  memset(&fArray[fN],0,(n-fN)*sizeof(Long64_t));
116  }
117  } else {
118  fArray = 0;
119  }
120  if (fN) delete [] temp;
121  fN = n;
122  }
123 }
124 
125 ////////////////////////////////////////////////////////////////////////////////
126 /// Set size of this array to n long64s and set the contents.
127 /// This function should not be called if the array was declared via Adopt.
128 
129 void TArrayL64::Set(Int_t n, const Long64_t *array)
130 {
131  if (fArray && fN != n) {
132  delete [] fArray;
133  fArray = 0;
134  }
135  fN = n;
136  if (fN == 0) return;
137  if (array == 0) return;
138  if (!fArray) fArray = new Long64_t[fN];
139  memmove(fArray, array, n*sizeof(Long64_t));
140 }
141 
142 ////////////////////////////////////////////////////////////////////////////////
143 /// Stream a TArrayL64 object.
144 
145 void TArrayL64::Streamer(TBuffer &b)
146 {
147  if (b.IsReading()) {
148  Int_t n;
149  b >> n;
150  Set(n);
151  b.ReadFastArray(fArray,n);
152  } else {
153  b << fN;
154  b.WriteFastArray(fArray, fN);
155  }
156 }
Abstract array base class.
Definition: TArray.h:33
long long Long64_t
Definition: RtypesCore.h:69
Bool_t IsReading() const
Definition: TBuffer.h:83
return c
ClassImp(TArrayL64) TArrayL64
Default TArrayL64 ctor.
Definition: TArrayL64.cxx:21
Buffer base class used for serializing objects.
Definition: TBuffer.h:42
int Int_t
Definition: RtypesCore.h:41
Long64_t * fArray
Definition: TArrayL64.h:32
Int_t fN
Definition: TArray.h:40
Bool_t BoundsOk(const char *where, Int_t at) const
Definition: TArray.h:79
void AddAt(Long64_t c, Int_t i)
Add long64 c at position i. Check for out of bounds.
Definition: TArrayL64.cxx:93
virtual void ReadFastArray(Bool_t *b, Int_t n)=0
virtual void WriteFastArray(const Bool_t *b, Int_t n)=0
TArrayL64 & operator=(const TArrayL64 &rhs)
TArrayL64 assignment operator.
Definition: TArrayL64.cxx:61
void Set(Int_t n)
Set size of this array to n long64s.
Definition: TArrayL64.cxx:105
Array of long64s (64 bits per element).
Definition: TArrayL64.h:29
virtual ~TArrayL64()
Delete TArrayL64 object.
Definition: TArrayL64.cxx:71
void Adopt(Int_t n, Long64_t *array)
Adopt array arr into TArrayL64, i.e.
Definition: TArrayL64.cxx:81
const Int_t n
Definition: legend1.C:16