quality: improve warning flags and fix issues

Demos/api/Orchestration/SimStep.cpp

@@ -8,7 +8,7 @@
 
 using namespace std::chrono_literals;
 
-std::ostream& operator<<(std::ostream& out, std::chrono::nanoseconds timestamp)
+static std::ostream& operator<<(std::ostream& out, std::chrono::nanoseconds timestamp)
 {
     out << std::chrono::duration_cast<std::chrono::milliseconds>(timestamp).count() << "ms";
     return out;

Demos/api/Orchestration/SimStepAsync.cpp

@@ -9,7 +9,7 @@
 
 using namespace std::chrono_literals;
 
-std::ostream& operator<<(std::ostream& out, std::chrono::nanoseconds timestamp)
+static std::ostream& operator<<(std::ostream& out, std::chrono::nanoseconds timestamp)
 {
     out << std::chrono::duration_cast<std::chrono::milliseconds>(timestamp).count() << "ms";
     return out;

Demos/communication/Can/CanDemoCommon.hpp

@@ -2,6 +2,8 @@
 //
 // SPDX-License-Identifier: MIT
 
+#pragma once
+
 #include "silkit/services/can/all.hpp"
 #include "silkit/services/can/string_utils.hpp"
 #include "silkit/services/logging/ILogger.hpp"
@@ -11,15 +13,15 @@ using namespace SilKit::Services::Can;
 // This is the common behavior used in CanReaderDemo and CanWriterDemo
 namespace CanDemoCommon {
 
-void FrameTransmitHandler(const CanFrameTransmitEvent& canFrameAck, ILogger* logger)
+inline void FrameTransmitHandler(const CanFrameTransmitEvent& canFrameAck, ILogger* logger)
 {
     std::stringstream ss;
     ss << "Receive CAN frame transmit acknowledge: canId=" << canFrameAck.canId << ", status='" << canFrameAck.status
        << "'";
     logger->Info(ss.str());
 }
 
-void FrameHandler(const CanFrameEvent& canFrameEvent, ILogger* logger, bool printHex)
+inline void FrameHandler(const CanFrameEvent& canFrameEvent, ILogger* logger, bool printHex)
 {
     std::string frameTypeHint = "";
     if ((canFrameEvent.frame.flags & static_cast<CanFrameFlagMask>(CanFrameFlag::Fdf)) != 0)

Demos/communication/Ethernet/EthernetDemoCommon.hpp

@@ -2,6 +2,8 @@
 //
 // SPDX-License-Identifier: MIT
 
+#pragma once
+
 #include "silkit/services/ethernet/all.hpp"
 #include "silkit/services/ethernet/string_utils.hpp"
 #include "silkit/services/logging/ILogger.hpp"
@@ -14,7 +16,7 @@ namespace EthernetDemoCommon {
 using EtherType = uint16_t;
 using EthernetMac = std::array<uint8_t, 6>;
 
-void FrameTransmitHandler(const EthernetFrameTransmitEvent& frameTransmitEvent, ILogger* logger)
+inline void FrameTransmitHandler(const EthernetFrameTransmitEvent& frameTransmitEvent, ILogger* logger)
 {
     std::stringstream ss;
     if (frameTransmitEvent.status == EthernetTransmitStatus::Transmitted)
@@ -45,7 +47,7 @@ void FrameTransmitHandler(const EthernetFrameTransmitEvent& frameTransmitEvent,
     logger->Info(ss.str());
 }
 
-auto PrintPayload(const std::vector<uint8_t>& payload, bool printHex)
+inline auto PrintPayload(const std::vector<uint8_t>& payload, bool printHex)
 {
     std::stringstream ss;
     if (printHex)
@@ -59,7 +61,7 @@ auto PrintPayload(const std::vector<uint8_t>& payload, bool printHex)
     return ss.str();
 }
 
-void FrameHandler(const EthernetFrameEvent& ethernetFrameEvent, ILogger* logger, bool printHex)
+inline void FrameHandler(const EthernetFrameEvent& ethernetFrameEvent, ILogger* logger, bool printHex)
 {
     const size_t FrameHeaderSize = 2 * sizeof(EthernetMac) + sizeof(EtherType);
     std::vector<uint8_t> payloadWithoutHeader;

Demos/communication/PubSub/PubSubDemoCommon.hpp

@@ -2,6 +2,8 @@
 //
 // SPDX-License-Identifier: MIT
 
+#pragma once
+
 #include "silkit/services/pubsub/all.hpp"
 #include "silkit/services/pubsub/string_utils.hpp"
 #include "silkit/services/logging/ILogger.hpp"
@@ -12,9 +14,15 @@ using namespace SilKit::Services::PubSub;
 // This are the common data structures used in PublisherDemo and SubscriberDemo
 namespace PubSubDemoCommon {
 
-const std::string mediaType{SilKit::Util::SerDes::MediaTypeData()};
-PubSubSpec dataSpecGps{"Gps", mediaType};
-PubSubSpec dataSpecTemperature{"Temperature", mediaType};
+inline PubSubSpec MakeGpsSpec()
+{
+    return {"Gps", SilKit::Util::SerDes::MediaTypeData()};
+}
+
+inline PubSubSpec MakeTemperatureSpec()
+{
+    return {"Temperature", SilKit::Util::SerDes::MediaTypeData()};
+}
 
 // ----------------------------------------------------------------
 // Data structure, serialization and deserialization for GPS Data
@@ -26,7 +34,8 @@ struct GpsData
     double longitude;
     std::string signalQuality;
 };
-std::vector<uint8_t> SerializeGPSData(const PubSubDemoCommon::GpsData& gpsData)
+
+inline std::vector<uint8_t> SerializeGPSData(const PubSubDemoCommon::GpsData& gpsData)
 {
     SilKit::Util::SerDes::Serializer serializer;
     serializer.BeginStruct();
@@ -38,7 +47,7 @@ std::vector<uint8_t> SerializeGPSData(const PubSubDemoCommon::GpsData& gpsData)
     return serializer.ReleaseBuffer();
 }
 
-PubSubDemoCommon::GpsData DeserializeGPSData(const std::vector<uint8_t>& eventData)
+inline PubSubDemoCommon::GpsData DeserializeGPSData(const std::vector<uint8_t>& eventData)
 {
     PubSubDemoCommon::GpsData gpsData;
 
@@ -56,15 +65,15 @@ PubSubDemoCommon::GpsData DeserializeGPSData(const std::vector<uint8_t>& eventDa
 // Serialization and deserialization for a double (temperature)
 // -----------------------------------------------------------------
 
-std::vector<uint8_t> SerializeTemperature(double temperature)
+inline std::vector<uint8_t> SerializeTemperature(double temperature)
 {
     SilKit::Util::SerDes::Serializer temperatureSerializer;
     temperatureSerializer.Serialize(temperature);
 
     return temperatureSerializer.ReleaseBuffer();
 }
 
-double DeserializeTemperature(const std::vector<uint8_t>& eventData)
+inline double DeserializeTemperature(const std::vector<uint8_t>& eventData)
 {
     double temperature;
 

Demos/communication/PubSub/PublisherDemo.cpp

@@ -21,9 +21,9 @@ class Publisher : public ApplicationBase
 
     void CreateControllers() override
     {
-        _gpsPublisher = GetParticipant()->CreateDataPublisher("GpsPublisher", PubSubDemoCommon::dataSpecGps, 0);
+        _gpsPublisher = GetParticipant()->CreateDataPublisher("GpsPublisher", PubSubDemoCommon::MakeGpsSpec(), 0);
         _temperaturePublisher =
-            GetParticipant()->CreateDataPublisher("TemperaturePublisher", PubSubDemoCommon::dataSpecTemperature, 0);
+            GetParticipant()->CreateDataPublisher("TemperaturePublisher", PubSubDemoCommon::MakeTemperatureSpec(), 0);
     }
 
     void InitControllers() override {}

Demos/communication/PubSub/SubscriberDemo.cpp

@@ -22,7 +22,7 @@ class Subscriber : public ApplicationBase
     void CreateControllers() override
     {
         _gpsSubscriber = GetParticipant()->CreateDataSubscriber(
-            "GpsSubscriber", PubSubDemoCommon::dataSpecGps,
+            "GpsSubscriber", PubSubDemoCommon::MakeGpsSpec(),
             [this](IDataSubscriber* /*subscriber*/, const DataMessageEvent& dataMessageEvent) {
             auto gpsData = PubSubDemoCommon::DeserializeGPSData(SilKit::Util::ToStdVector(dataMessageEvent.data));
 
@@ -33,7 +33,7 @@ class Subscriber : public ApplicationBase
         });
 
         _temperatureSubscriber = GetParticipant()->CreateDataSubscriber(
-            "TemperatureSubscriber", PubSubDemoCommon::dataSpecTemperature,
+            "TemperatureSubscriber", PubSubDemoCommon::MakeTemperatureSpec(),
             [this](IDataSubscriber* /*subscriber*/, const DataMessageEvent& dataMessageEvent) {
             double temperature =
                 PubSubDemoCommon::DeserializeTemperature(SilKit::Util::ToStdVector(dataMessageEvent.data));

Demos/communication/Rpc/RpcClientDemo.cpp

@@ -23,11 +23,11 @@ class RpcClient : public ApplicationBase
     void CreateControllers() override
     {
         _rpcClientSignalStrength = GetParticipant()->CreateRpcClient(
-            "ClientSignalStrength", RpcDemoCommon::rpcSpecSignalStrength,
+            "ClientSignalStrength", RpcDemoCommon::MakeSignalStrengthSpec(),
             [this](IRpcClient* /*client*/, RpcCallResultEvent event) { CallReturnGetSignalStrength(event); });
 
         _rpcClientSort = GetParticipant()->CreateRpcClient(
-            "ClientSort", RpcDemoCommon::rpcSpecSort,
+            "ClientSort", RpcDemoCommon::MakeSortSpec(),
             [this](IRpcClient* /*client*/, RpcCallResultEvent event) { CallReturnSort(event); });
     }
 

Demos/communication/Rpc/RpcDemoCommon.hpp

@@ -2,14 +2,16 @@
 //
 // SPDX-License-Identifier: MIT
 
+#pragma once
+
 #include "silkit/services/rpc/all.hpp"
 #include "silkit/services/rpc/string_utils.hpp"
 #include "silkit/services/logging/ILogger.hpp"
 #include "silkit/util/serdes/Serialization.hpp"
 
 using namespace SilKit::Services::Rpc;
 
-static std::ostream& operator<<(std::ostream& os, const SilKit::Util::Span<const uint8_t>& v)
+inline std::ostream& operator<<(std::ostream& os, const SilKit::Util::Span<const uint8_t>& v)
 {
     os << "[ ";
     for (auto i : v)
@@ -18,17 +20,23 @@ static std::ostream& operator<<(std::ostream& os, const SilKit::Util::Span<const
     return os;
 }
 
-static std::ostream& operator<<(std::ostream& os, const std::vector<uint8_t>& v)
+inline std::ostream& operator<<(std::ostream& os, const std::vector<uint8_t>& v)
 {
     return os << SilKit::Util::ToSpan(v);
 }
 
 // This are the common data structures used in RpcServerDemo and RpcClientDemo
 namespace RpcDemoCommon {
 
-std::string mediaType{SilKit::Util::SerDes::MediaTypeRpc()};
-RpcSpec rpcSpecSignalStrength{"GetSignalStrength", mediaType};
-RpcSpec rpcSpecSort{"Sort", mediaType};
+inline RpcSpec MakeSignalStrengthSpec()
+{
+    return {"GetSignalStrength", SilKit::Util::SerDes::MediaTypeRpc()};
+}
+
+inline RpcSpec MakeSortSpec()
+{
+    return {"Sort", SilKit::Util::SerDes::MediaTypeRpc()};
+}
 
 // ----------------------------------------------------------------
 // Data structure, serialization and deserialization for Tuner Data
@@ -46,7 +54,7 @@ struct TunerData
     TunerBand tunerBand;
 };
 
-std::vector<uint8_t> SerializeTunerData(const TunerData& tunerData)
+inline std::vector<uint8_t> SerializeTunerData(const TunerData& tunerData)
 {
     SilKit::Util::SerDes::Serializer serializer;
     serializer.BeginStruct();
@@ -57,7 +65,7 @@ std::vector<uint8_t> SerializeTunerData(const TunerData& tunerData)
     return serializer.ReleaseBuffer();
 }
 
-TunerData DeserializeTunerData(const std::vector<uint8_t>& eventData)
+inline TunerData DeserializeTunerData(const std::vector<uint8_t>& eventData)
 {
     TunerData tunerData;
 
@@ -74,15 +82,15 @@ TunerData DeserializeTunerData(const std::vector<uint8_t>& eventData)
 // Serialization and deserialization for a double (signal strength)
 // ----------------------------------------------------------------
 
-std::vector<uint8_t> SerializeSignalStrength(double signalStrength)
+inline std::vector<uint8_t> SerializeSignalStrength(double signalStrength)
 {
     SilKit::Util::SerDes::Serializer signalStrengthSerializer;
     signalStrengthSerializer.Serialize(signalStrength);
 
     return signalStrengthSerializer.ReleaseBuffer();
 }
 
-double DeserializeSignalStrength(const std::vector<uint8_t>& eventData)
+inline double DeserializeSignalStrength(const std::vector<uint8_t>& eventData)
 {
     double signalStrength;
 
@@ -96,23 +104,23 @@ double DeserializeSignalStrength(const std::vector<uint8_t>& eventData)
 // Serialization and deserialization for a std::vector<uint8_t>
 // ----------------------------------------------------------------
 
-std::vector<uint8_t> SerializeSortData(const std::vector<uint8_t>& numberList)
+inline std::vector<uint8_t> SerializeSortData(const std::vector<uint8_t>& numberList)
 {
     SilKit::Util::SerDes::Serializer serializer;
     serializer.Serialize(numberList);
 
     return serializer.ReleaseBuffer();
 }
 
-std::vector<uint8_t> DeserializeSortData(const std::vector<uint8_t>& eventData)
+inline std::vector<uint8_t> DeserializeSortData(const std::vector<uint8_t>& eventData)
 {
     SilKit::Util::SerDes::Deserializer deserializer(eventData);
     std::vector<uint8_t> numberList = deserializer.Deserialize<std::vector<uint8_t>>();
 
     return numberList;
 }
 
-bool EvaluateCallStatus(RpcCallResultEvent callResult, ILogger* logger)
+inline bool EvaluateCallStatus(RpcCallResultEvent callResult, ILogger* logger)
 {
     std::stringstream ss;
     bool isSuccessful = false;

Demos/communication/Rpc/RpcServerDemo.cpp

@@ -24,7 +24,7 @@ class RpcServer : public ApplicationBase
     void CreateControllers() override
     {
         _rpcServerSignalStrength =
-            GetParticipant()->CreateRpcServer("ServerSignalStrength", RpcDemoCommon::rpcSpecSignalStrength,
+            GetParticipant()->CreateRpcServer("ServerSignalStrength", RpcDemoCommon::MakeSignalStrengthSpec(),
                                               [this](IRpcServer* server, RpcCallEvent event) {
             auto tunerData = RpcDemoCommon::DeserializeTunerData(SilKit::Util::ToStdVector(event.argumentData));
 
@@ -63,7 +63,7 @@ class RpcServer : public ApplicationBase
             server->SubmitResult(event.callHandle, serializer.ReleaseBuffer());
         });
 
-        _rpcServerSort = GetParticipant()->CreateRpcServer("ServerSort", RpcDemoCommon::rpcSpecSort,
+        _rpcServerSort = GetParticipant()->CreateRpcServer("ServerSort", RpcDemoCommon::MakeSortSpec(),
                                                            [this](IRpcServer* server, RpcCallEvent event) {
             // Deserialize incoming data
             auto argumentData = RpcDemoCommon::DeserializeSortData(SilKit::Util::ToStdVector(event.argumentData));

Demos/communication/include/ApplicationBase.hpp

@@ -40,7 +40,7 @@ struct Arguments
 };
 std::shared_ptr<SilKit::Config::IParticipantConfiguration> _participantConfiguration{nullptr};
 
-std::ostream& operator<<(std::ostream& out, std::chrono::nanoseconds timestamp)
+inline std::ostream& operator<<(std::ostream& out, std::chrono::nanoseconds timestamp)
 {
     out << std::chrono::duration_cast<std::chrono::milliseconds>(timestamp).count() << "ms";
     return out;

Demos/communication/include/SignalHandler.hpp

@@ -22,7 +22,7 @@ static std::unique_ptr<SignalMonitor> gSignalMonitor;
 ////////////////////////////////////////////
 // Inline Platform Specific Implementations
 ////////////////////////////////////////////
-#if WIN32
+#if defined(_WIN32)
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
@@ -251,12 +251,12 @@ void systemHandler(const int sigNum)
 //! \brief RegisterSignalHandler can be used to portably register a single signal handler.
 // It only relies on async-signal-safe C functions internally, but
 // it uses a dedicated thread which safely runs the user-provided handler.
-void RegisterSignalHandler(SignalHandler handler)
+inline void RegisterSignalHandler(SignalHandler handler)
 {
     gSignalMonitor.reset(new SignalMonitor(std::move(handler)));
 }
 
-void ShutdownSignalHandler()
+inline void ShutdownSignalHandler()
 {
     gSignalMonitor.reset();
 }