// -----------------------------------------------------------------------------
// This file is automatically generated by hdl-registers version 8.1.1-dev.
// Code generator CppImplementationGenerator version 2.0.2.
// Generated 2026-07-22 21:43 from file regs_dma_axi_write_simple.toml at Git commit 0271e3b128e7.
// Register hash a600c44f72777903809768e11279acf79aae51d4.
// -----------------------------------------------------------------------------

#include "include/dma_axi_write_simple.h"

namespace fpga_regs
{

// Macros called by the register code below to check for runtime errors.
#ifdef NO_REGISTER_SETTER_ASSERT
  #define _SETTER_ASSERT_TRUE(expression, message) ((void)0)
#else
  #define _SETTER_ASSERT_TRUE(expression, message) (_ASSERT_TRUE(expression, message))
#endif

#ifdef NO_REGISTER_GETTER_ASSERT
  #define _GETTER_ASSERT_TRUE(expression, message) ((void)0)
#else
  #define _GETTER_ASSERT_TRUE(expression, message) (_ASSERT_TRUE(expression, message))
#endif

#ifdef NO_REGISTER_ARRAY_INDEX_ASSERT
  #define _ARRAY_INDEX_ASSERT_TRUE(expression, message) ((void)0)
#else
  #define _ARRAY_INDEX_ASSERT_TRUE(expression, message) (_ASSERT_TRUE(expression, message))
#endif

// Base macro called by the other macros.
#define _ASSERT_TRUE(expression, message)                                                      \
  {                                                                                            \
    if (!static_cast<bool>(expression)) {                                                      \
      std::ostringstream diagnostics;                                                          \
      diagnostics << "dma_axi_write_simple.cpp:" << __LINE__ << ": " << message << ".";        \
      std::string diagnostic_message = diagnostics.str();                                      \
      m_assertion_handler(&diagnostic_message);                                                \
    }                                                                                          \
  }

  DmaAxiWriteSimple::DmaAxiWriteSimple(uintptr_t base_address, bool (*assertion_handler) (const std::string*))
      : m_registers(reinterpret_cast<volatile uint32_t *>(base_address)),
        m_assertion_handler(assertion_handler)
  {
    // Empty
  }

  // ---------------------------------------------------------------------------
  // Methods for the 'interrupt_status' register.
  // Mode 'Read, Write-pulse'.
  // ---------------------------------------------------------------------------
  // Read the whole register value over the register bus.
  dma_axi_write_simple::interrupt_status::Value DmaAxiWriteSimple::get_interrupt_status() const
  {
    const uint32_t raw_value = get_interrupt_status_raw();

    const bool write_done_value = get_interrupt_status_write_done_from_raw(raw_value);
    const bool write_error_value = get_interrupt_status_write_error_from_raw(raw_value);
    const bool start_address_unaligned_error_value = get_interrupt_status_start_address_unaligned_error_from_raw(raw_value);
    const bool end_address_unaligned_error_value = get_interrupt_status_end_address_unaligned_error_from_raw(raw_value);
    const bool read_address_unaligned_error_value = get_interrupt_status_read_address_unaligned_error_from_raw(raw_value);

    return {write_done_value, write_error_value, start_address_unaligned_error_value, end_address_unaligned_error_value, read_address_unaligned_error_value};
  }

  // Read the whole register value over the register bus.
  // This method returns the raw register value without any type conversion.
  uint32_t DmaAxiWriteSimple::get_interrupt_status_raw() const
  {
    const size_t index = 0;
    const uint32_t raw_value = m_registers[index];

    return raw_value;
  }

  // Read the register and slice out the 'write_done' field value.
  bool DmaAxiWriteSimple::get_interrupt_status_write_done() const
  {
    const uint32_t raw_value = get_interrupt_status_raw();

    return get_interrupt_status_write_done_from_raw(raw_value);
  }

  // Slice out the 'write_done' field value from a given raw register value.
  // Performs no operation on the register bus.
  bool DmaAxiWriteSimple::get_interrupt_status_write_done_from_raw(
    uint32_t register_value
  ) const
  {
    const uint32_t result_masked = register_value & dma_axi_write_simple::interrupt_status::write_done::mask_shifted;
    const uint32_t result_shifted = result_masked >> dma_axi_write_simple::interrupt_status::write_done::shift;

    // Convert to the result type.
    const bool field_value = static_cast<bool>(result_shifted);

    return field_value;
  }

  // Read the register and slice out the 'write_error' field value.
  bool DmaAxiWriteSimple::get_interrupt_status_write_error() const
  {
    const uint32_t raw_value = get_interrupt_status_raw();

    return get_interrupt_status_write_error_from_raw(raw_value);
  }

  // Slice out the 'write_error' field value from a given raw register value.
  // Performs no operation on the register bus.
  bool DmaAxiWriteSimple::get_interrupt_status_write_error_from_raw(
    uint32_t register_value
  ) const
  {
    const uint32_t result_masked = register_value & dma_axi_write_simple::interrupt_status::write_error::mask_shifted;
    const uint32_t result_shifted = result_masked >> dma_axi_write_simple::interrupt_status::write_error::shift;

    // Convert to the result type.
    const bool field_value = static_cast<bool>(result_shifted);

    return field_value;
  }

  // Read the register and slice out the 'start_address_unaligned_error' field value.
  bool DmaAxiWriteSimple::get_interrupt_status_start_address_unaligned_error() const
  {
    const uint32_t raw_value = get_interrupt_status_raw();

    return get_interrupt_status_start_address_unaligned_error_from_raw(raw_value);
  }

  // Slice out the 'start_address_unaligned_error' field value from a given raw register value.
  // Performs no operation on the register bus.
  bool DmaAxiWriteSimple::get_interrupt_status_start_address_unaligned_error_from_raw(
    uint32_t register_value
  ) const
  {
    const uint32_t result_masked = register_value & dma_axi_write_simple::interrupt_status::start_address_unaligned_error::mask_shifted;
    const uint32_t result_shifted = result_masked >> dma_axi_write_simple::interrupt_status::start_address_unaligned_error::shift;

    // Convert to the result type.
    const bool field_value = static_cast<bool>(result_shifted);

    return field_value;
  }

  // Read the register and slice out the 'end_address_unaligned_error' field value.
  bool DmaAxiWriteSimple::get_interrupt_status_end_address_unaligned_error() const
  {
    const uint32_t raw_value = get_interrupt_status_raw();

    return get_interrupt_status_end_address_unaligned_error_from_raw(raw_value);
  }

  // Slice out the 'end_address_unaligned_error' field value from a given raw register value.
  // Performs no operation on the register bus.
  bool DmaAxiWriteSimple::get_interrupt_status_end_address_unaligned_error_from_raw(
    uint32_t register_value
  ) const
  {
    const uint32_t result_masked = register_value & dma_axi_write_simple::interrupt_status::end_address_unaligned_error::mask_shifted;
    const uint32_t result_shifted = result_masked >> dma_axi_write_simple::interrupt_status::end_address_unaligned_error::shift;

    // Convert to the result type.
    const bool field_value = static_cast<bool>(result_shifted);

    return field_value;
  }

  // Read the register and slice out the 'read_address_unaligned_error' field value.
  bool DmaAxiWriteSimple::get_interrupt_status_read_address_unaligned_error() const
  {
    const uint32_t raw_value = get_interrupt_status_raw();

    return get_interrupt_status_read_address_unaligned_error_from_raw(raw_value);
  }

  // Slice out the 'read_address_unaligned_error' field value from a given raw register value.
  // Performs no operation on the register bus.
  bool DmaAxiWriteSimple::get_interrupt_status_read_address_unaligned_error_from_raw(
    uint32_t register_value
  ) const
  {
    const uint32_t result_masked = register_value & dma_axi_write_simple::interrupt_status::read_address_unaligned_error::mask_shifted;
    const uint32_t result_shifted = result_masked >> dma_axi_write_simple::interrupt_status::read_address_unaligned_error::shift;

    // Convert to the result type.
    const bool field_value = static_cast<bool>(result_shifted);

    return field_value;
  }

  // Write the whole register value over the register bus.
  void DmaAxiWriteSimple::set_interrupt_status(
    dma_axi_write_simple::interrupt_status::Value register_value
  ) const
  {
    const uint32_t write_done_value = get_interrupt_status_write_done_to_raw(register_value.write_done);
    const uint32_t write_error_value = get_interrupt_status_write_error_to_raw(register_value.write_error);
    const uint32_t start_address_unaligned_error_value = get_interrupt_status_start_address_unaligned_error_to_raw(register_value.start_address_unaligned_error);
    const uint32_t end_address_unaligned_error_value = get_interrupt_status_end_address_unaligned_error_to_raw(register_value.end_address_unaligned_error);
    const uint32_t read_address_unaligned_error_value = get_interrupt_status_read_address_unaligned_error_to_raw(register_value.read_address_unaligned_error);
    const uint32_t raw_value = write_done_value | write_error_value | start_address_unaligned_error_value | end_address_unaligned_error_value | read_address_unaligned_error_value;

    set_interrupt_status_raw(raw_value);
  }

  // Write the whole register value over the register bus.
  // This method takes a raw register value and does not perform any type conversion.
  void DmaAxiWriteSimple::set_interrupt_status_raw(
    uint32_t register_value
  ) const
  {
    const size_t index = 0;
    m_registers[index] = register_value;
  }

  // Write the 'write_done' field value.
  // Will write the register with all other fields set as default.
  void DmaAxiWriteSimple::set_interrupt_status_write_done(
    bool field_value
  ) const
  {
    const size_t index = 0;

    const uint32_t base_value = dma_axi_write_simple::interrupt_status::write_error::default_value_raw | dma_axi_write_simple::interrupt_status::start_address_unaligned_error::default_value_raw | dma_axi_write_simple::interrupt_status::end_address_unaligned_error::default_value_raw | dma_axi_write_simple::interrupt_status::read_address_unaligned_error::default_value_raw;

    const uint32_t field_value_raw = get_interrupt_status_write_done_to_raw(field_value);
    const uint32_t register_value = base_value | field_value_raw;

    m_registers[index] = register_value;
  }

  // Get the raw representation of a given 'write_done' field value.
  // Performs no operation on the register bus.
  uint32_t DmaAxiWriteSimple::get_interrupt_status_write_done_to_raw(bool field_value) const
  {
    const uint32_t field_value_casted = static_cast<uint32_t>(field_value);
    const uint32_t field_value_shifted = field_value_casted << dma_axi_write_simple::interrupt_status::write_done::shift;

    return field_value_shifted;
  }

  // Write the 'write_error' field value.
  // Will write the register with all other fields set as default.
  void DmaAxiWriteSimple::set_interrupt_status_write_error(
    bool field_value
  ) const
  {
    const size_t index = 0;

    const uint32_t base_value = dma_axi_write_simple::interrupt_status::write_done::default_value_raw | dma_axi_write_simple::interrupt_status::start_address_unaligned_error::default_value_raw | dma_axi_write_simple::interrupt_status::end_address_unaligned_error::default_value_raw | dma_axi_write_simple::interrupt_status::read_address_unaligned_error::default_value_raw;

    const uint32_t field_value_raw = get_interrupt_status_write_error_to_raw(field_value);
    const uint32_t register_value = base_value | field_value_raw;

    m_registers[index] = register_value;
  }

  // Get the raw representation of a given 'write_error' field value.
  // Performs no operation on the register bus.
  uint32_t DmaAxiWriteSimple::get_interrupt_status_write_error_to_raw(bool field_value) const
  {
    const uint32_t field_value_casted = static_cast<uint32_t>(field_value);
    const uint32_t field_value_shifted = field_value_casted << dma_axi_write_simple::interrupt_status::write_error::shift;

    return field_value_shifted;
  }

  // Write the 'start_address_unaligned_error' field value.
  // Will write the register with all other fields set as default.
  void DmaAxiWriteSimple::set_interrupt_status_start_address_unaligned_error(
    bool field_value
  ) const
  {
    const size_t index = 0;

    const uint32_t base_value = dma_axi_write_simple::interrupt_status::write_done::default_value_raw | dma_axi_write_simple::interrupt_status::write_error::default_value_raw | dma_axi_write_simple::interrupt_status::end_address_unaligned_error::default_value_raw | dma_axi_write_simple::interrupt_status::read_address_unaligned_error::default_value_raw;

    const uint32_t field_value_raw = get_interrupt_status_start_address_unaligned_error_to_raw(field_value);
    const uint32_t register_value = base_value | field_value_raw;

    m_registers[index] = register_value;
  }

  // Get the raw representation of a given 'start_address_unaligned_error' field value.
  // Performs no operation on the register bus.
  uint32_t DmaAxiWriteSimple::get_interrupt_status_start_address_unaligned_error_to_raw(bool field_value) const
  {
    const uint32_t field_value_casted = static_cast<uint32_t>(field_value);
    const uint32_t field_value_shifted = field_value_casted << dma_axi_write_simple::interrupt_status::start_address_unaligned_error::shift;

    return field_value_shifted;
  }

  // Write the 'end_address_unaligned_error' field value.
  // Will write the register with all other fields set as default.
  void DmaAxiWriteSimple::set_interrupt_status_end_address_unaligned_error(
    bool field_value
  ) const
  {
    const size_t index = 0;

    const uint32_t base_value = dma_axi_write_simple::interrupt_status::write_done::default_value_raw | dma_axi_write_simple::interrupt_status::write_error::default_value_raw | dma_axi_write_simple::interrupt_status::start_address_unaligned_error::default_value_raw | dma_axi_write_simple::interrupt_status::read_address_unaligned_error::default_value_raw;

    const uint32_t field_value_raw = get_interrupt_status_end_address_unaligned_error_to_raw(field_value);
    const uint32_t register_value = base_value | field_value_raw;

    m_registers[index] = register_value;
  }

  // Get the raw representation of a given 'end_address_unaligned_error' field value.
  // Performs no operation on the register bus.
  uint32_t DmaAxiWriteSimple::get_interrupt_status_end_address_unaligned_error_to_raw(bool field_value) const
  {
    const uint32_t field_value_casted = static_cast<uint32_t>(field_value);
    const uint32_t field_value_shifted = field_value_casted << dma_axi_write_simple::interrupt_status::end_address_unaligned_error::shift;

    return field_value_shifted;
  }

  // Write the 'read_address_unaligned_error' field value.
  // Will write the register with all other fields set as default.
  void DmaAxiWriteSimple::set_interrupt_status_read_address_unaligned_error(
    bool field_value
  ) const
  {
    const size_t index = 0;

    const uint32_t base_value = dma_axi_write_simple::interrupt_status::write_done::default_value_raw | dma_axi_write_simple::interrupt_status::write_error::default_value_raw | dma_axi_write_simple::interrupt_status::start_address_unaligned_error::default_value_raw | dma_axi_write_simple::interrupt_status::end_address_unaligned_error::default_value_raw;

    const uint32_t field_value_raw = get_interrupt_status_read_address_unaligned_error_to_raw(field_value);
    const uint32_t register_value = base_value | field_value_raw;

    m_registers[index] = register_value;
  }

  // Get the raw representation of a given 'read_address_unaligned_error' field value.
  // Performs no operation on the register bus.
  uint32_t DmaAxiWriteSimple::get_interrupt_status_read_address_unaligned_error_to_raw(bool field_value) const
  {
    const uint32_t field_value_casted = static_cast<uint32_t>(field_value);
    const uint32_t field_value_shifted = field_value_casted << dma_axi_write_simple::interrupt_status::read_address_unaligned_error::shift;

    return field_value_shifted;
  }
  // ---------------------------------------------------------------------------

  // ---------------------------------------------------------------------------
  // Methods for the 'interrupt_mask' register.
  // Mode 'Read, Write'.
  // ---------------------------------------------------------------------------
  // Read the whole register value over the register bus.
  uint32_t DmaAxiWriteSimple::get_interrupt_mask() const
  {
    const size_t index = 1;
    const uint32_t raw_value = m_registers[index];

    return raw_value;
  }

  // Write the whole register value over the register bus.
  void DmaAxiWriteSimple::set_interrupt_mask(
    uint32_t register_value
  ) const
  {
    const size_t index = 1;
    m_registers[index] = register_value;
  }
  // ---------------------------------------------------------------------------

  // ---------------------------------------------------------------------------
  // Methods for the 'config' register.
  // Mode 'Read, Write'.
  // ---------------------------------------------------------------------------
  // Read the whole register value over the register bus.
  dma_axi_write_simple::config::Value DmaAxiWriteSimple::get_config() const
  {
    const uint32_t raw_value = get_config_raw();

    const bool enable_value = get_config_enable_from_raw(raw_value);

    return {enable_value};
  }

  // Read the whole register value over the register bus.
  // This method returns the raw register value without any type conversion.
  uint32_t DmaAxiWriteSimple::get_config_raw() const
  {
    const size_t index = 2;
    const uint32_t raw_value = m_registers[index];

    return raw_value;
  }

  // Read the register and slice out the 'enable' field value.
  bool DmaAxiWriteSimple::get_config_enable() const
  {
    const uint32_t raw_value = get_config_raw();

    return get_config_enable_from_raw(raw_value);
  }

  // Slice out the 'enable' field value from a given raw register value.
  // Performs no operation on the register bus.
  bool DmaAxiWriteSimple::get_config_enable_from_raw(
    uint32_t register_value
  ) const
  {
    const uint32_t result_masked = register_value & dma_axi_write_simple::config::enable::mask_shifted;
    const uint32_t result_shifted = result_masked >> dma_axi_write_simple::config::enable::shift;

    // Convert to the result type.
    const bool field_value = static_cast<bool>(result_shifted);

    return field_value;
  }

  // Write the whole register value over the register bus.
  void DmaAxiWriteSimple::set_config(
    dma_axi_write_simple::config::Value register_value
  ) const
  {
    const uint32_t enable_value = get_config_enable_to_raw(register_value.enable);
    const uint32_t raw_value = enable_value;

    set_config_raw(raw_value);
  }

  // Write the whole register value over the register bus.
  // This method takes a raw register value and does not perform any type conversion.
  void DmaAxiWriteSimple::set_config_raw(
    uint32_t register_value
  ) const
  {
    const size_t index = 2;
    m_registers[index] = register_value;
  }

  // Write the 'enable' field value.
  // Will write the register with all other fields set as default.
  void DmaAxiWriteSimple::set_config_enable(
    bool field_value
  ) const
  {
    const size_t index = 2;

    const uint32_t base_value = 0;

    const uint32_t field_value_raw = get_config_enable_to_raw(field_value);
    const uint32_t register_value = base_value | field_value_raw;

    m_registers[index] = register_value;
  }

  // Get the raw representation of a given 'enable' field value.
  // Performs no operation on the register bus.
  uint32_t DmaAxiWriteSimple::get_config_enable_to_raw(bool field_value) const
  {
    const uint32_t field_value_casted = static_cast<uint32_t>(field_value);
    const uint32_t field_value_shifted = field_value_casted << dma_axi_write_simple::config::enable::shift;

    return field_value_shifted;
  }
  // ---------------------------------------------------------------------------

  // ---------------------------------------------------------------------------
  // Methods for the 'buffer_start_address' register.
  // Mode 'Write'.
  // ---------------------------------------------------------------------------
  // Write the whole register value over the register bus.
  void DmaAxiWriteSimple::set_buffer_start_address(
    uint32_t register_value
  ) const
  {
    const size_t index = 3;
    m_registers[index] = register_value;
  }
  // ---------------------------------------------------------------------------

  // ---------------------------------------------------------------------------
  // Methods for the 'buffer_end_address' register.
  // Mode 'Write'.
  // ---------------------------------------------------------------------------
  // Write the whole register value over the register bus.
  void DmaAxiWriteSimple::set_buffer_end_address(
    uint32_t register_value
  ) const
  {
    const size_t index = 4;
    m_registers[index] = register_value;
  }
  // ---------------------------------------------------------------------------

  // ---------------------------------------------------------------------------
  // Methods for the 'buffer_written_address' register.
  // Mode 'Read'.
  // ---------------------------------------------------------------------------
  // Read the whole register value over the register bus.
  uint32_t DmaAxiWriteSimple::get_buffer_written_address() const
  {
    const size_t index = 5;
    const uint32_t raw_value = m_registers[index];

    return raw_value;
  }
  // ---------------------------------------------------------------------------

  // ---------------------------------------------------------------------------
  // Methods for the 'buffer_read_address' register.
  // Mode 'Write'.
  // ---------------------------------------------------------------------------
  // Write the whole register value over the register bus.
  void DmaAxiWriteSimple::set_buffer_read_address(
    uint32_t register_value
  ) const
  {
    const size_t index = 6;
    m_registers[index] = register_value;
  }
  // ---------------------------------------------------------------------------

} // namespace fpga_regs