Correction connected with compiler warnings on Darwin

diff --git a/HBTAN/AliHBTEvent.h b/HBTAN/AliHBTEvent.h
index cfd0f853a12575cf189e5369d199a69da73abd37..be7ddb799f3ac5f767fbf3228a5db0b160545473 100644 (file)
--- a/HBTAN/AliHBTEvent.h
+++ b/HBTAN/AliHBTEvent.h
@@ -22,7 +22,7 @@ class AliHBTEvent: public TObject
   public:
     AliHBTEvent();
     virtual ~AliHBTEvent();
-    const static UInt_t fgkInitEventSize; //initial number of the array
+    static const UInt_t fgkInitEventSize; //initial number of the array
                                           //if expanded, this size is used also
     AliHBTParticle* GetParticle(Int_t n);  //gets particle 
     AliHBTParticle* GetParticleSafely(Int_t n); //gets particle with index check

diff --git a/HBTAN/AliHBTFunction.cxx b/HBTAN/AliHBTFunction.cxx
index b93d5142bc0351586b52c3319e74b128724cb7df..fd1403e74846769b2566d537abbb2a785a4939aa 100644 (file)
--- a/HBTAN/AliHBTFunction.cxx
+++ b/HBTAN/AliHBTFunction.cxx
@@ -46,6 +46,7 @@ AliHBTFunction::AliHBTFunction():
 //Default constructor
 }
 /******************************************************************/
+
 AliHBTFunction::AliHBTFunction(const char* name,const char* title):
   TNamed(name,title),
   fPairCut(new AliHBTEmptyPairCut()) //dummy cut  
@@ -54,12 +55,27 @@ AliHBTFunction::AliHBTFunction(const char* name,const char* title):
 }
 /******************************************************************/
 
+AliHBTFunction::AliHBTFunction(const AliHBTFunction & source):
+ TNamed(source),
+ fPairCut((AliHBTPairCut*)source.fPairCut->Clone())
+{
+// Copy constructor needed by the coding conventions
+}
+/******************************************************************/
+
 AliHBTFunction::~AliHBTFunction()
 {
 //destructor  
   delete fPairCut;
 }
 /******************************************************************/
+AliHBTFunction & AliHBTFunction::operator= (const AliHBTFunction & source)
+{
+ // Assignment needed by the coding conventions
+  delete fPairCut;
+  fPairCut = (AliHBTPairCut*)source.fPairCut->Clone();
+  return * this;
+}
 
 void AliHBTFunction::WriteFunction()
 {
@@ -236,6 +252,22 @@ AliHBTFunction1D::AliHBTFunction1D(const Char_t *name, const Char_t *title,
 }
 /******************************************************************/
 
+AliHBTFunction1D::AliHBTFunction1D(const AliHBTFunction1D& source):
+ AliHBTFunction(source)
+{
+// Copy constructor needed by the coding conventions byt not used
+  Fatal("AliHBTFunction1D(const AliHBTFunction1D&)","Cpy ctor not usable.");
+}
+/******************************************************************/
+
+AliHBTFunction1D& AliHBTFunction1D::operator= (const AliHBTFunction1D & /*source*/) 
+{
+// Assignment needed by the coding conventions byt not used
+  Fatal("Assignment operator","not implemented");
+  return * this;
+ }
+/******************************************************************/
+
 AliHBTFunction1D::~AliHBTFunction1D()
 {
 //destructor
@@ -400,9 +432,24 @@ AliHBTFunction2D::AliHBTFunction2D(const Char_t *name, const Char_t *title,
   BuildHistos(nXbins,maxXval,minXval,nYbins,maxYval,minYval);
 }        
 /******************************************************************/
+AliHBTFunction2D::AliHBTFunction2D(const AliHBTFunction2D & source):
+ AliHBTFunction(source)
+{
+// Copy constructor needed by the coding conventions byt not used
+  Fatal("AliHBTFunction2D(const AliHBTFunction2D&)","Cpy ctor not usable.");
+}
+/******************************************************************/
+
+AliHBTFunction2D& AliHBTFunction2D::operator= (const AliHBTFunction2D& /*source*/) {
+// Assignment needed by the coding conventions byt not used
+  Fatal("Assignment operator","not implemented");
+  return * this;
+}
+/******************************************************************/
 
 AliHBTFunction2D::~AliHBTFunction2D()
 {
+//dtor
   delete fNumerator;
   delete fDenominator;
 }
@@ -419,7 +466,7 @@ void AliHBTFunction2D::BuildHistos()
 void AliHBTFunction2D::BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
                                    Int_t nybins, Float_t ymax, Float_t ymin)
 {
-  //Builds numerator and denominator histograms (2d-case)
+//Builds numerator and denominator histograms (2d-case)
  TString numstr = fName + " Numerator";  //title and name of the 
                                            //numerator histogram
  TString denstr = fName + " Denominator";//title and name of the 
@@ -446,9 +493,9 @@ void AliHBTFunction2D::SetNumberOfBinsToScale(UInt_t xn, UInt_t yn)
 
 Double_t AliHBTFunction2D::Scale()
 {
-  // Calculates the factor that should be used to scale 
-  // quatience of fNumerator and fDenominator to 1 at 
-  // given region
+// Calculates the factor that should be used to scale 
+// quatience of fNumerator and fDenominator to 1 at 
+// given region
   if (gDebug>0) Info("Scale","Enetered Scale()");
   if(!fNumerator) 
    {
@@ -596,6 +643,22 @@ AliHBTFunction3D::AliHBTFunction3D(const Char_t *name, const Char_t *title,
 }        
 /******************************************************************/
 
+AliHBTFunction3D::AliHBTFunction3D(const AliHBTFunction3D& source):
+ AliHBTFunction(source)
+{
+// Copy constructor needed by the coding conventions byt not used
+  Fatal("AliHBTFunction3D(const AliHBTFunction3D&)","Cpy ctor not usable.");
+}
+/******************************************************************/
+
+AliHBTFunction3D& AliHBTFunction3D::operator= (const AliHBTFunction3D & /*source*/) 
+{
+// Assignment needed by the coding conventions byt not used
+  Fatal("Assignment operator","not implemented");
+  return * this;
+ }
+/******************************************************************/
+
 
 AliHBTFunction3D::~AliHBTFunction3D()
 {

diff --git a/HBTAN/AliHBTFunction.h b/HBTAN/AliHBTFunction.h
index eb56486892ab0e55da5d3f2519683ae959b2079f..0eb565509bb503e069fd8f69b94c60bb3fd284f9 100644 (file)
--- a/HBTAN/AliHBTFunction.h
+++ b/HBTAN/AliHBTFunction.h
@@ -29,20 +29,12 @@ class AliHBTFunction: public TNamed
 {
   public:
     AliHBTFunction();
-    AliHBTFunction(const char* name,const char* title);
+    AliHBTFunction(const char* name, const char* title);
+    AliHBTFunction(const AliHBTFunction & source);
+    
     virtual ~AliHBTFunction();
     
-  AliHBTFunction(const AliHBTFunction & source) {
-    // Copy constructor needed by the coding conventions byt not used
-    Fatal("AliHBTFunction(const AliHBTFunction & source)",
-         "not implemented");
-  }
-
-  AliHBTFunction & operator= (const AliHBTFunction & source) {
-    // Assignment needed by the coding conventions byt not used
-    Fatal("Assignment operator","not implemented");
-    return * this;
-  }
+    AliHBTFunction & operator= (const AliHBTFunction & source);
 
     virtual TH1* GetNumerator() const = 0;
     virtual TH1* GetDenominator() const = 0;
@@ -63,7 +55,7 @@ class AliHBTFunction: public TNamed
     virtual void BuildHistos() = 0;//builds default histograms
     AliHBTPairCut*   fPairCut;     //pair cut
     
-   ClassDef(AliHBTFunction,2)
+    ClassDef(AliHBTFunction,2)
 };
 /******************************************************************/
 inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
@@ -175,16 +167,9 @@ class AliHBTFunction1D: public AliHBTFunction
   AliHBTFunction1D(const Char_t *name, const Char_t *title);
   AliHBTFunction1D(const Char_t *name, const Char_t *title,
                    Int_t nbins, Float_t maxXval, Float_t minXval);
-  AliHBTFunction1D(const AliHBTFunction1D & source) {
-    // Copy constructor needed by the coding conventions byt not used
-    Fatal("AliHBTFunction1D(const AliHBTFunction1D & source)",
-         "not implemented");
-  }
-  AliHBTFunction1D & operator= (const AliHBTFunction1D & source) {
-    // Assignment needed by the coding conventions byt not used
-    Fatal("Assignment operator","not implemented");
-    return * this;
-  }
+
+  AliHBTFunction1D(const AliHBTFunction1D & source);
+  AliHBTFunction1D & operator= (const AliHBTFunction1D& /*source*/);
 
   virtual ~AliHBTFunction1D();
   
@@ -244,17 +229,9 @@ class AliHBTFunction2D: public AliHBTFunction
                       Int_t nXbins, Double_t maxXval, Double_t minXval, 
                       Int_t nYbins, Double_t maxYval, Double_t minYval);
          
-  AliHBTFunction2D(const AliHBTFunction2D & source) {
-    // Copy constructor needed by the coding conventions byt not used
-    Fatal("AliHBTFunction2D(const AliHBTFunction2D & source)",
-         "not implemented");
-  }
-
-  AliHBTFunction2D & operator= (const AliHBTFunction2D & source) {
-    // Assignment needed by the coding conventions byt not used
-    Fatal("Assignment operator","not implemented");
-    return * this;
-  }
+  AliHBTFunction2D(const AliHBTFunction2D & source);
+
+  AliHBTFunction2D & operator= (const AliHBTFunction2D & /*source*/);
 
   virtual ~AliHBTFunction2D();
   
@@ -325,17 +302,8 @@ class AliHBTFunction3D: public AliHBTFunction
                    Int_t nYbins, Double_t maxYval, Double_t minYval, 
                    Int_t nZbins, Double_t maxZval, Double_t minZval);
 
-  AliHBTFunction3D(const AliHBTFunction3D & source) {
-    // Copy constructor needed by the coding conventions byt not used
-    Fatal("AliHBTFunction3D(const AliHBTFunction3D & source)",
-         "not implemented");
-  }
-
-  AliHBTFunction3D & operator= (const AliHBTFunction3D & source) {
-    // Assignment needed by the coding conventions byt not used
-    Fatal("Assignment operator","not implemented");
-    return * this;
-  }
+  AliHBTFunction3D(const AliHBTFunction3D & source);
+  AliHBTFunction3D & operator= (const AliHBTFunction3D & /*source*/);
 
   virtual ~AliHBTFunction3D();//destructor
 

diff --git a/HBTAN/AliHBTPairCut.h b/HBTAN/AliHBTPairCut.h
index 7de68ac0041c796bc3254c5e03b0bbadbee1ade2..caf9ef679e26931b5b0cfccd9f1e2107dae60014 100644 (file)
--- a/HBTAN/AliHBTPairCut.h
+++ b/HBTAN/AliHBTPairCut.h
@@ -41,7 +41,7 @@ class AliHBTPairCut: public TNamed
   
   void SetPartCut(AliHBTParticleCut* cut);//sets the the same cut on both particles
   
-  void AddBasePairCut(AliHbtBasePairCut* cut);
+  virtual void AddBasePairCut(AliHbtBasePairCut* cut);
   
   void SetQInvRange(Double_t min, Double_t max);
   void SetKtRange(Double_t min, Double_t max);
@@ -76,7 +76,7 @@ class AliHBTEmptyPairCut:  public AliHBTPairCut
   //Class describing cut on pairs of particles
  public:
   AliHBTEmptyPairCut(){};
-  AliHBTEmptyPairCut(const AliHBTEmptyPairCut& in){}; 
+  AliHBTEmptyPairCut(const AliHBTEmptyPairCut& in):AliHBTPairCut(in){};
   virtual ~AliHBTEmptyPairCut(){};
   
   Bool_t Pass(AliHBTPair*) const {return kFALSE;} //accpept everything