#include <assert.h>
	#include <stdlib.h>
	#include "StArray.h"
	#include "TDatime.h"
	#include "TBrowser.h"
	#include "StMkDeb.h"
	
	enum {kBelongs = BIT(22)};
	//______________________________________________________________________________
	ClassImp(StObjLink)
	//______________________________________________________________________________
	void StObjLink::Browse(TBrowser* b) {b->Add(fLink);}
	//______________________________________________________________________________
	void StObjLink::Streamer(TBuffer &R__b)
	{
	
	   if (R__b.IsReading()) {
	     fLink = 0;
	     UInt_t ubj;
	     R__b >> ubj ;
	     if (!ubj) 	return;
	     StProxyUrr *urr = new StProxyUrr(&fLink);
	     urr->push_back(ubj);
	     StXRefManager::fgManager->AddColl(urr);
	
	   } else {
	const static UInt_t kMustBeOne  = kIsOnHeap  | kNotDeleted;
	const static UInt_t kMustBeZero = kCanDelete | kObjInCanvas  | kHasUUID
	                                | kCannotPick| kNoContextMenu| kZombie;
	     if (!fLink || fLink->TestBits(kMustBeZero|kMustBeOne) !=(int)kMustBeOne)
	          fLink = 0;
	     if (!fLink) R__b << UInt_t(0);
	     else        fLink->Ztreamer(R__b);
	   }
	}
	
	//______________________________________________________________________________
	
	ClassImp(StObjArray)
	//______________________________________________________________________________
	Int_t StObjArray::getEntries() const
	{
	   int sz = size();
	   int en = 0;
	   for (int i=0;i<sz;i++) 
	   {
	     TObject *to = fV[i];
	     if (!to) 			continue;
	     if (to->IsZombie())	continue;
	     en++;
	   }
	   return en;
	}
	//______________________________________________________________________________
	TObject** StObjArray::Erase(TObject** it,int del) 
	{
	   int i = it-&fV[0];
	   if (del) {delete fV[i]; fV[i]=0;}
	   return &(*(fV.erase(fV.begin()+i)));		
	}		
	//______________________________________________________________________________
	TObject** StObjArray::Erase(TObject** fst,TObject** lst,int del)
	{
	   int ifst = fst-&fV[0];
	   int ilst = lst-&fV[0];
	   if (del) {for (int i=ifst;i<ilst;i++) {delete fV[i];fV[i]=0;}}
	   return &(*(fV.erase(fV.begin()+ifst,fV.begin()+ilst)));		
	}		
	//______________________________________________________________________________
	TObject* StObjArray::find(const char *name) const
	{
	   int n  = fV.size();
	   for (int i=0;i<n;i++) { 
	     if (!fV[i]) continue;
	     if (!strcmp(name,fV[i]->GetName())) return (TObject*)fV[i];
	   }
	   return 0;
	}		
	//______________________________________________________________________________
	void StObjArray::Streamer(TBuffer &b)
	{
	
	   // Stream all objects in the array to or from the I/O buffer.
	
	   Int_t nobjects;
	   if (b.IsReading()) {
	      Version_t v = b.ReadVersion(); if (v){/*touch*/}
	      clear();
	      b >> nobjects;
	      if (!nobjects) return;
	      resize(nobjects);
	      TObject *obj;
	      for (Int_t i = 0; i < nobjects; i++) {
	         b >> obj;  fV[i] =(obj);}
	   } else {
	      b.WriteVersion(Class());
	      nobjects = getEntries();
	      b << nobjects;
	
	      for (Int_t i = 0; nobjects; i++) {
	         TObject *to = at(i);
	         if (to && !to->IsZombie()) {b << to; nobjects--;}
	      }
	   }
	}
	
	
	
	//______________________________________________________________________________
	void StObjArray::Browse(TBrowser *b)
	{
	  enum { maxBrowsable =  5000};
	
	   // Browse this collection (called by TBrowser).
	   // If b=0, there is no Browse call TObject::Browse(0) instead.
	   //         This means TObject::Inspect() will be invoked indirectly
	 
	   if (!b) return;
	   TObject *obj=0;
	    
	   Int_t counter = 0;
	   Int_t totalSize = size();
	   for (int i=0; i<totalSize && ++counter <  maxBrowsable ; i++) {
	       obj = at(i); if (!obj || ((ULong_t)obj)&1) continue;
	       TString browseName(obj->GetName());
	       if (browseName.IsNull()) browseName = obj->ClassName();
	       char buffer[100];
	       sprintf(buffer,"_%d(%d)",counter,totalSize);
	       browseName += buffer;
	       b->Add(obj,browseName.Data());
	   }
	}
	//______________________________________________________________________________
	Bool_t StObjArray::IsFolder() const 
	{ return size();}
	   
	//______________________________________________________________________________
	void StObjArray::random_shuffle(int start,int end)
	{
	  
	  int lst = size();
	  if (start >= lst)	return;
	  if (end   > lst) 	end = lst;
	  ::random_shuffle(begin()+start,begin()+end);
	
	}
	//______________________________________________________________________________
	void StObjArray::ls(const char *tit) const
	{
	  if (!tit) tit ="";
	  int n = fV.size();
	  Info("ls","%s(%s)[%d]",ClassName(),tit,n);
	  for (int i=0;i<n;i++) { 
	    TObject *to = fV[i]; if (!to) continue;
	    printf("%4d - %p %s(%s)\n",i, (void*)to,to->ClassName(),to->GetName());
	  }
	}
	
	//______________________________________________________________________________
	ClassImp(StRefArray)
	StRefArray::StRefArray(Int_t sz):StObjArray(sz){};
	StRefArray::StRefArray(const StRefArray &from):StObjArray(from){};
	
	//______________________________________________________________________________
	void StRefArray::Streamer(TBuffer &R__b)
	{ 
	
	   // Stream all objects in the array to or from the I/O buffer.
	
	   Int_t nobjects;
	   if (R__b.IsReading()) {
	      Version_t v = R__b.ReadVersion(); if (v){/*touch*/}
	      clear();
	      R__b >> nobjects;
	      if (!nobjects) return;
	      if (v <=2 || nobjects>0) {	//OLD non split format
	        TObject *obj;
	        for (Int_t i = 0; i < nobjects; i++) {
	         R__b >> obj;  push_back(obj);}
	      } else {		//SPLIT format 
	        UInt_t ubj;
	        nobjects = -nobjects;
	        StProxyUrr *urr = new StProxyUrr(this);
	        for (Int_t i = 0; i < nobjects; i++) {
	         R__b >> ubj ; urr->push_back(ubj);
	        }
	        StXRefManager::fgManager->AddColl(urr);
	      }
	
	   } else {
	      R__b.WriteVersion(Class());
	      int nobjs = nobjects = getEntries();
	      if (StObject::fgTally) nobjs=-nobjs;
	      R__b << nobjs;
	      if (!nobjects) 	return;
	      TObject *to;
	      for (Int_t i = 0; nobjects; i++) {
	        to = at(i);
	        if (!to) 		continue;
	        if (to->IsZombie())	continue; 
	        nobjects--;
	        if (nobjs<0)  {((StObject*)to)->Ztreamer(R__b);}             
	        else          { R__b << to;                    }
	      }
	   }
	}
	
	//______________________________________________________________________________
	ClassImp(StStrArray)
	//______________________________________________________________________________
	StStrArray::StStrArray(Int_t sz):StObjArray(sz){}
	//______________________________________________________________________________
	 void StStrArray::operator=(const StStrArray &a)
	{
	  int n,i; TObject *sto;
	  
	  clear();
	  n = a.size();
	  resize(n);

	  for (i=0; i<n; i++)
	  {
	    sto = a[i];       

	    if (sto) sto = ((StObject*)sto)->clone(); 

	    sto->ResetBit(kBelongs);
	    put_at(sto,i);

	  }
	} 
	//______________________________________________________________________________
	StStrArray::StStrArray(const StStrArray &from){ *this = from;}
	//______________________________________________________________________________
	 void StStrArray::clear()
	{ 
	  assert(!fV.size() || !fV[0] || ((TObject*)fV[0])->TestBit(TObject::kNotDeleted));
	  int n,i;
	  
	  n = fV.size();
	  for (i=0; i<n; i++){
	    TObject *to = fV[i];
	    if (!to) continue;
	    if (to->TObject::TestBit(TObject::kNotDeleted)) {
	      delete fV[i];
	    } else {
	      Warning("clear","Object[%d]=%p is already deleted",i,to);
	#if 0
	      const char *mk=0;
	      mk = StMkDeb::GetName(StMkDeb::GetCurrent());
	      if (mk && *mk) printf("*** Now we are in %s ***\n",mk);
	      mk = StMkDeb::GetUser(to);
	      if (mk && *mk) printf("*** It was deleted in maker %s ***\n",mk);
	#endif
	//    assert(0);
	    }
	    fV[i]=0;
	  }
	  fV.clear();
	} 
	StStrArray::~StStrArray()
	{
	  clear(); 
	}
	//______________________________________________________________________________
	void StStrArray::put_at(TObject *obj,int i)
	{
	  assert(i>=0 && i<int(size()));
	  if (obj) {   
	     if (fV[i]==obj) return;
	     assert(!obj->TestBit(kBelongs) && obj->TestBit(TObject::kNotDeleted));
	     obj->SetBit(kBelongs);
	  }
	  fV[i]=obj;}
	//______________________________________________________________________________
	void StStrArray::push_back(const TObject * const to)
	{
	  TObject* obj = (TObject*)to;
	  if (obj) {   
	     assert(!obj->TestBit(kBelongs) && obj->TestBit(TObject::kNotDeleted));
	     obj->SetBit(kBelongs);
	  }
	
	  fV.push_back(obj);
	}
	
	//______________________________________________________________________________
	void StStrArray::Streamer(TBuffer &R__b)
	{
	   // Stream an object of class StStrArray.
	   if (R__b.IsReading()) {
	      Version_t R__v = R__b.ReadVersion(); if (R__v) { }
	      StObjArray::Streamer(R__b);
	      if (R__v >=3) 
	         StXRefManager::fgManager->AddColl(this);
	   } else {
	      R__b.WriteVersion(Class());
	      StObjArray::Streamer(R__b);
	   }
	
	}
	//______________________________________________________________________________
	void StStrArray::makeZombie(int flg) 
	{
	   StObject::makeZombie(flg);
	   int n = size();
	   for (int i=0;i<n;i++)
	   {  StObject *o = (StObject*)at(i); if (o) o->makeZombie(flg);}
	}
	//______________________________________________________________________________