NcObjMatrix.cxx

Go to the documentation of this file.

 
#include "NcObjMatrix.h"
#include "Riostream.h"
 
ClassImp(NcObjMatrix); // Class implementation to enable ROOT I/O
 
NcObjMatrix::NcObjMatrix() : TNamed()
{
 
 fRows=0;
 fOwn=0;
 fSwap=0;
 fMaxrow=0;
 fMaxcol=0;
 fObjects=0;
}

NcObjMatrix::~NcObjMatrix()
{
 
 if (fRows)
 {
  delete fRows;
  fRows=0;
 }
 if (fObjects)
 {
  delete fObjects;
  fObjects=0;
 }
}

NcObjMatrix::NcObjMatrix(const NcObjMatrix& m) : TNamed(m)
{
 
 fRows=0;
 fMaxrow=0;
 fMaxcol=0;
 fObjects=0;
 
 fOwn=m.fOwn;
 fSwap=m.fSwap;
 
 Int_t maxrow=m.GetMaxRow();
 Int_t maxcol=m.GetMaxColumn();
 for (Int_t irow=1; irow<=maxrow; irow++)
 {
  for (Int_t icol=1; icol<=maxcol; icol++)
  {
   TObject* obj=m.GetObject(irow,icol);
   if (obj)
   {
    if (!fOwn)
    {
     EnterObject(irow,icol,obj);
    }
    else
    {
     EnterObject(irow,icol,obj->Clone());
    }
   }
  }
 }
}

void NcObjMatrix::Reset()
{
 
 if (fRows)
 {
  delete fRows;
  fRows=0;
 }
 if (fObjects)
 {
  delete fObjects;
  fObjects=0;
 }
 
 fMaxrow=0;
 fMaxcol=0;
}

void NcObjMatrix::SetOwner(Int_t own)
{
 
 fOwn=own;
 
 if (!fRows) return;
 
 for (Int_t irow=0; irow<fRows->GetSize(); irow++)
 {
  TObjArray* mrow=(TObjArray*)fRows->At(irow);
  if (mrow)
  {
   if (own)
   {
    mrow->SetOwner(kTRUE);
   }
   else
   {
    mrow->SetOwner(kFALSE);
   }
  }
 }
}

Int_t NcObjMatrix::GetOwner() const
{
 
 return fOwn;
}

void NcObjMatrix::SetSwapMode(Int_t swap)
{
 
 if (!fRows)
 {
  fSwap=swap;
 }
 else
 {
  cout << " *NcObjMatrix::SetSwapMode* Matrix not empty ==> No action." << endl;
 }
}

Int_t NcObjMatrix::GetSwapMode() const
{
 
 return fSwap;
}

void NcObjMatrix::EnterObject(Int_t row,Int_t col,TObject* obj)
{
 
 if (row<1 || col<1)
 {
  cout << " *NcObjMatrix::AddObject* Invalid argument(s) (row,col) : ("
       << row << "," << col << ")" << endl;
  return;
 }
 
 if (row>fMaxrow) fMaxrow=row;
 if (col>fMaxcol) fMaxcol=col;
 
 Int_t rowx=row;
 if (fSwap) rowx=col;
 Int_t colx=col;
 if (fSwap) colx=row;
 
 if (!fRows)
 {
  fRows=new TObjArray(rowx);
  fRows->SetOwner();
 }
 else
 {
  if (rowx > fRows->GetSize()) fRows->Expand(rowx);
 }
 
 TObjArray* mrow=(TObjArray*)fRows->At(rowx-1);
 
 if (!mrow)
 {
  TObjArray* columns=new TObjArray(colx);
  if (fOwn) columns->SetOwner();
  fRows->AddAt(columns,rowx-1);
  mrow=columns;
 }
 else
 {
  if (colx > mrow->GetSize()) mrow->Expand(colx);
 }
 
 TObject* old=(TObject*)mrow->At(colx-1);
 if (old)
 {
  fObjects->Remove(old);
  fObjects->Compress();
  if (fOwn) delete old;
 }
 
 mrow->AddAt(obj,colx-1);
 
 if (!fObjects) fObjects=new TObjArray();
 fObjects->Add(obj);
}

void NcObjMatrix::RemoveObject(Int_t row,Int_t col)
{
 
 TObject* obj=0;
 
 if (!fRows || row<1 || col<1) return;
 
 
 Int_t rowx=row;
 if (fSwap) rowx=col;
 Int_t colx=col;
 if (fSwap) colx=row;
 
 TObjArray* mrow=0;
 if (rowx <= fRows->GetSize()) mrow=(TObjArray*)fRows->At(rowx-1);
 
 if (!mrow) return;
 
 if (colx <= mrow->GetSize()) obj=(TObject*)mrow->At(colx-1);
 
 if (obj)
 {
  fObjects->Remove(obj);
  fObjects->Compress();
  mrow->Remove(obj);
  if (fOwn) delete obj;
 }
}

void NcObjMatrix::RemoveObjects(TObject* obj,Int_t row,Int_t col)
{
 
 TArrayI rows;
 TArrayI cols;
 Int_t nrefs=0;
 
 if (row && col)
 {
  if (!obj)
  {
   RemoveObject(row,col);
  }
  else
  {
   TObject* objx=GetObject(row,col);
   if (objx==obj) RemoveObject(row,col);
  }
  return;
 }
 
 if (!row && !col)
 {
  if (!obj)
  {
   Reset();
   return;
  }
  else
  {
   nrefs=GetIndices(obj,rows,cols);
  }
 }
 
 if (row && !col) nrefs=GetIndices(obj,row,cols);
 if (!row && col) nrefs=GetIndices(obj,rows,col);
 
 // Remove the selected objects based on the obtained row and column indices
 Int_t irow,icol;
 for (Int_t i=0; i<nrefs; i++)
 {
  irow=row;
  if (!irow) irow=rows.At(i);
  icol=col;
  if (!icol) icol=cols.At(i);
  RemoveObject(irow,icol);
 }
}

TObject* NcObjMatrix::GetObject(Int_t row,Int_t col) const
{
 
 TObject* obj=0;
 
 if (!fRows || row<1 || col<1) return obj;
 
 
 Int_t rowx=row;
 if (fSwap) rowx=col;
 Int_t colx=col;
 if (fSwap) colx=row;
 
 TObjArray* mrow=0;
 if (rowx <= fRows->GetSize()) mrow=(TObjArray*)fRows->At(rowx-1);
 
 if (!mrow) return obj;
 
 if (colx <= mrow->GetSize()) obj=(TObject*)mrow->At(colx-1);
 
 return obj;
}

TObject* NcObjMatrix::GetObject(Int_t j) const
{
 
 TObject* obj=0;
 Int_t nobj=0;
 if (fObjects) nobj=fObjects->GetSize();
 
 if (j>0 && j<=nobj) obj=(TObject*)fObjects->At(j-1);
 
 return obj;
}

TObjArray* NcObjMatrix::GetObjects()
{
 
 return fObjects;
}

Int_t NcObjMatrix::GetMaxRow() const
{
 
 return fMaxrow;
}

Int_t NcObjMatrix::GetMaxColumn() const
{
 
 return fMaxcol;
}

Int_t NcObjMatrix::GetNobjects() const
{
 
 Int_t nobj=0;
 if (fObjects) nobj=fObjects->GetEntries();
 
 return nobj;
}

Int_t NcObjMatrix::GetNrefs(TObject* obj) const
{
 
 Int_t nobjs=GetNobjects();
 
 if (!obj) return nobjs;
 
 Int_t nrefs=0;
 for (Int_t i=1; i<=nobjs; i++)
 {
  TObject* objx=GetObject(i);
  if (objx==obj) nrefs++;
 }
 return nrefs;
}

Int_t NcObjMatrix::GetIndices(TObject* obj,TArrayI& rows,TArrayI& cols) const
{
 
 Int_t nrefs=GetNrefs(obj);
 rows.Reset();
 cols.Reset();
 rows.Set(nrefs);
 cols.Set(nrefs);
 if (!nrefs) return 0;
 
 Int_t irow,icol;
 Int_t jref=0;
 for (Int_t i=0; i<fRows->GetSize(); i++)
 {
  TObjArray* columns=(TObjArray*)fRows->At(i);
  if (!columns) continue;
 
  for (Int_t j=0; j<columns->GetSize(); j++)
  {
   TObject* objx=(TObject*)columns->At(j);
   if (objx && (objx==obj || !obj))
   {
    irow=i+1;
    if (fSwap) irow=j+1;
    icol=j+1;
    if (fSwap) icol=i+1;
    rows.AddAt(irow,jref);
    cols.AddAt(icol,jref);
    jref++;
   }
   // All references found ==> Done
   if (jref==nrefs) break;
  }
  // All references found ==> Done
  if (jref==nrefs) break;
 }
 return nrefs;
}

Int_t NcObjMatrix::GetIndices(TObject* obj,Int_t row,TArrayI& cols) const
{
 
 cols.Reset();
 
 if (row<0 || row>GetMaxRow()) return 0;
 
 Int_t nrefs=GetNrefs(obj);
 cols.Set(nrefs);
 if (!nrefs) return 0;
 
 Int_t irow,icol;
 Int_t jref=0;
 
 // No specific row selection
 if (!row)
 {
  TArrayI ar;
  TArrayI ac;
  Int_t n=GetIndices(obj,ar,ac);
  Int_t found=0;
  for (Int_t idx=0; idx<n; idx++)
  {
   icol=ac.At(idx);
   found=0;
   for (Int_t k=0; k<jref; k++)
   {
    if (icol==cols.At(k)) found=1;
   }
   if (!found)
   {
    cols.AddAt(icol,jref);
    jref++;
   }
  }
  // Set the array size to the actual number of different column indices
  cols.Set(jref);
 
  return jref;
 }
 
 // Specific row selection
 for (Int_t i=0; i<fRows->GetSize(); i++)
 {
  TObjArray* columns=(TObjArray*)fRows->At(i);
  if (!columns) continue;
 
  for (Int_t j=0; j<columns->GetSize(); j++)
  {
   TObject* objx=(TObject*)columns->At(j);
   if (objx && (objx==obj || !obj))
   {
    irow=i+1;
    if (fSwap) irow=j+1;
    icol=j+1;
    if (fSwap) icol=i+1;
    if (irow==row)
    {
     cols.AddAt(icol,jref);
     jref++;
    }
   }
   // All references found ==> Done
   if (jref==nrefs) break;
  }
  // All references found ==> Done
  if (jref==nrefs) break;
 }
 // Set the array size to the actual number of found occurrences
 cols.Set(jref);
 
 return jref;
}

Int_t NcObjMatrix::GetIndices(TObject* obj,TArrayI& rows,Int_t col) const
{
 
 rows.Reset();
 
 if (col<0 || col>GetMaxColumn()) return 0;
 
 Int_t nrefs=GetNrefs(obj);
 rows.Set(nrefs);
 if (!nrefs) return 0;
 
 Int_t irow,icol;
 Int_t jref=0;
 
 // No specific column selection
 if (!col)
 {
  TArrayI ar;
  TArrayI ac;
  Int_t n=GetIndices(obj,ar,ac);
  Int_t found=0;
  for (Int_t idx=0; idx<n; idx++)
  {
   irow=ar.At(idx);
   found=0;
   for (Int_t k=0; k<jref; k++)
   {
    if (irow==rows.At(k)) found=1;
   }
   if (!found)
   {
    rows.AddAt(irow,jref);
    jref++;
   }
  }
  // Set the array size to the actual number of different row indices
  rows.Set(jref);
 
  return jref;
 }
 
 // Specific column selection
 for (Int_t i=0; i<fRows->GetSize(); i++)
 {
  TObjArray* columns=(TObjArray*)fRows->At(i);
  if (!columns) continue;
 
  for (Int_t j=0; j<columns->GetSize(); j++)
  {
   TObject* objx=(TObject*)columns->At(j);
   if (objx && (objx==obj || !obj))
   {
    irow=i+1;
    if (fSwap) irow=j+1;
    icol=j+1;
    if (fSwap) icol=i+1;
    if (icol==col)
    {
     rows.AddAt(irow,jref);
     jref++;
    }
   }
   // All references found ==> Done
   if (jref==nrefs) break;
  }
  // All references found ==> Done
  if (jref==nrefs) break;
 }
 // Set the array size to the actual number of found occurrences
 rows.Set(jref);
 
 return jref;
}

TObject* NcObjMatrix::Clone(const char* name) const
{
 
 NcObjMatrix* m=new NcObjMatrix(*this);
 if (name)
 {
  if (strlen(name)) m->SetName(name);
 }
 return m;
}