RootTreeContainer.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 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 <string>
#include <string_view>
#include <vector>
#include <memory>
 
// Forward declarations
class StatucCode;
class TBranch;
class TTree;
class TLeaf;
class TClass;
 
namespace RootAuxDynIO {
   class IRootAuxDynWriter;
   class IRootAuxDynReader;
   class IFactoryTool;
}
     
 
/*
 * 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;
    };

    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;

    std::unique_ptr<RootAuxDynIO::IFactoryTool>       m_auxDynTool;
 
  private:

    StatusCode addBranch( const DbColumn* col,
                          BranchDesc& dsc,
                          std::string_view desc);

    StatusCode addObject( DbDatabase& dbH,
                          const DbColumn* col,
                          BranchDesc& dsc,
                          const std::string& desc,
                          int splitLevel,
                          int bufferSize,
                          int branchOffsetTabLen);
 
    // Routine needed for TRANSACT_FLUSH, if branch is specified by user.
    StatusCode finishTransAct();

    TBranch* branch(const std::string& nam)  const;

    void setBranchOffsetTabLen(TBranch* b, int offsettab_len);  
    
  public:
    explicit RootTreeContainer(const std::string& name);
    virtual ~RootTreeContainer();

    virtual StatusCode close() override;

    virtual StatusCode open(DbDatabase& dbH, 
                            const std::string& nam, 
                            const DbTypeInfo* info,
                            DbAccessMode mod) override;

    virtual StatusCode checkAccess(DbDatabase& dbH,
                                   const std::string& nam) const override final;


    virtual StatusCode getOption(DbOption& opt) override;


    virtual StatusCode setOption(const DbOption& opt) 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 StatusCode loadObject( void** ptr, ShapeH shape, 
                                 Token::OID_t& oid) override;

    virtual StatusCode writeObject(ActionList::value_type&) override;

    virtual StatusCode transAct(Transaction::Action action) override;
  };
}
#endif //POOL_ROOTTREECONTAINER_H