IRootAuxDynIO.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef IROOTAUXDYN_IO_H
#define IROOTAUXDYN_IO_H
 
#include "GaudiKernel/StatusCode.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;
 
class IAthenaSerializeSvc;
class IAthenaIPCTool;
 
// Forward declarations
namespace ROOT { class RNTupleReader; }
 
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 IAuxDynShare {
   public:
      virtual ~IAuxDynShare() = default;

      virtual StatusCode receiveStore(TClass* cl, void* obj, int num = 0) = 0;

      virtual StatusCode sendStore(TClass* cl, const void* obj, const std::string& classId, const std::string& contName, int num = 0) = 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 std::unique_ptr<IAuxDynShare> getAuxDynShare(const IAthenaSerializeSvc* serSvc, IAthenaIPCTool* ipcTool) 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