toolbox.hpp

Go to the documentation of this file.

 
#ifndef TIMING_INCLUDE_TIMING_TOOLBOX_HPP_
#define TIMING_INCLUDE_TIMING_TOOLBOX_HPP_
 
#include "definitions.hpp"
 
#include "TimingIssues.hpp"
 
#include "ers/Issue.hpp"
#include "logging/Logging.hpp"
 
// uHAL Headers
#include <uhal/Node.hpp>
 
// Boost Headers
#include <boost/format.hpp>
#include <boost/format/group.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_signed.hpp>
#include <boost/type_traits/is_unsigned.hpp>
#include <boost/unordered_map.hpp>
 
// C++ Headers
#include <chrono>
#include <cstdint>
#include <cstdlib>
#include <iomanip>
#include <istream>
#include <string>
#include <vector>
 
namespace dunedaq {
namespace timing {
 
// Wrappers to be used by lexical_cast
template<typename T>
struct stol;
template<typename T>
struct stoul;
 
template<typename T>
std::string
to_string(const T&);
 
template<typename M>
bool
map_value_comparator(typename M::value_type& p1, typename M::value_type& p2);
 
template<typename T>
std::vector<T>
sanitize(const std::vector<T>& vec);
 
template<typename T, typename U>
T
safe_enum_cast(const U& value, const std::vector<T>& valid);
 
Snapshot
snapshot(const uhal::Node& node);
 
Snapshot
snapshot(const uhal::Node& node, const std::string& regex);
 
void
millisleep(const double& time_in_milliseconds);
 
std::string
strprintf(const char* fmt, ...); // NOLINT
 
std::vector<std::string>
shell_expand_paths(const std::string& path);
 
std::string
shellExpandPath(const std::string& path);
 
void
throw_if_not_file(const std::string& path);
 
template<typename C>
std::string
join(const C& strings, const std::string& delimiter = " ");
 
uint8_t                                                 // NOLINT(build/unsigned)
dec_rng(uint8_t word, uint8_t ibit, uint8_t nbits = 1); // NOLINT(build/unsigned)
 
uint64_t                                             // NOLINT(build/unsigned)
tstamp2int(uhal::ValVector<uint32_t> raw_timestamp); // NOLINT(build/unsigned)
 
template<class T>
std::string
format_reg_value(T reg_value, uint32_t base = 16); // NOLINT(build/unsigned)
 
template<class T>
std::string
format_reg_table(T data, std::string title = "", std::vector<std::string> headers = { "Register", "Value" });
 
int64_t
get_milliseconds_since_epoch();
 
int64_t
get_seconds_since_epoch();
 
std::string
format_timestamp(uhal::ValVector<uint32_t> raw_timestamp, uint32_t clock_frequency_hz); // NOLINT(build/unsigned)
 
std::string
format_timestamp(uint64_t raw_timestamp, uint32_t clock_frequency_hz); // NOLINT(build/unsigned)
 
template<class T>
std::string
format_counters_table(std::vector<T> counters,
                      std::vector<std::string> counter_node_titles = {},
                      std::string table_title = "",
                      std::vector<std::string> counter_labels = {},
                      std::string counter_labels_header = "Cmd");
 
double
convert_bits_to_float(uint64_t bits, bool is_double_precision = false); // NOLINT(build/unsigned)
 
BoardType
convert_value_to_board_type(uint32_t Board_type); // NOLINT(build/unsigned)
CarrierType
convert_value_to_carrier_type(uint32_t darrier_type); // NOLINT(build/unsigned)
DesignType
convert_value_to_design_type(uint32_t design_type); // NOLINT(build/unsigned)
 
template<typename T>
std::string
vec_fmt(const std::vector<T>& vec);
 
template<typename T>
std::string
short_vec_fmt(const std::vector<T>& vec);
 
std::string
format_firmware_version(uint32_t firmware_version); // NOLINT(build/unsigned)
 
} // namespace timing
} // namespace dunedaq
 
#include "detail/toolbox.hxx"
 
#endif // TIMING_INCLUDE_TIMING_TOOLBOX_HPP_