RingerIOVarDepObj.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef RINGERSELECTORTOOLS_TOOLS_RINGERIOVARDEPOBJ_H
#define RINGERSELECTORTOOLS_TOOLS_RINGERIOVARDEPOBJ_H
 
// STL includes:
#include <string>
 
// Root includes:
#include <TFile.h>
 
// Local includes:
#include "RingerSelectorTools/RingerSelectorToolsDefs.h"
#include "RingerSelectorTools/procedures/IRingerProcedure.h"
#include "RingerSelectorTools/tools/VariableDependency.h"

 
#define RINGER_IO_VARDEP_BASE(self)                                            \
  public:                                                                      \
                                                                               \
    RINGER_DEFINE_PROCEDURE(self)                                              \
                                                                               \
    static void read(self *newObj,                                             \
        TDirectory *configDir,                                                 \
        unsigned version );                                                    \
                                                                               \
    virtual void write(TDirectory *configDir, const char* idxStr = "")         \
      const override;

#define RINGER_IO_VARDEP_BASE_NOMEMBER(self)                                   \
  public:                                                                      \
                                                                               \
     RINGER_DEFINE_NOMEMBER_PROCEDURE(self)                                    \
                                                                               \
    static void read(self *,                                                   \
        TDirectory *,                                                          \
        unsigned ) {;}                                                         \
                                                                               \
    virtual void write(TDirectory *, const char*) const                        \
      override {;}

#define RINGER_IO_VARDEP_OBJ(self, base)                                       \
                                                                               \
  public:                                                                      \
    typedef base base_t;                                                       \
                                                                               \
    template <typename T = const char*>                                        \
    static T procType()                                                        \
    {                                                                          \
      return base::template procType<T>();                                     \
    }                                                                          \
                                                                               \
    virtual std::string name() const                                           \
      override final                                                           \
    {                                                                          \
      return this->RingerIOVarDepObj<self>::name();                            \
    }                                                                          \
                                                                               \
    void print(MSG::Level lvl) const                                           \
      override final                                                           \
    {                                                                          \
      this->base_t::print(lvl);                                                \
    }                                                                          \
                                                                               \
    virtual void write(TDirectory *baseDir, const char* idxStr = "") const     \
      override final                                                           \
    {                                                                          \
      this->RingerIOVarDepObj<self>::write(baseDir, idxStr);                   \
    }                                                                          \
                                                                               \
    static self* read(TDirectory *configDir){                                  \
      return RingerIOVarDepObj<self>::read(configDir);                         \
    }                                                                          \
                                                                               \
    typedef typename Ringer::template RingerProcedureType<base>::              \
      baseInterface_t baseInterface_t;                                         \
                                                                               \
    using baseInterface_t::procType;
 
namespace Ringer {

template < class CRTP  >
class RingerIOVarDepObj : virtual public VariableDependency
{
 
  public:
    //typedef CRTP crtp_t;
 
    // Make sure we initialize the variable dependency
    RingerIOVarDepObj():VariableDependency(){;}

    std::string name() const;

    static CRTP* read(TDirectory *configDir);

    void write(TDirectory *baseDir, const char* idxStr="")
      const;
};
 
} // namespace Ringer
 
#endif // RINGERSELECTORTOOLS_TOOLS_RINGERIOVARDEPOBJ_H
 
#ifndef INCLUDE_HEADER_ONLY // Use to avoid circular includes
#include "RingerIOVarDepObj.icc"
#endif // INCLUDE_HEADER_ONLY