IRootAuxDynIO.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef IROOTAUXDYN_IO_H
#define IROOTAUXDYN_IO_H
 
#include "RootAuxDynIO/RootAuxDynDefs.h"
 
#include <string>
#include <memory>
#include <vector>
#include <mutex>
#include <tuple>
 
#include "RVersion.h"
 
class TBranch;
class TTree;
class TFile;
class TClass;
 
 
#if ROOT_VERSION_CODE >= ROOT_VERSION( 6, 35, 0 )
   namespace ROOT { class RNTupleReader; }
#else
   namespace ROOT::Experimental { class RNTupleReader; }
   namespace ROOT { using RNTupleReader = ROOT::Experimental::RNTupleReader; }
#endif
 
namespace RootAuxDynIO
{
   // 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 size_t getBytesRead() const = 0;
 
      virtual void resetBytesRead() = 0; 
 
      virtual ~IRootAuxDynReader() {}
   };
 
 
   class IRootAuxDynWriter {
   public:
      virtual ~IRootAuxDynWriter() = default;
 
      //  may throw exceptions
      virtual int writeAuxAttributes(const std::string& base_branch, void* object, 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, void* object ) = 0;
   };
 
 
 
   class IFactoryTool
   {
   public:
      virtual ~IFactoryTool() = default;
 
      virtual std::unique_ptr<IRootAuxDynReader>
      getBranchAuxDynReader(TTree*, TBranch*) const = 0;
 
      virtual std::unique_ptr<IRootAuxDynWriter>
      getBranchAuxDynWriter(TTree&, TClass&, int bufferSize, int splitLevel,
                            int offsettab_len, bool do_branch_fill) const = 0;
 
      virtual std::unique_ptr<IRNTupleAuxDynWriter>
      getNTupleAuxDynWriter(TClass &tc) const = 0;
 
      virtual std::unique_ptr<IRootAuxDynReader>
      getNTupleAuxDynReader(const std::string& field_name, const std::string& field_type,
                            ROOT::RNTupleReader* reader) const = 0;
 
 
      virtual bool hasAuxStore(std::string_view fieldname, TClass *tc) const = 0;
 
      virtual bool hasAuxStoreIO(TClass *tc) const = 0;
 
      virtual bool isAuxDynBranch(TBranch *branch) const = 0;
   };
 
} // namespace
 
#endif