cpplint

src/domino/DataDomino.hpp

@@ -15,7 +15,7 @@
 #include "DataStore.hpp"
 #include "UniLog.hpp"
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 template<typename aDominoType>

src/domino/Domino.cpp

@@ -9,7 +9,7 @@
 
 using namespace std;
 
-namespace RLib
+namespace rlib
 {
 static const Domino::Events defaultEVs;  // internal use only
 
@@ -144,7 +144,7 @@ void Domino::pureSetPrev_(const Event& aValidEv, const SimuEvents& aSimuPrevEven
 // ***********************************************************************************************
 bool Domino::pureSetStateOK_(const Event& aValidEv, const bool aNewState)
 {
-    if (states_[aValidEv] != aNewState) // do need change
+    if (states_[aValidEv] != aNewState)  // do need change
     {
         states_[aValidEv] = aNewState;
         HID("(Domino) Succeed, EvName=" << ev_en_[aValidEv] << " newState=" << aNewState);

src/domino/Domino.hpp

@@ -54,7 +54,7 @@
 
 #include "UniLog.hpp"
 
-namespace RLib
+namespace rlib
 {
 const char DOM_RESERVED_EVNAME[] = "[Dom Reserved EvName]";
 

src/domino/FreeHdlrDomino.hpp

@@ -22,7 +22,7 @@
 
 #include <vector>
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 template<class aDominoType>

src/domino/HdlrDomino.hpp

@@ -27,14 +27,15 @@
 #pragma once
 
 #include <functional>
+#include <memory>
 #include <unordered_map>
 
 #include "MsgSelf.hpp"
 #include "ObjAnywhere.hpp"
 #include "SafePtr.hpp"
 #include "UniLog.hpp"
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 template<class aDominoType>

src/domino/MultiHdlrDomino.hpp

@@ -20,12 +20,13 @@
 #pragma once
 
 #include <map>
+#include <memory>
 #include <string>
 #include <unordered_map>
 
 #include "UniLog.hpp"
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 template<class aDominoType>
@@ -175,7 +176,7 @@ bool MultiHdlrDomino<aDominoType>::rmOneHdlrOK_(const Domino::Event& aValidEv, c
 
     // rm
     auto&& ev_hdlrs = ev_hdlrs_S_.find(aValidEv);
-    //if (ev_hdlrs == ev_hdlrs_S_.end()) return false;  // impossible if valid aValidHdlr
+    // if (ev_hdlrs == ev_hdlrs_S_.end()) return false;  // impossible if valid aValidHdlr
     for (auto&& name_hdlr = ev_hdlrs->second.begin(); name_hdlr != ev_hdlrs->second.end(); ++name_hdlr)
     {
         if (name_hdlr->second != aValidHdlr)

src/domino/PriDomino.hpp

@@ -17,7 +17,7 @@
 #include <unordered_map>
 #include "UniLog.hpp"
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 template<class aDominoType>

src/domino/RmEvDom.hpp

@@ -31,7 +31,7 @@
 
 #include <unordered_set>
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 template<typename aDominoType>

src/domino/WbasicDatDom.hpp

@@ -11,9 +11,10 @@
 // ***********************************************************************************************
 #pragma once
 
+#include <vector>
 #include "UniLog.hpp"
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 template<typename aDominoType>

src/log/BaseSL.hpp

@@ -16,7 +16,7 @@
 // ***********************************************************************************************
 #pragma once
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 class BaseSL  // SL = Smart Log
@@ -27,7 +27,7 @@ class BaseSL  // SL = Smart Log
 
 //------------------------------------------------------------------------------------------------
 protected:    // derive use only
-     virtual ~BaseSL() = default;
+    virtual ~BaseSL() = default;
 
 //------------------------------------------------------------------------------------------------
 private:

src/log/StrCoutFSL.hpp

@@ -21,11 +21,11 @@
 #pragma once
 
 #include <iostream>
-#include <sstream>  //stringstream
+#include <sstream>  // stringstream
 
 #include "BaseSL.hpp"
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 class StrCoutFSL  // FSL = Formatted Smart Log
@@ -44,7 +44,7 @@ public :
 inline
 StrCoutFSL::~StrCoutFSL()
 {
-    if( canDelLog() )
+    if (canDelLog())
         return;
 
     forceSave();

src/log/UniBaseLog.hpp

@@ -37,7 +37,7 @@ using LogName = std::string;
 
 #define GTEST_LOG_FAIL { if (Test::HasFailure()) needLog(); }  // UT only
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 // - MT safe : yes
@@ -48,7 +48,8 @@ inline const char* timestamp()
 
     auto now_tp = std::chrono::system_clock::now();
     auto now_tt = std::chrono::system_clock::to_time_t(now_tp);
-    strftime(buf, sizeof(buf), "%j/%T.", localtime(&now_tt));
+    struct tm now_tm;
+    strftime(buf, sizeof(buf), "%j/%T.", localtime_r(&now_tt, &now_tm));  // cpplint asks localtime_r (MT safe)
     snprintf(buf + sizeof(buf) - 7, 7, "%06u",  // snprintf is safer than sprintf
         unsigned(std::chrono::duration_cast<std::chrono::microseconds>(now_tp.time_since_epoch()).count()
         % 1'000'000));

src/log/UniCoutLog.cpp

@@ -8,7 +8,7 @@
 
 using namespace std;
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 ostream& UniCoutLog::oneLog()

src/log/UniCoutLog.hpp

@@ -24,7 +24,7 @@
 
 #include "UniBaseLog.hpp"
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 class UniCoutLog

src/log/UniLog.hpp

@@ -43,7 +43,7 @@
 //                     :    :            :    :
 //                     :    :            :    :
 //         UniSmartLogTest.cpp          UniCoutLogTest.cpp
- //
+//
 // - REQ:
 //   * uni-interface (INF/...) for all users (eg DomLib, swm, rfsw)
 //     * easily support INF/etc macros

src/log/UniSmartLog.cpp

@@ -8,12 +8,12 @@
 
 using namespace std;
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 UniSmartLog::UniSmartLog(const LogName& aUniLogName) : uniLogName_(aUniLogName)
 {
-    //for(auto&& name_log : name_log_S_) cout << name_log.first<<", p=" << name_log.second.get() << endl;
+    // for(auto&& name_log : name_log_S_) cout << name_log.first<<", p=" << name_log.second.get() << endl;
     auto&& name_log = name_log_S_.find(aUniLogName);
     if (name_log == name_log_S_.end())
     {

src/log/UniSmartLog.hpp

@@ -27,7 +27,7 @@
 #include "StrCoutFSL.hpp"
 #include "UniBaseLog.hpp"
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 using SmartLog = StrCoutFSL;

src/msg_self/MsgSelf.cpp

@@ -7,7 +7,7 @@
 #include "MsgSelf.hpp"
 #include "MT_PingMainTH.hpp"
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 // - performance optimization need 5 lines code, with a little benfit in most cases

src/msg_self/MsgSelf.hpp

@@ -38,14 +38,15 @@
 // ***********************************************************************************************
 #pragma once
 
-#include <functional>
 #include <deque>
+#include <functional>
+#include <memory>
 
 #include "UniLog.hpp"
 
 #define MSG_SELF (ObjAnywhere::getObj<MsgSelf>())
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 enum EMsgPriority : unsigned char

src/obj_anywhere/DataStore.hpp

@@ -20,7 +20,7 @@
 #include "SafePtr.hpp"  // can't UniPtr.hpp since ut(=req) build-err
 #include "UniLog.hpp"   // debug
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 template<typename aDataKey>

src/obj_anywhere/ObjAnywhere.cpp

@@ -3,11 +3,12 @@
  * Licensed under the BSD 3 Clause license
  * SPDX-License-Identifier: BSD-3-Clause
  */
+#include <memory>
 #include "ObjAnywhere.hpp"
 
 using namespace std;
 
-namespace RLib
+namespace rlib
 {
 shared_ptr<DataStore<ObjName>> ObjAnywhere::name_obj_S_;
 

src/obj_anywhere/ObjAnywhere.hpp

@@ -22,12 +22,13 @@
 // ***********************************************************************************************
 #pragma once
 
+#include <memory>
 #include <string>
 
 #include "DataStore.hpp"
 #include "UniLog.hpp"
 
-namespace RLib
+namespace rlib
 {
 using ObjName = std::string;
 

src/safe_mem/SafePtr.hpp

@@ -33,10 +33,11 @@
 #include <memory>
 #include <type_traits>
 #include <typeindex>
+#include <utility>
 
 #include "UniLog.hpp"
 
-namespace RLib
+namespace rlib
 {
 // ***********************************************************************************************
 template<typename T = void>
@@ -103,17 +104,17 @@ std::shared_ptr<To> SafePtr<T>::cast() const noexcept
 {
     if constexpr(std::is_base_of_v<To, T>)  // safer than is_convertible()
     {
-        //HID("(SafePtr) cast to base/self");  // ERR() not MT safe
+        // HID("(SafePtr) cast to base/self");  // ERR() not MT safe
         return std::dynamic_pointer_cast<To>(pT_);  // private/protected inherit will compile err(rare & no easy fix)
     }
-     else if constexpr(std::is_base_of_v<T, To>)  // else if for constexpr
+    else if constexpr(std::is_base_of_v<T, To>)  // else if for constexpr
     {
-        //HID("(SafePtr) cast to derived");
+        // HID("(SafePtr) cast to derived");
         return std::dynamic_pointer_cast<To>(pT_);
     }
     else if constexpr(std::is_void_v<To>)
     {
-        //HID("(SafePtr) cast to void (for container to store diff types)");
+        // HID("(SafePtr) cast to void (for container to store diff types)");
         return pT_;
     }
     else if constexpr(!std::is_void_v<T>)
@@ -124,12 +125,12 @@ std::shared_ptr<To> SafePtr<T>::cast() const noexcept
 
     else if (realType_ == typeid(To))
     {
-        //HID("(SafePtr) cast void->origin");
+        // HID("(SafePtr) cast void->origin");
         return std::static_pointer_cast<To>(pT_);
     }
     else if (lastType_  == typeid(To))
     {
-        //HID("(SafePtr) cast void to last-type-except-void");
+        // HID("(SafePtr) cast void to last-type-except-void");
         return std::static_pointer_cast<To>(pT_);
     }
     HID("(SafePtr) can't cast from=void/" << typeid(T).name() << " to=" << typeid(To).name());
@@ -155,9 +156,9 @@ void SafePtr<T>::init_(const SafePtr<From>& aSafeFrom) noexcept
     else
         lastType_ = aSafeFrom.lastType();
 
-    /*HID("cp from=" << typeid(From).name() << " to=" << typeid(T).name()
+    /* HID("cp from=" << typeid(From).name() << " to=" << typeid(T).name()
         << ", diff=" << (lastType_ == nullptr ? "null" : lastType_->name())
-        << ", real=" << (realType_ == nullptr ? "null" : realType_->name()));*/
+        << ", real=" << (realType_ == nullptr ? "null" : realType_->name())); */
 }
 
 
@@ -168,7 +169,7 @@ SafePtr<U> make_safe(ConstructArgs&&... aArgs)
 {
     SafePtr<U> safeU;
     safeU.pT_ = std::make_shared<U>(std::forward<ConstructArgs>(aArgs)...);  // std::~, or ambiguous with boost::~
-    //HID("new ptr=" << (void*)(safeU.pT_.get()));  // too many print; void* print addr rather than content(dangeous)
+    // HID("new ptr=" << (void*)(safeU.pT_.get()));  // too many print; void* print addr rather than content(dangeous)
     return safeU;
 }
 
@@ -194,26 +195,26 @@ bool operator<(SafePtr<T> lhs, SafePtr<U> rhs)
 
 // ***********************************************************************************************
 template<typename To, typename From>
-RLib::SafePtr<To> std::dynamic_pointer_cast(const RLib::SafePtr<From>& aSafeFrom) noexcept
+rlib::SafePtr<To> std::dynamic_pointer_cast(const rlib::SafePtr<From>& aSafeFrom) noexcept
 {
-    RLib::SafePtr<To> safeTo;
+    rlib::SafePtr<To> safeTo;
     safeTo.pT_ = aSafeFrom.template cast<To>();
     safeTo.init_(aSafeFrom);
     return safeTo;
 }
 
 // ***********************************************************************************************
 template<typename To, typename From>
-RLib::SafePtr<To> std::static_pointer_cast(const RLib::SafePtr<From>& aSafeFrom) noexcept
+rlib::SafePtr<To> std::static_pointer_cast(const rlib::SafePtr<From>& aSafeFrom) noexcept
 {
     return std::dynamic_pointer_cast<To>(aSafeFrom);
 }
 
 // ***********************************************************************************************
 template<typename T>
-struct std::hash<RLib::SafePtr<T>>
+struct std::hash<rlib::SafePtr<T>>
 {
-    auto operator()(const RLib::SafePtr<T>& aSafePtr) const { return hash<shared_ptr<T>>()(aSafePtr.get()); }
+    auto operator()(const rlib::SafePtr<T>& aSafePtr) const { return hash<shared_ptr<T>>()(aSafePtr.get()); }
 };
 
 // ***********************************************************************************************