FairMultiLinkedData.h

Go to the documentation of this file.

/********************************************************************************
 *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
 *                                                                              *
 *              This software is distributed under the terms of the             *
 *              GNU Lesser General Public Licence (LGPL) version 3,             *
 *                  copied verbatim in the file "LICENSE"                       *
 ********************************************************************************/
#ifndef FAIRMULTILINKEDDATA_H_
#define FAIRMULTILINKEDDATA_H_

#include "FairLink.h"   // for FairLink

#include <Rtypes.h>    // for Int_t, Bool_t, kFALSE, etc
#include <TObject.h>   // for TObject
#include <TString.h>   // for TString
#include <iosfwd>      // for ostream
#include <iostream>    // for operator<<, ostream, cout
#include <set>         // for set
#include <vector>      // for vector

class FairMultiLinkedData : public TObject
{
  public:
    FairMultiLinkedData();                                                                   
    FairMultiLinkedData(const std::set<FairLink>& links, Bool_t persistanceCheck = kTRUE);   
    FairMultiLinkedData(TString dataType,
                        const 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,
                        const 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 FairLink GetEntryNr() const { return fEntryNr; }         
    virtual Int_t GetNLinks() const { return fLinks.size(); }        
    virtual FairLink GetLink(Int_t pos) const;                       
    virtual FairMultiLinkedData GetLinksWithType(
        Int_t type) const;   
    virtual std::vector<FairLink>
        GetSortedMCTracks();   
    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 SetInsertHistory(Bool_t val)
    {
        fInsertHistory = val;
    }   
    Bool_t GetInsertHistory() const { return fInsertHistory; }

    virtual void SetEntryNr(FairLink entry) { fEntryNr = entry; }
    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 InsertHistory(
        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(); }   

    std::ostream& PrintLinkInfo(std::ostream& out = std::cout) const
    {
        out << GetEntryNr() << " -> [";
        for (Int_t i = 0; i < GetNLinks(); i++) {
            GetLink(i).PrintLinkInfo(out);
            out << " ";
        }
        out << "]";
        return out;
    }   

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

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

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

    ClassDef(FairMultiLinkedData, 4);
};

#endif /* FAIRMULTILinkedData_H_ */