SSPLEDCalibModule.hpp

Go to the documentation of this file.

// *** this file is generated by oksdalgen, do not modify it ***
 
#ifndef _SSPLEDCalibModule_0_dunedaq__appmodel_0_appmodel_H_
#define _SSPLEDCalibModule_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"
 
  // include files for classes used in inheritance hierarchy
 
#include "confmodel/DaqModule.hpp"
 
  // forward declaration for classes used in relationships and algorithms
 
namespace dunedaq {
  namespace appmodel {
    class SSPRegister;
  }
}
 
 
namespace dunedaq {
  namespace appmodel {
 
    class SSPLEDCalibModule : public dunedaq::confmodel::DaqModule {
 
      friend class conffwk::Configuration;
      friend class conffwk::DalObject;
      friend class conffwk::DalFactory;
      friend class conffwk::DalRegistry;
 
      protected:
 
        SSPLEDCalibModule(conffwk::DalRegistry& db, const conffwk::ConfigObject& obj) noexcept;
        virtual ~SSPLEDCalibModule() 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:
 
        uint32_t m_card_id;
        uint32_t m_board_id;
        uint32_t m_module_id;
        std::string m_board_ip;
        uint32_t m_partition_number;
        uint32_t m_timing_address;
        uint32_t m_number_channels;
        uint32_t m_channel_mask;
        std::string m_pulse_mode;
        uint32_t m_burst_count;
        uint32_t m_double_pulse_delay_ticks;
        uint32_t m_pulse1_width_ticks;
        uint32_t m_pulse2_width_ticks;
        uint32_t m_pulse_bias_percent_270nm;
        uint32_t m_pulse_bias_percent_367nm;
        std::vector<const dunedaq::appmodel::SSPRegister*> m_hardware_configuration;
 
 
      public:
 
          // attribute names
 
        inline static const std::string s_card_id = "card_id";
        inline static const std::string s_board_id = "board_id";
        inline static const std::string s_module_id = "module_id";
        inline static const std::string s_board_ip = "board_ip";
        inline static const std::string s_partition_number = "partition_number";
        inline static const std::string s_timing_address = "timing_address";
        inline static const std::string s_number_channels = "number_channels";
        inline static const std::string s_channel_mask = "channel_mask";
        inline static const std::string s_pulse_mode = "pulse_mode";
        inline static const std::string s_burst_count = "burst_count";
        inline static const std::string s_double_pulse_delay_ticks = "double_pulse_delay_ticks";
        inline static const std::string s_pulse1_width_ticks = "pulse1_width_ticks";
        inline static const std::string s_pulse2_width_ticks = "pulse2_width_ticks";
        inline static const std::string s_pulse_bias_percent_270nm = "pulse_bias_percent_270nm";
        inline static const std::string s_pulse_bias_percent_367nm = "pulse_bias_percent_367nm";
 
        static const std::string& __get_card_id_str() noexcept { return s_card_id; }
        static const std::string& __get_board_id_str() noexcept { return s_board_id; }
        static const std::string& __get_module_id_str() noexcept { return s_module_id; }
        static const std::string& __get_board_ip_str() noexcept { return s_board_ip; }
        static const std::string& __get_partition_number_str() noexcept { return s_partition_number; }
        static const std::string& __get_timing_address_str() noexcept { return s_timing_address; }
        static const std::string& __get_number_channels_str() noexcept { return s_number_channels; }
        static const std::string& __get_channel_mask_str() noexcept { return s_channel_mask; }
        static const std::string& __get_pulse_mode_str() noexcept { return s_pulse_mode; }
        static const std::string& __get_burst_count_str() noexcept { return s_burst_count; }
        static const std::string& __get_double_pulse_delay_ticks_str() noexcept { return s_double_pulse_delay_ticks; }
        static const std::string& __get_pulse1_width_ticks_str() noexcept { return s_pulse1_width_ticks; }
        static const std::string& __get_pulse2_width_ticks_str() noexcept { return s_pulse2_width_ticks; }
        static const std::string& __get_pulse_bias_percent_270nm_str() noexcept { return s_pulse_bias_percent_270nm; }
        static const std::string& __get_pulse_bias_percent_367nm_str() noexcept { return s_pulse_bias_percent_367nm; }
 
 
        uint32_t
        get_card_id() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_card_id;
          }
 
        void
        set_card_id(uint32_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_card_id, value);
          }
 
 
        uint32_t
        get_board_id() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_board_id;
          }
 
        void
        set_board_id(uint32_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_board_id, value);
          }
 
 
        uint32_t
        get_module_id() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_module_id;
          }
 
        void
        set_module_id(uint32_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_module_id, value);
          }
 
 
        const std::string&
        get_board_ip() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_board_ip;
          }
 
        void
        set_board_ip(const std::string& value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_ref(s_board_ip, value);
          }
 
 
        uint32_t
        get_partition_number() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_partition_number;
          }
 
        void
        set_partition_number(uint32_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_partition_number, value);
          }
 
 
        uint32_t
        get_timing_address() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_timing_address;
          }
 
        void
        set_timing_address(uint32_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_timing_address, value);
          }
 
 
        uint32_t
        get_number_channels() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_number_channels;
          }
 
        void
        set_number_channels(uint32_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_number_channels, value);
          }
 
 
        uint32_t
        get_channel_mask() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_channel_mask;
          }
 
        void
        set_channel_mask(uint32_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_channel_mask, value);
          }
 
 
        struct Pulse_mode {
          inline static const std::string Single = "single";
          inline static const std::string Double = "double";
          inline static const std::string Burst = "burst";
        };
 
        const std::string&
        get_pulse_mode() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_pulse_mode;
          }
 
        void
        set_pulse_mode(const std::string& value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_enum(s_pulse_mode, value);
          }
 
 
        uint32_t
        get_burst_count() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_burst_count;
          }
 
        void
        set_burst_count(uint32_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_burst_count, value);
          }
 
 
        uint32_t
        get_double_pulse_delay_ticks() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_double_pulse_delay_ticks;
          }
 
        void
        set_double_pulse_delay_ticks(uint32_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_double_pulse_delay_ticks, value);
          }
 
 
        uint32_t
        get_pulse1_width_ticks() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_pulse1_width_ticks;
          }
 
        void
        set_pulse1_width_ticks(uint32_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_pulse1_width_ticks, value);
          }
 
 
        uint32_t
        get_pulse2_width_ticks() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_pulse2_width_ticks;
          }
 
        void
        set_pulse2_width_ticks(uint32_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_pulse2_width_ticks, value);
          }
 
 
        uint32_t
        get_pulse_bias_percent_270nm() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_pulse_bias_percent_270nm;
          }
 
        void
        set_pulse_bias_percent_270nm(uint32_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_pulse_bias_percent_270nm, value);
          }
 
 
        uint32_t
        get_pulse_bias_percent_367nm() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_pulse_bias_percent_367nm;
          }
 
        void
        set_pulse_bias_percent_367nm(uint32_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_pulse_bias_percent_367nm, value);
          }
 
 
          // relationship names
 
        inline static const std::string s_hardware_configuration = "hardware_configuration";
 
        static const std::string& __get_hardware_configuration_str() noexcept { return s_hardware_configuration; }
 
 
        const std::vector<const dunedaq::appmodel::SSPRegister*>&
        get_hardware_configuration() const
        {
          std::lock_guard scoped_lock(m_mutex);
          check();
          check_init();
          return m_hardware_configuration;
        }
 
 
        void
        set_hardware_configuration(const std::vector<const dunedaq::appmodel::SSPRegister*>& value);
 
    };
 
      // out stream operator
 
    inline std::ostream& operator<<(std::ostream& s, const SSPLEDCalibModule& obj)
      {
        return obj.print_object(s);
      }
 
    typedef std::vector<const SSPLEDCalibModule*>::const_iterator SSPLEDCalibModuleIterator;
 
  }
}
 
#endif