DaphneV2BoardConf.hpp

Go to the documentation of this file.

// *** this file is generated by oksdalgen, do not modify it ***
 
#ifndef _DaphneV2BoardConf_0_dunedaq__appmodel_0_appmodel_H_
#define _DaphneV2BoardConf_0_dunedaq__appmodel_0_appmodel_H_
 
#include <stdint.h>   // to define 64 bits types
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <vector>
 
#include "conffwk/Configuration.hpp"
#include "conffwk/DalObject.hpp"
 
 
  // forward declaration for classes used in relationships and algorithms
 
namespace dunedaq {
  namespace appmodel {
    class DaphneV2AFE;
    class DaphneV2Channel;
  }
}
 
 
namespace dunedaq {
  namespace appmodel {
 
    class DaphneV2BoardConf : public virtual dunedaq::conffwk::DalObject {
 
      friend class conffwk::Configuration;
      friend class conffwk::DalObject;
      friend class conffwk::DalFactory;
      friend class conffwk::DalRegistry;
 
      protected:
 
        DaphneV2BoardConf(conffwk::DalRegistry& db, const conffwk::ConfigObject& obj) noexcept;
        virtual ~DaphneV2BoardConf() noexcept;
        virtual void init(bool init_children);
 
      public:
 
        static const std::string& s_class_name;
 
 
        virtual void print(unsigned int offset, bool print_header, std::ostream& s) const;
 
 
        virtual std::vector<const dunedaq::conffwk::DalObject *> get(const std::string& name, bool upcast_unregistered = true) const;
 
 
      protected:
 
        bool get(const std::string& name, std::vector<const dunedaq::conffwk::DalObject *>& vec, bool upcast_unregistered, bool first_call) const;
 
 
      private:
 
        uint16_t m_bias_ctrl;
        uint64_t m_self_trigger_threshold;
        std::vector<uint8_t> m_full_stream_channels;
        uint64_t m_self_trigger_xcorr;
        uint32_t m_tp_conf;
        uint64_t m_compensator;
        uint64_t m_inverter;
        std::string m_address;
        uint16_t m_slot_id;
        uint16_t m_crate_id;
        uint16_t m_detector_id;
        std::vector<const dunedaq::appmodel::DaphneV2Channel*> m_active_channels;
        std::vector<const dunedaq::appmodel::DaphneV2AFE*> m_active_afes;
        const dunedaq::appmodel::DaphneV2Channel* m_default_channel;
        const dunedaq::appmodel::DaphneV2AFE* m_default_afe;
 
 
      public:
 
          // attribute names
 
        inline static const std::string s_bias_ctrl = "bias_ctrl";
        inline static const std::string s_self_trigger_threshold = "self_trigger_threshold";
        inline static const std::string s_full_stream_channels = "full_stream_channels";
        inline static const std::string s_self_trigger_xcorr = "self_trigger_xcorr";
        inline static const std::string s_tp_conf = "tp_conf";
        inline static const std::string s_compensator = "compensator";
        inline static const std::string s_inverter = "inverter";
        inline static const std::string s_address = "address";
        inline static const std::string s_slot_id = "slot_id";
        inline static const std::string s_crate_id = "crate_id";
        inline static const std::string s_detector_id = "detector_id";
 
        static const std::string& __get_bias_ctrl_str() noexcept { return s_bias_ctrl; }
        static const std::string& __get_self_trigger_threshold_str() noexcept { return s_self_trigger_threshold; }
        static const std::string& __get_full_stream_channels_str() noexcept { return s_full_stream_channels; }
        static const std::string& __get_self_trigger_xcorr_str() noexcept { return s_self_trigger_xcorr; }
        static const std::string& __get_tp_conf_str() noexcept { return s_tp_conf; }
        static const std::string& __get_compensator_str() noexcept { return s_compensator; }
        static const std::string& __get_inverter_str() noexcept { return s_inverter; }
        static const std::string& __get_address_str() noexcept { return s_address; }
        static const std::string& __get_slot_id_str() noexcept { return s_slot_id; }
        static const std::string& __get_crate_id_str() noexcept { return s_crate_id; }
        static const std::string& __get_detector_id_str() noexcept { return s_detector_id; }
 
 
        uint16_t
        get_bias_ctrl() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_bias_ctrl;
          }
 
        void
        set_bias_ctrl(uint16_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_bias_ctrl, value);
          }
 
 
        uint64_t
        get_self_trigger_threshold() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_self_trigger_threshold;
          }
 
        void
        set_self_trigger_threshold(uint64_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_self_trigger_threshold, value);
          }
 
 
        const std::vector<uint8_t>&
        get_full_stream_channels() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_full_stream_channels;
          }
 
        void
        set_full_stream_channels(const std::vector<uint8_t>& value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_full_stream_channels, value);
          }
 
 
        uint64_t
        get_self_trigger_xcorr() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_self_trigger_xcorr;
          }
 
        void
        set_self_trigger_xcorr(uint64_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_self_trigger_xcorr, value);
          }
 
 
        uint32_t
        get_tp_conf() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_tp_conf;
          }
 
        void
        set_tp_conf(uint32_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_tp_conf, value);
          }
 
 
        uint64_t
        get_compensator() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_compensator;
          }
 
        void
        set_compensator(uint64_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_compensator, value);
          }
 
 
        uint64_t
        get_inverter() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_inverter;
          }
 
        void
        set_inverter(uint64_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_inverter, value);
          }
 
 
        const std::string&
        get_address() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_address;
          }
 
        void
        set_address(const std::string& value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_ref(s_address, value);
          }
 
 
        uint16_t
        get_slot_id() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_slot_id;
          }
 
        void
        set_slot_id(uint16_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_slot_id, value);
          }
 
 
        uint16_t
        get_crate_id() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_crate_id;
          }
 
        void
        set_crate_id(uint16_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_crate_id, value);
          }
 
 
        uint16_t
        get_detector_id() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_detector_id;
          }
 
        void
        set_detector_id(uint16_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_detector_id, value);
          }
 
 
          // relationship names
 
        inline static const std::string s_active_channels = "active_channels";
        inline static const std::string s_active_afes = "active_afes";
        inline static const std::string s_default_channel = "default_channel";
        inline static const std::string s_default_afe = "default_afe";
 
        static const std::string& __get_active_channels_str() noexcept { return s_active_channels; }
        static const std::string& __get_active_afes_str() noexcept { return s_active_afes; }
        static const std::string& __get_default_channel_str() noexcept { return s_default_channel; }
        static const std::string& __get_default_afe_str() noexcept { return s_default_afe; }
 
 
        const std::vector<const dunedaq::appmodel::DaphneV2Channel*>&
        get_active_channels() const
        {
          std::lock_guard scoped_lock(m_mutex);
          check();
          check_init();
          return m_active_channels;
        }
 
 
        void
        set_active_channels(const std::vector<const dunedaq::appmodel::DaphneV2Channel*>& value);
 
        const std::vector<const dunedaq::appmodel::DaphneV2AFE*>&
        get_active_afes() const
        {
          std::lock_guard scoped_lock(m_mutex);
          check();
          check_init();
          return m_active_afes;
        }
 
 
        void
        set_active_afes(const std::vector<const dunedaq::appmodel::DaphneV2AFE*>& value);
 
        const dunedaq::appmodel::DaphneV2Channel *
        get_default_channel() const
        {
          std::lock_guard scoped_lock(m_mutex);
          check();
          check_init();
          if (!m_default_channel)
            {
              std::ostringstream text;
              text << "relationship \"" << s_default_channel << "\" of object " << this << " is not set";
              throw dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str());
            }
          return m_default_channel;
        }
 
 
        void
        set_default_channel(const dunedaq::appmodel::DaphneV2Channel * value);
 
        const dunedaq::appmodel::DaphneV2AFE *
        get_default_afe() const
        {
          std::lock_guard scoped_lock(m_mutex);
          check();
          check_init();
          if (!m_default_afe)
            {
              std::ostringstream text;
              text << "relationship \"" << s_default_afe << "\" of object " << this << " is not set";
              throw dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str());
            }
          return m_default_afe;
        }
 
 
        void
        set_default_afe(const dunedaq::appmodel::DaphneV2AFE * value);
 
 
      public:
 
          // user-defined algorithms
 
        const DaphneV2Channel & get_channel(size_t ch) const ;
 
 
        const DaphneV2AFE & get_afe( size_t id) const ;
 
 
        bool is_channel_used(size_t ch) const;
 
 
        bool is_afe_used(size_t ch) const;
    };
 
      // out stream operator
 
    inline std::ostream& operator<<(std::ostream& s, const DaphneV2BoardConf& obj)
      {
        return obj.print_object(s);
      }
 
    typedef std::vector<const DaphneV2BoardConf*>::const_iterator DaphneV2BoardConfIterator;
 
  }
}
 
#endif