DataStructure.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGCONFDATA_DATASTRUCTURE_H
#define TRIGCONFDATA_DATASTRUCTURE_H
 
#include <iostream>
#include <vector>
#include <memory>
#include <type_traits>
#include <optional>
#include "boost/property_tree/ptree.hpp"
 
namespace TrigConf {
 
   class DataStructure {
   public:
 
      using ptree = boost::property_tree::ptree;
 
      DataStructure();
 
      DataStructure(const DataStructure&) = default;
      DataStructure(DataStructure&&) = default;
 
      DataStructure& operator=(const DataStructure&) = default;
      DataStructure& operator=(DataStructure&&) = default;
 
      DataStructure(const ptree & data);
      DataStructure(const std::string & name, const ptree & data);
      DataStructure(ptree && data);
      DataStructure(const std::string & name, ptree && data);
 
      virtual ~DataStructure() = default;
 
      void setData(const ptree & data);
      void setData(ptree && data);
 
      void setName(const std::string& n);
 
      virtual std::string className() const;
 
      virtual const std::string & name() const final;
 
      virtual void clear();
 
      const ptree & data() const {
         if( ! isInitialized() ) {
            throw std::runtime_error("Trying to access data of uninitialized object of type " + className());
         }
         // Don't use ?: operator here: it confuses cppcheck.
         if (ownsData()) {
            return *m_dataSPtr.get();
         }
         return *m_dataPtr;
      }
 
      bool isValue() const;
 
      std::string getValue() const;  // this will be removed in the next MR (TrigSignatureMoniMT still depends on it)
 
      template<class T>
      T getValue() const {
         return data().get_value<T>();
      }
 
      template<class T>
      std::optional<T> getValue_optional() const {
         auto v = data().get_value_optional<T>();
         return v ? std::optional<T>(std::move(*v)) : std::nullopt;
      }
 
      bool hasAttribute(const std::string & key) const;
 
      bool isNull(const std::string & key) const;
 
      bool hasChild(const std::string & path) const;
 
      std::string operator[](const std::string & key) const;
 
      template<class T>
      T getAttribute(const std::string & key, bool ignoreIfMissing = false, const T & def = T()) const {
         const auto & obj = data().get_child_optional(key);
         if( !obj ) {
            if( ignoreIfMissing ) {
               return def;
            } else {
               throw std::runtime_error(className() + "#" + name() + ": structure '" + key + "' does not exist" );
            }
         }
         return obj.get().get_value<T>();
      }
 
      template<class T>
      std::optional<T> getAttribute_optional(const std::string & key) const {
         const auto & obj = data().get_child_optional(key);
         if( ! obj ) {
            return std::nullopt;
         }
         auto v = obj.get().get_value_optional<T>();
         return v ? std::optional(std::move(*v)) : std::nullopt;
      }
 
      const std::string & getAttribute(const std::string & key, bool ignoreIfMissing = false, const std::string & def = "") const;
 
      std::vector<DataStructure> getList(const std::string & pathToChild, bool ignoreIfMissing = false) const;
 
      std::optional<std::vector<DataStructure> > getList_optional(const std::string & pathToChild) const;
 
      DataStructure getObject(const std::string & pathToChild, bool ignoreIfMissing = false) const;
 
      std::optional<TrigConf::DataStructure>
      getObject_optional(const std::string & pathToChild) const;
 
 
      std::vector<std::string> getKeys() const;
 
 
      explicit operator bool() const { return m_initialized; }
      bool isValid() const { return m_initialized; }
      bool isInitialized() const { return m_initialized; }
 
      bool empty() const { return data().empty(); }
 
      /* Print this object including children
       * @param os The output stream
       */
      void printRaw(std::ostream & os = std::cout) const;
 
      /* Print this object including children
       * @param os The output stream
       */
      virtual void print(std::ostream & os = std::cout) const;
 
      static void printElement(const std::string& key, 
                               const ptree & data,
                               uint level = 0,
                               std::ostream & os = std::cout);
 
      bool ownsData() const {
         return (bool)m_dataSPtr;
      }
 
   protected:
 
      virtual void update() {};
 
      bool m_initialized { false }; 
 
      std::shared_ptr<ptree> m_dataSPtr { nullptr }; // used when owning the tree
      const ptree * m_dataPtr { nullptr }; // used when not owning the tree
 
      std::string m_name{""}; // most objects are named
   
   };
 
}
 
#ifndef TRIGCONF_STANDALONE
#ifndef XAOD_STANDALONE
 
#include "AthenaKernel/CLASS_DEF.h" 
CLASS_DEF( TrigConf::DataStructure , 98904516 , 1 )
 
#include "AthenaKernel/CondCont.h"
CONDCONT_DEF( TrigConf::DataStructure , 265887802 );
 
#endif
#endif
 
 
#endif