_ZN4epee4spanIKhEC2IS1_vEEPT_m: 82| 855| : ptr(src_ptr), len(count) {} _ZNK4epee4spanIKhE5beginEv: 101| 395| constexpr iterator begin() const noexcept { return ptr; } _ZN4epee4spanIKhE13remove_prefixEm: 94| 145k| { 95| 145k| amount = std::min(len, amount); 96| 145k| ptr += amount; 97| 145k| len -= amount; 98| 145k| return amount; 99| 145k| } _ZNK4epee4spanIKhE4dataEv: 108| 145k| constexpr pointer data() const noexcept { return ptr; } _ZNK4epee4spanIKhE6cbeginEv: 102| 1.84k| constexpr const_iterator cbegin() const noexcept { return ptr; } _ZNK4epee4spanIKhE4cendEv: 105| 1.38k| constexpr const_iterator cend() const noexcept { return cbegin() + size(); } _ZNK4epee4spanIKhE4sizeEv: 109| 1.82k| constexpr std::size_t size() const noexcept { return len; } _ZNK4epee4spanIKhE5emptyEv: 107| 3| constexpr bool empty() const noexcept { return size() == 0; } _ZN2el4base5debug12CrashHandlerC2Eb: 3310| 2|CrashHandler::CrashHandler(bool useDefault) { 3311| 2| if (useDefault) { ------------------ | Branch (3311:7): [True: 0, False: 2] ------------------ 3312| 0| setHandler(defaultCrashHandler); 3313| 0| } 3314| 2|} _ZN2el11LevelHelper12forEachLevelEPjRKNSt3__18functionIFbvEEE: 251| 96|void LevelHelper::forEachLevel(base::type::EnumType* startIndex, const std::function& fn) { 252| 96| base::type::EnumType lIndexMax = LevelHelper::kMaxValid; 253| 672| do { 254| 672| if (fn()) { ------------------ | Branch (254:9): [True: 0, False: 672] ------------------ 255| 0| break; 256| 0| } 257| 672| *startIndex = static_cast(*startIndex << 1); 258| 672| } while (*startIndex <= lIndexMax); ------------------ | Branch (258:12): [True: 576, False: 96] ------------------ 259| 96|} _ZN2el13ConfigurationC2ENS_5LevelENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 333| 288| m_level(level), 334| 288| m_configurationType(configurationType), 335| 288| m_value(value) { 336| 288|} _ZN2el13Configuration9PredicateC2ENS_5LevelENS_17ConfigurationTypeE: 346| 802| m_level(level), 347| 802| m_configurationType(configurationType) { 348| 802|} _ZNK2el13Configuration9PredicateclEPKS0_: 350| 29.5k|bool Configuration::Predicate::operator()(const Configuration* conf) const { 351| 29.5k| return ((conf != nullptr) && (conf->level() == m_level) && (conf->configurationType() == m_configurationType)); ------------------ | Branch (351:11): [True: 29.5k, False: 0] | Branch (351:32): [True: 3.76k, False: 25.7k] | Branch (351:62): [True: 514, False: 3.24k] ------------------ 352| 29.5k|} _ZN2el14ConfigurationsC2Ev: 357| 4| m_configurationFile(std::string()), 358| 4| m_isFromFile(false) { 359| 4|} _ZN2el14Configurations11setFromBaseEPS0_: 393| 2|void Configurations::setFromBase(Configurations* base) { 394| 2| if (base == nullptr || base == this) { ------------------ | Branch (394:7): [True: 0, False: 2] | Branch (394:26): [True: 0, False: 2] ------------------ 395| 0| return; 396| 0| } 397| 2| base::threading::ScopedLock scopedLock(base->lock()); 398| 144| for (Configuration*& conf : base->list()) { ------------------ | Branch (398:29): [True: 144, False: 2] ------------------ 399| 144| set(conf); 400| 144| } 401| 2|} _ZN2el14Configurations3setENS_5LevelENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 426| 298|void Configurations::set(Level level, ConfigurationType configurationType, const std::string& value) { 427| 298| base::threading::ScopedLock scopedLock(lock()); 428| 298| unsafeSet(level, configurationType, value); // This is not unsafe anymore as we have locked mutex 429| 298| if (level == Level::Global) { ------------------ | Branch (429:7): [True: 36, False: 262] ------------------ 430| 36| unsafeSetGlobally(configurationType, value, false); // Again this is not unsafe either 431| 36| } 432| 298|} _ZN2el14Configurations3setEPNS_13ConfigurationE: 434| 144|void Configurations::set(Configuration* conf) { 435| 144| if (conf == nullptr) { ------------------ | Branch (435:7): [True: 0, False: 144] ------------------ 436| 0| return; 437| 0| } 438| 144| set(conf->level(), conf->configurationType(), conf->value()); 439| 144|} _ZN2el14Configurations12setToDefaultEv: 441| 2|void Configurations::setToDefault(void) { 442| 2| setGlobally(ConfigurationType::Enabled, std::string("true"), true); 443| 2| setGlobally(ConfigurationType::Filename, std::string(base::consts::kDefaultLogFile), true); 444| |#if defined(ELPP_NO_LOG_TO_FILE) 445| | setGlobally(ConfigurationType::ToFile, std::string("false"), true); 446| |#else 447| 2| setGlobally(ConfigurationType::ToFile, std::string("true"), true); 448| 2|#endif // defined(ELPP_NO_LOG_TO_FILE) 449| 2| setGlobally(ConfigurationType::ToStandardOutput, std::string("true"), true); 450| 2| setGlobally(ConfigurationType::SubsecondPrecision, std::string("3"), true); 451| 2| setGlobally(ConfigurationType::PerformanceTracking, std::string("true"), true); 452| 2| setGlobally(ConfigurationType::MaxLogFileSize, std::string("0"), true); 453| 2| setGlobally(ConfigurationType::LogFlushThreshold, std::string("0"), true); 454| | 455| 2| setGlobally(ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"), true); 456| 2| set(Level::Debug, ConfigurationType::Format, 457| 2| std::string("%datetime %level [%logger] [%user@%host] [%func] [%loc] %msg")); 458| | // INFO and WARNING are set to default by Level::Global 459| 2| set(Level::Error, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg")); 460| 2| set(Level::Fatal, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg")); 461| 2| set(Level::Verbose, ConfigurationType::Format, std::string("%datetime %level-%vlevel [%logger] %msg")); 462| 2| set(Level::Trace, ConfigurationType::Format, std::string("%datetime %level [%logger] [%func] [%loc] %msg")); 463| 2|} _ZN2el14Configurations9unsafeSetENS_5LevelENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 624| 802|void Configurations::unsafeSet(Level level, ConfigurationType configurationType, const std::string& value) { 625| 802| Configuration* conf = RegistryWithPred::get(level, configurationType); 626| 802| if (conf == nullptr) { ------------------ | Branch (626:7): [True: 288, False: 514] ------------------ 627| 288| registerNew(new Configuration(level, configurationType, value)); 628| 514| } else { 629| 514| conf->setValue(value); 630| 514| } 631| 802| if (level == Level::Global) { ------------------ | Branch (631:7): [True: 36, False: 766] ------------------ 632| 36| unsafeSetGlobally(configurationType, value, false); 633| 36| } 634| 802|} _ZN2el14Configurations11setGloballyENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEb: 637| 18| bool includeGlobalLevel) { 638| 18| if (includeGlobalLevel) { ------------------ | Branch (638:7): [True: 18, False: 0] ------------------ 639| 18| set(Level::Global, configurationType, value); 640| 18| } 641| 18| base::type::EnumType lIndex = LevelHelper::kMinValid; 642| 18| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 643| 18| set(LevelHelper::castFromInt(lIndex), configurationType, value); 644| 18| return false; // Do not break lambda function yet as we need to set all levels regardless 645| 18| }); 646| 18|} _ZN2el14Configurations17unsafeSetGloballyENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEb: 649| 72| bool includeGlobalLevel) { 650| 72| if (includeGlobalLevel) { ------------------ | Branch (650:7): [True: 0, False: 72] ------------------ 651| 0| unsafeSet(Level::Global, configurationType, value); 652| 0| } 653| 72| base::type::EnumType lIndex = LevelHelper::kMinValid; 654| 72| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 655| 72| unsafeSet(LevelHelper::castFromInt(lIndex), configurationType, value); 656| 72| return false; // Do not break lambda function yet as we need to set all levels regardless 657| 72| }); 658| 72|} _ZN2el6LoggerC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_14ConfigurationsEPNS1_13unordered_mapIS7_NS1_10shared_ptrINS1_13basic_fstreamIcS4_EEEENS1_4hashIS7_EENS1_8equal_toIS7_EENS5_INS1_4pairIS8_SH_EEEEEE: 712| 2| m_id(id), 713| 2| m_typedConfigurations(nullptr), 714| 2| m_parentApplicationName(std::string()), 715| 2| m_isConfigured(false), 716| 2| m_logStreamsReference(logStreamsReference) { 717| 2| initUnflushedCount(); 718| 2| configure(configurations); 719| 2|} _ZN2el6Logger9configureERKNS_14ConfigurationsE: 745| 2|void Logger::configure(const Configurations& configurations) { 746| 2| m_isConfigured = false; // we set it to false in case if we fail 747| 2| initUnflushedCount(); 748| 2| if (m_typedConfigurations != nullptr) { ------------------ | Branch (748:7): [True: 0, False: 2] ------------------ 749| 0| Configurations* c = const_cast(m_typedConfigurations->configurations()); 750| 0| if (c->hasConfiguration(Level::Global, ConfigurationType::Filename)) { ------------------ | Branch (750:9): [True: 0, False: 0] ------------------ 751| 0| flush(); 752| 0| } 753| 0| } 754| 2| base::threading::ScopedLock scopedLock(lock()); 755| 2| if (m_configurations != configurations) { ------------------ | Branch (755:7): [True: 2, False: 0] ------------------ 756| 2| m_configurations.setFromBase(const_cast(&configurations)); 757| 2| } 758| 2| base::utils::safeDelete(m_typedConfigurations); 759| 2| m_typedConfigurations = new base::TypedConfigurations(&m_configurations, m_logStreamsReference); 760| 2| resolveLoggerFormatSpec(); 761| 2| m_isConfigured = true; 762| 2|} _ZN2el6Logger9isValidIdERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 769| 2|bool Logger::isValidId(const std::string& id) { 770| 16| for (std::string::const_iterator it = id.begin(); it != id.end(); ++it) { ------------------ | Branch (770:53): [True: 14, False: 2] ------------------ 771| 14| if (!base::utils::Str::contains(base::consts::kValidLoggerIdSymbols, *it)) { ------------------ | Branch (771:9): [True: 0, False: 14] ------------------ 772| 0| return false; 773| 0| } 774| 14| } 775| 2| return true; 776| 2|} _ZN2el6Logger18initUnflushedCountEv: 802| 4|void Logger::initUnflushedCount(void) { 803| 4| m_unflushedCount.clear(); 804| 4| base::type::EnumType lIndex = LevelHelper::kMinValid; 805| 4| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 806| 4| m_unflushedCount.insert(std::make_pair(LevelHelper::castFromInt(lIndex), 0)); 807| 4| return false; 808| 4| }); 809| 4|} _ZNK2el6Logger23resolveLoggerFormatSpecEv: 811| 2|void Logger::resolveLoggerFormatSpec(void) const { 812| 2| base::type::EnumType lIndex = LevelHelper::kMinValid; 813| 2| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 814| 2| base::LogFormat* logFormat = 815| 2| const_cast(&m_typedConfigurations->logFormat(LevelHelper::castFromInt(lIndex))); 816| 2| base::utils::Str::replaceFirstWithEscape(logFormat->m_format, base::consts::kLoggerIdFormatSpecifier, m_id); 817| 2| return false; 818| 2| }); 819| 2|} _ZN2el4base5utils3Str5ltrimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 988| 112|std::string& Str::ltrim(std::string& str) { 989| 112| str.erase(str.begin(), std::find_if(str.begin(), str.end(), [](char c) { 990| 112| return !std::isspace(c); 991| 112| } )); 992| 112| return str; 993| 112|} _ZN2el4base5utils3Str5rtrimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 995| 112|std::string& Str::rtrim(std::string& str) { 996| 112| str.erase(std::find_if(str.rbegin(), str.rend(), [](char c) { 997| 112| return !std::isspace(c); 998| 112| }).base(), str.end()); 999| 112| return str; 1000| 112|} _ZN2el4base5utils3Str4trimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 1002| 112|std::string& Str::trim(std::string& str) { 1003| 112| return ltrim(rtrim(str)); 1004| 112|} _ZN2el4base5utils3Str22replaceFirstWithEscapeERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKS9_SC_: 1031| 46| const base::type::string_t& replaceWith) { 1032| 46| std::size_t foundAt = base::type::string_t::npos; 1033| 46| while ((foundAt = str.find(replaceWhat, foundAt + 1)) != base::type::string_t::npos) { ------------------ | Branch (1033:10): [True: 32, False: 14] ------------------ 1034| 32| if (foundAt > 0 && str[foundAt - 1] == base::consts::kFormatSpecifierChar) { ------------------ | Branch (1034:9): [True: 32, False: 0] | Branch (1034:24): [True: 0, False: 32] ------------------ 1035| 0| str.erase(foundAt - 1, 1); 1036| 0| ++foundAt; 1037| 32| } else { 1038| 32| str.replace(foundAt, replaceWhat.length(), replaceWith); 1039| 32| return; 1040| 32| } 1041| 32| } 1042| 46|} _ZN2el4base5utils3Str8containsEPKcc: 1083| 14|bool Str::contains(const char* str, char c) { 1084| 138| for (; *str; ++str) { ------------------ | Branch (1084:10): [True: 138, False: 0] ------------------ 1085| 138| if (*str == c) ------------------ | Branch (1085:9): [True: 14, False: 124] ------------------ 1086| 14| return true; 1087| 138| } 1088| 0| return false; 1089| 14|} _ZN2el4base5utils2OS22getEnvironmentVariableEPKcS4_S4_: 1198| 34| const char* alternativeBashCommand) { 1199| 34|#if ELPP_OS_UNIX 1200| 34| const char* val = getenv(variableName); 1201| |#elif ELPP_OS_WINDOWS 1202| | const char* val = getWindowsEnvironmentVariable(variableName); 1203| |#endif // ELPP_OS_UNIX 1204| 34| if ((val == nullptr) || ((strcmp(val, "") == 0))) { ------------------ | Branch (1204:7): [True: 18, False: 16] | Branch (1204:27): [True: 0, False: 16] ------------------ 1205| |#if ELPP_OS_UNIX && defined(ELPP_FORCE_ENV_VAR_FROM_BASH) 1206| | // Try harder on unix-based systems 1207| | std::string valBash = base::utils::OS::getBashOutput(alternativeBashCommand); 1208| | if (valBash.empty()) { 1209| | return std::string(defaultVal); 1210| | } else { 1211| | return valBash; 1212| | } 1213| |#elif ELPP_OS_WINDOWS || ELPP_OS_UNIX 1214| 18| ELPP_UNUSED(alternativeBashCommand); ------------------ | | 240| 18|#define ELPP_UNUSED(x) (void)x ------------------ 1215| 18| return std::string(defaultVal); 1216| 18|#endif // ELPP_OS_UNIX && defined(ELPP_FORCE_ENV_VAR_FROM_BASH) 1217| 18| } 1218| 16| return std::string(val); 1219| 34|} _ZN2el4base5utils2OS11currentUserEv: 1221| 16|std::string OS::currentUser(void) { 1222| 16|#if ELPP_OS_UNIX && !ELPP_OS_ANDROID 1223| 16| return getEnvironmentVariable("USER", base::consts::kUnknownUser, "whoami"); 1224| |#elif ELPP_OS_WINDOWS 1225| | return getEnvironmentVariable("USERNAME", base::consts::kUnknownUser); 1226| |#elif ELPP_OS_ANDROID 1227| | ELPP_UNUSED(base::consts::kUnknownUser); 1228| | return std::string("android"); 1229| |#else 1230| | return std::string(); 1231| |#endif // ELPP_OS_UNIX && !ELPP_OS_ANDROID 1232| 16|} _ZN2el4base5utils2OS11currentHostEv: 1234| 16|std::string OS::currentHost(void) { 1235| 16|#if ELPP_OS_UNIX && !ELPP_OS_ANDROID 1236| 16| return getEnvironmentVariable("HOSTNAME", base::consts::kUnknownHost, "hostname"); 1237| |#elif ELPP_OS_WINDOWS 1238| | return getEnvironmentVariable("COMPUTERNAME", base::consts::kUnknownHost); 1239| |#elif ELPP_OS_ANDROID 1240| | ELPP_UNUSED(base::consts::kUnknownHost); 1241| | return getDeviceName(); 1242| |#else 1243| | return std::string(); 1244| |#endif // ELPP_OS_UNIX && !ELPP_OS_ANDROID 1245| 16|} _ZN2el4base5utils2OS17termSupportsColorEv: 1247| 2|bool OS::termSupportsColor(void) { 1248| 2| std::string term = getEnvironmentVariable("TERM", ""); 1249| 2| return term == "xterm" || term == "xterm-color" || term == "xterm-256color" ------------------ | Branch (1249:10): [True: 0, False: 2] | Branch (1249:29): [True: 0, False: 2] | Branch (1249:54): [True: 0, False: 2] ------------------ 1250| 2| || term == "screen" || term == "linux" || term == "cygwin" ------------------ | Branch (1250:13): [True: 0, False: 2] | Branch (1250:33): [True: 0, False: 2] | Branch (1250:52): [True: 0, False: 2] ------------------ 1251| 2| || term == "screen-256color" || term == "screen.xterm-256color"; ------------------ | Branch (1251:13): [True: 0, False: 2] | Branch (1251:42): [True: 0, False: 2] ------------------ 1252| 2|} _ZN2el4base5utils15CommandLineArgs7setArgsEiPPc: 1423| 2|void CommandLineArgs::setArgs(int argc, char** argv) { 1424| 2| m_params.clear(); 1425| 2| m_paramsWithValue.clear(); 1426| 2| if (argc == 0 || argv == nullptr) { ------------------ | Branch (1426:7): [True: 2, False: 0] | Branch (1426:20): [True: 0, False: 0] ------------------ 1427| 2| return; 1428| 2| } 1429| 0| m_argc = argc; 1430| 0| m_argv = argv; 1431| 0| for (int i = 1; i < m_argc; ++i) { ------------------ | Branch (1431:19): [True: 0, False: 0] ------------------ 1432| 0| const char* v = (strstr(m_argv[i], "=")); 1433| 0| if (v != nullptr && strlen(v) > 0) { ------------------ | Branch (1433:9): [True: 0, False: 0] | Branch (1433:25): [True: 0, False: 0] ------------------ 1434| 0| std::string key = std::string(m_argv[i]); 1435| 0| key = key.substr(0, key.find_first_of('=')); 1436| 0| if (hasParamWithValue(key.c_str())) { ------------------ | Branch (1436:11): [True: 0, False: 0] ------------------ 1437| 0| ELPP_INTERNAL_INFO(1, "Skipping [" << key << "] arg since it already has value [" 1438| 0| << getParamValue(key.c_str()) << "]"); 1439| 0| } else { 1440| 0| m_paramsWithValue.insert(std::make_pair(key, std::string(v + 1))); 1441| 0| } 1442| 0| } 1443| 0| if (v == nullptr) { ------------------ | Branch (1443:9): [True: 0, False: 0] ------------------ 1444| 0| if (hasParam(m_argv[i])) { ------------------ | Branch (1444:11): [True: 0, False: 0] ------------------ 1445| 0| ELPP_INTERNAL_INFO(1, "Skipping [" << m_argv[i] << "] arg since it already exists"); 1446| 0| } else { 1447| 0| m_params.push_back(std::string(m_argv[i])); 1448| 0| } 1449| 0| } 1450| 0| } 1451| 0|} _ZN2el4base18SubsecondPrecision4initEi: 1510| 16|void SubsecondPrecision::init(int width) { 1511| 16| if (width < 1 || width > 6) { ------------------ | Branch (1511:7): [True: 0, False: 16] | Branch (1511:20): [True: 0, False: 16] ------------------ 1512| 0| width = base::consts::kDefaultSubsecondPrecision; 1513| 0| } 1514| 16| m_width = width; 1515| 16| switch (m_width) { 1516| 16| case 3: ------------------ | Branch (1516:3): [True: 16, False: 0] ------------------ 1517| 16| m_offset = 1000; 1518| 16| break; 1519| 0| case 4: ------------------ | Branch (1519:3): [True: 0, False: 16] ------------------ 1520| 0| m_offset = 100; 1521| 0| break; 1522| 0| case 5: ------------------ | Branch (1522:3): [True: 0, False: 16] ------------------ 1523| 0| m_offset = 10; 1524| 0| break; 1525| 0| case 6: ------------------ | Branch (1525:3): [True: 0, False: 16] ------------------ 1526| 0| m_offset = 1; 1527| 0| break; 1528| 0| default: ------------------ | Branch (1528:3): [True: 0, False: 16] ------------------ 1529| 0| m_offset = 1000; 1530| 0| break; 1531| 16| } 1532| 16|} _ZN2el4base9LogFormatC2ENS_5LevelERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 1547| 16| : m_level(level), m_userFormat(format), m_currentUser(base::utils::OS::currentUser()), 1548| 16| m_currentHost(base::utils::OS::currentHost()) { 1549| 16| parseFromFormat(m_userFormat); 1550| 16|} _ZN2el4base9LogFormatC2ERKS1_: 1553| 16| m_level(logFormat.m_level), 1554| 16| m_userFormat(logFormat.m_userFormat), 1555| 16| m_format(logFormat.m_format), 1556| 16| m_dateTimeFormat(logFormat.m_dateTimeFormat), 1557| 16| m_flags(logFormat.m_flags), 1558| 16| m_currentUser(logFormat.m_currentUser), 1559| 16| m_currentHost(logFormat.m_currentHost) { 1560| 16|} _ZN2el4base9LogFormatC2EOS1_: 1562| 16|LogFormat::LogFormat(LogFormat&& logFormat) { 1563| 16| m_level = std::move(logFormat.m_level); 1564| 16| m_userFormat = std::move(logFormat.m_userFormat); 1565| 16| m_format = std::move(logFormat.m_format); 1566| 16| m_dateTimeFormat = std::move(logFormat.m_dateTimeFormat); 1567| 16| m_flags = std::move(logFormat.m_flags); 1568| 16| m_currentUser = std::move(logFormat.m_currentUser); 1569| 16| m_currentHost = std::move(logFormat.m_currentHost); 1570| 16|} _ZN2el4base9LogFormateqERKS1_: 1584| 14|bool LogFormat::operator==(const LogFormat& other) { 1585| 14| return m_level == other.m_level && m_userFormat == other.m_userFormat && m_format == other.m_format && ------------------ | Branch (1585:10): [True: 0, False: 14] | Branch (1585:38): [True: 0, False: 0] | Branch (1585:76): [True: 0, False: 0] ------------------ 1586| 14| m_dateTimeFormat == other.m_dateTimeFormat && m_flags == other.m_flags; ------------------ | Branch (1586:10): [True: 0, False: 0] | Branch (1586:56): [True: 0, False: 0] ------------------ 1587| 14|} _ZN2el4base9LogFormat15parseFromFormatERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1591| 16|void LogFormat::parseFromFormat(const base::type::string_t& userFormat) { 1592| | // We make copy because we will be changing the format 1593| | // i.e, removing user provided date format from original format 1594| | // and then storing it. 1595| 16| base::type::string_t formatCopy = userFormat; 1596| 16| m_flags = 0x0; 1597| 16| auto conditionalAddFlag = [&](const base::type::char_t* specifier, base::FormatFlags flag) { 1598| 16| std::size_t foundAt = base::type::string_t::npos; 1599| 16| while ((foundAt = formatCopy.find(specifier, foundAt + 1)) != base::type::string_t::npos) { 1600| 16| if (foundAt > 0 && formatCopy[foundAt - 1] == base::consts::kFormatSpecifierChar) { 1601| 16| if (hasFlag(flag)) { 1602| | // If we already have flag we remove the escape chars so that '%%' is turned to '%' 1603| | // even after specifier resolution - this is because we only replaceFirst specifier 1604| 16| formatCopy.erase(foundAt - 1, 1); 1605| 16| ++foundAt; 1606| 16| } 1607| 16| } else { 1608| 16| if (!hasFlag(flag)) addFlag(flag); 1609| 16| } 1610| 16| } 1611| 16| }; 1612| 16| conditionalAddFlag(base::consts::kAppNameFormatSpecifier, base::FormatFlags::AppName); 1613| 16| conditionalAddFlag(base::consts::kSeverityLevelFormatSpecifier, base::FormatFlags::Level); 1614| 16| conditionalAddFlag(base::consts::kSeverityLevelShortFormatSpecifier, base::FormatFlags::LevelShort); 1615| 16| conditionalAddFlag(base::consts::kLoggerIdFormatSpecifier, base::FormatFlags::LoggerId); 1616| 16| conditionalAddFlag(base::consts::kThreadIdFormatSpecifier, base::FormatFlags::ThreadId); 1617| 16| conditionalAddFlag(base::consts::kLogFileFormatSpecifier, base::FormatFlags::File); 1618| 16| conditionalAddFlag(base::consts::kLogFileBaseFormatSpecifier, base::FormatFlags::FileBase); 1619| 16| conditionalAddFlag(base::consts::kLogLineFormatSpecifier, base::FormatFlags::Line); 1620| 16| conditionalAddFlag(base::consts::kLogLocationFormatSpecifier, base::FormatFlags::Location); 1621| 16| conditionalAddFlag(base::consts::kLogFunctionFormatSpecifier, base::FormatFlags::Function); 1622| 16| conditionalAddFlag(base::consts::kCurrentUserFormatSpecifier, base::FormatFlags::User); 1623| 16| conditionalAddFlag(base::consts::kCurrentHostFormatSpecifier, base::FormatFlags::Host); 1624| 16| conditionalAddFlag(base::consts::kMessageFormatSpecifier, base::FormatFlags::LogMessage); 1625| 16| conditionalAddFlag(base::consts::kVerboseLevelFormatSpecifier, base::FormatFlags::VerboseLevel); 1626| | // For date/time we need to extract user's date format first 1627| 16| std::size_t dateIndex = std::string::npos; 1628| 16| if ((dateIndex = formatCopy.find(base::consts::kDateTimeFormatSpecifier)) != std::string::npos) { ------------------ | Branch (1628:7): [True: 16, False: 0] ------------------ 1629| 16| while (dateIndex > 0 && formatCopy[dateIndex - 1] == base::consts::kFormatSpecifierChar) { ------------------ | Branch (1629:12): [True: 0, False: 16] | Branch (1629:29): [True: 0, False: 0] ------------------ 1630| 0| dateIndex = formatCopy.find(base::consts::kDateTimeFormatSpecifier, dateIndex + 1); 1631| 0| } 1632| 16| if (dateIndex != std::string::npos) { ------------------ | Branch (1632:9): [True: 16, False: 0] ------------------ 1633| 16| addFlag(base::FormatFlags::DateTime); 1634| 16| updateDateFormat(dateIndex, formatCopy); 1635| 16| } 1636| 16| } 1637| 16| m_format = formatCopy; 1638| 16| updateFormatSpec(); 1639| 16|} _ZN2el4base9LogFormat16updateDateFormatEmRNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1641| 16|void LogFormat::updateDateFormat(std::size_t index, base::type::string_t& currFormat) { 1642| 16| if (hasFlag(base::FormatFlags::DateTime)) { ------------------ | Branch (1642:7): [True: 16, False: 0] ------------------ 1643| 16| index += ELPP_STRLEN(base::consts::kDateTimeFormatSpecifier); ------------------ | | 540| 16|# define ELPP_STRLEN strlen ------------------ 1644| 16| } 1645| 16| const base::type::char_t* ptr = currFormat.c_str() + index; 1646| 16| if ((currFormat.size() > index) && (ptr[0] == '{')) { ------------------ | Branch (1646:7): [True: 16, False: 0] | Branch (1646:38): [True: 0, False: 16] ------------------ 1647| | // User has provided format for date/time 1648| 0| ++ptr; 1649| 0| int count = 1; // Start by 1 in order to remove starting brace 1650| 0| std::stringstream ss; 1651| 0| for (; *ptr; ++ptr, ++count) { ------------------ | Branch (1651:12): [True: 0, False: 0] ------------------ 1652| 0| if (*ptr == '}') { ------------------ | Branch (1652:11): [True: 0, False: 0] ------------------ 1653| 0| ++count; // In order to remove ending brace 1654| 0| break; 1655| 0| } 1656| 0| ss << static_cast(*ptr); 1657| 0| } 1658| 0| currFormat.erase(index, count); 1659| 0| m_dateTimeFormat = ss.str(); 1660| 16| } else { 1661| | // No format provided, use default 1662| 16| if (hasFlag(base::FormatFlags::DateTime)) { ------------------ | Branch (1662:9): [True: 16, False: 0] ------------------ 1663| 16| m_dateTimeFormat = std::string(base::consts::kDefaultDateTimeFormat); 1664| 16| } 1665| 16| } 1666| 16|} _ZN2el4base9LogFormat16updateFormatSpecEv: 1668| 16|void LogFormat::updateFormatSpec(void) { 1669| | // Do not use switch over strongly typed enums because Intel C++ compilers dont support them yet. 1670| 16| if (m_level == Level::Debug) { ------------------ | Branch (1670:7): [True: 2, False: 14] ------------------ 1671| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1672| 2| base::consts::kDebugLevelLogValue); 1673| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1674| 2| base::consts::kDebugLevelShortLogValue); 1675| 14| } else if (m_level == Level::Info) { ------------------ | Branch (1675:14): [True: 2, False: 12] ------------------ 1676| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1677| 2| base::consts::kInfoLevelLogValue); 1678| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1679| 2| base::consts::kInfoLevelShortLogValue); 1680| 12| } else if (m_level == Level::Warning) { ------------------ | Branch (1680:14): [True: 2, False: 10] ------------------ 1681| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1682| 2| base::consts::kWarningLevelLogValue); 1683| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1684| 2| base::consts::kWarningLevelShortLogValue); 1685| 10| } else if (m_level == Level::Error) { ------------------ | Branch (1685:14): [True: 2, False: 8] ------------------ 1686| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1687| 2| base::consts::kErrorLevelLogValue); 1688| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1689| 2| base::consts::kErrorLevelShortLogValue); 1690| 8| } else if (m_level == Level::Fatal) { ------------------ | Branch (1690:14): [True: 2, False: 6] ------------------ 1691| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1692| 2| base::consts::kFatalLevelLogValue); 1693| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1694| 2| base::consts::kFatalLevelShortLogValue); 1695| 6| } else if (m_level == Level::Verbose) { ------------------ | Branch (1695:14): [True: 2, False: 4] ------------------ 1696| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1697| 2| base::consts::kVerboseLevelLogValue); 1698| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1699| 2| base::consts::kVerboseLevelShortLogValue); 1700| 4| } else if (m_level == Level::Trace) { ------------------ | Branch (1700:14): [True: 2, False: 2] ------------------ 1701| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1702| 2| base::consts::kTraceLevelLogValue); 1703| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1704| 2| base::consts::kTraceLevelShortLogValue); 1705| 2| } 1706| 16| if (hasFlag(base::FormatFlags::User)) { ------------------ | Branch (1706:7): [True: 2, False: 14] ------------------ 1707| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kCurrentUserFormatSpecifier, 1708| 2| m_currentUser); 1709| 2| } 1710| 16| if (hasFlag(base::FormatFlags::Host)) { ------------------ | Branch (1710:7): [True: 2, False: 14] ------------------ 1711| 2| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kCurrentHostFormatSpecifier, 1712| 2| m_currentHost); 1713| 2| } 1714| | // Ignore Level::Global and Level::Unknown 1715| 16|} _ZN2el4base19TypedConfigurationsC2EPNS_14ConfigurationsEPNSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_10shared_ptrINS4_13basic_fstreamIcS8_EEEENS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SF_EEEEEE: 1720| 2| base::LogStreamsReferenceMap* logStreamsReference) { 1721| 2| m_configurations = configurations; 1722| 2| m_logStreamsReference = logStreamsReference; 1723| 2| build(m_configurations); 1724| 2|} _ZN2el4base19TypedConfigurations9logFormatENS_5LevelE: 1748| 14|const base::LogFormat& TypedConfigurations::logFormat(Level level) { 1749| 14| return getConfigByRef(level, &m_logFormatMap, "logFormat"); 1750| 14|} _ZN2el4base19TypedConfigurations5buildEPNS_14ConfigurationsE: 1776| 2|void TypedConfigurations::build(Configurations* configurations) { 1777| 2| base::threading::ScopedLock scopedLock(lock()); 1778| 2| auto getBool = [] (std::string boolStr) -> bool { // Pass by value for trimming 1779| 2| base::utils::Str::trim(boolStr); 1780| 2| return (boolStr == "TRUE" || boolStr == "true" || boolStr == "1"); 1781| 2| }; 1782| 2| setValue(Level::Global, base::FileStreamPtr(NULL), &m_fileStreamMap); 1783| 2| std::vector withFileSizeLimit; 1784| 146| for (Configurations::const_iterator it = configurations->begin(); it != configurations->end(); ++it) { ------------------ | Branch (1784:69): [True: 144, False: 2] ------------------ 1785| 144| Configuration* conf = *it; 1786| | // We cannot use switch on strong enums because Intel C++ dont support them yet 1787| 144| if (conf->configurationType() == ConfigurationType::Enabled) { ------------------ | Branch (1787:9): [True: 16, False: 128] ------------------ 1788| 16| setValue(conf->level(), getBool(conf->value()), &m_enabledMap); 1789| 128| } else if (conf->configurationType() == ConfigurationType::ToFile) { ------------------ | Branch (1789:16): [True: 16, False: 112] ------------------ 1790| 16| setValue(conf->level(), getBool(conf->value()), &m_toFileMap); 1791| 112| } else if (conf->configurationType() == ConfigurationType::ToStandardOutput) { ------------------ | Branch (1791:16): [True: 16, False: 96] ------------------ 1792| 16| setValue(conf->level(), getBool(conf->value()), &m_toStandardOutputMap); 1793| 96| } else if (conf->configurationType() == ConfigurationType::Filename) { ------------------ | Branch (1793:16): [True: 16, False: 80] ------------------ 1794| | // We do not yet configure filename but we will configure in another 1795| | // loop. This is because if file cannot be created, we will force ToFile 1796| | // to be false. Because configuring logger is not necessarily performance 1797| | // sensative operation, we can live with another loop; (by the way this loop 1798| | // is not very heavy either) 1799| 80| } else if (conf->configurationType() == ConfigurationType::Format) { ------------------ | Branch (1799:16): [True: 16, False: 64] ------------------ 1800| 16| setValue(conf->level(), base::LogFormat(conf->level(), 1801| 16| base::type::string_t(conf->value().begin(), conf->value().end())), &m_logFormatMap); 1802| 64| } else if (conf->configurationType() == ConfigurationType::SubsecondPrecision) { ------------------ | Branch (1802:16): [True: 16, False: 48] ------------------ 1803| 16| setValue(Level::Global, 1804| 16| base::SubsecondPrecision(static_cast(getULong(conf->value()))), &m_subsecondPrecisionMap); 1805| 48| } else if (conf->configurationType() == ConfigurationType::PerformanceTracking) { ------------------ | Branch (1805:16): [True: 16, False: 32] ------------------ 1806| 16| setValue(Level::Global, getBool(conf->value()), &m_performanceTrackingMap); 1807| 32| } else if (conf->configurationType() == ConfigurationType::MaxLogFileSize) { ------------------ | Branch (1807:16): [True: 16, False: 16] ------------------ 1808| 16| auto v = getULong(conf->value()); 1809| 16| setValue(conf->level(), static_cast(v), &m_maxLogFileSizeMap); 1810| 16| if (v != 0) { ------------------ | Branch (1810:11): [True: 0, False: 16] ------------------ 1811| 0| withFileSizeLimit.push_back(conf); 1812| 0| } 1813| 16| } else if (conf->configurationType() == ConfigurationType::LogFlushThreshold) { ------------------ | Branch (1813:16): [True: 16, False: 0] ------------------ 1814| 16| setValue(conf->level(), static_cast(getULong(conf->value())), &m_logFlushThresholdMap); 1815| 16| } 1816| 144| } 1817| | // As mentioned earlier, we will now set filename configuration in separate loop to deal with non-existent files 1818| 146| for (Configurations::const_iterator it = configurations->begin(); it != configurations->end(); ++it) { ------------------ | Branch (1818:69): [True: 144, False: 2] ------------------ 1819| 144| Configuration* conf = *it; 1820| 144| if (conf->configurationType() == ConfigurationType::Filename) { ------------------ | Branch (1820:9): [True: 16, False: 128] ------------------ 1821| 16| insertFile(conf->level(), conf->value()); 1822| 16| } 1823| 144| } 1824| 2| for (std::vector::iterator conf = withFileSizeLimit.begin(); 1825| 2| conf != withFileSizeLimit.end(); ++conf) { ------------------ | Branch (1825:8): [True: 0, False: 2] ------------------ 1826| | // This is not unsafe as mutex is locked in currect scope 1827| 0| unsafeValidateFileRolling((*conf)->level(), base::defaultPreRollOutCallback); 1828| 0| } 1829| 2|} _ZN2el4base19TypedConfigurations8getULongENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1831| 48|unsigned long TypedConfigurations::getULong(std::string confVal) { 1832| 48| bool valid = true; 1833| 48| base::utils::Str::trim(confVal); 1834| 48| valid = !confVal.empty() && std::find_if(confVal.begin(), confVal.end(), ------------------ | Branch (1834:11): [True: 48, False: 0] | Branch (1834:31): [True: 48, False: 0] ------------------ 1835| 48| [](char c) { 1836| 48| return !base::utils::Str::isDigit(c); 1837| 48| }) == confVal.end(); 1838| 48| if (!valid) { ------------------ | Branch (1838:7): [True: 0, False: 48] ------------------ 1839| 0| valid = false; 1840| 0| ELPP_ASSERT(valid, "Configuration value not a valid integer [" << confVal << "]"); ------------------ | | 178| 0|# define ELPP_ASSERT(expr, msg) if (!(expr)) { \ | | ------------------ | | | Branch (178:40): [True: 0, False: 0] | | ------------------ | | 179| 0|std::stringstream internalInfoStream; internalInfoStream << msg; \ | | ------------------ | | | | 160| 0|# define ELPP_INTERNAL_DEBUGGING_OUT_ERROR std::cerr | | ------------------ | | 180| 0|ELPP_INTERNAL_DEBUGGING_OUT_ERROR\ | | 181| 0|<< "ASSERTION FAILURE FROM EASYLOGGING++ (LINE: " \ | | 182| 0|<< __LINE__ << ") [" #expr << "] WITH MESSAGE \"" << ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << "\"" \ | | ------------------ | | | | 166| 0|# define ELPP_INTERNAL_DEBUGGING_MSG(msg) msg | | ------------------ | | 183| 0|<< ELPP_INTERNAL_DEBUGGING_ENDL; } | | ------------------ | | | | 163| 0|# define ELPP_INTERNAL_DEBUGGING_ENDL std::endl | | ------------------ ------------------ 1841| 0| return 0; 1842| 0| } 1843| 48| return atol(confVal.c_str()); 1844| 48|} _ZN2el4base19TypedConfigurations10insertFileENS_5LevelERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 1885| 16|void TypedConfigurations::insertFile(Level level, const std::string& fullFilename) { 1886| 16| if (fullFilename.empty()) ------------------ | Branch (1886:7): [True: 16, False: 0] ------------------ 1887| 16| return; 1888| 0| std::string resolvedFilename = resolveFilename(fullFilename); 1889| 0| if (resolvedFilename.empty()) { ------------------ | Branch (1889:7): [True: 0, False: 0] ------------------ 1890| 0| std::cerr << "Could not load empty file for logging, please re-check your configurations for level [" 1891| 0| << LevelHelper::convertToString(level) << "]"; 1892| 0| } 1893| 0| std::string filePath = base::utils::File::extractPathFromFilename(resolvedFilename, base::consts::kFilePathSeperator); 1894| 0| if (filePath.size() < resolvedFilename.size()) { ------------------ | Branch (1894:7): [True: 0, False: 0] ------------------ 1895| 0| base::utils::File::createPath(filePath); 1896| 0| } 1897| 0| auto create = [&](Level level) { 1898| 0| base::LogStreamsReferenceMap::iterator filestreamIter = m_logStreamsReference->find(resolvedFilename); 1899| 0| base::type::fstream_t* fs = nullptr; 1900| 0| if (filestreamIter == m_logStreamsReference->end()) { 1901| | // We need a completely new stream, nothing to share with 1902| 0| fs = base::utils::File::newFileStream(resolvedFilename); 1903| 0| m_filenameMap.insert(std::make_pair(level, resolvedFilename)); 1904| 0| m_fileStreamMap.insert(std::make_pair(level, base::FileStreamPtr(fs))); 1905| 0| m_logStreamsReference->insert(std::make_pair(resolvedFilename, base::FileStreamPtr(m_fileStreamMap.at(level)))); 1906| 0| } else { 1907| | // Woops! we have an existing one, share it! 1908| 0| m_filenameMap.insert(std::make_pair(level, filestreamIter->first)); 1909| 0| m_fileStreamMap.insert(std::make_pair(level, base::FileStreamPtr(filestreamIter->second))); 1910| 0| fs = filestreamIter->second.get(); 1911| 0| } 1912| 0| if (fs == nullptr) { 1913| | // We display bad file error from newFileStream() 1914| 0| ELPP_INTERNAL_ERROR("Setting [TO_FILE] of [" 1915| 0| << LevelHelper::convertToString(level) << "] to FALSE", false); 1916| 0| setValue(level, false, &m_toFileMap); 1917| 0| } 1918| 0| }; 1919| | // If we dont have file conf for any level, create it for Level::Global first 1920| | // otherwise create for specified level 1921| 0| create(m_filenameMap.empty() && m_fileStreamMap.empty() ? Level::Global : level); ------------------ | Branch (1921:10): [True: 0, False: 0] | Branch (1921:35): [True: 0, False: 0] ------------------ 1922| 0|} _ZN2el4base17RegisteredLoggersC2ERKNSt3__110shared_ptrINS_10LogBuilderEEE: 1991| 2| m_defaultLogBuilder(defaultLogBuilder) { 1992| 2| m_defaultConfigurations.setToDefault(); 1993| 2|} _ZN2el4base17RegisteredLoggers3getERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEb: 1995| 4|Logger* RegisteredLoggers::get(const std::string& id, bool forceCreation) { 1996| 4| base::threading::ScopedLock scopedLock(lock()); 1997| 4| Logger* logger_ = base::utils::Registry::get(id); 1998| 4| if (logger_ == nullptr && forceCreation) { ------------------ | Branch (1998:7): [True: 2, False: 2] | Branch (1998:29): [True: 2, False: 0] ------------------ 1999| 2| bool validId = Logger::isValidId(id); 2000| 2| if (!validId) { ------------------ | Branch (2000:9): [True: 0, False: 2] ------------------ 2001| 0| ELPP_ASSERT(validId, "Invalid logger ID [" << id << "]. Not registering this logger."); ------------------ | | 178| 0|# define ELPP_ASSERT(expr, msg) if (!(expr)) { \ | | ------------------ | | | Branch (178:40): [True: 0, False: 0] | | ------------------ | | 179| 0|std::stringstream internalInfoStream; internalInfoStream << msg; \ | | ------------------ | | | | 160| 0|# define ELPP_INTERNAL_DEBUGGING_OUT_ERROR std::cerr | | ------------------ | | 180| 0|ELPP_INTERNAL_DEBUGGING_OUT_ERROR\ | | 181| 0|<< "ASSERTION FAILURE FROM EASYLOGGING++ (LINE: " \ | | 182| 0|<< __LINE__ << ") [" #expr << "] WITH MESSAGE \"" << ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << "\"" \ | | ------------------ | | | | 166| 0|# define ELPP_INTERNAL_DEBUGGING_MSG(msg) msg | | ------------------ | | 183| 0|<< ELPP_INTERNAL_DEBUGGING_ENDL; } | | ------------------ | | | | 163| 0|# define ELPP_INTERNAL_DEBUGGING_ENDL std::endl | | ------------------ ------------------ 2002| 0| return nullptr; 2003| 0| } 2004| 2| logger_ = new Logger(id, m_defaultConfigurations, &m_logStreamsReference); 2005| 2| logger_->m_logBuilder = m_defaultLogBuilder; 2006| 2| registerNew(id, logger_); 2007| 2| LoggerRegistrationCallback* callback = nullptr; 2008| 2| for (const std::pair& h 2009| 2| : m_loggerRegistrationCallbacks) { ------------------ | Branch (2009:10): [True: 0, False: 2] ------------------ 2010| 0| callback = h.second.get(); 2011| 0| if (callback != nullptr && callback->enabled()) { ------------------ | Branch (2011:11): [True: 0, False: 0] | Branch (2011:34): [True: 0, False: 0] ------------------ 2012| 0| callback->handle(logger_); 2013| 0| } 2014| 0| } 2015| 2| } 2016| 4| return logger_; 2017| 4|} _ZN2el4base17RegisteredLoggers14unsafeFlushAllEv: 2032| 1|void RegisteredLoggers::unsafeFlushAll(void) { 2033| 1| ELPP_INTERNAL_INFO(1, "Flushing all log files"); 2034| 1| for (base::LogStreamsReferenceMap::iterator it = m_logStreamsReference.begin(); 2035| 1| it != m_logStreamsReference.end(); ++it) { ------------------ | Branch (2035:8): [True: 0, False: 1] ------------------ 2036| 0| if (it->second.get() == nullptr) continue; ------------------ | Branch (2036:9): [True: 0, False: 0] ------------------ 2037| 0| it->second->flush(); 2038| 0| } 2039| 1|} _ZN2el4base9VRegistryC2EtPj: 2043| 2|VRegistry::VRegistry(base::type::VerboseLevel level, base::type::EnumType* pFlags) : m_level(level), m_pFlags(pFlags) { 2044| 2|} _ZN2el4base7Storage7getELPPEv: 2283| 2|{ 2284| 2| if (!el::base::elStorage) ------------------ | Branch (2284:7): [True: 0, False: 2] ------------------ 2285| 0| el::base::elStorage = new el::base::Storage(el::LogBuilderPtr(new el::base::DefaultLogBuilder())); 2286| 2| return el::base::elStorage; 2287| 2|} _ZN2el4base7StorageC2ERKNSt3__110shared_ptrINS_10LogBuilderEEE: 2294| 2| m_registeredHitCounters(new base::RegisteredHitCounters()), 2295| 2| m_registeredLoggers(new base::RegisteredLoggers(defaultLogBuilder)), 2296| 2| m_flags(ELPP_DEFAULT_LOGGING_FLAGS), ------------------ | | 2279| 2|# define ELPP_DEFAULT_LOGGING_FLAGS 0x0 ------------------ 2297| 2| m_vRegistry(new base::VRegistry(0, &m_flags)), 2298| | 2299| |#if ELPP_ASYNC_LOGGING 2300| | m_asyncLogQueue(new base::AsyncLogQueue()), 2301| | m_asyncDispatchWorker(asyncDispatchWorker), 2302| |#endif // ELPP_ASYNC_LOGGING 2303| | 2304| 2| m_preRollOutCallback(base::defaultPreRollOutCallback) { 2305| | // Register default logger 2306| 2| m_registeredLoggers->get(std::string(base::consts::kDefaultLoggerId)); 2307| | // We register default logger anyway (worse case it's not going to register) just in case 2308| 2| m_registeredLoggers->get("default"); 2309| | 2310| |#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 2311| | // Register performance logger and reconfigure format 2312| | Logger* performanceLogger = m_registeredLoggers->get(std::string(base::consts::kPerformanceLoggerId)); 2313| | m_registeredLoggers->get("performance"); 2314| | performanceLogger->configurations()->setGlobally(ConfigurationType::Format, std::string("%datetime %level %msg")); 2315| | performanceLogger->reconfigure(); 2316| |#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 2317| | 2318| |#if defined(ELPP_SYSLOG) 2319| | // Register syslog logger and reconfigure format 2320| | Logger* sysLogLogger = m_registeredLoggers->get(std::string(base::consts::kSysLogLoggerId)); 2321| | sysLogLogger->configurations()->setGlobally(ConfigurationType::Format, std::string("%level: %msg")); 2322| | sysLogLogger->reconfigure(); 2323| |#endif // defined(ELPP_SYSLOG) 2324| 2| addFlag(LoggingFlag::AllowVerboseIfModuleNotSpecified); 2325| 2| addFlag(LoggingFlag::CreateLoggerAutomatically); 2326| |#if ELPP_ASYNC_LOGGING 2327| | installLogDispatchCallback(std::string("AsyncLogDispatchCallback")); 2328| |#else 2329| 2| installLogDispatchCallback(std::string("DefaultLogDispatchCallback")); 2330| 2|#endif // ELPP_ASYNC_LOGGING 2331| |#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 2332| | installPerformanceTrackingCallback 2333| | (std::string("DefaultPerformanceTrackingCallback")); 2334| |#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 2335| 2| ELPP_INTERNAL_INFO(1, "Easylogging++ has been initialized"); 2336| |#if ELPP_ASYNC_LOGGING 2337| | m_asyncDispatchWorker->start(); 2338| |#endif // ELPP_ASYNC_LOGGING 2339| 2|} _ZN2el4base7StorageD2Ev: 2341| 1|Storage::~Storage(void) { 2342| 1| ELPP_INTERNAL_INFO(4, "Destroying storage"); 2343| |#if ELPP_ASYNC_LOGGING 2344| | ELPP_INTERNAL_INFO(5, "Replacing log dispatch callback to synchronous"); 2345| | uninstallLogDispatchCallback(std::string("AsyncLogDispatchCallback")); 2346| | installLogDispatchCallback(std::string("DefaultLogDispatchCallback")); 2347| | ELPP_INTERNAL_INFO(5, "Destroying asyncDispatchWorker"); 2348| | base::utils::safeDelete(m_asyncDispatchWorker); 2349| | ELPP_INTERNAL_INFO(5, "Destroying asyncLogQueue"); 2350| | base::utils::safeDelete(m_asyncLogQueue); 2351| |#endif // ELPP_ASYNC_LOGGING 2352| 1| ELPP_INTERNAL_INFO(5, "Destroying registeredHitCounters"); 2353| 1| base::utils::safeDelete(m_registeredHitCounters); 2354| 1| ELPP_INTERNAL_INFO(5, "Destroying registeredLoggers"); 2355| 1| base::utils::safeDelete(m_registeredLoggers); 2356| 1| ELPP_INTERNAL_INFO(5, "Destroying vRegistry"); 2357| 1| base::utils::safeDelete(m_vRegistry); 2358| 1|} easylogging++.cc:_ZZN2el4base9LogFormat15parseFromFormatERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEENK3$_0clEPKcNS0_11FormatFlagsE: 1597| 224| auto conditionalAddFlag = [&](const base::type::char_t* specifier, base::FormatFlags flag) { 1598| 224| std::size_t foundAt = base::type::string_t::npos; 1599| 286| while ((foundAt = formatCopy.find(specifier, foundAt + 1)) != base::type::string_t::npos) { ------------------ | Branch (1599:12): [True: 62, False: 224] ------------------ 1600| 62| if (foundAt > 0 && formatCopy[foundAt - 1] == base::consts::kFormatSpecifierChar) { ------------------ | Branch (1600:11): [True: 62, False: 0] | Branch (1600:26): [True: 0, False: 62] ------------------ 1601| 0| if (hasFlag(flag)) { ------------------ | Branch (1601:13): [True: 0, False: 0] ------------------ 1602| | // If we already have flag we remove the escape chars so that '%%' is turned to '%' 1603| | // even after specifier resolution - this is because we only replaceFirst specifier 1604| 0| formatCopy.erase(foundAt - 1, 1); 1605| 0| ++foundAt; 1606| 0| } 1607| 62| } else { 1608| 62| if (!hasFlag(flag)) addFlag(flag); ------------------ | Branch (1608:13): [True: 62, False: 0] ------------------ 1609| 62| } 1610| 62| } 1611| 224| }; easylogging++.cc:_ZZN2el4base19TypedConfigurations5buildEPNS_14ConfigurationsEENK3$_0clENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 1778| 64| auto getBool = [] (std::string boolStr) -> bool { // Pass by value for trimming 1779| 64| base::utils::Str::trim(boolStr); 1780| 64| return (boolStr == "TRUE" || boolStr == "true" || boolStr == "1"); ------------------ | Branch (1780:13): [True: 0, False: 64] | Branch (1780:34): [True: 64, False: 0] | Branch (1780:55): [True: 0, False: 0] ------------------ 1781| 64| }; _ZN2el4base10EnsureELPPC2Ev: 2288| 2|static struct EnsureELPP { EnsureELPP() { el::base::Storage::getELPP(); } } ensureELPP; easylogging++.cc:_ZZN2el14Configurations11setGloballyENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbENK3$_0clEv: 642| 126| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 643| 126| set(LevelHelper::castFromInt(lIndex), configurationType, value); 644| 126| return false; // Do not break lambda function yet as we need to set all levels regardless 645| 126| }); easylogging++.cc:_ZZN2el14Configurations17unsafeSetGloballyENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbENK3$_0clEv: 654| 504| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 655| 504| unsafeSet(LevelHelper::castFromInt(lIndex), configurationType, value); 656| 504| return false; // Do not break lambda function yet as we need to set all levels regardless 657| 504| }); easylogging++.cc:_ZZN2el6Logger18initUnflushedCountEvENK3$_0clEv: 805| 28| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 806| 28| m_unflushedCount.insert(std::make_pair(LevelHelper::castFromInt(lIndex), 0)); 807| 28| return false; 808| 28| }); easylogging++.cc:_ZZNK2el6Logger23resolveLoggerFormatSpecEvENK3$_0clEv: 813| 14| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 814| 14| base::LogFormat* logFormat = 815| 14| const_cast(&m_typedConfigurations->logFormat(LevelHelper::castFromInt(lIndex))); 816| 14| base::utils::Str::replaceFirstWithEscape(logFormat->m_format, base::consts::kLoggerIdFormatSpecifier, m_id); 817| 14| return false; 818| 14| }); easylogging++.cc:_ZZN2el4base5utils3Str5ltrimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEENK3$_0clEc: 989| 112| str.erase(str.begin(), std::find_if(str.begin(), str.end(), [](char c) { 990| 112| return !std::isspace(c); 991| 112| } )); easylogging++.cc:_ZZN2el4base5utils3Str5rtrimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEENK3$_0clEc: 996| 112| str.erase(std::find_if(str.rbegin(), str.rend(), [](char c) { 997| 112| return !std::isspace(c); 998| 112| }).base(), str.end()); easylogging++.cc:_ZZN2el4base19TypedConfigurations8getULongENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEENK3$_0clEc: 1835| 48| [](char c) { 1836| 48| return !base::utils::Str::isDigit(c); 1837| 48| }) == confVal.end(); _ZN2el4base6NoCopyC2Ev: 571| 8| NoCopy(void) {} _ZNKSt3__14hashIN2el5LevelEEclERKS2_: 624| 200| std::size_t operator()(const el::Level& l) const { 625| 200| return hash {}(static_cast(l)); 626| 200| } _ZN2el11LevelHelper11castFromIntEj: 642| 672| static Level castFromInt(base::type::EnumType l) { 643| 672| return static_cast(l); 644| 672| } _ZN2el4base18SubsecondPrecisionC2Ei: 870| 16| explicit SubsecondPrecision(int width) { 871| 16| init(width); 872| 16| } _ZN2el4base18SubsecondPrecisioneqERKS1_: 873| 14| bool operator==(const SubsecondPrecision& ssPrec) { 874| 14| return m_width == ssPrec.m_width && m_offset == ssPrec.m_offset; ------------------ | Branch (874:12): [True: 14, False: 0] | Branch (874:41): [True: 14, False: 0] ------------------ 875| 14| } _ZN2el4base9threading10ThreadSafe4lockEv: 1037| 322| virtual inline base::threading::Mutex& lock(void) ELPP_FINAL { return m_mutex; } _ZN2el4base9threading10ThreadSafeC2Ev: 1039| 18| ThreadSafe(void) {} _ZN2el4base9threading10ThreadSafeD2Ev: 1040| 9| virtual ~ThreadSafe(void) {} _ZN2el4base5utils3Str7isDigitEc: 1107| 48| static inline bool isDigit(char c) { 1108| 48| return c >= '0' && c <= '9'; ------------------ | Branch (1108:12): [True: 48, False: 0] | Branch (1108:24): [True: 48, False: 0] ------------------ 1109| 48| } _ZN2el4base5utils15CommandLineArgsC2Ev: 1251| 2| CommandLineArgs(void) { 1252| 2| setArgs(0, static_cast(nullptr)); 1253| 2| } _ZN2el4base5utils15CommandLineArgsD2Ev: 1260| 1| virtual ~CommandLineArgs(void) {} _ZN2el8LoggableD2Ev: 1603| 185| virtual ~Loggable(void) {} _ZN2el4base9LogFormatD2Ev: 1620| 40| virtual ~LogFormat(void) {} _ZNK2el4base9LogFormat7hasFlagENS0_11FormatFlagsE: 1647| 126| inline bool hasFlag(base::FormatFlags flag) const { 1648| 126| return base::utils::hasFlag(flag, m_flags); 1649| 126| } _ZN2el4base9LogFormat7addFlagENS0_11FormatFlagsE: 1664| 78| inline void addFlag(base::FormatFlags flag) { 1665| 78| base::utils::addFlag(flag, &m_flags); 1666| 78| } _ZN2el13ConfigurationD2Ev: 1716| 144| virtual ~Configuration(void) { 1717| 144| } _ZNK2el13Configuration5levelEv: 1723| 29.8k| inline Level level(void) const { 1724| 29.8k| return m_level; 1725| 29.8k| } _ZNK2el13Configuration17configurationTypeEv: 1728| 4.77k| inline ConfigurationType configurationType(void) const { 1729| 4.77k| return m_configurationType; 1730| 4.77k| } _ZNK2el13Configuration5valueEv: 1733| 304| inline const std::string& value(void) const { 1734| 304| return m_value; 1735| 304| } _ZN2el13Configuration8setValueERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 1740| 514| inline void setValue(const std::string& value) { 1741| 514| m_value = value; 1742| 514| } _ZN2el14ConfigurationsD2Ev: 1781| 2| virtual ~Configurations(void) { 1782| 2| } _ZN2el4base19TypedConfigurationsD2Ev: 1950| 1| virtual ~TypedConfigurations(void) { 1951| 1| } _ZN2el10LogBuilderC2Ev: 2237| 2| LogBuilder() : m_termSupportsColor(base::utils::OS::termSupportsColor()) {} _ZN2el10LogBuilderD2Ev: 2238| 1| virtual ~LogBuilder(void) { 2239| 1| ELPP_INTERNAL_INFO(3, "Destroying log builder...") 2240| 1| } _ZN2el6LoggerD2Ev: 2259| 1| virtual ~Logger(void) { 2260| 1| base::utils::safeDelete(m_typedConfigurations); 2261| 1| } _ZN2el4base17RegisteredLoggersD2Ev: 2390| 1| virtual ~RegisteredLoggers(void) { 2391| 1| unsafeFlushAll(); 2392| 1| } _ZN2el4base7Storage7addFlagENS_11LoggingFlagE: 2659| 4| inline void addFlag(LoggingFlag flag) { 2660| 4| base::utils::addFlag(flag, &m_flags); 2661| 4| } _ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEE3getINS_5LevelENS_17ConfigurationTypeEEEPS3_RKT_T0_: 1554| 802| T_Ptr* get(const T& arg1, const T2 arg2) { 1555| 802| iterator iter = std::find_if(this->list().begin(), this->list().end(), Pred(arg1, arg2)); 1556| 802| if (iter != this->list().end() && *iter != nullptr) { ------------------ | Branch (1556:9): [True: 514, False: 288] | Branch (1556:9): [True: 514, False: 288] | Branch (1556:39): [True: 514, False: 0] ------------------ 1557| 514| return *iter; 1558| 514| } 1559| 288| return nullptr; 1560| 802| } _ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEE13unregisterAllEv: 1523| 2| virtual void unregisterAll(void) ELPP_FINAL { 1524| 2| if (!this->empty()) { ------------------ | Branch (1524:9): [True: 2, False: 0] ------------------ 1525| 144| for (auto&& curr : this->list()) { ------------------ | Branch (1525:24): [True: 144, False: 2] ------------------ 1526| 144| base::utils::safeDelete(curr); 1527| 144| } 1528| 2| this->list().clear(); 1529| 2| } 1530| 2| } _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEE10unregisterERKSA_: 1455| 2| void unregister(const T_Key& uniqKey) { 1456| 2| T_Ptr* existing = get(uniqKey); 1457| 2| if (existing != nullptr) { ------------------ | Branch (1457:9): [True: 0, False: 2] ------------------ 1458| 0| this->list().erase(uniqKey); 1459| 0| base::utils::safeDelete(existing); 1460| 0| } 1461| 2| } _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEE3getERKSA_: 1464| 6| T_Ptr* get(const T_Key& uniqKey) { 1465| 6| iterator it = this->list().find(uniqKey); 1466| 6| return it == this->list().end() ------------------ | Branch (1466:12): [True: 4, False: 2] ------------------ 1467| 6| ? nullptr 1468| 6| : it->second; 1469| 6| } _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE5beginEv: 1348| 4| virtual inline iterator begin(void) ELPP_FINAL { 1349| 4| return m_list.begin(); 1350| 4| } _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE3endEv: 1353| 292| virtual inline iterator end(void) ELPP_FINAL { 1354| 292| return m_list.end(); 1355| 292| } _ZNK2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE5emptyEv: 1369| 2| virtual inline bool empty(void) const ELPP_FINAL { 1370| 2| return m_list.empty(); 1371| 2| } _ZNK2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE4sizeEv: 1374| 4| virtual inline std::size_t size(void) const ELPP_FINAL { 1375| 4| return m_list.size(); 1376| 4| } _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE4listEv: 1379| 2.70k| virtual inline Container& list(void) ELPP_FINAL { 1380| 2.70k| return m_list; 1381| 2.70k| } _ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEE11registerNewEPS3_: 1547| 288| virtual inline void registerNew(T_Ptr* ptr) ELPP_FINAL { 1548| 288| this->list().push_back(ptr); 1549| 288| } _ZNK2el4base5utils16AbstractRegistryINS_6LoggerENSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPS3_NS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SC_EEEEEEE5emptyEv: 1369| 1| virtual inline bool empty(void) const ELPP_FINAL { 1370| 1| return m_list.empty(); 1371| 1| } _ZN2el4base5utils16AbstractRegistryINS_6LoggerENSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPS3_NS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SC_EEEEEEE4listEv: 1379| 16| virtual inline Container& list(void) ELPP_FINAL { 1380| 16| return m_list; 1381| 16| } _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEE13unregisterAllEv: 1439| 1| virtual void unregisterAll(void) ELPP_FINAL { 1440| 1| if (!this->empty()) { ------------------ | Branch (1440:9): [True: 1, False: 0] ------------------ 1441| 1| for (auto&& curr : this->list()) { ------------------ | Branch (1441:24): [True: 1, False: 1] ------------------ 1442| 1| base::utils::safeDelete(curr.second); 1443| 1| } 1444| 1| this->list().clear(); 1445| 1| } 1446| 1| } _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEE11registerNewERKSA_PS3_: 1449| 2| virtual void registerNew(const T_Key& uniqKey, T_Ptr* ptr) ELPP_FINAL { 1450| 2| unregister(uniqKey); 1451| 2| this->list().insert(std::make_pair(uniqKey, ptr)); 1452| 2| } easylogging++.cc:_ZN2el4base5utilsL7addFlagINS0_11FormatFlagsEEEvT_Pj: 912| 78|static inline void addFlag(Enum e, base::type::EnumType* flag) { 913| 78| *flag = base::utils::bitwise::Or(e, *flag); 914| 78|} easylogging++.cc:_ZN2el4base5utils7bitwiseL2OrINS0_11FormatFlagsEEEjT_j: 907| 78|static inline base::type::EnumType Or(Enum e, base::type::EnumType flag) { 908| 78| return static_cast(flag) | static_cast(e); 909| 78|} easylogging++.cc:_ZN2el4base5utilsL7hasFlagINS0_11FormatFlagsEEEbT_j: 920| 126|static inline bool hasFlag(Enum e, base::type::EnumType flag) { 921| 126| return base::utils::bitwise::And(e, flag) > 0x0; 922| 126|} easylogging++.cc:_ZN2el4base5utils7bitwiseL3AndINS0_11FormatFlagsEEEjT_j: 899| 126|static inline base::type::EnumType And(Enum e, base::type::EnumType flag) { 900| 126| return static_cast(flag) & static_cast(e); 901| 126|} easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS_6LoggerEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 1|safeDelete(T*& pointer) { 890| 1| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 0, False: 1] ------------------ 891| 0| return; 892| 1| delete pointer; 893| 1| pointer = nullptr; 894| 1|} _ZN2el4base5utils16RegistryWithPredINS0_10HitCounterENS3_9PredicateEEC2Ev: 1489| 2| RegistryWithPred(void) { 1490| 2| } _ZN2el4base5utils16AbstractRegistryINS0_10HitCounterENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEEC2Ev: 1299| 2| AbstractRegistry(void) {} _ZN2el4base5utils16AbstractRegistryINS0_10HitCounterENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEED2Ev: 1344| 1| virtual ~AbstractRegistry(void) { 1345| 1| } _ZN2el4base5utils16RegistryWithPredINS0_10HitCounterENS3_9PredicateEED2Ev: 1492| 1| virtual ~RegistryWithPred(void) { 1493| 1| unregisterAll(); 1494| 1| } _ZNK2el4base5utils16AbstractRegistryINS0_10HitCounterENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE5emptyEv: 1369| 1| virtual inline bool empty(void) const ELPP_FINAL { 1370| 1| return m_list.empty(); 1371| 1| } _ZN2el4base5utils16RegistryWithPredINS0_10HitCounterENS3_9PredicateEE13unregisterAllEv: 1523| 1| virtual void unregisterAll(void) ELPP_FINAL { 1524| 1| if (!this->empty()) { ------------------ | Branch (1524:9): [True: 0, False: 1] ------------------ 1525| 0| for (auto&& curr : this->list()) { ------------------ | Branch (1525:24): [True: 0, False: 0] ------------------ 1526| 0| base::utils::safeDelete(curr); 1527| 0| } 1528| 0| this->list().clear(); 1529| 0| } 1530| 1| } easylogging++.cc:_ZN2el4base5utilsL7addFlagINS_11LoggingFlagEEEvT_Pj: 912| 4|static inline void addFlag(Enum e, base::type::EnumType* flag) { 913| 4| *flag = base::utils::bitwise::Or(e, *flag); 914| 4|} easylogging++.cc:_ZN2el4base5utils7bitwiseL2OrINS_11LoggingFlagEEEjT_j: 907| 4|static inline base::type::EnumType Or(Enum e, base::type::EnumType flag) { 908| 4| return static_cast(flag) | static_cast(e); 909| 4|} _ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEED2Ev: 1492| 2| virtual ~RegistryWithPred(void) { 1493| 2| unregisterAll(); 1494| 2| } _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEED2Ev: 1344| 2| virtual ~AbstractRegistry(void) { 1345| 2| } easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS0_19TypedConfigurationsEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 3|safeDelete(T*& pointer) { 890| 3| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 2, False: 1] ------------------ 891| 2| return; 892| 1| delete pointer; 893| 1| pointer = nullptr; 894| 1|} _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEED2Ev: 1434| 1| virtual ~Registry(void) { 1435| 1| unregisterAll(); 1436| 1| } _ZN2el4base5utils16AbstractRegistryINS_6LoggerENSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPS3_NS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SC_EEEEEEED2Ev: 1344| 1| virtual ~AbstractRegistry(void) { 1345| 1| } _ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEEC2Ev: 1489| 4| RegistryWithPred(void) { 1490| 4| } _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEEC2Ev: 1299| 4| AbstractRegistry(void) {} _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEEneERKSA_: 1322| 2| bool operator!=(const AbstractRegistry& other) { 1323| 2| if (size() != other.size()) { ------------------ | Branch (1323:9): [True: 2, False: 0] ------------------ 1324| 2| return true; 1325| 2| } 1326| 0| for (std::size_t i = 0; i < m_list.size(); ++i) { ------------------ | Branch (1326:29): [True: 0, False: 0] ------------------ 1327| 0| if (m_list.at(i) != other.m_list.at(i)) { ------------------ | Branch (1327:11): [True: 0, False: 0] ------------------ 1328| 0| return true; 1329| 0| } 1330| 0| } 1331| 0| return false; 1332| 0| } _ZN2el4base19TypedConfigurations14getConfigByRefINS0_9LogFormatEEERT_NS_5LevelEPNSt3__113unordered_mapIS6_S4_NS7_4hashIS6_EENS7_8equal_toIS6_EENS7_9allocatorINS7_4pairIKS6_S4_EEEEEEPKc: 1996| 14| inline Conf_T& getConfigByRef(Level level, std::unordered_map* confMap, const char* confName) { 1997| 14| base::threading::ScopedLock scopedLock(lock()); 1998| 14| return unsafeGetConfigByRef(level, confMap, confName); // This is not unsafe anymore - mutex locked in scope 1999| 14| } _ZN2el4base19TypedConfigurations20unsafeGetConfigByRefINS0_9LogFormatEEERT_NS_5LevelEPNSt3__113unordered_mapIS6_S4_NS7_4hashIS6_EENS7_8equal_toIS6_EENS7_9allocatorINS7_4pairIKS6_S4_EEEEEEPKc: 2019| 14| Conf_T& unsafeGetConfigByRef(Level level, std::unordered_map* confMap, const char* confName) { 2020| 14| ELPP_UNUSED(confName); ------------------ | | 240| 14|#define ELPP_UNUSED(x) (void)x ------------------ 2021| 14| typename std::unordered_map::iterator it = confMap->find(level); 2022| 14| if (it == confMap->end()) { ------------------ | Branch (2022:9): [True: 0, False: 14] ------------------ 2023| 0| try { 2024| 0| return confMap->at(Level::Global); 2025| 0| } catch (...) { 2026| 0| ELPP_INTERNAL_ERROR("Unable to get configuration [" << confName << "] for level [" 2027| 0| << LevelHelper::convertToString(level) << "]" 2028| 0| << std::endl << "Please ensure you have properly configured logger.", false); 2029| 0| throw; // The exception has to be rethrown, to abort a branch leading to UB. 2030| 0| } 2031| 0| } 2032| 14| return it->second; 2033| 14| } _ZN2el4base19TypedConfigurations8setValueINSt3__110shared_ptrINS3_13basic_fstreamIcNS3_11char_traitsIcEEEEEEEEvNS_5LevelERKT_PNS3_13unordered_mapISA_SB_NS3_4hashISA_EENS3_8equal_toISA_EENS3_9allocatorINS3_4pairIKSA_SB_EEEEEEb: 2037| 2| bool includeGlobalLevel = true) { 2038| | // If map is empty and we are allowed to add into generic level (Level::Global), do it! 2039| 2| if (confMap->empty() && includeGlobalLevel) { ------------------ | Branch (2039:9): [True: 2, False: 0] | Branch (2039:29): [True: 2, False: 0] ------------------ 2040| 2| confMap->insert(std::make_pair(Level::Global, value)); 2041| 2| return; 2042| 2| } 2043| | // If same value exist in generic level already, dont add it to explicit level 2044| 0| typename std::unordered_map::iterator it = confMap->find(Level::Global); 2045| 0| if (it != confMap->end() && it->second == value) { ------------------ | Branch (2045:9): [True: 0, False: 0] | Branch (2045:9): [True: 0, False: 0] | Branch (2045:33): [True: 0, False: 0] ------------------ 2046| 0| return; 2047| 0| } 2048| | // Now make sure we dont double up values if we really need to add it to explicit level 2049| 0| it = confMap->find(level); 2050| 0| if (it == confMap->end()) { ------------------ | Branch (2050:9): [True: 0, False: 0] ------------------ 2051| | // Value not found for level, add new 2052| 0| confMap->insert(std::make_pair(level, value)); 2053| 0| } else { 2054| | // Value found, just update value 2055| 0| confMap->at(level) = value; 2056| 0| } 2057| 0| } _ZN2el4base19TypedConfigurations8setValueIbEEvNS_5LevelERKT_PNSt3__113unordered_mapIS3_S4_NS7_4hashIS3_EENS7_8equal_toIS3_EENS7_9allocatorINS7_4pairIKS3_S4_EEEEEEb: 2037| 64| bool includeGlobalLevel = true) { 2038| | // If map is empty and we are allowed to add into generic level (Level::Global), do it! 2039| 64| if (confMap->empty() && includeGlobalLevel) { ------------------ | Branch (2039:9): [True: 8, False: 56] | Branch (2039:29): [True: 8, False: 0] ------------------ 2040| 8| confMap->insert(std::make_pair(Level::Global, value)); 2041| 8| return; 2042| 8| } 2043| | // If same value exist in generic level already, dont add it to explicit level 2044| 56| typename std::unordered_map::iterator it = confMap->find(Level::Global); 2045| 56| if (it != confMap->end() && it->second == value) { ------------------ | Branch (2045:9): [True: 56, False: 0] | Branch (2045:9): [True: 56, False: 0] | Branch (2045:33): [True: 56, False: 0] ------------------ 2046| 56| return; 2047| 56| } 2048| | // Now make sure we dont double up values if we really need to add it to explicit level 2049| 0| it = confMap->find(level); 2050| 0| if (it == confMap->end()) { ------------------ | Branch (2050:9): [True: 0, False: 0] ------------------ 2051| | // Value not found for level, add new 2052| 0| confMap->insert(std::make_pair(level, value)); 2053| 0| } else { 2054| | // Value found, just update value 2055| 0| confMap->at(level) = value; 2056| 0| } 2057| 0| } _ZN2el4base19TypedConfigurations8setValueINS0_9LogFormatEEEvNS_5LevelERKT_PNSt3__113unordered_mapIS4_S5_NS8_4hashIS4_EENS8_8equal_toIS4_EENS8_9allocatorINS8_4pairIKS4_S5_EEEEEEb: 2037| 16| bool includeGlobalLevel = true) { 2038| | // If map is empty and we are allowed to add into generic level (Level::Global), do it! 2039| 16| if (confMap->empty() && includeGlobalLevel) { ------------------ | Branch (2039:9): [True: 2, False: 14] | Branch (2039:29): [True: 2, False: 0] ------------------ 2040| 2| confMap->insert(std::make_pair(Level::Global, value)); 2041| 2| return; 2042| 2| } 2043| | // If same value exist in generic level already, dont add it to explicit level 2044| 14| typename std::unordered_map::iterator it = confMap->find(Level::Global); 2045| 14| if (it != confMap->end() && it->second == value) { ------------------ | Branch (2045:9): [True: 14, False: 0] | Branch (2045:9): [True: 0, False: 14] | Branch (2045:33): [True: 0, False: 14] ------------------ 2046| 0| return; 2047| 0| } 2048| | // Now make sure we dont double up values if we really need to add it to explicit level 2049| 14| it = confMap->find(level); 2050| 14| if (it == confMap->end()) { ------------------ | Branch (2050:9): [True: 14, False: 0] ------------------ 2051| | // Value not found for level, add new 2052| 14| confMap->insert(std::make_pair(level, value)); 2053| 14| } else { 2054| | // Value found, just update value 2055| 0| confMap->at(level) = value; 2056| 0| } 2057| 14| } _ZN2el4base19TypedConfigurations8setValueINS0_18SubsecondPrecisionEEEvNS_5LevelERKT_PNSt3__113unordered_mapIS4_S5_NS8_4hashIS4_EENS8_8equal_toIS4_EENS8_9allocatorINS8_4pairIKS4_S5_EEEEEEb: 2037| 16| bool includeGlobalLevel = true) { 2038| | // If map is empty and we are allowed to add into generic level (Level::Global), do it! 2039| 16| if (confMap->empty() && includeGlobalLevel) { ------------------ | Branch (2039:9): [True: 2, False: 14] | Branch (2039:29): [True: 2, False: 0] ------------------ 2040| 2| confMap->insert(std::make_pair(Level::Global, value)); 2041| 2| return; 2042| 2| } 2043| | // If same value exist in generic level already, dont add it to explicit level 2044| 14| typename std::unordered_map::iterator it = confMap->find(Level::Global); 2045| 14| if (it != confMap->end() && it->second == value) { ------------------ | Branch (2045:9): [True: 14, False: 0] | Branch (2045:9): [True: 14, False: 0] | Branch (2045:33): [True: 14, False: 0] ------------------ 2046| 14| return; 2047| 14| } 2048| | // Now make sure we dont double up values if we really need to add it to explicit level 2049| 0| it = confMap->find(level); 2050| 0| if (it == confMap->end()) { ------------------ | Branch (2050:9): [True: 0, False: 0] ------------------ 2051| | // Value not found for level, add new 2052| 0| confMap->insert(std::make_pair(level, value)); 2053| 0| } else { 2054| | // Value found, just update value 2055| 0| confMap->at(level) = value; 2056| 0| } 2057| 0| } _ZN2el4base19TypedConfigurations8setValueImEEvNS_5LevelERKT_PNSt3__113unordered_mapIS3_S4_NS7_4hashIS3_EENS7_8equal_toIS3_EENS7_9allocatorINS7_4pairIKS3_S4_EEEEEEb: 2037| 32| bool includeGlobalLevel = true) { 2038| | // If map is empty and we are allowed to add into generic level (Level::Global), do it! 2039| 32| if (confMap->empty() && includeGlobalLevel) { ------------------ | Branch (2039:9): [True: 4, False: 28] | Branch (2039:29): [True: 4, False: 0] ------------------ 2040| 4| confMap->insert(std::make_pair(Level::Global, value)); 2041| 4| return; 2042| 4| } 2043| | // If same value exist in generic level already, dont add it to explicit level 2044| 28| typename std::unordered_map::iterator it = confMap->find(Level::Global); 2045| 28| if (it != confMap->end() && it->second == value) { ------------------ | Branch (2045:9): [True: 28, False: 0] | Branch (2045:9): [True: 28, False: 0] | Branch (2045:33): [True: 28, False: 0] ------------------ 2046| 28| return; 2047| 28| } 2048| | // Now make sure we dont double up values if we really need to add it to explicit level 2049| 0| it = confMap->find(level); 2050| 0| if (it == confMap->end()) { ------------------ | Branch (2050:9): [True: 0, False: 0] ------------------ 2051| | // Value not found for level, add new 2052| 0| confMap->insert(std::make_pair(level, value)); 2053| 0| } else { 2054| | // Value found, just update value 2055| 0| confMap->at(level) = value; 2056| 0| } 2057| 0| } _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEC2Ev: 1413| 2| Registry(void) {} _ZN2el4base5utils16AbstractRegistryINS_6LoggerENSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPS3_NS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SC_EEEEEEEC2Ev: 1299| 2| AbstractRegistry(void) {} _ZN2el4base7Storage26installLogDispatchCallbackINS0_26DefaultLogDispatchCallbackEEEbRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 2708| 2| inline bool installLogDispatchCallback(const std::string& id) { 2709| 2| return base::utils::Utils::installCallback(id, &m_logDispatchCallbacks); 2710| 2| } _ZN2el4base5utils5Utils15installCallbackINS0_26DefaultLogDispatchCallbackENSt3__110shared_ptrINS_19LogDispatchCallbackEEEEEbRKNS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEPNS5_13unordered_mapISE_T0_NS5_4hashISE_EENS5_8equal_toISE_EENSC_INS5_4pairISF_SI_EEEEEE: 1572| 2| static bool installCallback(const std::string& id, std::unordered_map* mapT) { 1573| 2| if (mapT->find(id) == mapT->end()) { ------------------ | Branch (1573:9): [True: 2, False: 0] ------------------ 1574| 2| mapT->insert(std::make_pair(id, TPtr(new T()))); 1575| 2| return true; 1576| 2| } 1577| 0| return false; 1578| 2| } _ZN2el8CallbackINS_15LogDispatchDataEEC2Ev: 2184| 2| Callback(void) : m_enabled(true) {} easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS0_21RegisteredHitCountersEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 1|safeDelete(T*& pointer) { 890| 1| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 0, False: 1] ------------------ 891| 0| return; 892| 1| delete pointer; 893| 1| pointer = nullptr; 894| 1|} easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS0_17RegisteredLoggersEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 1|safeDelete(T*& pointer) { 890| 1| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 0, False: 1] ------------------ 891| 0| return; 892| 1| delete pointer; 893| 1| pointer = nullptr; 894| 1|} easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS0_9VRegistryEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 1|safeDelete(T*& pointer) { 890| 1| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 0, False: 1] ------------------ 891| 0| return; 892| 1| delete pointer; 893| 1| pointer = nullptr; 894| 1|} easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS_13ConfigurationEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 144|safeDelete(T*& pointer) { 890| 144| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 0, False: 144] ------------------ 891| 0| return; 892| 144| delete pointer; 893| 144| pointer = nullptr; 894| 144|} _ZN5tools11read_varintIRPKhmEEiOT_S5_RT0_: 125| 460| int read_varint(InputIt &&first, InputIt &&last, T &i) { 126| 460| return read_varint::digits>(std::forward(first), std::forward(last), i); 127| 460| } _ZN5tools11read_varintILi64ERPKhmEENSt3__19enable_ifIXaaaaaasr3std11is_integralIT1_EE5valuesr3std11is_unsignedIS6_EE5valueleLi0ET_leT_sr3std14numeric_limitsIS6_EE6digitsEiE4typeEOT0_SA_RS6_: 94| 460| read_varint(InputIt &&first, InputIt &&last, T &write) { 95| 460| int read = 0; 96| 460| write = 0; 97| 1.58k| for (int shift = 0;; shift += 7) { 98| 1.58k| if (first == last) { ------------------ | Branch (98:11): [True: 46, False: 1.54k] ------------------ 99| 46| return read; 100| 46| } 101| 1.54k| unsigned char byte = *first; 102| 1.54k| ++first; 103| 1.54k| ++read; 104| 1.54k| if (shift + 7 >= bits && byte >= 1 << (bits - shift)) { ------------------ | Branch (104:11): [True: 76, False: 1.46k] | Branch (104:32): [True: 15, False: 61] ------------------ 105| 15| return EVARINT_OVERFLOW; 106| 15| } 107| 1.52k| if (byte == 0 && shift != 0) { ------------------ | Branch (107:11): [True: 137, False: 1.38k] | Branch (107:24): [True: 5, False: 132] ------------------ 108| 5| return EVARINT_REPRESENT; 109| 5| } 110| | 111| 1.52k| write |= static_cast(byte & 0x7f) << shift; /* Does the actually placing into write, stripping the first bit */ 112| | 113| | /* If there is no next */ 114| 1.52k| if ((byte & 0x80) == 0) { ------------------ | Branch (114:11): [True: 394, False: 1.12k] ------------------ 115| 394| break; 116| 394| } 117| 1.52k| } 118| 394| return read; 119| 460| } _ZN3rct11BulletproofC2Ev: 222| 395| A({}), S({}), T1({}), T2({}), taux({}), mu({}), a({}), b({}), t({}), V({}), L({}), R({}) {} _ZN3rct11Bulletproof19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE: 230| 395| BEGIN_SERIALIZE_OBJECT() ------------------ | | 184| 395| bool do_serialize_object(Archive &ar){ ------------------ 231| | // Commitments aren't saved, they're restored via outPk 232| | // FIELD(V) 233| 395| FIELD(A) ------------------ | | 226| 395| do { \ | | 227| 395| ar.tag(#f); \ | | 228| 395| bool r = do_serialize(ar, f); \ | | 229| 395| if (!r || !ar.good()) return false; \ | | ------------------ | | | Branch (229:9): [True: 0, False: 395] | | | Branch (229:15): [True: 9, False: 386] | | ------------------ | | 230| 395| } while(0); | | ------------------ | | | Branch (230:11): [Folded - Ignored] | | ------------------ ------------------ 234| 386| FIELD(S) ------------------ | | 226| 386| do { \ | | 227| 386| ar.tag(#f); \ | | 228| 386| bool r = do_serialize(ar, f); \ | | 229| 386| if (!r || !ar.good()) return false; \ | | ------------------ | | | Branch (229:9): [True: 0, False: 386] | | | Branch (229:15): [True: 9, False: 377] | | ------------------ | | 230| 386| } while(0); | | ------------------ | | | Branch (230:11): [Folded - Ignored] | | ------------------ ------------------ 235| 377| FIELD(T1) ------------------ | | 226| 377| do { \ | | 227| 377| ar.tag(#f); \ | | 228| 377| bool r = do_serialize(ar, f); \ | | 229| 377| if (!r || !ar.good()) return false; \ | | ------------------ | | | Branch (229:9): [True: 0, False: 377] | | | Branch (229:15): [True: 9, False: 368] | | ------------------ | | 230| 377| } while(0); | | ------------------ | | | Branch (230:11): [Folded - Ignored] | | ------------------ ------------------ 236| 368| FIELD(T2) ------------------ | | 226| 368| do { \ | | 227| 368| ar.tag(#f); \ | | 228| 368| bool r = do_serialize(ar, f); \ | | 229| 368| if (!r || !ar.good()) return false; \ | | ------------------ | | | Branch (229:9): [True: 0, False: 368] | | | Branch (229:15): [True: 9, False: 359] | | ------------------ | | 230| 368| } while(0); | | ------------------ | | | Branch (230:11): [Folded - Ignored] | | ------------------ ------------------ 237| 359| FIELD(taux) ------------------ | | 226| 359| do { \ | | 227| 359| ar.tag(#f); \ | | 228| 359| bool r = do_serialize(ar, f); \ | | 229| 359| if (!r || !ar.good()) return false; \ | | ------------------ | | | Branch (229:9): [True: 0, False: 359] | | | Branch (229:15): [True: 9, False: 350] | | ------------------ | | 230| 359| } while(0); | | ------------------ | | | Branch (230:11): [Folded - Ignored] | | ------------------ ------------------ 238| 350| FIELD(mu) ------------------ | | 226| 350| do { \ | | 227| 350| ar.tag(#f); \ | | 228| 350| bool r = do_serialize(ar, f); \ | | 229| 350| if (!r || !ar.good()) return false; \ | | ------------------ | | | Branch (229:9): [True: 0, False: 350] | | | Branch (229:15): [True: 9, False: 341] | | ------------------ | | 230| 350| } while(0); | | ------------------ | | | Branch (230:11): [Folded - Ignored] | | ------------------ ------------------ 239| 341| FIELD(L) ------------------ | | 226| 341| do { \ | | 227| 341| ar.tag(#f); \ | | 228| 341| bool r = do_serialize(ar, f); \ | | 229| 341| if (!r || !ar.good()) return false; \ | | ------------------ | | | Branch (229:9): [True: 222, False: 119] | | | Branch (229:15): [True: 0, False: 119] | | ------------------ | | 230| 341| } while(0); | | ------------------ | | | Branch (230:11): [Folded - Ignored] | | ------------------ ------------------ 240| 119| FIELD(R) ------------------ | | 226| 119| do { \ | | 227| 119| ar.tag(#f); \ | | 228| 119| bool r = do_serialize(ar, f); \ | | 229| 119| if (!r || !ar.good()) return false; \ | | ------------------ | | | Branch (229:9): [True: 13, False: 106] | | | Branch (229:15): [True: 0, False: 106] | | ------------------ | | 230| 119| } while(0); | | ------------------ | | | Branch (230:11): [Folded - Ignored] | | ------------------ ------------------ 241| 106| FIELD(a) ------------------ | | 226| 106| do { \ | | 227| 106| ar.tag(#f); \ | | 228| 106| bool r = do_serialize(ar, f); \ | | 229| 106| if (!r || !ar.good()) return false; \ | | ------------------ | | | Branch (229:9): [True: 0, False: 106] | | | Branch (229:15): [True: 14, False: 92] | | ------------------ | | 230| 106| } while(0); | | ------------------ | | | Branch (230:11): [Folded - Ignored] | | ------------------ ------------------ 242| 92| FIELD(b) ------------------ | | 226| 92| do { \ | | 227| 92| ar.tag(#f); \ | | 228| 92| bool r = do_serialize(ar, f); \ | | 229| 92| if (!r || !ar.good()) return false; \ | | ------------------ | | | Branch (229:9): [True: 0, False: 92] | | | Branch (229:15): [True: 3, False: 89] | | ------------------ | | 230| 92| } while(0); | | ------------------ | | | Branch (230:11): [Folded - Ignored] | | ------------------ ------------------ 243| 89| FIELD(t) ------------------ | | 226| 89| do { \ | | 227| 89| ar.tag(#f); \ | | 228| 89| bool r = do_serialize(ar, f); \ | | 229| 89| if (!r || !ar.good()) return false; \ | | ------------------ | | | Branch (229:9): [True: 0, False: 89] | | | Branch (229:15): [True: 4, False: 85] | | ------------------ | | 230| 89| } while(0); | | ------------------ | | | Branch (230:11): [Folded - Ignored] | | ------------------ ------------------ 244| | 245| 85| if (L.empty() || L.size() != R.size()) ------------------ | Branch (245:13): [True: 33, False: 52] | Branch (245:26): [True: 49, False: 3] ------------------ 246| 82| return false; 247| 3| END_SERIALIZE() ------------------ | | 207| 3| return ar.good(); \ | | 208| 85| } ------------------ _ZN14binary_archiveILb0EEC2EN4epee4spanIKhEE: 96| 395| : base_type(), bytes_(s), begin_(s.begin()), good_(true), varint_bug_backward_compatibility_(false) 97| 395| {} _ZN19binary_archive_baseILb0EEC2Ev: 68| 395| explicit binary_archive_base() { } _ZN19binary_archive_baseILb0EE12begin_objectEv: 72| 395| void begin_object() { } _ZN19binary_archive_baseILb0EE3tagEPKc: 71| 2.98k| void tag(const char *) { } _ZN14binary_archiveILb0EE14serialize_blobEPvmPKc: 131| 145k| { 132| 145k| const std::size_t actual = bytes_.remove_prefix(len); 133| 145k| good_ &= (len == actual); 134| 145k| std::memcpy(buf, bytes_.data() - actual, actual); 135| 145k| } _ZNK14binary_archiveILb0EE4goodEv: 99| 146k| bool good() const noexcept { return good_; } _ZN14binary_archiveILb0EE11begin_arrayERm: 154| 460| { 155| 460| serialize_varint(s); 156| 460| } _ZN14binary_archiveILb0EE16serialize_varintImEEvRT_: 139| 460| { 140| 460| serialize_uvarint(*(typename boost::make_unsigned::type *)(&v)); 141| 460| } _ZN14binary_archiveILb0EE17serialize_uvarintImEEvRT_: 145| 460| { 146| 460| auto current = bytes_.cbegin(); 147| 460| auto end = bytes_.cend(); 148| 460| good_ &= (0 <= tools::read_varint(current, end, v)); 149| 460| current = std::min(current, bytes_.cend()); 150| 460| bytes_ = {current, std::size_t(bytes_.cend() - current)}; 151| 460| } _ZNK14binary_archiveILb0EE15remaining_bytesEv: 169| 440| size_t remaining_bytes() const noexcept { return good() ? bytes_.size() : 0; } ------------------ | Branch (169:52): [True: 440, False: 0] ------------------ _ZN14binary_archiveILb0EE8set_failEv: 100| 153| void set_fail() noexcept { good_ = false; } _ZN14binary_archiveILb0EE13delimit_arrayEv: 159| 142k| void delimit_array() { } _ZN14binary_archiveILb0EE9end_arrayEv: 160| 225| void end_array() { } _ZN19binary_archive_baseILb0EE10end_objectEv: 73| 395| void end_object() { } _ZNK14binary_archiveILb0EE3eofEv: 103| 3| bool eof() const noexcept { return bytes_.empty(); } _Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN3rct3keyENS1_9allocatorIS4_EEEEEbRT_ILb0EERT0_: 87| 460|{ 88| 460| size_t cnt; 89| 460| ar.begin_array(cnt); 90| 460| if (!ar.good()) ------------------ | Branch (90:7): [True: 20, False: 440] ------------------ 91| 20| return false; 92| 440| v.clear(); 93| | 94| | // very basic sanity check 95| 440| if (ar.remaining_bytes() < cnt) { ------------------ | Branch (95:7): [True: 153, False: 287] ------------------ 96| 153| ar.set_fail(); 97| 153| return false; 98| 153| } 99| | 100| 287| ::serialization::detail::do_reserve(v, cnt); 101| | 102| 143k| for (size_t i = 0; i < cnt; i++) { ------------------ | Branch (102:22): [True: 143k, False: 225] ------------------ 103| 143k| if (i > 0) ------------------ | Branch (103:9): [True: 142k, False: 151] ------------------ 104| 142k| ar.delimit_array(); 105| 143k| typename ::serialization::detail::serializable_value_type::type e; 106| 143k| if (!::serialization::detail::serialize_container_element(ar, e)) ------------------ | Branch (106:9): [True: 0, False: 143k] ------------------ 107| 0| return false; 108| 143k| ::serialization::detail::do_add(v, std::move(e)); 109| 143k| if (!ar.good()) ------------------ | Branch (109:9): [True: 62, False: 143k] ------------------ 110| 62| return false; 111| 143k| } 112| 225| ar.end_array(); 113| 225| return true; 114| 287|} _ZN13serialization6detail10do_reserveINSt3__16vectorIN3rct3keyENS2_9allocatorIS5_EEEEEEDTcldtfp_7reservefp0_EERT_m: 72| 287| auto do_reserve(C &c, std::size_t N) -> decltype(c.reserve(N)) { return c.reserve(N); } _ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EEN3rct3keyEEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RS8_: 44| 143k| { 45| 143k| return do_serialize(ar, e); 46| 143k| } _ZN13serialization6detail6do_addINSt3__16vectorIN3rct3keyENS2_9allocatorIS5_EEEEEEDTcldtfp_12emplace_backfp0_EERT_ONSA_10value_typeE: 63| 143k| { return c.emplace_back(e); } _Z12do_serializeI14binary_archiveILb0EENSt3__16vectorIN3rct3keyENS2_9allocatorIS5_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSA_: 61| 460|{ 62| 460| return ::do_serialize_container(ar, c); 63| 460|} _ZN13serialization9serializeI14binary_archiveILb0EEN3rct11BulletproofEEEbRT_RT0_: 363| 395| { 364| 395| bool r = do_serialize(ar, v); 365| 395| return r && check_stream_state(ar, false); ------------------ | Branch (365:12): [True: 3, False: 392] | Branch (365:17): [True: 1, False: 2] ------------------ 366| 395| } _Z12do_serializeI14binary_archiveILb0EEN3rct11BulletproofEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_: 89| 395|{ 90| 395| return v.member_do_serialize(ar); 91| 395|} _ZN3rct11Bulletproof19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE: 177| 395| bool member_do_serialize(Archive &ar) { \ 178| 395| ar.begin_object(); \ 179| 395| bool r = do_serialize_object(ar); \ 180| 395| ar.end_object(); \ 181| 395| return r; \ 182| 395| } \ _Z12do_serializeI14binary_archiveILb0EEN3rct3keyEENSt3__19enable_ifIXsr12is_blob_typeIT0_E4typeE5valueEbE4typeERT_RS6_: 75| 145k|{ 76| 145k| static_assert(std::is_trivially_copyable() || is_blob_forced(), 77| 145k| "sanity check: types that can't be trivially copied shouldn't be using the blob serializer"); 78| 145k| ar.serialize_blob(&v, sizeof(v)); 79| 145k| return true; 80| 145k|} _ZN13serialization18check_stream_stateI14binary_archiveILb0EEEEbRT_b: 353| 3| { 354| 3| return detail::do_check_stream_state(ar, typename Archive::is_saving(), noeof); 355| 3| } _ZN13serialization6detail21do_check_stream_stateI14binary_archiveILb0EEEEbRT_N4mpl_5bool_ILb0EEEb: 337| 3| { 338| 3| bool result = false; 339| 3| if (ar.good()) ------------------ | Branch (339:11): [True: 3, False: 0] ------------------ 340| 3| { 341| 3| result = noeof || ar.eof(); ------------------ | Branch (341:13): [True: 0, False: 3] | Branch (341:22): [True: 1, False: 2] ------------------ 342| 3| } 343| 3| return result; 344| 3| } LLVMFuzzerTestOneInput: 39| 790|BEGIN_SIMPLE_FUZZER() ------------------ | | 53| 395| { \ | | 54| 395| try \ | | 55| 395| { \ | | 56| 395| static bool first = true; \ | | 57| 395| if (first) \ | | ------------------ | | | Branch (57:11): [True: 1, False: 394] | | ------------------ | | 58| 395| { \ | | 59| 1| if (init()) \ | | ------------------ | | | Branch (59:13): [True: 0, False: 1] | | ------------------ | | 60| 1| return 1; \ | | 61| 1| first = false; \ | | 62| 1| } \ ------------------ 40| 395| binary_archive ba{{buf, len}}; 41| 395| rct::Bulletproof proof = AUTO_VAL_INIT(proof); ------------------ | | 36| 395|#define AUTO_VAL_INIT(v) boost::value_initialized() ------------------ 42| 395| ::serialization::serialize(ba, proof); 43| 395|END_SIMPLE_FUZZER() ------------------ | | 65| 395| } \ | | 66| 395| catch (const std::exception &e) \ | | 67| 395| { \ | | 68| 0| fprintf(stderr, "Exception: %s\n", e.what()); \ | | 69| 0| delete el::base::elStorage; \ | | 70| 0| el::base::elStorage = NULL; \ | | 71| 0| return 0; \ | | 72| 0| } \ | | 73| 395| delete el::base::elStorage; \ | | 74| 395| el::base::elStorage = NULL; \ | | 75| 395| return 0; \ | | 76| 395| } \ ------------------ bulletproof.cpp:_ZL4initv: 36| 2|BEGIN_INIT_SIMPLE_FUZZER() ------------------ | | 36| 1| { \ | | 37| 1| try \ | | 38| 1| { ------------------ 37| 2|END_INIT_SIMPLE_FUZZER() ------------------ | | 41| 1| } \ | | 42| 1| catch (const std::exception &e) \ | | 43| 1| { \ | | 44| 0| fprintf(stderr, "Exception: %s\n", e.what()); \ | | 45| 0| return 1; \ | | 46| 0| } \ | | 47| 1| return 0; \ | | 48| 1| } ------------------