ApplicationOutputs.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/ApplicationOutputs.h>
 
namespace sick {
namespace datastructure {
 
ApplicationOutputs::ApplicationOutputs() {}
 
std::vector<bool> ApplicationOutputs::getEvalOutVector() const
{
  return m_eval_out_vector;
}
 
void ApplicationOutputs::setEvalOutVector(const std::vector<bool>& eval_out_vector)
{
  m_eval_out_vector = eval_out_vector;
}
 
std::vector<bool> ApplicationOutputs::getEvalOutIsSafeVector() const
{
  return m_eval_out_is_safe_vector;
}
 
void ApplicationOutputs::setEvalOutIsSafeVector(const std::vector<bool>& eval_out_is_safe_vector)
{
  m_eval_out_is_safe_vector = eval_out_is_safe_vector;
}
 
std::vector<bool> ApplicationOutputs::getEvalOutIsValidVector() const
{
  return m_eval_out_is_valid_vector;
}
 
void ApplicationOutputs::setEvalOutIsValidVector(const std::vector<bool>& eval_out_is_valid_vector)
{
  m_eval_out_is_valid_vector = eval_out_is_valid_vector;
}
 
std::vector<uint16_t> ApplicationOutputs::getMonitoringCaseVector() const
{
  return m_monitoring_case_vector;
}
 
void ApplicationOutputs::setMonitoringCaseVector(
  const std::vector<uint16_t>& monitoring_case_vector)
{
  m_monitoring_case_vector = monitoring_case_vector;
}
 
std::vector<bool> ApplicationOutputs::getMonitoringCaseFlagsVector() const
{
  return m_monitoring_case_flags_vector;
}
 
void ApplicationOutputs::setMonitoringCaseFlagsVector(
  const std::vector<bool>& monitoring_case_flags_vector)
{
  m_monitoring_case_flags_vector = monitoring_case_flags_vector;
}
 
int8_t ApplicationOutputs::getSleepModeOutput() const
{
  return m_sleep_mode_output;
}
 
void ApplicationOutputs::setSleepModeOutput(const int8_t& sleep_mode_output)
{
  m_sleep_mode_output = sleep_mode_output;
}
 
bool ApplicationOutputs::getHostErrorFlagContaminationWarning() const
{
  return m_host_error_flag_contamination_warning;
}
 
void ApplicationOutputs::setHostErrorFlagContaminationWarning(
  bool host_error_flag_contamination_warning)
{
  m_host_error_flag_contamination_warning = host_error_flag_contamination_warning;
}
 
bool ApplicationOutputs::getHostErrorFlagContaminationError() const
{
  return m_host_error_flag_contamination_error;
}
 
void ApplicationOutputs::setHostErrorFlagContaminationError(
  bool host_error_flag_contamination_error)
{
  m_host_error_flag_contamination_error = host_error_flag_contamination_error;
}
 
bool ApplicationOutputs::getHostErrorFlagManipulationError() const
{
  return m_host_error_flag_manipulation_error;
}
 
void ApplicationOutputs::setHostErrorFlagManipulationError(bool host_error_flag_manipulation_error)
{
  m_host_error_flag_manipulation_error = host_error_flag_manipulation_error;
}
 
bool ApplicationOutputs::getHostErrorFlagGlare() const
{
  return m_host_error_flag_glare;
}
 
void ApplicationOutputs::setHostErrorFlagGlare(bool host_error_flag_glare)
{
  m_host_error_flag_glare = host_error_flag_glare;
}
 
bool ApplicationOutputs::getHostErrorFlagReferenceContourIntruded() const
{
  return m_host_error_flag_reference_contour_intruded;
}
 
void ApplicationOutputs::setHostErrorFlagReferenceContourIntruded(
  bool host_error_flag_reference_contour_intruded)
{
  m_host_error_flag_reference_contour_intruded = host_error_flag_reference_contour_intruded;
}
 
bool ApplicationOutputs::getHostErrorFlagCriticalError() const
{
  return m_host_error_flag_critical_error;
}
 
void ApplicationOutputs::setHostErrorFlagCriticalError(bool host_error_flag_critical_error)
{
  m_host_error_flag_critical_error = host_error_flag_critical_error;
}
 
int16_t ApplicationOutputs::getVelocity0() const
{
  return m_velocity_0;
}
 
void ApplicationOutputs::setVelocity0(const int16_t& velocity_0)
{
  m_velocity_0 = velocity_0;
}
 
int16_t ApplicationOutputs::getVelocity1() const
{
  return m_velocity_1;
}
 
void ApplicationOutputs::setVelocity1(const int16_t& velocity_1)
{
  m_velocity_1 = velocity_1;
}
 
bool ApplicationOutputs::getVelocity0Valid() const
{
  return m_velocity_0_valid;
}
 
void ApplicationOutputs::setVelocity0Valid(bool velocity_0_valid)
{
  m_velocity_0_valid = velocity_0_valid;
}
 
bool ApplicationOutputs::getVelocity1Valid() const
{
  return m_velocity_1_valid;
}
 
void ApplicationOutputs::setVelocity1Valid(bool velocity_1_valid)
{
  m_velocity_1_valid = velocity_1_valid;
}
 
bool ApplicationOutputs::getVelocity0TransmittedSafely() const
{
  return m_velocity_0_transmitted_safely;
}
 
void ApplicationOutputs::setVelocity0TransmittedSafely(bool velocity_0_transmitted_safely)
{
  m_velocity_0_transmitted_safely = velocity_0_transmitted_safely;
}
 
bool ApplicationOutputs::getVelocity1TransmittedSafely() const
{
  return m_velocity_1_transmitted_safely;
}
 
void ApplicationOutputs::setVelocity1TransmittedSafely(bool velocity_1_transmitted_safely)
{
  m_velocity_1_transmitted_safely = velocity_1_transmitted_safely;
}
 
std::vector<int16_t> ApplicationOutputs::getResultingVelocityVector() const
{
  return m_resulting_velocity_vector;
}
 
void ApplicationOutputs::setResultingVelocityVector(
  const std::vector<int16_t>& resulting_velocity_vector)
{
  m_resulting_velocity_vector = resulting_velocity_vector;
}
 
std::vector<bool> ApplicationOutputs::getResultingVelocityIsValidVector() const
{
  return m_resulting_velocity_is_valid_vector;
}
 
void ApplicationOutputs::setResultingVelocityIsValidVector(
  const std::vector<bool>& resulting_velocity_is_valid_vector)
{
  m_resulting_velocity_is_valid_vector = resulting_velocity_is_valid_vector;
}
 
bool ApplicationOutputs::getFlagsSleepModeOutputIsValid() const
{
  return m_flags_sleep_mode_output_is_valid;
}
 
void ApplicationOutputs::setFlagsSleepModeOutputIsValid(bool flags_sleep_mode_output_is_valid)
{
  m_flags_sleep_mode_output_is_valid = flags_sleep_mode_output_is_valid;
}
 
bool ApplicationOutputs::getFlagsHostErrorFlagsAreValid() const
{
  return m_flags_host_error_flags_are_valid;
}
 
void ApplicationOutputs::setFlagsHostErrorFlagsAreValid(bool flags_host_error_flags_are_valid)
{
  m_flags_host_error_flags_are_valid = flags_host_error_flags_are_valid;
}
 
} // namespace datastructure
} // namespace sick