log.hpp

#ifndef _CHRONOPTICS_TOF_LOG_HPP_
#define _CHRONOPTICS_TOF_LOG_HPP_
 
#include <chronoptics/tof/log.h>
 
#include <chronoptics/tof/base.hpp>
 
namespace chronoptics {
namespace tof {
 
// Function pointer type for log callback
using log_callback_fn = std::function<void(const char*)>;
constexpr auto log_callback_cb_handler = &detail::callback_handler<void, const char*>;
 
// Function pointer type for log callback separated
using log_callback_separated_fn = std::function<void(int16_t, const char*, const char*)>;
constexpr auto log_callback_separated_cb_handler = &detail::callback_handler<void, int16_t, const char*, const char*>;
 
/** Class containing log information about the crash that occurred
*/
class CrashReport : public detail::Base<tof_crash_report, tof_crash_report_delete> {
 public:
  /** Construct from pointer */
  CrashReport(tof_crash_report_t ptr = nullptr) {
    this->ptr_ = ptr;
  }
 
  /** Generate crash report on a camera
   * @param serial Camera to generate the crash report on
   * @param description Description of what happened
   */
  CrashReport(StringView serial, StringView description) {
    this->ptr_ = tof_crash_report_new(serial, description, TOF_ERROR_HANDLER{});
  }
 
  /** Get the description
   * @return Description
   */
  const char* get_description() const {
    return tof_crash_report_get_description(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the description
   * @param description Description
   */
  void set_description(StringView description) {
    return tof_crash_report_set_description(this->ptr_, description, TOF_ERROR_HANDLER{});
  }
 
  /** Get the complete report
   * @return String of the entire report
   */
  const char* get_report() const {
    return tof_crash_report_get_report(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Save report to disk
   * @param file_name File to save the report to
   */
  void save(StringView file_name) const {
    return tof_crash_report_save(this->ptr_, file_name, TOF_ERROR_HANDLER{});
  }
 
};
 
/** Get the version of the tof library
 * @return Library version
 */
inline const char* get_version() {
  return tof_get_version(TOF_ERROR_HANDLER{});
}
 
/** Log info/warning/error occuring in the tof library to stdout
 */
inline void log_to_console() {
  return tof_log_to_console(TOF_ERROR_HANDLER{});
}
 
/** Log info/warning/error occuring in the tof library
 * @param file_location Location where to store the log file
 */
inline void log_to_file(StringView file_location) {
  return tof_log_to_file(file_location, TOF_ERROR_HANDLER{});
}
 
/** Log info/warning/error occuring in the tof library to function
 * @param callback Function that is called with log data
 */
inline void log_callback(log_callback_fn &callback) {
  return tof_log_callback(log_callback_cb_handler, &callback, TOF_ERROR_HANDLER{});
}
 
/** Log info/warning/error occuring in the tof library to function
 * @param callback Function that is called with log data
 * @param callback_user_data User data that will be passed back when the function pointer is called
 */
inline void log_callback(tof_log_callback_t callback, void* callback_user_data) {
  return tof_log_callback(callback, callback_user_data, TOF_ERROR_HANDLER{});
}
 
/** Log info/warning/error occuring in the tof library to function
 * @param callback_separated Function that is called with separated log data
 */
inline void log_callback_separated(log_callback_separated_fn &callback_separated) {
  return tof_log_callback_separated(log_callback_separated_cb_handler, &callback_separated, TOF_ERROR_HANDLER{});
}
 
/** Log info/warning/error occuring in the tof library to function
 * @param callback_separated Function that is called with separated log data
 * @param callback_separated_user_data User data that will be passed back when the function pointer is called
 */
inline void log_callback_separated(tof_log_callback_separated_t callback_separated, void* callback_separated_user_data) {
  return tof_log_callback_separated(callback_separated, callback_separated_user_data, TOF_ERROR_HANDLER{});
}
 
/** Stop logging
 */
inline void log_drop() {
  return tof_log_drop(TOF_ERROR_HANDLER{});
}
 
} // tof
} // chronoptics
 
#endif