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_ */