detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-04-20 02:40:03 +02:00
Code Issues Actions Packages Releases Activity

WIP

Browse Source
This commit is contained in:
Erik Frojdh 2020-03-04 15:25:49 +01:00
parent ff9c37701b
commit 661adaf4ed
4 changed files with 118 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
sample/CMakeLists.txt
View File

@ -1,36 +1,35 @@
add_executable(a api.cpp) add_executable(using_logger using_logger.cpp)
target_link_libraries(a target_link_libraries(using_logger
slsDetectorShared
slsSupportLib slsSupportLib
pthread pthread
rt rt
) )
set_target_properties(a PROPERTIES set_target_properties(using_logger PROPERTIES
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
) )
add_executable(result useResult.cpp) # add_executable(result useResult.cpp)
target_link_libraries(result # target_link_libraries(result
slsDetectorShared # slsDetectorShared
) # )
set_target_properties(result PROPERTIES # set_target_properties(result PROPERTIES
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin # RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
) # )
add_executable(udp udp.cpp) # add_executable(udp udp.cpp)
target_link_libraries(udp # target_link_libraries(udp
slsDetectorShared # slsDetectorShared
slsSupportLib # slsSupportLib
pthread # pthread
rt # rt
fmt # fmt
) # )
set_target_properties(udp PROPERTIES # set_target_properties(udp PROPERTIES
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin # RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
) # )

32
sample/using_logger.cpp Normal file
View File

@ -0,0 +1,32 @@
#include "logger.h"
#include "logger2.h"
#include <iostream>
#include <chrono>
int main(){
std::cout << "Compare output between old and new:\n";
FILE_LOG(logINFO) << "Old message";
LOG(logINFO) << "New message";
FILE_LOG(logERROR) << "Old error";
LOG(logERROR) << "New error";
FILE_LOG(logWARNING) << "Old warning";
LOG(logWARNING) << "New warning";
// // sls::Logger::ReportingLevel() = logERROR;
// const auto N = 100000;
// auto t0 = std::chrono::steady_clock::now();
// for (int i = 0; i!=N; ++i){
// // LOG(logWARNING) << "HEY";
// FILE_LOG(logWARNING) << "HEY";
// }
// auto t1 = std::chrono::steady_clock::now();
// for (int i = 0; i!=N; ++i){
// LOG(logWARNING) << "HEY";
// }
// auto t2 = std::chrono::steady_clock::now();
// std::cout << "Old: " << (t1-t0).count() << "\n";
// std::cout << "New: " << (t2-t1).count() << "\n";
}

60
slsSupportLib/include/logger2.h
View File

@ -1,33 +1,26 @@
#pragma once #pragma once
/*Utility to log to console*/ /*Utility to log to console*/
#include "ansi.h" //Colors #include "ansi.h" //Colors
#include "logger.h" #include "logger.h" //for enum, to be removed
#include <iostream> #include <iostream>
#include <chrono>
#include <sstream> #include <sstream>
#include <iomanip>
#include <map>
/* // Compiler should optimize away anything below this value
Define the max level that is visible #ifndef LOG_MAX_REPORTING_LEVEL
The compiler should optimize away any calls below #define LOG_MAX_REPORTING_LEVEL logINFO
this level
*/
#ifndef LOG_MAX_LEVEL
#define LOG_MAX_LEVEL logINFO
#endif #endif
namespace sls { namespace sls {
class Logger { class Logger {
std::ostringstream os; std::ostringstream os;
TLogLevel level = LOG_MAX_LEVEL; TLogLevel level = LOG_MAX_REPORTING_LEVEL;
public: public:
Logger() = default; Logger() = default;
Logger(TLogLevel level) : level(level){}; Logger(TLogLevel level) : level(level){};
~Logger() { ~Logger() {
// output happens in the destructor to allow for << // output in the destructor to allow for << syntax
os << Reset() << '\n'; os << Reset() << '\n';
std::clog << os.str(); // Single write std::clog << os.str(); // Single write
} }
@ -38,13 +31,14 @@ class Logger {
} }
// Danger this buffer need as many elements as TLogLevel // Danger this buffer need as many elements as TLogLevel
static const char *Color(TLogLevel level) { static const char *Color(TLogLevel level) noexcept {
static const char *const colors[] = { static const char *const colors[] = {
RED BOLD, YELLOW BOLD, RESET, BLUE, RED, RESET, RED BOLD, YELLOW BOLD, RESET, BLUE, RED, RESET,
RESET, RESET, RESET, RESET, RESET, RESET}; RESET, RESET, RESET, RESET, RESET, RESET};
return colors[level]; return colors[level];
} }
static const char *Reset() {
static const char *Reset() noexcept {
static const char *reset = RESET; static const char *reset = RESET;
return reset; return reset;
} }
@ -58,26 +52,32 @@ class Logger {
} }
std::ostringstream &Get() { std::ostringstream &Get() {
os << Color(level); os << Color(level) << "- " << Timestamp() << " " << ToString(level)
os << "- " << Time(); << ": ";
os << " " << ToString(level) << ": ";
return os; return os;
} }
std::string Time(decltype(std::chrono::system_clock::now()) now =
std::chrono::system_clock::now()) { std::string Timestamp() {
std::ostringstream oss; constexpr size_t buffer_len = 12;
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>( char buffer[buffer_len];
now.time_since_epoch()) % time_t t;
1000; time(&t);
std::time_t now_time = std::chrono::system_clock::to_time_t(now); tm r;
oss << std::put_time(std::localtime(&now_time), "%H:%M:%S") << "." strftime(buffer, buffer_len, "%X", localtime_r(&t, &r));
<< std::setw(3) << std::setfill('0') << ms.count(); buffer[buffer_len - 1] = '\0';
return oss.str(); struct timeval tv;
gettimeofday(&tv, nullptr);
constexpr size_t result_len = 100;
char result[result_len];
snprintf(result, result_len, "%s.%03ld", buffer,
(long)tv.tv_usec / 1000);
result[result_len - 1] = '\0';
return result;
} }
}; };
#define LOG(level) \ #define LOG(level) \
if (level > LOG_MAX_LEVEL) \ if (level > LOG_MAX_REPORTING_LEVEL) \
; \ ; \
else if (level > sls::Logger::ReportingLevel()) \ else if (level > sls::Logger::ReportingLevel()) \
; \ ; \

69
slsSupportLib/tests/test-logger.cpp
View File

@ -6,54 +6,53 @@
#include <fstream> #include <fstream>
#include <chrono> #include <chrono>
TEST_CASE("Get time"){ using sls::Logger;
auto now = std::chrono::system_clock::now();
sls::Logger log;
auto time = log.Time(now);
TEST_CASE("LogLevel to string") {
CHECK(Logger::ToString(logERROR) == "ERROR");
CHECK(Logger::ToString(logWARNING) == "WARNING");
CHECK(Logger::ToString(logINFOBLUE) == "INFO");
CHECK(Logger::ToString(logINFOGREEN) == "INFO");
CHECK(Logger::ToString(logINFORED) == "INFO");
CHECK(Logger::ToString(logINFO) == "INFO");
CHECK(Logger::ToString(logDEBUG) == "DEBUG");
CHECK(Logger::ToString(logDEBUG1) == "DEBUG1");
CHECK(Logger::ToString(logDEBUG2) == "DEBUG2");
CHECK(Logger::ToString(logDEBUG3) == "DEBUG3");
CHECK(Logger::ToString(logDEBUG4) == "DEBUG4");
CHECK(Logger::ToString(logDEBUG5) == "DEBUG5");
} }
TEST_CASE("fail"){ TEST_CASE("get reset string"){
std::string reset(Logger::Reset());
CHECK(reset == RESET);
}
FILE_LOG(logINFO) << "A message"; TEST_CASE("Test output") {
FILE_LOG(logWARNING) << "An error";
FILE_LOG(logERROR) << "A warning";
// sls::Logger::ReportingLevel() = logERROR; auto old_value = Logger::ReportingLevel();
// std::cout << sls::Logger::ReportingLevel() << '\n';
LOG(logINFO) << "A new message";
LOG(logERROR) << "A new error";
LOG(logWARNING) << "A new warning";
LOG(logDEBUG3) << "This should not be printed"; Logger::ReportingLevel() = logERROR;
//Redirect std::clog to local buffer
std::ostringstream local; std::ostringstream local;
auto clog_buff = std::clog.rdbuf(); auto clog_buff = std::clog.rdbuf();
std::clog.rdbuf(local.rdbuf()); std::clog.rdbuf(local.rdbuf());
LOG(logERROR) << "This should also not be printed";
//Try printing something with too low level
LOG(logDEBUG) << "This should not be printed";
CHECK(local.str().empty());
//Try printing something with a higher level
LOG(logERROR) << "This should be printed";
CHECK(!local.str().empty());
std::clog.rdbuf(clog_buff); // restore std::clog.rdbuf(clog_buff); // restore
LOG(logERROR) << "But this should"; Logger::ReportingLevel() = old_value; //reset
std::cout << "we got: " << local.str() << '\n';
// sls::Logger::ReportingLevel() = logDEBUG1; //Check that the message is in the printed string
// std::cout << sls::Logger::ReportingLevel() << '\n'; auto r = local.str();
// std::ostream& os = std::cout; auto pos = r.find("This should be printed");
// Output2FILE::Stream(); CHECK(pos != std::string::npos);
// os << "hej pa dig\n";
// std::ostringstream oss;
// std::ostream& os = oss;
// auto& out = Output2FILE::Stream();
// out = os;
// Output2FILE::Stream() = std::cout;
// FILE_LOG(logERROR) << "An error message";
// CHECK(false);
} }