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 <map>
#include <set>
#include <string>
#include <vector>

#include "RootCnv/RootRefs.h"
#include "TFile.h"
#include "TTreePerfStats.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 StatusCode 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