CONTAINERS/AliClassInfo.cxx

   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 $Log$
  18 Revision 1.1  2000/11/01 16:01:22  kowal2
  19 Classes for handling the new hits structures
  20
  21 */
  22 ///////////////////////////////////////////////////////////////////////////////
  23 //                                                                           //
  24 //  AliClassInfo                                                             //
  25 //                                                                           //
  26 //Defined to make unified interface to primitive types (in Root described by //
  27 // TDataType) and TClass.                                                    //
  28 // Additional virtual function (comparing to ROOT  TClass) neccesary         //
  29 //                        for AliContainers                                  //
  30 //   virtual void CTORBuffer(void * pointer, UInt_t size=1)                  //
  31 //       should construct buffer of size =size  objects at position pointer  //
  32 //   virtual void DTORBuffer(void * pointer, UInt_t size=1)                  //
  33 //         should destruct buffer of size =size  objects at position pointer //
  34 //   virtual void StreamBuffer(TBuffer& b, const void *object, UInt_t size)  //
  35 //         stream buffer of objects   `
  36 //Begin_Html
  37 //<img src="../gif/AliClassInfo.gif">
  38 //End_Html
  39 //                                                                           //
  40 //                                                                          //
  41 ///////////////////////////////////////////////////////////////////////////////
  42
  43
  44 #include "AliClassInfo.h"
  45 #include "TMath.h"
  46 #include "TClass.h"
  47
  48 #include "TROOT.h"
  49 #include "iostream.h"
  50 #include "AliDataType.h"
  51
  52 ClassImp(AliClassInfo)
  53
  54
  55 TList AliClassInfo::fgList; // list of loaded class
  56
  57 AliClassInfo * AliClassInfo::FindClassInfo(const char * name)
  58 {
  59   //
  60   TIter      next(&fgList);
  61   TString sname(name);
  62   AliClassInfo * info;
  63   while ((info = (AliClassInfo *) next()))
  64     if (info->GetName()==sname) return info;
  65   return 0;
  66 }
  67
  68
  69
  70 AliClassInfo * AliClassInfo::GenerClassInfo(const char * classname)
  71 {
  72    //
  73   // Set class information fClassInfo  according class name
  74   //
  75   char name[100];
  76   AliClassInfo *info=0;
  77   sprintf(name,"AliClassType%s",classname);
  78   info = AliClassInfo::FindClassInfo(classname);
  79   if (info) return info;
  80   //
  81   if ( (!info) &&  (gROOT->GetType(classname),kTRUE)){
  82     //if data type information exist
  83     //    char line[100];
  84     //    sprintf(line,"(*((AliClassInfo**)%p))= new AliDataType(\"%s\");",
  85     //      &info,classname);
  86     // sprintf(line,"new AliDataType(\"%s\");",
  87     //    classname);
  88
  89     //cout<<line<<"\n";
  90     //   gROOT->ProcessLine(line);
  91     new AliDataType(classname);
  92     info = AliClassInfo::FindClassInfo(classname);
  93   }
  94   if (info) return info;
  95
  96   TClass * cl = gROOT->GetClass(classname);
  97   // if exist root class information
  98   if ( (!info) && (gROOT->GetClass(classname))){  //is it class?
  99     char chinter[1000];
 100     sprintf(chinter,"%s.C",classname);
 101     GenerClassInfoCode(classname,kTRUE,cl->GetDeclFileName(),chinter);
 102     info = AliClassInfo::FindClassInfo(classname);
 103   }
 104   if (!info){
 105     TClass * cl = new TClass(classname,0);
 106     if (cl->Size()>0){ //if root information doesn't exist
 107       //but exist cint information
 108       char chinclude[1000];
 109       sprintf(chinclude,"%s.h",classname);
 110       char chinter[1000];
 111       sprintf(chinter,"%s.C",classname);
 112       GenerClassInfoCode(classname,kTRUE,chinclude,chinter);
 113     }
 114   }
 115
 116   return info;
 117 }
 118
 119
 120
 121 void AliClassInfo::GenerClassInfoCode(const char * clname, Bool_t load,
 122                                       const char *incpath, const char *outfile)
 123 {
 124
 125   // gener temporary file - name
 126
 127   FILE *fout = fopen(outfile,"w");
 128   if (!clname){
 129     cerr<<"Class not  specified\n";
 130     return ;
 131   }
 132   char buff[1000];
 133   const char *pchar =incpath;
 134   //replace  with /0
 135   char * pchar2 =buff;
 136   fprintf(fout,"#include \"AliClassInfo.h\"\n");
 137
 138   if (incpath==0) {}
 139   else{
 140     // proces headers - header separated by
 141     pchar =incpath;
 142     pchar2 =buff;
 143     //
 144     while (*pchar==' ') pchar++;
 145     while (*pchar) {
 146       if (*pchar!=' ') *pchar2++ = *pchar;
 147       else
 148         if (*(pchar2-1)!=0) *pchar2++=0;
 149       pchar++;
 150     }
 151     *pchar2=0;
 152     Int_t index = pchar2-buff;
 153     for (Int_t i=0;i<index;i++)
 154       if ( (i==0) ||(buff[i-1]==0))
 155         fprintf(fout,"#include \"%s\"\n",&buff[i]);
 156   }
 157   //process classes
 158   pchar =clname;
 159   pchar2 =buff;
 160   while (*pchar==' ') pchar++;
 161   while (*pchar) {
 162     if (*pchar!=' ') *pchar2++ = *pchar;
 163     else
 164       if (*(pchar2-1)!=0) *pchar2++=0;
 165     pchar++;
 166   }
 167   *pchar2=0;
 168   Int_t index = pchar2-buff;
 169   for (Int_t i=0;i<index;i++)
 170     if ( (i==0) ||(buff[i-1]==0))
 171       GenerClassInterface(&buff[i],fout);
 172
 173   fclose(fout);
 174   //
 175
 176   if (load) {
 177     char line[100];
 178     // gSystem->Rename("/tmp/root_tmpinterinter"
 179     sprintf(line,".L %s+",outfile);
 180     cout<<line<<"\nGenerating class Interface \n";
 181     cout<<line<<"\n*****************************\n";
 182     gROOT->ProcessLine(line);
 183     cout<<line<<"\n*****************************\n";
 184     cout<<line<<"\nClass Interface generated \n";
 185   }
 186 }
 187
 188
 189
 190 Bool_t  AliClassInfo::GenerClassInterface(const char * clname, FILE * fout)
 191 {
 192   //  TClass * cl = gROOT->GetClass("AliLHit",kTRUE);
 193   fprintf(fout,"\n/************************************************/\n");
 194   fprintf(fout,"/* Automaticaly generated interface for class     \n");
 195   fprintf(fout,"                 %s                                \n",clname);
 196   fprintf(fout,"**************************************************/\n");
 197   fprintf(fout,"\n\n");
 198   //constructor
 199   fprintf(fout,"class AliClass%s : public AliClassInfo {\n",clname);
 200   fprintf(fout,"public:\n");
 201   fprintf(fout,"\tAliClass%s(){\n",clname);
 202   fprintf(fout,"\t  SetName(\"%s\");\n",clname);
 203   fprintf(fout,"\t  SetTitle(\"Interface for %s class \");\n",clname);
 204   fprintf(fout,"\t  fgList.Add(this);\n");
 205   fprintf(fout,"\t  fSize = sizeof(%s);\n\t}\n",clname);
 206   //
 207   fprintf(fout,"\tconst char * GetClassName(){ return \"%s\";}\n",clname);
 208   //
 209   fprintf(fout,"\tvirtual TClass* GetClass(){return %s::Class();}\n",clname);
 210  //placement constructor interface
 211   fprintf(fout,"\tvoid CTORBuffer(void * pointer, UInt_t size=1)\n\t{\n");
 212   fprintf(fout,"\t  %s * last = &((%s*)pointer)[size];\n",clname,clname);
 213   fprintf(fout,"\t  %s * p = (%s*)pointer;\n",clname,clname);
 214   fprintf(fout,"\t  while (p!=last) new (p++)%s;\n\t}\n",clname);
 215   //placement destructor interface
 216   fprintf(fout,"\tvoid DTORBuffer(void * pointer, UInt_t size=1)\n\t{\n");
 217   fprintf(fout,"\t  %s * last = &((%s*)pointer)[size];\n",clname,clname);
 218   fprintf(fout,"\t  %s * p = (%s*)pointer;\n",clname,clname);
 219   fprintf(fout,"\t  while (p!=last) (p++)->~%s();\n\t}\n",clname);
 220   //streamer interface
 221   fprintf(fout,"\tvoid StreamBuffer(TBuffer &b,const void * pointer, UInt_t size=1)\n\t{\n");
 222   fprintf(fout,"\t  for (UInt_t i=0;i<size;i++) ((%s*)pointer)[i].Streamer(b);\n\t}\n",clname);
 223   //
 224   fprintf(fout,"\t  void ObjectDump(void *p) {((%s*)p)->Dump();}\n",clname);
 225   fprintf(fout,"};\n");
 226   //make instance of the class
 227   fprintf(fout,"AliClass%s galiclass____%s; \n",clname,clname);
 228   return kTRUE;
 229 }
 230
 231
 232
 233
 234
 235
 236
 237
 238