FairMultiLinkedData.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file FairMultiLinkedData.h

#ifndef FAIRMULTILINKEDDATA_H_
#define FAIRMULTILINKEDDATA_H_

//#include "FairLinkedData.h"
#include "FairLink.h"
#include "FairRootManager.h"
#include "TClonesArray.h"
#include "TObject.h"
#include <set>
#include <utility>

class FairMultiLinkedData : public  TObject
{
  public:
    FairMultiLinkedData();
    FairMultiLinkedData(std::set<FairLink> links, Bool_t persistanceCheck = kTRUE);
    FairMultiLinkedData(TString dataType, std::vector<Int_t> links, Int_t fileId = -1, Int_t evtId = -1,Bool_t persistanceCheck = kTRUE, Bool_t bypass = kFALSE, Float_t mult = 1.0);
    FairMultiLinkedData(Int_t dataType, std::vector<Int_t> links, Int_t fileId = -1, Int_t evtId = -1, Bool_t persistanceCheck = kTRUE, Bool_t bypass = kFALSE, Float_t mult = 1.0);

    virtual ~FairMultiLinkedData() {};

    virtual std::set<FairLink>    GetLinks() const {    return fLinks;}           
    virtual Int_t           GetNLinks() const { return fLinks.size(); }       
    virtual FairLink        GetLink(Int_t pos) const;                 
    virtual FairMultiLinkedData   GetLinksWithType(Int_t type) const;             
    TObject*         GetData(FairLink& myLink);                  
    virtual Int_t GetDefaultType() { return fDefaultType;}
    Bool_t              GetPersistanceCheck() {return fPersistanceCheck;}     
    Int_t             GetVerbose() {return fVerbose;}             
    virtual void SetDefaultType(Int_t type) {  fDefaultType = type;}
    virtual void SetPersistanceCheck(Bool_t check) {fPersistanceCheck = check;}       
    virtual void SetVerbose(Int_t level) {fVerbose = level;}                

    virtual void SetLinks(FairMultiLinkedData links, Float_t mult = 1.0);           
    virtual void SetLink(FairLink link, Bool_t bypass = kFALSE, Float_t mult = 1.0);      

    virtual void AddLinks(FairMultiLinkedData links, Float_t mult = 1.0);           
    virtual void AddLink(FairLink link, Bool_t bypass = kFALSE, Float_t mult = 1.0);      

    virtual void InsertLink(FairLink link);                         



    virtual void AddAllWeights(Double_t weight);                        
    virtual void SetAllWeights(Double_t weight);                        
    virtual void MultiplyAllWeights(Double_t weight);                   


    virtual Bool_t IsLinkInList(FairLink link)    {return IsLinkInList(link.GetType(), link.GetIndex());}   
    virtual Bool_t IsLinkInList(Int_t type, Int_t index);                             
    virtual Int_t LinkPosInList(FairLink link)  {return LinkPosInList(link.GetType(), link.GetIndex());}    
    virtual Int_t LinkPosInList(Int_t type, Int_t index);                             

    virtual void DeleteLink(FairLink link)    {DeleteLink(link.GetType(), link.GetIndex());}          
    virtual void DeleteLink(Int_t type, Int_t index);                               

    virtual void Reset() {ResetLinks();}
    virtual void ResetLinks() {fLinks.clear();}                                    


    void Print(std::ostream& out = std::cout) const {
      out << "[";
      for (Int_t i = 0; i < GetNLinks(); i++) {
        GetLink(i).Print(out);
        out << " ";
      }
      out << "]";
    }                                                     

    friend std::ostream& operator<< (std::ostream& out, const FairMultiLinkedData& data) {
      data.Print(out);
      return out;
    }                                                     

  protected:
    std::set<FairLink> fLinks;
    Bool_t fPersistanceCheck;
    Int_t fVerbose;

    virtual void SimpleAddLinks(Int_t fileId, Int_t evtId, Int_t dataType, std::vector<Int_t> links, Bool_t bypass, Float_t mult) {
      for (UInt_t i = 0; i < links.size(); i++) {
        AddLink(FairLink(fileId, evtId, dataType, links[i]), bypass, mult);
      }
    }
    Int_t fDefaultType;


    ClassDef(FairMultiLinkedData, 3);
};

#endif /* FAIRMULTILinkedData_H_ */