StoreGate/StoreGate/VarHandleKeyArray.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include "CxxUtils/checker_macros.h"
#include <print>
 
 
namespace SG {
  /**
   * @brief forward the initialization to the member VarHandleKeys
   * @param used If false, then this handle is not to be used.
   *             Instead of normal initialization, the key will be cleared.
   */
  template <class Base>
  inline
  StatusCode VarHandleKeyArrayCommon<Base>::initialize (bool used /*= true*/) {
    StatusCode sc(StatusCode::SUCCESS);
    if (used) {
      IDataHandleHolder* const owner = this->owner();
      for (Base& b : *this) {
    if (owner != nullptr) {
      b.setOwner(owner);
    }
        if ( b.initialize().isFailure() ) {
          sc = StatusCode::FAILURE;
        }
      }
    }
    else {
      this->clear();
    }
    return sc;
  }
 
  //
  // Set the VarHandleKey from a string
  //
  template <class Base>
  inline
  StatusCode VarHandleKeyArrayCommon<Base>::assign(const std::vector<std::string>& vs) {
    StatusCode sc(StatusCode::SUCCESS);
    this->clear();
    for (auto & s : vs) {
      Base b = this->keyFromString (s);
      if (!b.assign(s)) {
        sc = StatusCode::FAILURE;
      } else {
        // Skip blank keys
        if (b.key() != "") {
          std::vector<Base>::emplace_back(std::move(b));
        }
      }
    }
    return sc;
  }
  
  //
  // string representation of VarHandleKeyArray
  //
  template <class Base>
  inline
  std::string VarHandleKeyArrayCommon<Base>::toString() const {
    std::ostringstream ost;
    typename std::vector<Base>::const_iterator itr;
    itr = this->begin();
    size_t sz = this->size();
    for ( size_t i=0; i < sz; ++i, ++itr) {
      std::print (ost, "'{}'", itr->objKey());
      if (i != sz-1) {
        std::print (ost, ",");
      }
    }
    return ost.str();      
  }
  
  //
  // create array of all base VarHandleKeys in the Array
  //
  template <class Base>
  inline  
  std::vector<SG::VarHandleKey*> VarHandleKeyArrayCommon<Base>::keys() const {
    std::vector<SG::VarHandleKey*> keys;
    for (const SG::VarHandleKey& k : *this) {
      // FIXME: This is a rule violation, but we can't really fix it without
      // changing the IDataHandleHolder base class from Gaudi.
      SG::VarHandleKey* k_nc ATLAS_THREAD_SAFE = const_cast<SG::VarHandleKey*>(&k);
      keys.push_back (k_nc);
    }
    return keys;
  }      
 
  template <class Base>
  inline  
  void VarHandleKeyArrayCommon<Base>::declare(IDataHandleHolder* owner) {
    if ( renounced() ) {
      return;
    }     
    for (auto k: keys() ) {
      owner->declare ( *k );
      k->setOwner( owner );
    }
  }
 
 
  /**
   * Create a HandleKey from a string.
   * @param s String from which to create the HandleKey.
   *
   * This is for decoration handle keys.  If this array was initialized
   * with a container key, then that will be used to for the handle keys.
   */
  template <class Base>
  template <class T /*= Base*/>
  requires T::isDecorHandleKey
  inline
  Base VarHandleKeyArrayCommon<Base>::keyFromString (const std::string& s) const
  {
    if (m_contKey)
      return Base (*m_contKey, s);
    return Base (s);
  }
 
 
  /**
   * Create a HandleKey from a string.
   * @param s String from which to create the HandleKey.
   *
   * This is for non-decoration handle keys.
   */
  template <class Base>
  template <class T /*= Base*/>
  requires (!T::isDecorHandleKey)
  inline
  Base VarHandleKeyArrayCommon<Base>::keyFromString (const std::string& s) const
  {
    return Base (s);
  }
}
 
 
namespace std {
 
template <std::derived_from<SG::VarHandleKeyArray> T>
template <class FmtContext>
FmtContext::iterator
formatter<T>::format(const T& k, FmtContext& ctx) const
{
  return std::format_to (ctx.out(), "[{}]", k.toString());
}
 
} // namespace std