GeneralSystemState.cpp

Go to the documentation of this file.

// this is for emacs file handling -*- mode: c++; indent-tabs-mode: nil -*-
 
// -- BEGIN LICENSE BLOCK ----------------------------------------------
 
// -- END LICENSE BLOCK ------------------------------------------------
 
//----------------------------------------------------------------------
//----------------------------------------------------------------------
 
#include <sick_safetyscanners/datastructure/GeneralSystemState.h>
 
namespace sick {
namespace datastructure {
 
GeneralSystemState::GeneralSystemState()
  : m_is_empty(false)
{
}
 
bool GeneralSystemState::getRunModeActive() const
{
  return m_run_mode_active;
}
 
void GeneralSystemState::setRunModeActive(bool run_mode_active)
{
  m_run_mode_active = run_mode_active;
}
 
bool GeneralSystemState::getStandbyModeActive() const
{
  return m_standby_mode_active;
}
 
void GeneralSystemState::setStandbyModeActive(bool standby_mode_active)
{
  m_standby_mode_active = standby_mode_active;
}
 
bool GeneralSystemState::getContaminationWarning() const
{
  return m_contamination_warning;
}
 
void GeneralSystemState::setContaminationWarning(bool contamination_warning)
{
  m_contamination_warning = contamination_warning;
}
 
bool GeneralSystemState::getContaminationError() const
{
  return m_contamination_error;
}
 
void GeneralSystemState::setContaminationError(bool contamination_error)
{
  m_contamination_error = contamination_error;
}
 
bool GeneralSystemState::getReferenceContourStatus() const
{
  return m_reference_contour_status;
}
 
void GeneralSystemState::setReferenceContourStatus(bool reference_contour_status)
{
  m_reference_contour_status = reference_contour_status;
}
 
bool GeneralSystemState::getManipulationStatus() const
{
  return m_manipulation_status;
}
 
void GeneralSystemState::setManipulationStatus(bool manipulation_status)
{
  m_manipulation_status = manipulation_status;
}
 
std::vector<bool> GeneralSystemState::getSafeCutOffPathVector() const
{
  return m_safe_cut_off_path_vector;
}
 
void GeneralSystemState::setSafeCutOffPathvector(const std::vector<bool>& safe_cut_off_path_vector)
{
  m_safe_cut_off_path_vector = safe_cut_off_path_vector;
}
 
std::vector<bool> GeneralSystemState::getNonSafeCutOffPathVector() const
{
  return m_non_safe_cut_off_path_vector;
}
 
void GeneralSystemState::setNonSafeCutOffPathVector(
  const std::vector<bool>& non_safe_cut_off_path_vector)
{
  m_non_safe_cut_off_path_vector = non_safe_cut_off_path_vector;
}
 
std::vector<bool> GeneralSystemState::getResetRequiredCutOffPathVector() const
{
  return m_reset_required_cut_off_path_vector;
}
 
void GeneralSystemState::setResetRequiredCutOffPathVector(
  const std::vector<bool>& reset_required_cut_off_path_vector)
{
  m_reset_required_cut_off_path_vector = reset_required_cut_off_path_vector;
}
 
uint8_t GeneralSystemState::getCurrentMonitoringCaseNoTable1() const
{
  return m_current_monitoring_case_no_table_1;
}
 
void GeneralSystemState::setCurrentMonitoringCaseNoTable1(
  const uint8_t& current_monitoring_case_no_table_1)
{
  m_current_monitoring_case_no_table_1 = current_monitoring_case_no_table_1;
}
 
uint8_t GeneralSystemState::getCurrentMonitoringCaseNoTable2() const
{
  return m_current_monitoring_case_no_table_2;
}
 
void GeneralSystemState::setCurrentMonitoringCaseNoTable2(
  const uint8_t& current_monitoring_case_no_table_2)
{
  m_current_monitoring_case_no_table_2 = current_monitoring_case_no_table_2;
}
 
uint8_t GeneralSystemState::getCurrentMonitoringCaseNoTable3() const
{
  return m_current_monitoring_case_no_table_3;
}
 
void GeneralSystemState::setCurrentMonitoringCaseNoTable3(
  const uint8_t& current_monitoring_case_no_table_3)
{
  m_current_monitoring_case_no_table_3 = current_monitoring_case_no_table_3;
}
 
uint8_t GeneralSystemState::getCurrentMonitoringCaseNoTable4() const
{
  return m_current_monitoring_case_no_table_4;
}
 
void GeneralSystemState::setCurrentMonitoringCaseNoTable4(
  const uint8_t& current_monitoring_case_no_table_4)
{
  m_current_monitoring_case_no_table_4 = current_monitoring_case_no_table_4;
}
 
bool GeneralSystemState::getApplicationError() const
{
  return m_application_error;
}
 
void GeneralSystemState::setApplicationError(bool application_error)
{
  m_application_error = application_error;
}
 
bool GeneralSystemState::getDeviceError() const
{
  return m_device_error;
}
 
void GeneralSystemState::setDeviceError(bool device_error)
{
  m_device_error = device_error;
}
 
bool GeneralSystemState::isEmpty() const
{
  return m_is_empty;
}
 
void GeneralSystemState::setIsEmpty(bool is_empty)
{
  m_is_empty = is_empty;
}
 
 
} // namespace datastructure
} // namespace sick