// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file tools.license for terms.

#ifndef tools_wroot_infos
#define tools_wroot_infos

#include "info"

namespace tools {
namespace wroot {

inline void scs(unsigned int& a_cs,const std::string& a_s) {
  unsigned int l = a_s.size();
  for(unsigned int i=0;i<l;i++) a_cs = a_cs*3+a_s[i];
}

inline void acs(unsigned int& a_cs,int a_n,int* a_dims) {
  for(int i=0;i<a_n;i++) a_cs = a_cs*3+(unsigned int)a_dims[i];
}

inline void fill_vec(List<StreamerInfo>& a_infos,
                     const std::string& a_type,
                     streamer_info::Type a_si_type) {
  unsigned int check = 196608;
  StreamerInfo* info =
    new StreamerInfo(std::string("vector<")+a_type+">",4,check);
  a_infos.push_back(info);
  info->add(new streamer_STL("This","Used to call the proper TStreamerInfo case",0,a_si_type,std::string("vector<")+a_type+">"));
}


inline void fill_infos_core(List<StreamerInfo>& a_infos,std::ostream&) {

  // sizeof(TString) = 8   (4 (virtual ~) + 1 + 3 (align))
  // sizeof(TObject) = 12
  // sizeof(TNamed)  = 28
  // sizeof(TObjArray) = 40
  // sizeof(TArray) = 8
  // sizeof(TArrayI) = 12
  // sizeof(TArrayD) = 12
  // sizeof(TArrayF) = 12

  //const int size_DOUBLE = 8;
  const int size_INT = 4;
  const int size_POINTER = 4;
  //const int size_OBJECT_POINTER = 4;
  //const int size_COUNTER = 4;
  const int size_VIRTUAL = 4;

  const int size_TArray = 8;

  short TObject_version = 1;
  short TNamed_version = 1;
  short TStreamerElement_version = 2;
  short TArray_version = 1;

 {unsigned int check = 0;  
  //this :
  scs(check,"TNamed");
  //base :
  scs(check,"TObject");
  //members :
  scs(check,"fName");
  scs(check,"TString");

  scs(check,"fTitle");
  scs(check,"TString");

  StreamerInfo* info = new StreamerInfo("TNamed",1,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TObject","Basic ROOT object",0,TObject_version)); //12
  info->add(new streamer_string("fName","object identifier",12));//8
  info->add(new streamer_string("fTitle","object title",20));//8

  //28
 }

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerInfo");
  //bases :
  scs(check,"TNamed");
  //members :
  scs(check,"fCheckSum");
  scs(check,"UInt_t");

  scs(check,"fClassVersion");
  scs(check,"Int_t");

  scs(check,"fElements");
  scs(check,"TObjArray*");

  StreamerInfo* info = new StreamerInfo("TStreamerInfo",2,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TNamed","The basis for a named object (name, title)",0,TNamed_version));//28
  info->add(new streamer_basic_type("fCheckSum","checksum of original class",28,streamer_info::UNSIGNED_INT,"UInt_t"));//4
  info->add(new streamer_basic_type("fClassVersion","Class version identifier",32,streamer_info::INT,"Int_t"));//4
  //40 = 2*int+4*int_p+2*ulong_p+bool+p (bool=4 !)
  info->add(new streamer_object_pointer("fElements","Array of TStreamerElements",76,"TObjArray*"));//4

  //80
 }

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerElement");
  //bases :
  scs(check,"TNamed");
  //members :
  scs(check,"fType");
  scs(check,"Int_t");

  scs(check,"fSize");
  scs(check,"Int_t");

  scs(check,"fArrayLength");
  scs(check,"Int_t");

  scs(check,"fArrayDim");
  scs(check,"Int_t");

  scs(check,"fMaxIndex");
  scs(check,"Int_t");
  int dim = 5;
  acs(check,1,&dim);

  scs(check,"fTypeName");
  scs(check,"TString");
  //Should be : 2369818458U

  StreamerInfo* info = new StreamerInfo("TStreamerElement",2,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TNamed","The basis for a named object (name, title)",0,TNamed_version));
  info->add(new streamer_basic_type("fType","element type",28,streamer_info::INT,"Int_t"));
  info->add(new streamer_basic_type("fSize","sizeof element",32,streamer_info::INT,"Int_t"));
  info->add(new streamer_basic_type("fArrayLength","cumulative size of all array dims",36,streamer_info::INT,"Int_t"));
  info->add(new streamer_basic_type("fArrayDim","number of array dimensions",40,streamer_info::INT,"Int_t"));

 {streamer_element* elem = new streamer_basic_type("fMaxIndex","Maximum array index for array dimension \"dim\"",44,streamer_info::INT,"Int_t");
  info->add(elem);
  elem->setArrayDimension(1);
  elem->setMaxIndex(0,5);}

  info->add(new streamer_string("fTypeName","Data type name of data member",72));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerBase");
  //bases :
  scs(check,"TStreamerElement");
  //members :
  scs(check,"fBaseVersion");
  scs(check,"Int_t");
  //Should be : 2671078514U

  StreamerInfo* info = new StreamerInfo("TStreamerBase",3,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));
  info->add(new streamer_basic_type("fBaseVersion","version number of the base class",88,streamer_info::INT,"Int_t"));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerString");
  //bases :
  scs(check,"TStreamerElement");
  //Should be : 2525579865U

  StreamerInfo* info = new StreamerInfo("TStreamerString",2,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerBasicType");
  //bases :
  scs(check,"TStreamerElement");
  //Should be : 3001875966U;

  StreamerInfo* info = new StreamerInfo("TStreamerBasicType",2,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerBasicPointer");
  //bases :
  scs(check,"TStreamerElement");
  //members :
  scs(check,"fCountVersion");
  scs(check,"Int_t");

  scs(check,"fCountName");
  scs(check,"TString");

  scs(check,"fCountClass");
  scs(check,"TString");
  //Should be : 1587298059U

  StreamerInfo* info = new StreamerInfo("TStreamerBasicPointer",2,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));
  info->add(new streamer_basic_type("fCountVersion","version number of the class with the counter",88,streamer_info::INT,"Int_t"));
  info->add(new streamer_string("fCountName","name of data member holding the array count",92));
  info->add(new streamer_string("fCountClass","name of the class with the counter",100));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerObject");
  //bases :
  scs(check,"TStreamerElement");
  //Should be : 2177456715U

  StreamerInfo* info = new StreamerInfo("TStreamerObject",2,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerObjectPointer");
  //bases :
  scs(check,"TStreamerElement");
  //Should be : 720556968U

  StreamerInfo* info = new StreamerInfo("TStreamerObjectPointer",2,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerObjectAny");
  //bases :
  scs(check,"TStreamerElement");
  //Should be : 3108880127U

  StreamerInfo* info = new StreamerInfo("TStreamerObjectAny",2,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TArray");
  //members :
  scs(check,"fN");
  scs(check,"Int_t");

  StreamerInfo* info = new StreamerInfo("TArray",1,check);
  a_infos.push_back(info);

  // Elements :
  int offset = 0;
  offset += size_VIRTUAL;

  info->add(new streamer_basic_type(
      "fN",
      "Number of array elements",
      offset,
      streamer_info::INT,"Int_t")); //4
  offset += size_INT;

  //8
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TArrayI");
  //base :
  scs(check,"TArray");
  //members :
  scs(check,"fArray");
  scs(check,"Int_t*");

  StreamerInfo* info = new StreamerInfo("TArrayI",1,check);
  a_infos.push_back(info);

  // Elements :
  int offset = 0;

  info->add(new streamer_base(
      "TArray",
      "Abstract array base class",
      offset,
      TArray_version));
  offset += size_TArray;

  info->add(new streamer_basic_pointer(
      "fArray",
      "[fN] Array of fN integers",
      offset,
      streamer_info::INT,"fN","TArray",1,"Int_t*"));
  offset += size_POINTER;

  //12
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TArrayD");
  //base :
  scs(check,"TArray");
  //members :
  scs(check,"fArray");
  scs(check,"Double_t*");

  StreamerInfo* info = new StreamerInfo("TArrayD",1,check);
  a_infos.push_back(info);

  // Elements :
  int offset = 0;

  info->add(new streamer_base(
      "TArray",
      "Abstract array base class",
      offset,
      TArray_version));
  offset += size_TArray; //8

  info->add(new streamer_basic_pointer(
      "fArray",
      "[fN] Array of fN integers",
      offset,
      streamer_info::DOUBLE,"fN","TArray",1,"Double_t*"));
  offset += size_POINTER;

  //12
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TArrayF");
  //base :
  scs(check,"TArray");
  //members :
  scs(check,"fArray");
  scs(check,"Float_t*");

  StreamerInfo* info = new StreamerInfo("TArrayF",1,check);
  a_infos.push_back(info);

  // Elements :
  int offset = 0;

  info->add(new streamer_base(
      "TArray",
      "Abstract array base class",
      offset,
      TArray_version));
  offset += size_TArray;

  info->add(new streamer_basic_pointer(
      "fArray",
      "[fN] Array of fN integers",
      offset,
      streamer_info::FLOAT,"fN","TArray",1,"Float_t*"));
  offset += size_POINTER;

  //12
  }

  fill_vec(a_infos,"char",streamer_info::CHAR);
  fill_vec(a_infos,"short",streamer_info::SHORT);
  fill_vec(a_infos,"int",streamer_info::INT);
  fill_vec(a_infos,"unsigned char",streamer_info::UNSIGNED_CHAR);
  fill_vec(a_infos,"unsigned short",streamer_info::UNSIGNED_SHORT);
  fill_vec(a_infos,"unsigned int",streamer_info::UNSIGNED_INT);
  fill_vec(a_infos,"float",streamer_info::FLOAT);
  fill_vec(a_infos,"double",streamer_info::DOUBLE);
  fill_vec(a_infos,"bool",streamer_info::BOOL);

}

inline void fill_infos_graf(List<StreamerInfo>& a_infos,std::ostream&) {

  //sizeof(Font_t) = 2
  //sizeof(Style_t) = 2
  //sizeof(Marker_t) = 2
  //sizeof(Width_t) = 2
  //sizeof(Size_t) = 4

 {unsigned int check = 0;  
  //this :
  scs(check,"TAttLine");
  //members :
  scs(check,"fLineColor");
  scs(check,"Color_t");

  scs(check,"fLineStyle");
  scs(check,"Style_t");

  scs(check,"fLineWidth");
  scs(check,"Width_t");

  //Should be : 1369587346U

  // Beurk ; but the ROOT TTree compells indirectly the below.
  StreamerInfo* info = new StreamerInfo("TAttLine",1,check);
  a_infos.push_back(info);
  // Elements :
  //4 (virtual ~)
  info->add(new streamer_basic_type("fLineColor","line color",4,streamer_info::SHORT,"Color_t"));//2
  info->add(new streamer_basic_type("fLineStyle","line style",6,streamer_info::SHORT,"Style_t"));//2
  info->add(new streamer_basic_type("fLineWidth","line width",8,streamer_info::SHORT,"Width_t"));//2
  //2 (alignement ???)

  //12
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TAttFill");
  //members :
  scs(check,"fFillColor");
  scs(check,"Color_t");

  scs(check,"fFillStyle");
  scs(check,"Style_t");

    //Should be : 1204118360U
  StreamerInfo* info = new StreamerInfo("TAttFill",1,check);
  a_infos.push_back(info);
  // Elements :
  //4 (virtual ~)
  info->add(new streamer_basic_type("fFillColor","fill area color",4,streamer_info::SHORT,"Color_t"));//2
  info->add(new streamer_basic_type("fFillStyle","fill area style",6,streamer_info::SHORT,"Style_t"));//2

  //8
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TAttMarker");
  //members :
  scs(check,"fMarkerColor");
  scs(check,"Color_t");

  scs(check,"fMarkerStyle");
  scs(check,"Style_t");

  scs(check,"fMarkerSize");
  scs(check,"Size_t");

  //Should be 4207747460U

  StreamerInfo* info = new StreamerInfo("TAttMarker",1,check);
  a_infos.push_back(info);
  // Elements :
  //4 (virtual ~)
  info->add(new streamer_basic_type("fMarkerColor","Marker color index",0,streamer_info::SHORT,"Color_t"));//2
  info->add(new streamer_basic_type("fMarkerStyle","Marker style",4,streamer_info::SHORT,"Style_t"));//2
  info->add(new streamer_basic_type("fMarkerSize","Marker size",6,streamer_info::FLOAT,"Size_t"));//4

  //12
  }

}

inline void fill_infos_tree(List<StreamerInfo>& a_infos,std::ostream& a_out) {

  const int size_DOUBLE = 8;
  const int size_INT = 4;
  const int size_POINTER = 4;
  const int size_COUNTER = 4;

  const int size_TNamed = 28;
  const int size_TAttLine = 12;
  const int size_TAttFill = 8;
  const int size_TAttMarker = 12;
  const int size_TObjArray = 40;
  const int size_TArrayD = 12;

  const int size_TString = 8;
  const int size_TBranch = 256;
  const int size_TLeaf = 64;

  short TNamed_version = 1;

  short TAttLine_version = 1;
  short TAttFill_version = 1;
  short TAttMarker_version = 1;
  short TBranch_version = 8;
  short TLeaf_version = 2;

 {unsigned int check = 0;  
  //this :
  scs(check,"TTree");
  //bases :
  scs(check,"TNamed");
  scs(check,"TAttLine");
  scs(check,"TAttFill");
  scs(check,"TAttMarker");
  //members :
  scs(check,"fEntries");
  scs(check,"Stat_t");

  scs(check,"fTotBytes");
  scs(check,"Stat_t");

  scs(check,"fZipBytes");
  scs(check,"Stat_t");

  scs(check,"fSavedBytes");
  scs(check,"Stat_t");

  scs(check,"fTimerInterval");
  scs(check,"Int_t");

  scs(check,"fScanField");
  scs(check,"Int_t");

  scs(check,"fUpdate");
  scs(check,"Int_t");

  scs(check,"fMaxEntryLoop");
  scs(check,"Int_t");

  scs(check,"fMaxVirtualSize");
  scs(check,"Int_t");

  scs(check,"fAutoSave");
  scs(check,"Int_t");

  scs(check,"fEstimate");
  scs(check,"Int_t");

  scs(check,"fBranches");
  scs(check,"TObjArray");

  scs(check,"fLeaves");
  scs(check,"TObjArray");

  //scs(check,"fAliases");
  //scs(check,"TList*");

  scs(check,"fIndexValues");
  scs(check,"TArrayD");

  scs(check,"fIndex");
  scs(check,"TArrayI");

  //scs(check,"fFriends");
  //scs(check,"TList*");
  //Should be : 3245044844U //3.00.06
  //Should be : FIXME //3.10.02

  StreamerInfo* info = new StreamerInfo("TTree",5,check);
  a_infos.push_back(info);
  // Elements :
  int offset = 0;

  info->add(new streamer_base(
      "TNamed",
      "The basis for a named object (name, title)",
      offset,
      TNamed_version));
  offset += size_TNamed;

  info->add(new streamer_base(
      "TAttLine",
      "Line attributes",
      offset,
      TAttLine_version));
  offset += size_TAttLine;

  info->add(new streamer_base(
      "TAttFill",
      "Fill area attributes",
      offset,
      TAttFill_version));
  offset += size_TAttFill;

  info->add(new streamer_base(
      "TAttMarker",
      "Marker attributes",
      offset,
      TAttMarker_version));
  offset += size_TAttMarker;

  info->add(new streamer_basic_type(
      "fEntries",
      "Number of entries",
      offset,
      streamer_info::DOUBLE,"Stat_t"));
  offset += size_DOUBLE;

  info->add(new streamer_basic_type(
      "fTotBytes",
      "Total number of bytes in all branches before compression",
      offset,
      streamer_info::DOUBLE,"Stat_t"));
  offset += size_DOUBLE;

  info->add(new streamer_basic_type(
      "fZipBytes",
      "Total number of bytes in all branches after compression",
      offset,
      streamer_info::DOUBLE,"Stat_t"));
  offset += size_DOUBLE;

  info->add(new streamer_basic_type(
      "fSavedBytes",
      "Number of autosaved bytes",
      offset,
      streamer_info::DOUBLE,"Stat_t"));
  offset += size_DOUBLE;

  info->add(new streamer_basic_type(
      "fTimerInterval",
      "Timer interval in milliseconds",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fScanField",
      "Number of runs before prompting in Scan",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fUpdate",
      "Update frequency for EntryLoop",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fMaxEntryLoop",
      "Maximum number of entries to process",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fMaxVirtualSize",
      "Maximum total size of buffers kept in memory",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fAutoSave",
      "Autosave tree when fAutoSave bytes produced",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fEstimate",
      "Number of entries to estimate histogram limits",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  offset += 5*size_INT+size_POINTER, //! //144

  info->add(new streamer_object(
      "fBranches",
      "List of Branches",
      offset,
      "TObjArray"));
  offset += size_TObjArray;

  info->add(new streamer_object(
      "fLeaves",
      "Direct pointers to individual branch leaves",
      offset,
      "TObjArray"));
  offset += size_TObjArray;

  //info->add(new streamer_object_pointer(
  //  "fAliases",
  //  "List of aliases for expressions based on the tree branches.",
  //  offset,
  //  "TList*"));
  //offset += size_OBJECT_POINTER;

  offset += size_POINTER; //! //228

  info->add(new streamer_object_any(
      "fIndexValues",
      "Sorted index values",
      offset,
      "TArrayD"));
  offset += size_TArrayD;

  info->add(new streamer_object_any(
      "fIndex",
      "Index of sorted values",
      offset,
      "TArrayI"));

  //info->add(new streamer_object_pointer(
  //  "fFriends",
  //  "pointer to list of friend elements",
  //  offset,
  //  "TList*"));
  //offset += size_OBJECT_POINTER;

  if(offset!=240) {
    a_out << "tools::wroot::fill_infos :"
          << " Tree " << offset << " (240 expected.)"
          << std::endl;
  }}

  //---------------------------------------------------------------------
 {unsigned int check = 0;  
  //this :
  scs(check,"TBranch");
  //bases :
  scs(check,"TNamed");
  scs(check,"TAttFill");
  //members :
  scs(check,"fCompress");
  scs(check,"Int_t");

  scs(check,"fBasketSize");
  scs(check,"Int_t");

  scs(check,"fEntryOffsetLen");
  scs(check,"Int_t");

  scs(check,"fWriteBasket");
  scs(check,"Int_t");

  scs(check,"fEntryNumber");
  scs(check,"Int_t");

  scs(check,"fOffset");
  scs(check,"Int_t");

  scs(check,"fMaxBaskets");
  scs(check,"Int_t");

  scs(check,"fSplitLevel");
  scs(check,"Int_t");

  scs(check,"fEntries");
  scs(check,"Stat_t");

  scs(check,"fTotBytes");
  scs(check,"Stat_t");

  scs(check,"fZipBytes");
  scs(check,"Stat_t");

  scs(check,"fBranches");
  scs(check,"TObjArray");

  scs(check,"fLeaves");
  scs(check,"TObjArray");

  scs(check,"fBaskets");
  scs(check,"TObjArray");

  scs(check,"fBasketBytes");
  scs(check,"Int_t*");

  scs(check,"fBasketEntry");
  scs(check,"Int_t*");

  scs(check,"fBasketSeek");
  scs(check,"Seek_t*");

  scs(check,"fFileName");
  scs(check,"TString");
  //Should be : 2056727376U (6 3.00.06)
  //Should be : FIXME (7 3.03.01)

  StreamerInfo* info = new StreamerInfo("TBranch",8,check);
  a_infos.push_back(info);
  // Elements :
  int offset = 0;

  info->add(new streamer_base(
      "TNamed",
      "The basis for a named object (name, title)",
      offset,
      TNamed_version));
  offset += size_TNamed;

  info->add(new streamer_base(
      "TAttFill",
      "Fill area attributes",
      offset,
      TAttFill_version));
  offset += size_TAttFill;

  info->add(new streamer_basic_type(
      "fCompress",
      "(=1 branch is compressed, 0 otherwise)",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fBasketSize",
      "Initial Size of  Basket Buffer",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fEntryOffsetLen",
      "Initial Length of fEntryOffset table in the basket buffers",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fWriteBasket",
      "Last basket number written",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fEntryNumber",
      "Current entry number (last one filled in this branch)",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fOffset",
      "Offset of this branch",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fMaxBaskets",
      "Maximum number of Baskets so far",
      offset,
      streamer_info::COUNTER,"Int_t"));
  offset += size_COUNTER;

  info->add(new streamer_basic_type( //3.03.01
      "fSplitLevel",
      "Branch split level",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  offset += 3*size_INT; //!

  info->add(new streamer_basic_type(
      "fEntries",
      "Number of entries",
      offset,
      streamer_info::DOUBLE,"Stat_t"));
  offset += size_DOUBLE;

  info->add(new streamer_basic_type(
      "fTotBytes",
      "Total number of bytes in all leaves before compression",
      offset,
      streamer_info::DOUBLE,"Stat_t"));
  offset += size_DOUBLE;

  info->add(new streamer_basic_type(
      "fZipBytes",
      "Total number of bytes in all leaves after compression",
      offset,
      streamer_info::DOUBLE,"Stat_t"));
  offset += size_DOUBLE;

  info->add(new streamer_object(
      "fBranches",
      "-> List of Branches of this branch",
      offset,
      "TObjArray"));
  offset += size_TObjArray;

  info->add(new streamer_object(
      "fLeaves", 
      "-> List of leaves of this branch",
      size_TNamed+6*size_INT+size_COUNTER+
      offset,
      "TObjArray"));
  offset += size_TObjArray;

  info->add(new streamer_object(
      "fBaskets",
      "-> List of baskets of this branch",
      offset,
      "TObjArray"));
  offset += size_TObjArray;

  offset += size_INT+size_POINTER; //!

  info->add(new streamer_basic_pointer(
      "fBasketBytes",
      "[fMaxBaskets] Lenght of baskets on file",
      offset,
      streamer_info::INT,"fMaxBaskets","TBranch",6,"Int_t*"));
  offset += size_POINTER;

  info->add(new streamer_basic_pointer(
      "fBasketEntry",
      "[fMaxBaskets] Table of first entry in eack basket",
      offset,
      streamer_info::INT,"fMaxBaskets","TBranch",6,"Int_t*"));
  offset += size_POINTER;

  info->add(new streamer_basic_pointer(
      "fBasketSeek",
      "[fMaxBaskets] Addresses of baskets on file",
      offset,
      streamer_info::INT,"fMaxBaskets","TBranch",6,"Seek_t*"));
  offset += size_POINTER;

  offset += 3*size_POINTER; //!

  info->add(new streamer_string(
      "fFileName",
      "Name of file where buffers are stored (\"\" if in same file as Tree header)",
      offset));

  if(offset!=256) {
    a_out << "tools::wroot::fill_infos :"
          << " Branch " << offset << " (256 expected.)"
          << std::endl;
  }}

 {unsigned int check = 0;  
  //this :
  scs(check,"TBranchObject");
  //bases :
  scs(check,"TBranch");
  //members :
  scs(check,"fClassName");
  scs(check,"TString");

  //Should be : 2857878535U

  StreamerInfo* info = new StreamerInfo("TBranchObject",1,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TBranch","Branch descriptor",0,TBranch_version));
  info->add(new streamer_string("fClassName","Class name of referenced object",256));
  }

  //---------------------------------------------------------------------
 {unsigned int check = 0;  
  //this :
  scs(check,"TBranchElement");
  //bases :
  scs(check,"TBranch");
  //members :
  scs(check,"fClassName");
  scs(check,"TString");

  scs(check,"fClassVersion");
  scs(check,"Int_t");

  scs(check,"fID");
  scs(check,"Int_t");

  scs(check,"fType");
  scs(check,"Int_t");

  scs(check,"fStreamerType");
  scs(check,"Int_t");

  StreamerInfo* info = new StreamerInfo("TBranchElement",1,check);
  a_infos.push_back(info);
  // Elements :
  int offset = 0;
  info->add(new streamer_base("TBranch","Branch descriptor",offset,TBranch_version));
  offset += size_TBranch;

  info->add(new streamer_string("fClassName","Class name of referenced object",offset));
  offset += size_TString;

  info->add(new streamer_basic_type("fClassVersion","Version number of class",offset,streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type("fID","element serial number in fInfo",offset,streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type("fType","branch type",offset,streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type("fStreamerType","branch streamer type",offset,streamer_info::INT,"Int_t"));
  offset += size_INT;

  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TLeaf");
  //bases :
  scs(check,"TNamed");
  //members :
  scs(check,"fLen");
  scs(check,"Int_t");

  scs(check,"fLenType");
  scs(check,"Int_t");

  scs(check,"fOffset");
  scs(check,"Int_t");

  scs(check,"fIsRange");
  scs(check,"Bool_t");

  scs(check,"fIsUnsigned");
  scs(check,"Bool_t");

  scs(check,"fLeafCount");
  scs(check,"TLeaf*");

  //Should be : 727988519U

  StreamerInfo* info = new StreamerInfo("TLeaf",2,check);
  a_infos.push_back(info);

  // Elements :
  info->add(new streamer_base("TNamed","The basis for a named object (name, title)",0,TNamed_version));
  info->add(new streamer_basic_type("fLen","Number of fixed length elements",32,streamer_info::INT,"Int_t"));
  info->add(new streamer_basic_type("fLenType","Number of bytes for this data type",36,streamer_info::INT,"Int_t"));
  info->add(new streamer_basic_type("fOffset","Offset in ClonesArray object (if one)",40,streamer_info::INT,"Int_t"));
  info->add(new streamer_basic_type("fIsRange","(=kTRUE if leaf has a range, kFALSE otherwise)",44,streamer_info::UNSIGNED_CHAR,"Bool_t"));
  info->add(new streamer_basic_type("fIsUnsigned","(=kTRUE if unsigned, kFALSE otherwise)",45,streamer_info::UNSIGNED_CHAR,"Bool_t"));
  info->add(new streamer_object_pointer("fLeafCount","Pointer to Leaf count if variable length",48,"TLeaf*"));

  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TLeafS");
  //bases :
  scs(check,"TLeaf");
  //members :
  scs(check,"fMinimum");
  scs(check,"Short_t");

  scs(check,"fMaximum");
  scs(check,"Short_t");

  //Should be : FIXME

  StreamerInfo* info = new StreamerInfo("TLeafS",1,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",0,TLeaf_version));
  info->add(new streamer_basic_type("fMinimum","Minimum value if leaf range is specified",56,streamer_info::SHORT,"Short_t"));
  info->add(new streamer_basic_type("fMaximum","Maximum value if leaf range is specified",58,streamer_info::SHORT,"Short_t"));

  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TLeafI");
  //bases :
  scs(check,"TLeaf");
  //members :
  scs(check,"fMinimum");
  scs(check,"Int_t");

  scs(check,"fMaximum");
  scs(check,"Int_t");

    //Should be : 3495201397U

  StreamerInfo* info = new StreamerInfo("TLeafI",1,check);
  a_infos.push_back(info);

  // Elements :
  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",0,TLeaf_version));
  info->add(new streamer_basic_type("fMinimum","Minimum value if leaf range is specified",56,streamer_info::INT,"Int_t"));
  info->add(new streamer_basic_type("fMaximum","Maximum value if leaf range is specified",60,streamer_info::INT,"Int_t"));

  }

 {unsigned int check = 0;  
  //name :
  scs(check,"TLeafF");
  //bases :
  scs(check,"TLeaf");
  //members :
  scs(check,"fMinimum");
  scs(check,"Float_t");

  scs(check,"fMaximum");
  scs(check,"Float_t");

  //Should be 1366318032U

  StreamerInfo* info = new StreamerInfo("TLeafF",1,check);
  a_infos.push_back(info);

  // Elements :
  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",0,TLeaf_version));
  info->add(new streamer_basic_type("fMinimum","Minimum value if leaf range is specified",56,streamer_info::FLOAT,"Float_t"));
  info->add(new streamer_basic_type("fMaximum","Maximum value if leaf range is specified",60,streamer_info::FLOAT,"Float_t"));
 
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TLeafD");
  //bases :
  scs(check,"TLeaf");
  //members :
  scs(check,"fMinimum");
  scs(check,"Double_t");

  scs(check,"fMaximum");
  scs(check,"Double_t");

  //Should be

  StreamerInfo* info = new StreamerInfo("TLeafD",1,check);
  a_infos.push_back(info);

  // Elements :
  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",0,TLeaf_version));
  info->add(new streamer_basic_type("fMinimum","Minimum value if leaf range is specified",56,streamer_info::DOUBLE,"Double_t"));
  info->add(new streamer_basic_type("fMaximum","Maximum value if leaf range is specified",64,streamer_info::DOUBLE,"Double_t"));
 
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TLeafB");
  //bases :
  scs(check,"TLeaf");
  //members :
  scs(check,"fMinimum");
  scs(check,"Char_t");

  scs(check,"fMaximum");
  scs(check,"Char_t");

  //Should be : FIXME

  StreamerInfo* info = new StreamerInfo("TLeafB",1,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",0,TLeaf_version));
  info->add(new streamer_basic_type("fMinimum","Minimum value if leaf range is specified",56,streamer_info::CHAR,"Char_t"));
  info->add(new streamer_basic_type("fMaximum","Maximum value if leaf range is specified",57,streamer_info::CHAR,"Char_t"));
 
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TLeafC");
  //bases :
  scs(check,"TLeaf");
  //members :
  scs(check,"fMinimum");
  scs(check,"Int_t");

  scs(check,"fMaximum");
  scs(check,"Int_t");

  //Should be : FIXME

  StreamerInfo* info = new StreamerInfo("TLeafC",1,check);
  a_infos.push_back(info);

  // Elements :
  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",0,TLeaf_version));
  info->add(new streamer_basic_type("fMinimum","Minimum value if leaf range is specified",56,streamer_info::INT,"Int_t"));
  info->add(new streamer_basic_type("fMaximum","Maximum value if leaf range is specified",60,streamer_info::INT,"Int_t"));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TLeafObject");
  //bases :
  scs(check,"TLeaf");
  //members :
  scs(check,"fVirtual");
  scs(check,"Bool_t");

  //Should be 2312661809U

  StreamerInfo* info = new StreamerInfo("TLeafObject",4,check);
  a_infos.push_back(info);

  // Elements :
  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",0,TLeaf_version));
  info->add(new streamer_basic_type("fVirtual","Support for Virtuality",64,streamer_info::UNSIGNED_CHAR,"Bool_t"));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TLeafElement");
  //bases :
  scs(check,"TLeaf");
  //members :
  scs(check,"fID");
  scs(check,"Int_t");

  scs(check,"fType");
  scs(check,"Int_t");

  StreamerInfo* info = new StreamerInfo("TLeafElement",1,check);
  a_infos.push_back(info);

  // Elements :
  int offset = 0;
  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",offset,TLeaf_version));
  offset += size_TLeaf;

  offset += size_POINTER;

  info->add(new streamer_basic_type("fID","element serial number in fInfo",offset,streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type("fType","leaf type",offset,streamer_info::INT,"Int_t"));
  offset += size_INT;}

}

inline void fill_infos_histo(List<StreamerInfo>& a_infos,std::ostream&) {

  short TNamed_version = 1;
  short TArrayF_version = 1;
  short TArrayD_version = 1;

  short TAttLine_version = 1;
  short TAttFill_version = 1;
  short TAttMarker_version = 1;

  short TAttAxis_version = 4;

 {unsigned int check = 0;  
  //this :
  scs(check,"TAttAxis");
  //members :
  scs(check,"fNdivisions");
  scs(check,"Int_t");

  scs(check,"fAxisColor");
  scs(check,"Color_t");

  scs(check,"fLabelColor");
  scs(check,"Color_t");

  scs(check,"fLabelFont");
  scs(check,"Style_t");

  scs(check,"fLabelOffset");
  scs(check,"Float_t");

  scs(check,"fLabelSize");
  scs(check,"Float_t");

  scs(check,"fTickLength");
  scs(check,"Float_t");

  scs(check,"fTitleOffset");
  scs(check,"Float_t");

  scs(check,"fTitleSize");
  scs(check,"Float_t");

  scs(check,"fTitleColor");
  scs(check,"Color_t");

  scs(check,"fTitleFont");
  scs(check,"Style_t");

  StreamerInfo* info = new StreamerInfo("TAttAxis",4,check);
  a_infos.push_back(info);

  // Elements :
  //4 (virtual ~)
  info->add(new streamer_basic_type("fNdivisions","Number of divisions(10000*n3 + 100*n2 + n1)",4,streamer_info::INT,"Int_t")); //4
  info->add(new streamer_basic_type("fAxisColor","color of the line axis",8,streamer_info::SHORT,"Color_t")); //2
  info->add(new streamer_basic_type("fLabelColor","color of labels",10,streamer_info::SHORT,"Color_t")); //2
  info->add(new streamer_basic_type("fLabelFont","font for labels",12,streamer_info::SHORT,"Style_t")); //2
  info->add(new streamer_basic_type("fLabelOffset","offset of labels",16,streamer_info::FLOAT,"Float_t")); //4
  info->add(new streamer_basic_type("fLabelSize","size of labels",20,streamer_info::FLOAT,"Float_t")); //4
  info->add(new streamer_basic_type("fTickLength","length of tick marks",24,streamer_info::FLOAT,"Float_t")); //4
  info->add(new streamer_basic_type("fTitleOffset","offset of axis title",28,streamer_info::FLOAT,"Float_t")); //4
  info->add(new streamer_basic_type("fTitleSize","size of axis title",32,streamer_info::FLOAT,"Float_t")); //4
  info->add(new streamer_basic_type("fTitleColor","color of axis title",36,streamer_info::SHORT,"Color_t")); //2 
  info->add(new streamer_basic_type("fTitleFont","font for axis title",38,streamer_info::SHORT,"Style_t")); //2
  //40
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TAxis");
  //bases :
  scs(check,"TNamed");
  scs(check,"TAttAxis");
  //members :
  scs(check,"fNbins");
  scs(check,"Int_t");

  scs(check,"fXmin");
  scs(check,"Axis_t");

  scs(check,"fXmax");
  scs(check,"Axis_t");

  scs(check,"fXbins");
  scs(check,"TArrayD");

  scs(check,"fFirst");
  scs(check,"Int_t");
    
  scs(check,"fLast");
  scs(check,"Int_t");

  scs(check,"fTimeDisplay");
  scs(check,"Bool_t");

  scs(check,"fTimeFormat");
  scs(check,"TString");

  StreamerInfo* info = new StreamerInfo("TAxis",6,check);
  a_infos.push_back(info);

  // Elements :
  info->add(new streamer_base("TNamed","The basis for a named object (name, title)",0,TNamed_version)); //28
  info->add(new streamer_base("TAttAxis","Axis attributes",28,TAttAxis_version)); //40
  info->add(new streamer_basic_type("fNbins","Number of bins",68,streamer_info::INT,"Int_t")); //4
  info->add(new streamer_basic_type("fXmin","low edge of first bin",72,streamer_info::DOUBLE,"Axis_t")); //8
  info->add(new streamer_basic_type("fXmax","upper edge of last bin",80,streamer_info::DOUBLE,"Axis_t")); //8
  info->add(new streamer_basic_type("fXbins","Bin edges array in X",88,streamer_info::OBJECT_ANY,"TArrayD")); //12
  info->add(new streamer_basic_type("fFirst","first bin to display",100,streamer_info::INT,"Int_t")); //4
  info->add(new streamer_basic_type("fLast","last bin to display",104,streamer_info::INT,"Int_t")); //4
  info->add(new streamer_basic_type("fTimeDisplay","on/off displaying time values instead of numerics",108,streamer_info::UNSIGNED_CHAR,"Bool_t")); //4 (Bool_t = 1 + 3 for alignement)
  info->add(new streamer_basic_type("fTimeFormat","Date&time format, ex: 09/12/99 12:34:00",112,streamer_info::TSTRING,"TString")); //8
  //offset 120 //4
  //offset 124 //4
  //128

  //v3-05-07 : 124 (stored) + 4  = 128
  }

  short TH1_version = 3;
 {unsigned int check = 0;  
  //this :
  scs(check,"TH1");
  //bases :
  scs(check,"TNamed");
  scs(check,"TAttLine");
  scs(check,"TAttFill");
  scs(check,"TAttMarker");
  //members :
  scs(check,"fNcells");
  scs(check,"Int_t");

  scs(check,"fXaxis");
  scs(check,"TAxis");

  scs(check,"fBarOffset");
  scs(check,"Short_t");

  scs(check,"fBarWidth");
  scs(check,"Short_t");

  scs(check,"fEntries");
  scs(check,"Stat_t");

  scs(check,"fTsumw");
  scs(check,"Stat_t");

  scs(check,"fTsumw2");
  scs(check,"Stat_t");

  scs(check,"fTsumwx");
  scs(check,"Stat_t");

  scs(check,"fTsumwx2");
  scs(check,"Stat_t");

  scs(check,"fMaximum");
  scs(check,"Double_t");

  scs(check,"fMinimum");
  scs(check,"Double_t");

  scs(check,"fNormFactor");
  scs(check,"Double_t");

  scs(check,"fContour");
  scs(check,"TArrayD");

  scs(check,"fSumw2");
  scs(check,"TArrayD");

  scs(check,"fOption");
  scs(check,"TString");

  scs(check,"fFunctions");
  scs(check,"TList*");

  StreamerInfo* info = new StreamerInfo("TH1",TH1_version,check);
  a_infos.push_back(info);

  info->add(new streamer_base("TNamed","The basis for a named object (name, title)",0,TNamed_version)); //28
  info->add(new streamer_base("TAttLine","Line attributes",28,TAttLine_version)); //12
  info->add(new streamer_base("TAttFill","Fill area attributes",40,TAttFill_version)); //8
  info->add(new streamer_base("TAttMarker","Marker attributes",48,TAttMarker_version)); //12
  info->add(new streamer_basic_type("fNcells","number of bins(1D), cells (2D) +U/Overflows",60,streamer_info::INT,"Int_t")); //4
  info->add(new streamer_basic_type("fXaxis","X axis descriptor",64,streamer_info::OBJECT_ANY,"TAxis")); //128
  info->add(new streamer_basic_type("fYaxis","Y axis descriptor",192,streamer_info::OBJECT_ANY,"TAxis")); //128
  info->add(new streamer_basic_type("fZaxis","Z axis descriptor",320,streamer_info::OBJECT_ANY,"TAxis")); //128
  info->add(new streamer_basic_type("fBarOffset","(1000*offset) for bar charts or legos",448,streamer_info::SHORT,"Short_t"));//2
  info->add(new streamer_basic_type("fBarWidth","(1000*width) for bar charts or legos",450,streamer_info::SHORT,"Short_t"));//2
  info->add(new streamer_basic_type("fEntries","Number of entries",452,streamer_info::DOUBLE,"Stat_t"));//2
  info->add(new streamer_basic_type("fTsumw","Total Sum of weights",460,streamer_info::DOUBLE,"Stat_t"));//8
  info->add(new streamer_basic_type("fTsumw2","Total Sum of squares of weights",468,streamer_info::DOUBLE,"Stat_t"));//8
  info->add(new streamer_basic_type("fTsumwx","Total Sum of weight*X",476,streamer_info::DOUBLE,"Stat_t"));//8
  info->add(new streamer_basic_type("fTsumwx2","Total Sum of weight*X*X",484,streamer_info::DOUBLE,"Stat_t"));//8
  info->add(new streamer_basic_type("fMaximum","Maximum value for plotting",492,streamer_info::DOUBLE,"Double_t"));//8
  info->add(new streamer_basic_type("fMinimum","Minimum value for plotting",500,streamer_info::DOUBLE,"Double_t"));//8
  info->add(new streamer_basic_type("fNormFactor","Normalization factor",508,streamer_info::DOUBLE,"Double_t"));//8
  info->add(new streamer_basic_type("fContour","Array to display contour levels",516,streamer_info::OBJECT_ANY,"TArrayD"));//12
  info->add(new streamer_basic_type("fSumw2","Array of sum of squares of weights",528,streamer_info::OBJECT_ANY,"TArrayD"));//12
  info->add(new streamer_basic_type("fOption","histogram options",540,streamer_info::TSTRING,"TString"));//8
  info->add(new streamer_basic_type("fFunctions","->Pointer to list of functions (fits and user)",548,streamer_info::OBJECT_ARROW,"TList*"));//4
  //!fDirectory offset 552 : //4
  //!fDimension offset 556 : //4
  //!fIntegral  offset 560 : //4
  //!fPainter   offset 564 : //4
  //568

  //v3-05-07 : 576  = 568 + 2 * 4 = ok
 }

 {unsigned int check = 0;  
  //this :
  scs(check,"TH1F");
  //base :
  scs(check,"TH1");
  scs(check,"TArrayF");

  StreamerInfo* info = new StreamerInfo("TH1F",1,check);
  a_infos.push_back(info);
  info->add(new streamer_base("TH1","1-Dim histogram base class",0,TH1_version));//568
  info->add(new streamer_base("TArrayF","Array of floats",568,TArrayF_version));//12
 }

  short TH1D_version = 1;
 {unsigned int check = 0;  
  //this :
  scs(check,"TH1D");
  //base :
  scs(check,"TH1");
  scs(check,"TArrayD");

  StreamerInfo* info = new StreamerInfo("TH1D",TH1D_version,check);
  a_infos.push_back(info);
  info->add(new streamer_base("TH1","1-Dim histogram base class",0,TH1_version));//568
  info->add(new streamer_base("TArrayD","Array of doubles",568,TArrayD_version));//12
  //580

  //v3-05-07 : 588 = 576 + 12 = ok
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TProfile");
  //base :
  scs(check,"TH1D");
  //members :
  scs(check,"fBinEntries");
  scs(check,"TArrayD");

  scs(check,"fErrorMode");
  scs(check,"EErrorType");//FIXME : ok ?

  scs(check,"fYmin");
  scs(check,"Double_t");

  scs(check,"fYmax");
  scs(check,"Double_t");

  StreamerInfo* info = new StreamerInfo("TProfile",3,check);
  a_infos.push_back(info);

  info->add(new streamer_base("TH1D","1-Dim histograms (one double per channel)",0,TH1D_version));//580
  info->add(new streamer_basic_type("fBinEntries","number of entries per bin",580,streamer_info::OBJECT_ANY,"TArrayD"));//12
  info->add(new streamer_basic_type("fErrorMode","Option to compute errors",592,streamer_info::DOUBLE,"EErrorType"));//4
  info->add(new streamer_basic_type("fYmin","Lower limit in Y (if set)",596,streamer_info::DOUBLE,"Double_t"));//8
  info->add(new streamer_basic_type("fYmax","Upper limit in Y (if set)",604,streamer_info::DOUBLE,"Double_t"));//8
  //612

  //v3-05-07 : 624 = 612 + 4 + 8 (diff TH1D) = ok
  }

  short TH2_version = 3;
 {unsigned int check = 0;  
  //this :
  scs(check,"TH2");
  //bases :
  scs(check,"TH1");
  //members :
  scs(check,"fScaleFactor");
  scs(check,"Double_t");

  scs(check,"fTsumwy");
  scs(check,"Double_t");

  scs(check,"fTsumwy2");
  scs(check,"Double_t");

  scs(check,"fTsumwxy");
  scs(check,"Double_t");

  StreamerInfo* info = new StreamerInfo("TH2",TH2_version,check);
  a_infos.push_back(info);

  info->add(new streamer_base("TH1","1-Dim histogram base class",0,TH1_version));//568
  info->add(new streamer_basic_type("fScaleFactor","Scale Factor",576,streamer_info::DOUBLE,"Double_t"));//8
  info->add(new streamer_basic_type("fTsumwy","Total Sum of weight*Y",584,streamer_info::DOUBLE,"Double_t"));//8
  info->add(new streamer_basic_type("fTsumwy2","Total Sum of weight*Y*Y",592,streamer_info::DOUBLE,"Double_t"));//8
  info->add(new streamer_basic_type("fTsumwxy","Total Sum of weight*X*Y",600,streamer_info::DOUBLE,"Double_t"));//8
  //600

  //v3-05-07 : <to be checked>
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TH2F");
  //base :
  scs(check,"TH2");
  scs(check,"TArrayF");

  StreamerInfo* info = new StreamerInfo("TH2F",3,check);
  a_infos.push_back(info);

  info->add(new streamer_base("TH2","2-Dim histogram base class",0,TH2_version));//600
  info->add(new streamer_base("TArrayF","Array of floats",600,TArrayF_version));//12
  //612

  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TH2D");
  //base :
  scs(check,"TH2");
  scs(check,"TArrayD");

  StreamerInfo* info = new StreamerInfo("TH2D",3,check);
  a_infos.push_back(info);

  info->add(new streamer_base("TH2","2-Dim histogram base class",0,TH2_version));//600
  info->add(new streamer_base("TArrayD","Array of doubles",600,TArrayD_version));//12
  //612

  }

}

inline void fill_infos(List<StreamerInfo>& a_infos,std::ostream& a_out) {

  fill_infos_core(a_infos,a_out);
  fill_infos_graf(a_infos,a_out);
  fill_infos_tree(a_infos,a_out);
  fill_infos_histo(a_infos,a_out);

}

}}

#endif