RootAuxDynIO.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ROOTAUXDYN_IO_H
#define ROOTAUXDYN_IO_H
 
#include "RVersion.h"
 
#include <string>
#include <memory>
#include <vector>
#include <mutex>
#include <tuple>
#include "RootAuxDynIO/RootAuxDynDefs.h"
 
class TBranch;
class TTree;
class TFile;
class TClass;
 
namespace ROOT::Experimental {
  class RNTupleReader;
#if ROOT_VERSION_CODE < ROOT_VERSION( 6, 31, 0 )
  namespace Detail {
    class RFieldBase;
  }
#else
  class RFieldBase;
#endif
}
namespace SG { class IAuxStoreIO;  class auxid_set_t; }
 
 
namespace RootAuxDynIO
{
#if ROOT_VERSION_CODE >= ROOT_VERSION( 6, 31, 0 )
   using ROOT::Experimental::RFieldBase;
#else
   using ROOT::Experimental::Detail::RFieldBase;
#endif
   using ROOT::Experimental::RNTupleReader;
   class IRootAuxDynReader;
   class IRootAuxDynWriter;
   class IRNTupleAuxDynWriter;
   class IRNTupleWriter;
 
   bool hasAuxStore(std::string_view fieldname, TClass *tc);
 
   bool isAuxDynBranch(TBranch *branch);
 
   std::string getKeyFromBranch(TBranch* branch);
 
   std::unique_ptr<IRootAuxDynReader> getBranchAuxDynReader(TTree*, TBranch*);
   std::unique_ptr<IRootAuxDynWriter> getBranchAuxDynWriter(TTree*, int bufferSize, int splitLevel,
                                                              int offsettab_len, bool do_branch_fill);
   
   std::unique_ptr<IRootAuxDynReader>    getNTupleAuxDynReader(const std::string& field_name, const std::string& field_type, RNTupleReader* reader);
   std::unique_ptr<IRNTupleAuxDynWriter> getNTupleAuxDynWriter();
   std::unique_ptr<IRNTupleWriter>       getNTupleWriter(TFile*,  const std::string& ntupleName, bool enableBufferedWrite, bool enableMetrics);
 
   // The convention for the tuple is <name, type, data>
   typedef std::tuple<std::string, std::string, void*> attrDataTuple;
 
   class IRootAuxDynReader
   {
   public :
      virtual void addReaderToObject(void* object, size_t row, std::recursive_mutex* iomtx = nullptr) = 0;
 
      virtual const SG::auxid_set_t& auxIDs() const = 0;
 
      virtual size_t getBytesRead() const = 0;
 
      virtual void resetBytesRead() = 0; 
 
      virtual ~IRootAuxDynReader() {}
   };
 
 
   class IRootAuxDynWriter {
   public:
      virtual ~IRootAuxDynWriter() {}
 
      //  may throw exceptions
      virtual int writeAuxAttributes(const std::string& base_branch, SG::IAuxStoreIO* store, size_t rows_written ) = 0;
 
      virtual bool needsCommit() = 0;
 
      virtual int commit() = 0;
 
      virtual void setBranchFillMode(bool) = 0;
   };
 
   class IRNTupleAuxDynWriter {
   public:
      virtual ~IRNTupleAuxDynWriter() = default;
 
      virtual std::vector<attrDataTuple> collectAuxAttributes( const std::string& base_branch, SG::IAuxStoreIO* store ) = 0;
   };
 
} // namespace
 
#endif