RootDataConnection.h

Go to the documentation of this file.

#ifndef GAUDIROOT_ROOTDATACONNECTION_H
#define GAUDIROOT_ROOTDATACONNECTION_H

// Framework include files
#include "GaudiKernel/ClassID.h"
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/SmartIF.h"
#include "GaudiUtils/IIODataManager.h"
#include <string>
#include <vector>
#include <map>
#include <set>

#include "TFile.h"
#include "TTreePerfStats.h"
#include "RootCnv/RootRefs.h"

// Forward declarations
class TTree;
class TClass;
class TBranch;

class MsgStream;
class IRegistry;
class DataObject;
class IIncidentSvc;

/*
 *  Gaudi namespace declaration
 */
namespace Gaudi  {

  class GAUDI_API RootConnectionSetup final {
  private:
    std::unique_ptr<MsgStream>    m_msgSvc;
    SmartIF<IIncidentSvc> m_incidentSvc = nullptr;

  public:
    typedef std::vector<std::string> StringVec;

    StringVec     cacheBranches;
    StringVec     vetoBranches;
    std::string   loadSection;
    int           cacheSize;
    int           learnEntries;

    RootConnectionSetup() = default;

    static long setCompression(const std::string& compression);
    static int compression();

    void setMessageSvc(MsgStream* m);
    MsgStream& msgSvc() const {  return *m_msgSvc; }

    void setIncidentSvc(IIncidentSvc* m);
    IIncidentSvc* incidentSvc() const {  return m_incidentSvc.get(); }
  };

  class GAUDI_API RootDataConnection : virtual public Gaudi::IDataConnection  {
  public:

    enum { ROOT_READ_ERROR = 0x2,
       ROOT_OPEN_ERROR = 0x4
    };

    struct ContainerSection {
      ContainerSection() : start(-1), length(0) {}
      ContainerSection(int s, int l) : start(s), length(l) {}
      ContainerSection(const ContainerSection& s) : start(s.start), length(s.length) {}
      ContainerSection& operator=(const ContainerSection& s) {
    if ( this != &s ) {
      start=s.start;
      length=s.length; 
    }
    return *this;
      }
      int start;
      int length;
    };

    typedef std::vector<std::string>                                 StringVec;
    typedef std::vector<std::pair<std::string,std::string> >         ParamMap;
    typedef std::map<std::string,TTree*>                             Sections;
    typedef std::vector<ContainerSection>                            ContainerSections;
    typedef std::map<std::string,ContainerSections>                  MergeSections;
    typedef std::vector<RootRef>                                     LinkSections;
    typedef std::set<const IInterface*>                              Clients;

    MsgStream& msgSvc() const {  return m_setup->msgSvc(); }


  protected:
    std::shared_ptr<RootConnectionSetup> m_setup;
    std::unique_ptr<TTreePerfStats> m_statistics;
    std::unique_ptr<TFile> m_file;
    TTree               *m_refs = nullptr;
    Sections             m_sections;
    StringVec            m_dbs;
    StringVec            m_conts;
    StringVec            m_links;
    StringVec            m_mergeFIDs;
    ParamMap             m_params;
    MergeSections        m_mergeSects;
    LinkSections         m_linkSects;
    Clients              m_clients;
    std::string          m_empty;

    const std::string& empty() const;

    StatusCode saveRefs();

  public:
    class Tool {
    protected:
      typedef RootDataConnection::StringVec          StringVec;
      typedef RootDataConnection::ParamMap           ParamMap;
      typedef RootDataConnection::Sections           Sections;
      typedef RootDataConnection::MergeSections      MergeSections;
      typedef RootDataConnection::LinkSections       LinkSections;
      typedef RootDataConnection::ContainerSection   ContainerSection;
      typedef RootDataConnection::ContainerSections  ContainerSections;

      RootDataConnection* c;
    public:
      TTree*             refs()               const { return c->m_refs;       }
      StringVec&         dbs()                const { return c->m_dbs;        }
      StringVec&         conts()              const { return c->m_conts;      }
      StringVec&         links()              const { return c->m_links;      }
      ParamMap&          params()             const { return c->m_params;     }
      MsgStream&         msgSvc()             const { return c->msgSvc();     }
      const std::string& name()               const { return c->m_name;       }
      Sections&          sections()           const { return c->m_sections;   }
      LinkSections&      linkSections()       const { return c->m_linkSects;  }
      MergeSections&     mergeSections()      const { return c->m_mergeSects; }

      virtual ~Tool() = default;
      virtual TBranch* getBranch(const std::string&  section, const std::string& n) = 0;
      virtual RootRef poolRef(size_t /* which */) const { return RootRef(); }

      virtual StatusCode readRefs() = 0;
      virtual StatusCode saveRefs() = 0;
      virtual int loadRefs(const std::string& section, const std::string& cnt, unsigned long entry, RootObjectRefs& refs) = 0;
    };
    std::unique_ptr<Tool> m_tool;
    friend class Tool;

    Tool* makeTool();

  public:

    RootDataConnection(const IInterface* own, const std::string& nam, std::shared_ptr<RootConnectionSetup> setup);
    ~RootDataConnection() override = default;

    TFile* file() const                         { return m_file.get();                   }
    bool isConnected() const override           { return bool(m_file);                   }
    bool isWritable() const                     { return m_file && m_file->IsWritable(); }
    Tool* tool() const                          { return m_tool.get();                   }
    const MergeSections& mergeSections() const  { return m_mergeSects;                   }
    const StringVec& mergeFIDs() const          { return m_mergeFIDs;                    }


    void addClient(const IInterface* client);
    size_t removeClient(const IInterface* client);
    bool lookupClient(const IInterface* client) const;

    void badWriteError(const std::string& msg)  const;

    std::pair<const RootRef*,const ContainerSection*>  getMergeSection(const std::string& container, int entry) const;

    void enableStatistics(const std::string& section);
    void saveStatistics(const std::string& statisticsFile);

    int loadObj(const std::string& section, const std::string& cnt, unsigned long entry, DataObject*& pObj);

    int loadRefs(const std::string& section, const std::string& cnt, unsigned long entry, RootObjectRefs& refs);

    std::pair<int,unsigned long> saveObj(const std::string& section,const std::string& cnt, TClass* cl, DataObject* pObj, int buff_siz, int split_lvl,bool fill_missing=false);
    std::pair<int,unsigned long> save(const std::string& section,const std::string& cnt, TClass* cl, void* pObj, int buff_siz, int split_lvl,bool fill_missing=false);


    StatusCode connectRead() override;
    StatusCode connectWrite(IoType typ) override;
    StatusCode disconnect() override;
    StatusCode read(void* const, size_t) override  { return StatusCode::FAILURE; }
    StatusCode write(const void*, int) override { return StatusCode::FAILURE; }
    long long int seek(long long int, int) override { return -1; }

    TTree* getSection(const std::string& sect, bool create=false);

    TBranch* getBranch(const std::string& section,const std::string& branch_name)
    { return m_tool->getBranch(section,branch_name); }
    TBranch* getBranch(const std::string& section, const std::string& branch_name, TClass* cl, void* ptr, int buff_siz, int split_lvl);

    void makeRef(IRegistry* pA, RootRef& ref);
    void makeRef(const std::string& name, long clid, int tech, const std::string& db, const std::string& cnt, int entry, RootRef& ref);

    int makeLink(const std::string& p);

    const std::string& getDb(int which) const;

    const std::string& getCont(int which) const
      { return (which>=0)&&(size_t(which)<m_conts.size()) ? *(m_conts.begin()+which) : empty();    }

    const std::string& getLink(int which) const
      { return (which>=0)&&(size_t(which)<m_links.size()) ? *(m_links.begin()+which) : empty();    }
  };
}         // End namespace Gaudi
#endif    // GAUDIROOT_ROOTDATACONNECTION_H