RootTreeContainer.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
//====================================================================
//    Root Database implementation
//--------------------------------------------------------------------
//
//    Package    : APR RootStorageSvc (former POOL project)
//
//    Author     : M.Frank M.Nowak S.Snyder
//====================================================================
#ifndef POOL_ROOTTREECONTAINER_H
#define POOL_ROOTTREECONTAINER_H 1
 
// Framework include files
#include "StorageSvc/DbDatabase.h"
#include "StorageSvc/DbContainerImp.h"
 
#include <map>
#include <vector>
#include <set>
#include <functional>
 
// Forward declarations
class TBranch;
class TTree;
class TLeaf;
class TClass;
 
namespace SG { class IAuxStoreIO; }
namespace RootAuxDynIO {
   class IRootAuxDynWriter;
   class IRootAuxDynReader;
}
     
 
/*
 * POOL namespace declaration
 */
namespace pool  { 
 
  // Forward declaration
   class DbColumn;
   class RootDatabase;
 
  class RootTreeContainer : public DbContainerImp
  {
  protected:
 
    struct BranchDesc {
      TClass*           clazz   = nullptr;
      TBranch*          branch  = nullptr;
      TLeaf*            leaf    = nullptr;
      void*             object  = nullptr;
      void*             buffer  = nullptr;
      const DbColumn*   column  = nullptr;
 
      // ----  extra variables used for AuxDyn attributes
      // number of rows written to this branch so far
      size_t            rows_written = 0;
 
      int               aux_iostore_IFoffset = -1;
      // AuxDyn writer and the reader for this branch (object type)
      std::unique_ptr<RootAuxDynIO::IRootAuxDynWriter>  auxdyn_writer;
      std::unique_ptr<RootAuxDynIO::IRootAuxDynReader>  auxdyn_reader;
 
 
      BranchDesc() = default;
      BranchDesc(TClass* cl, TBranch* b, TLeaf* l, void* o, const DbColumn* c);
      BranchDesc(BranchDesc && other) = default;
      BranchDesc(BranchDesc const& other) = delete;
 
      BranchDesc& operator=(BranchDesc const& other) = delete;
      BranchDesc& operator=(BranchDesc && other) = default;
      SG::IAuxStoreIO* getIOStorePtr();
    };
 
    typedef std::vector<BranchDesc> Branches;
 
    TTree*             m_tree;
    const DbTypeInfo*  m_type;
    Branches           m_branches;
    DbDatabase         m_dbH;
    RootDatabase*      m_rootDb;
    std::string        m_branchName;
    int                m_ioBytes;
    bool               m_treeFillMode;
    bool               m_isDirty;
 
  private:
 
    DbStatus addBranch( const DbColumn* col,
                        BranchDesc& dsc,
                        const std::string& desc);
 
    DbStatus addObject( DbDatabase& dbH,
                        const DbColumn* col,
                        BranchDesc& dsc,
                        const std::string& desc,
                        int splitLevel,
                        int bufferSize,
                        int branchOffsetTabLen);
 
    DbStatus selectRow( const DataCallBack* call,
                        const Token::OID_t& linkH,
                        DbAccessMode        mode);
 
    // Routine needed for TRANSACT_FLUSH, if branch is specified by user.
    DbStatus finishTransAct();
 
    TBranch* branch(const std::string& nam)  const;
 
    void setBranchOffsetTabLen(TBranch* b, int offsettab_len);  
    
  public:
    RootTreeContainer();
 
    virtual ~RootTreeContainer();
 
    virtual DbStatus close() override;
 
    virtual DbStatus open(DbDatabase& dbH, 
                          const std::string& nam, 
                          const DbTypeInfo* info,
                          DbAccessMode mod) override;
 
 
    virtual DbStatus getOption(DbOption& opt) override;
 
 
    virtual DbStatus setOption(const DbOption& opt) override;
 
    virtual DbStatus isShapeSupported(const DbTypeInfo* typ) const override;
 
    virtual DbStatus select(DbSelect& criteria) override;
 
    virtual uint64_t size() override;
 
    TTree*      getTTree() { return m_tree; }
 
    const std::string& getName() const { return m_name; }
 
    bool        isBranchContainer() const { return !m_branchName.empty(); }
 
    void        setTreeFillMode(bool mode);
 
    bool        usingTreeFillMode() const { return  m_treeFillMode; }
 
    bool        isDirty() const { return m_isDirty; }
 
    void        clearDirty() { m_isDirty = false; }
 
    virtual DbStatus fetch(DbSelect& sel) override;
 
    virtual DbStatus fetch(const Token::OID_t& linkH, Token::OID_t& stmt) override;
 
 
    virtual DbStatus loadObject( void** ptr, ShapeH shape, 
                                 Token::OID_t& oid) override;
 
    virtual DbStatus writeObject(ActionList::value_type&) override;
 
    virtual DbStatus transAct(Transaction::Action action) override;
  };
}
#endif //POOL_ROOTTREECONTAINER_H