// @(#)root/cont:$Id$
// Author: Fons Rademakers   21/10/97

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#ifndef ROOT_TArray
#define ROOT_TArray


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TArray                                                               //
//                                                                      //
// Abstract array base class. Used by TArrayC, TArrayS, TArrayI,        //
// TArrayL, TArrayF and TArrayD.                                        //
// Data member is public for historical reasons.                        //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#ifndef ROOT_Rtypes
#include "Rtypes.h"
#endif
#include <string.h>

class TBuffer;

class TArray {

protected:
   Bool_t        BoundsOk(const char *where, Int_t at) const;
   Bool_t        OutOfBoundsError(const char *where, Int_t i) const;

public:
   Int_t     fN;            //Number of array elements

   TArray(): fN(0) { }
   TArray(Int_t n): fN(n) { }
   TArray(const TArray &a): fN(a.fN) { }
   TArray         &operator=(const TArray &rhs) 
     {if(this!=&rhs) fN = rhs.fN; return *this; }
   virtual        ~TArray() { fN = 0; }

   Int_t          GetSize() const { return fN; }
   virtual void   Set(Int_t n) = 0;

   virtual Double_t GetAt(Int_t i) const = 0;
   virtual void   SetAt(Double_t v, Int_t i) = 0;

   static TArray *ReadArray(TBuffer &b, const TClass *clReq);
   static void    WriteArray(TBuffer &b, const TArray *a);

   friend TBuffer &operator<<(TBuffer &b, const TArray *obj);

   ClassDef(TArray,1)  //Abstract array base class
};

#if defined R__TEMPLATE_OVERLOAD_BUG
template <>
#endif
inline TBuffer &operator>>(TBuffer &buf, TArray *&obj)
{
   // Read TArray object from buffer.

   obj = (TArray *) TArray::ReadArray(buf, TArray::Class());
   return buf;
}

#if defined R__TEMPLATE_OVERLOAD_BUG
template <>
#endif
TBuffer &operator<<(TBuffer &b, const TArray *obj);

inline Bool_t TArray::BoundsOk(const char *where, Int_t at) const
{
   return (at < 0 || at >= fN)
                  ? OutOfBoundsError(where, at)
                  : kTRUE;
}

#endif
 TArray.h:1
 TArray.h:2
 TArray.h:3
 TArray.h:4
 TArray.h:5
 TArray.h:6
 TArray.h:7
 TArray.h:8
 TArray.h:9
 TArray.h:10
 TArray.h:11
 TArray.h:12
 TArray.h:13
 TArray.h:14
 TArray.h:15
 TArray.h:16
 TArray.h:17
 TArray.h:18
 TArray.h:19
 TArray.h:20
 TArray.h:21
 TArray.h:22
 TArray.h:23
 TArray.h:24
 TArray.h:25
 TArray.h:26
 TArray.h:27
 TArray.h:28
 TArray.h:29
 TArray.h:30
 TArray.h:31
 TArray.h:32
 TArray.h:33
 TArray.h:34
 TArray.h:35
 TArray.h:36
 TArray.h:37
 TArray.h:38
 TArray.h:39
 TArray.h:40
 TArray.h:41
 TArray.h:42
 TArray.h:43
 TArray.h:44
 TArray.h:45
 TArray.h:46
 TArray.h:47
 TArray.h:48
 TArray.h:49
 TArray.h:50
 TArray.h:51
 TArray.h:52
 TArray.h:53
 TArray.h:54
 TArray.h:55
 TArray.h:56
 TArray.h:57
 TArray.h:58
 TArray.h:59
 TArray.h:60
 TArray.h:61
 TArray.h:62
 TArray.h:63
 TArray.h:64
 TArray.h:65
 TArray.h:66
 TArray.h:67
 TArray.h:68
 TArray.h:69
 TArray.h:70
 TArray.h:71
 TArray.h:72
 TArray.h:73
 TArray.h:74
 TArray.h:75
 TArray.h:76
 TArray.h:77
 TArray.h:78
 TArray.h:79
 TArray.h:80
 TArray.h:81
 TArray.h:82
 TArray.h:83
 TArray.h:84
 TArray.h:85
 TArray.h:86