FairMultiLinkedData_Interface.h

Go to the documentation of this file.

 
#ifndef FairMultiLinkedData_Interface_H_
#define FairMultiLinkedData_Interface_H_
 
#include "FairLink.h"   // for FairLink
#include "FairMultiLinkedData.h"
 
#include <Rtypes.h>    // for Int_t, Bool_t, kFALSE, etc
#include <TObject.h>   // for TObject
#include <TString.h>   // for TString
#include <iostream>    // for operator<<, ostream, cout
#include <memory>      // for std::unique_ptr
#include <set>         // for set
#include <vector>      // for vector
 
class FairMultiLinkedData_Interface : public TObject
{
  public:
    FairMultiLinkedData_Interface() = default;   
    FairMultiLinkedData_Interface(FairMultiLinkedData& links, Bool_t persistanceCheck = kTRUE);   
    FairMultiLinkedData_Interface(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_Interface(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);   
    FairMultiLinkedData_Interface(const FairMultiLinkedData_Interface& toCopy);
 
    ~FairMultiLinkedData_Interface() = default;
 
    FairMultiLinkedData_Interface& operator=(const FairMultiLinkedData_Interface& rhs);
 
    std::set<FairLink> GetLinks() const;                      
    Int_t GetNLinks() const;                                  
    FairLink GetLink(Int_t pos) const;                        
    FairMultiLinkedData GetLinksWithType(Int_t type) const;   
    FairLink GetEntryNr() const;
    FairMultiLinkedData* GetPointerToLinks() const { return fLink.get(); }   
 
    std::vector<FairLink> GetSortedMCTracks();
 
    void SetLinks(FairMultiLinkedData links);   
    void SetLink(FairLink link);                
    void SetInsertHistory(Bool_t val);
    void SetEntryNr(FairLink val);
    void SetPointerToLinks(FairMultiLinkedData* links) { fLink.reset(links); }
    void SetPointerToLinks(std::unique_ptr<FairMultiLinkedData> links) { fLink = std::move(links); }
 
    void AddLinks(FairMultiLinkedData links,
                  Float_t mult = 1.0);   
    void AddLink(FairLink link);   
    void AddInterfaceData(FairMultiLinkedData_Interface* data);
 
    void ResetLinks();
 
    std::ostream& PrintLinkInfo(std::ostream& out = std::cout) const
    {
        if (GetPointerToLinks() != 0)
            GetPointerToLinks()->PrintLinkInfo(out);
        return out;
    }   
 
    friend std::ostream& operator<<(std::ostream& out, const FairMultiLinkedData_Interface& data)
    {
        data.PrintLinkInfo(out);
        return out;
    }   
 
  protected:
    std::unique_ptr<FairMultiLinkedData> fLink;
    FairMultiLinkedData* CreateFairMultiLinkedData();   
 
    ClassDef(FairMultiLinkedData_Interface, 6);
};
 
#endif /* FairMultiLinkedData_Interface_H_ */