00001 // this is for emacs file handling -*- mode: c++; indent-tabs-mode: nil -*- 00002 00003 // -- BEGIN LICENSE BLOCK ---------------------------------------------- 00004 00024 // -- END LICENSE BLOCK ------------------------------------------------ 00025 00026 //---------------------------------------------------------------------- 00033 //---------------------------------------------------------------------- 00034 00035 #include <sick_safetyscanners/datastructure/ApplicationOutputs.h> 00036 00037 namespace sick { 00038 namespace datastructure { 00039 00040 ApplicationOutputs::ApplicationOutputs() {} 00041 00042 std::vector<bool> ApplicationOutputs::getEvalOutVector() const 00043 { 00044 return m_eval_out_vector; 00045 } 00046 00047 void ApplicationOutputs::setEvalOutVector(const std::vector<bool>& eval_out_vector) 00048 { 00049 m_eval_out_vector = eval_out_vector; 00050 } 00051 00052 std::vector<bool> ApplicationOutputs::getEvalOutIsSafeVector() const 00053 { 00054 return m_eval_out_is_safe_vector; 00055 } 00056 00057 void ApplicationOutputs::setEvalOutIsSafeVector(const std::vector<bool>& eval_out_is_safe_vector) 00058 { 00059 m_eval_out_is_safe_vector = eval_out_is_safe_vector; 00060 } 00061 00062 std::vector<bool> ApplicationOutputs::getEvalOutIsValidVector() const 00063 { 00064 return m_eval_out_is_valid_vector; 00065 } 00066 00067 void ApplicationOutputs::setEvalOutIsValidVector(const std::vector<bool>& eval_out_is_valid_vector) 00068 { 00069 m_eval_out_is_valid_vector = eval_out_is_valid_vector; 00070 } 00071 00072 std::vector<uint16_t> ApplicationOutputs::getMonitoringCaseVector() const 00073 { 00074 return m_monitoring_case_vector; 00075 } 00076 00077 void ApplicationOutputs::setMonitoringCaseVector( 00078 const std::vector<uint16_t>& monitoring_case_vector) 00079 { 00080 m_monitoring_case_vector = monitoring_case_vector; 00081 } 00082 00083 std::vector<bool> ApplicationOutputs::getMonitoringCaseFlagsVector() const 00084 { 00085 return m_monitoring_case_flags_vector; 00086 } 00087 00088 void ApplicationOutputs::setMonitoringCaseFlagsVector( 00089 const std::vector<bool>& monitoring_case_flags_vector) 00090 { 00091 m_monitoring_case_flags_vector = monitoring_case_flags_vector; 00092 } 00093 00094 int8_t ApplicationOutputs::getSleepModeOutput() const 00095 { 00096 return m_sleep_mode_output; 00097 } 00098 00099 void ApplicationOutputs::setSleepModeOutput(const int8_t& sleep_mode_output) 00100 { 00101 m_sleep_mode_output = sleep_mode_output; 00102 } 00103 00104 bool ApplicationOutputs::getHostErrorFlagContaminationWarning() const 00105 { 00106 return m_host_error_flag_contamination_warning; 00107 } 00108 00109 void ApplicationOutputs::setHostErrorFlagContaminationWarning( 00110 bool host_error_flag_contamination_warning) 00111 { 00112 m_host_error_flag_contamination_warning = host_error_flag_contamination_warning; 00113 } 00114 00115 bool ApplicationOutputs::getHostErrorFlagContaminationError() const 00116 { 00117 return m_host_error_flag_contamination_error; 00118 } 00119 00120 void ApplicationOutputs::setHostErrorFlagContaminationError( 00121 bool host_error_flag_contamination_error) 00122 { 00123 m_host_error_flag_contamination_error = host_error_flag_contamination_error; 00124 } 00125 00126 bool ApplicationOutputs::getHostErrorFlagManipulationError() const 00127 { 00128 return m_host_error_flag_manipulation_error; 00129 } 00130 00131 void ApplicationOutputs::setHostErrorFlagManipulationError(bool host_error_flag_manipulation_error) 00132 { 00133 m_host_error_flag_manipulation_error = host_error_flag_manipulation_error; 00134 } 00135 00136 bool ApplicationOutputs::getHostErrorFlagGlare() const 00137 { 00138 return m_host_error_flag_glare; 00139 } 00140 00141 void ApplicationOutputs::setHostErrorFlagGlare(bool host_error_flag_glare) 00142 { 00143 m_host_error_flag_glare = host_error_flag_glare; 00144 } 00145 00146 bool ApplicationOutputs::getHostErrorFlagReferenceContourIntruded() const 00147 { 00148 return m_host_error_flag_reference_contour_intruded; 00149 } 00150 00151 void ApplicationOutputs::setHostErrorFlagReferenceContourIntruded( 00152 bool host_error_flag_reference_contour_intruded) 00153 { 00154 m_host_error_flag_reference_contour_intruded = host_error_flag_reference_contour_intruded; 00155 } 00156 00157 bool ApplicationOutputs::getHostErrorFlagCriticalError() const 00158 { 00159 return m_host_error_flag_critical_error; 00160 } 00161 00162 void ApplicationOutputs::setHostErrorFlagCriticalError(bool host_error_flag_critical_error) 00163 { 00164 m_host_error_flag_critical_error = host_error_flag_critical_error; 00165 } 00166 00167 int16_t ApplicationOutputs::getVelocity0() const 00168 { 00169 return m_velocity_0; 00170 } 00171 00172 void ApplicationOutputs::setVelocity0(const int16_t& velocity_0) 00173 { 00174 m_velocity_0 = velocity_0; 00175 } 00176 00177 int16_t ApplicationOutputs::getVelocity1() const 00178 { 00179 return m_velocity_1; 00180 } 00181 00182 void ApplicationOutputs::setVelocity1(const int16_t& velocity_1) 00183 { 00184 m_velocity_1 = velocity_1; 00185 } 00186 00187 bool ApplicationOutputs::getVelocity0Valid() const 00188 { 00189 return m_velocity_0_valid; 00190 } 00191 00192 void ApplicationOutputs::setVelocity0Valid(bool velocity_0_valid) 00193 { 00194 m_velocity_0_valid = velocity_0_valid; 00195 } 00196 00197 bool ApplicationOutputs::getVelocity1Valid() const 00198 { 00199 return m_velocity_1_valid; 00200 } 00201 00202 void ApplicationOutputs::setVelocity1Valid(bool velocity_1_valid) 00203 { 00204 m_velocity_1_valid = velocity_1_valid; 00205 } 00206 00207 bool ApplicationOutputs::getVelocity0TransmittedSafely() const 00208 { 00209 return m_velocity_0_transmitted_safely; 00210 } 00211 00212 void ApplicationOutputs::setVelocity0TransmittedSafely(bool velocity_0_transmitted_safely) 00213 { 00214 m_velocity_0_transmitted_safely = velocity_0_transmitted_safely; 00215 } 00216 00217 bool ApplicationOutputs::getVelocity1TransmittedSafely() const 00218 { 00219 return m_velocity_1_transmitted_safely; 00220 } 00221 00222 void ApplicationOutputs::setVelocity1TransmittedSafely(bool velocity_1_transmitted_safely) 00223 { 00224 m_velocity_1_transmitted_safely = velocity_1_transmitted_safely; 00225 } 00226 00227 std::vector<int16_t> ApplicationOutputs::getResultingVelocityVector() const 00228 { 00229 return m_resulting_velocity_vector; 00230 } 00231 00232 void ApplicationOutputs::setResultingVelocityVector( 00233 const std::vector<int16_t>& resulting_velocity_vector) 00234 { 00235 m_resulting_velocity_vector = resulting_velocity_vector; 00236 } 00237 00238 std::vector<bool> ApplicationOutputs::getResultingVelocityIsValidVector() const 00239 { 00240 return m_resulting_velocity_is_valid_vector; 00241 } 00242 00243 void ApplicationOutputs::setResultingVelocityIsValidVector( 00244 const std::vector<bool>& resulting_velocity_is_valid_vector) 00245 { 00246 m_resulting_velocity_is_valid_vector = resulting_velocity_is_valid_vector; 00247 } 00248 00249 bool ApplicationOutputs::getFlagsSleepModeOutputIsValid() const 00250 { 00251 return m_flags_sleep_mode_output_is_valid; 00252 } 00253 00254 void ApplicationOutputs::setFlagsSleepModeOutputIsValid(bool flags_sleep_mode_output_is_valid) 00255 { 00256 m_flags_sleep_mode_output_is_valid = flags_sleep_mode_output_is_valid; 00257 } 00258 00259 bool ApplicationOutputs::getFlagsHostErrorFlagsAreValid() const 00260 { 00261 return m_flags_host_error_flags_are_valid; 00262 } 00263 00264 void ApplicationOutputs::setFlagsHostErrorFlagsAreValid(bool flags_host_error_flags_are_valid) 00265 { 00266 m_flags_host_error_flags_are_valid = flags_host_error_flags_are_valid; 00267 } 00268 00269 } // namespace datastructure 00270 } // namespace sick