ToolWithConstants.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
 * Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration.
 */
#ifndef CALOUTILS_TOOLWITHCONSTANTS_H
#define CALOUTILS_TOOLWITHCONSTANTS_H
 
 
#include "CaloUtils/exceptions.h"
#include "CaloInterface/IToolWithConstants.h"
#include "CaloConditions/ToolConstants.h"
#include "AthenaBaseComps/AthCheckMacros.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/ReadCondHandle.h"
#include "AthenaKernel/errorcheck.h"
#include "CxxUtils/concepts.h"
#include "Gaudi/Property.h"
#include <string>
#include <sstream>
#include <type_traits>
 
 
namespace Gaudi {
namespace Parsers {
 
 
// Unused, because we override fromString() below, but required
// in order to compile the overridden fromString() from Gaudi.
template <unsigned int N>
StatusCode parse (CaloRec::Array<N>&, const std::string&)
{
  return StatusCode::FAILURE;
}
 
 
}} // namespace Gaudi::Parsers
 
 
namespace CaloUtils {
 
 
struct ToolConstantsContext
{
public:
  const EventContext& ctx() const { return m_ctx; }
 
  ToolConstantsContext (const CaloRec::ToolConstants* constants,
                        const EventContext& ctx)
    : m_constants (constants),
      m_ctx (ctx)
  {
  }
  const CaloRec::ToolConstants* m_constants;
  const EventContext& m_ctx;
};
 
 
 
class IToolConstant
{
public:
  virtual ~IToolConstant() = default;
 
  virtual std::string name() const = 0;
 
  virtual bool setFromJO() const = 0;
};
 
 
//***********************************************************************
 
 
class ToolWithConstantsImpl
{
public:
  using Context = ToolConstantsContext;
 
 
  ToolWithConstantsImpl (const std::string& toolName,
                         const std::string& prefix,
                         SG::ReadCondHandleKey<CaloRec::ToolConstants>& DBHandle);
 
 
  StatusCode initialize();
 
 
  Context context (const EventContext& ctx) const;
 
 
  void addConstant (IToolConstant* c);
 
 
  void writeConstants (std::ostream& stream,
                       const std::string& name,
                       const EventContext& ctx) const;
 
 
  StatusCode
  mergeConstants (const std::string& typeName,
                  int toolVersion,
                  Context& myctx,
                  bool isDummy,
                  CaloRec::ToolConstants& out) const;
 
 
  std::string m_toolName;
 
  // Note: Held by a reference, not by value.
  // This comes from a property of the owning tool, and is not set
  // until we run initialize() on that tool.
  const std::string& m_prefix;
 
  CaloRec::ToolConstants m_constants;
 
  SG::ReadCondHandleKey<CaloRec::ToolConstants>& m_DBHandle;
 
  std::vector<IToolConstant*> m_declaredConstants;
};
 
 
//***********************************************************************
 
 
template <class T>
  // Must be able to initialize a T with fromArrayrep
  // Doesn't actaully work like this, though, as there's a conflict
  // with the friend declaration below.
  //ATH_REQUIRES( requires (T t, const CxxUtils::Arrayrep& rep) { { CxxUtils::fromArrayrep (rep, t); } } )
class ToolConstant
  : public IToolConstant
{
public:
  using Context = ToolConstantsContext;
 
 
  template <class OWNER>
  ToolConstant (OWNER* owner,
                const std::string& name,
                const std::string& doc = "");
 
 
  template <class OWNER>
  ToolConstant (OWNER* owner,
                const std::string& name,
                const char* doc);
 
 
  template <class OWNER,
            typename U = T,
            typename = std::enable_if_t<std::is_arithmetic_v<U> > >
  ToolConstant (OWNER* owner,
                const std::string& name,
                const T& deflt,
                const std::string& doc = "");
 
 
  T operator() (const Context& c) const;
 
 
  T operator()() const;
 
 
  virtual std::string name() const override;
 
 
  virtual bool setFromJO() const override;
 
  
private:
  class CProperty
    : public Gaudi::Property<T>
  {
  public:
    CProperty (const std::string& name,
               const std::string& doc,
               ToolWithConstantsImpl& impl);
 
      
    CProperty (const std::string& name,
               const std::string& doc,
               ToolWithConstantsImpl& impl,
               const T& deflt);
 
 
    // To be able to assign to this wrapper.
    using Gaudi::Property<T>::operator=;
 
 
    virtual std::string toString() const override;
 
 
    virtual void toStream( std::ostream& out ) const override;
 
 
    virtual StatusCode fromString( const std::string& value ) override;
 
 
    ToolWithConstantsImpl& m_impl;
 
    bool m_setFromJO = false;
 
    bool m_hasDefault = false;
  };
 
 
  CProperty m_prop;
 
  int m_toolVersion;
};
 
 
//***************************************************************************
 
 
#define ATH_TWC_REQUIRES ATH_REQUIRES( requires (BASE& b, Gaudi::Property<int>& p) { { b.declareProperty(p) }; } )
template <class BASE>
  ATH_TWC_REQUIRES
class ToolWithConstants
  : public extends<BASE, IToolWithConstants>
{
public:
  typedef ToolWithConstants base_class;
 
 
  using extends<BASE, IToolWithConstants>::extends;
 
 
  using Context = CaloUtils::ToolConstantsContext;
 
 
  template <class T>
  using Constant = ToolConstant<T>;
 
 
  virtual StatusCode initialize() override;
 
 
  Context context (const EventContext& ctx) const;
 
 
  virtual void writeConstants (std::ostream& stream,
                               const std::string& name,
                               const EventContext& ctx) const;
 
 
  virtual StatusCode mergeConstants (CaloRec::ToolConstants& out,
                                     const EventContext& ctx) const override;
 
 
  virtual int toolVersion() const;
 
 
  virtual const std::string& toolType() const;
 
 
private:
  // Make this a friend so it can access m_impl.
  template <class T>
  friend class CaloUtils::ToolConstant;
 
  SG::ReadCondHandleKey<CaloRec::ToolConstants> m_DBHandle
  { this, "DBHandleKey", "", "" };
 
  StringProperty m_prefix
  { this, "prefix", "", "" };
 
  ToolWithConstantsImpl m_impl { this->name(), m_prefix, m_DBHandle };
 
  Constant<int> m_order
    { this, "order", 0 };
 
  Constant<bool> m_isdummy
    {this, "isDummy", false };
};
 
 
} // namespace CaloUtils
 
 
#include "CaloUtils/ToolWithConstants.icc"
 
 
#undef ATH_TWC_REQUIRES
 
 
#endif // not CALOUTILS_TOOLWITHCONSTANTS_H