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 "boost/utility/string_ref.hpp"
#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( boost::string_ref 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 class Status : StatusCode::code_t { 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*, std::less<>> Sections;
    typedef std::vector<ContainerSection> ContainerSections;
    typedef std::map<std::string, ContainerSections, std::less<>> 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( boost::string_ref section, boost::string_ref n ) = 0;
      virtual RootRef poolRef( size_t /* which */ ) const { return RootRef(); }

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

    Tool* makeTool();

  public:
    RootDataConnection( const IInterface* own, boost::string_ref nam, std::shared_ptr<RootConnectionSetup> setup );

    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( boost::string_ref msg ) const;

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

    void enableStatistics( boost::string_ref section );
    void saveStatistics( boost::string_ref statisticsFile );

    int loadObj( boost::string_ref section, boost::string_ref cnt, unsigned long entry, DataObject*& pObj );

    int loadRefs( boost::string_ref section, boost::string_ref cnt, unsigned long entry, RootObjectRefs& refs );

    std::pair<int, unsigned long> saveObj( boost::string_ref section, boost::string_ref cnt, TClass* cl,
                                           DataObject* pObj, int buff_siz, int split_lvl, bool fill_missing = false );
    std::pair<int, unsigned long> save( boost::string_ref section, boost::string_ref 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( boost::string_ref sect, bool create = false );

    TBranch* getBranch( boost::string_ref section, boost::string_ref branch_name ) {
      return m_tool->getBranch( section, branch_name );
    }
    TBranch* getBranch( boost::string_ref section, boost::string_ref branch_name, TClass* cl, void* ptr, int buff_siz,
                        int split_lvl );

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

    int makeLink( boost::string_ref 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

STATUSCODE_ENUM_DECL( Gaudi::RootDataConnection::Status )

#endif // GAUDIROOT_ROOTDATACONNECTION_H