Change the naming scheme for class field members

I'm not a fan of Hungarian notation, but C++ kind of needs it with its
implicit `this`. And of all the common options for this, I find
suffixing members with an underscore the least offensive one.

src/common/logging/common.cpp

@@ -51,11 +51,11 @@ Logger::Logger(std::shared_ptr<std::ostream> stream,
                bool editor_tracing,
                std::string prefix,
                bool prefix_timestamp)
-    : verbosity(verbosity_level),
-      editor_tracing(editor_tracing),
-      stream(stream),
-      prefix(prefix),
-      prefix_timestamp(prefix_timestamp) {}
+    : verbosity_(verbosity_level),
+      editor_tracing_(editor_tracing),
+      stream_(stream),
+      prefix_(prefix),
+      prefix_timestamp_(prefix_timestamp) {}
 
 Logger Logger::create_from_environment(std::string prefix,
                                        std::shared_ptr<std::ostream> stream,
@@ -126,7 +126,7 @@ Logger Logger::create_exception_logger() {
 void Logger::log(const std::string& message) {
     std::ostringstream formatted_message;
 
-    if (prefix_timestamp) {
+    if (prefix_timestamp_) {
         const auto current_time = std::chrono::system_clock::now();
         const time_t timestamp =
             std::chrono::system_clock::to_time_t(current_time);
@@ -140,12 +140,12 @@ void Logger::log(const std::string& message) {
         formatted_message << std::put_time(&tm, "%T") << " ";
     }
 
-    formatted_message << prefix;
+    formatted_message << prefix_;
     formatted_message << message;
     // Flushing a stringstream doesn't do anything, but we need to put a
     // linefeed in this string stream rather writing it sprightly to the output
     // stream to prevent two messages from being put on the same row
     formatted_message << std::endl;
 
-    *stream << formatted_message.str() << std::flush;
+    *stream_ << formatted_message.str() << std::flush;
 }

src/common/logging/common.h

@@ -195,7 +195,7 @@ class Logger {
      */
     template <invocable_returning<std::string> F>
     void log_trace(F&& fn) {
-        if (verbosity >= Verbosity::all_events) [[unlikely]] {
+        if (verbosity_ >= Verbosity::all_events) [[unlikely]] {
             log(fn());
         }
     }
@@ -209,7 +209,7 @@ class Logger {
      */
     template <invocable_returning<std::string> F>
     void log_editor_trace(F&& fn) {
-        if (editor_tracing) [[unlikely]] {
+        if (editor_tracing_) [[unlikely]] {
             log(fn());
         }
     }
@@ -218,28 +218,28 @@ class Logger {
      * The verbosity level of this logger instance. Based on this certain
      * messages may or may not be shown.
      */
-    const Verbosity verbosity;
+    const Verbosity verbosity_;
 
     /**
      * If this is set to true, then we'll print debug traces for the plugin
      * editor.
      */
-    const bool editor_tracing;
+    const bool editor_tracing_;
 
    private:
     /**
      * The output stream to write the log messages to. Typically either STDERR
      * or a file stream.
      */
-    std::shared_ptr<std::ostream> stream;
+    std::shared_ptr<std::ostream> stream_;
 
     /**
      * A prefix that gets prepended before every message.
      */
-    const std::string prefix;
+    const std::string prefix_;
 
     /**
      * Whether the log messages should be prefixed with a time stamp.
      */
-    const bool prefix_timestamp;
+    const bool prefix_timestamp_;
 };

src/common/logging/vst2.cpp

@@ -18,7 +18,7 @@
 
 #include <sstream>
 
-Vst2Logger::Vst2Logger(Logger& generic_logger) : logger(generic_logger) {}
+Vst2Logger::Vst2Logger(Logger& generic_logger) : logger_(generic_logger) {}
 
 std::optional<std::string> opcode_to_string(bool is_dispatch, int opcode) {
     if (is_dispatch) {
@@ -333,7 +333,7 @@ std::optional<std::string> opcode_to_string(bool is_dispatch, int opcode) {
 }
 
 void Vst2Logger::log_get_parameter(int index) {
-    if (logger.verbosity >= Logger::Verbosity::most_events) [[unlikely]] {
+    if (logger_.verbosity_ >= Logger::Verbosity::most_events) [[unlikely]] {
         std::ostringstream message;
         message << ">> getParameter() " << index;
 
@@ -342,7 +342,7 @@ void Vst2Logger::log_get_parameter(int index) {
 }
 
 void Vst2Logger::log_get_parameter_response(float value) {
-    if (logger.verbosity >= Logger::Verbosity::most_events) [[unlikely]] {
+    if (logger_.verbosity_ >= Logger::Verbosity::most_events) [[unlikely]] {
         std::ostringstream message;
         message << "   getParameter() :: " << value;
 
@@ -351,7 +351,7 @@ void Vst2Logger::log_get_parameter_response(float value) {
 }
 
 void Vst2Logger::log_set_parameter(int index, float value) {
-    if (logger.verbosity >= Logger::Verbosity::most_events) [[unlikely]] {
+    if (logger_.verbosity_ >= Logger::Verbosity::most_events) [[unlikely]] {
         std::ostringstream message;
         message << ">> setParameter() " << index << " = " << value;
 
@@ -360,7 +360,7 @@ void Vst2Logger::log_set_parameter(int index, float value) {
 }
 
 void Vst2Logger::log_set_parameter_response() {
-    if (logger.verbosity >= Logger::Verbosity::most_events) [[unlikely]] {
+    if (logger_.verbosity_ >= Logger::Verbosity::most_events) [[unlikely]] {
         log("   setParameter() :: OK");
     }
 }
@@ -373,7 +373,7 @@ void Vst2Logger::log_event(
     const Vst2Event::Payload& payload,
     float option,
     const std::optional<Vst2Event::Payload>& value_payload) {
-    if (logger.verbosity >= Logger::Verbosity::most_events) [[unlikely]] {
+    if (logger_.verbosity_ >= Logger::Verbosity::most_events) [[unlikely]] {
         if (should_filter_event(is_dispatch, opcode)) {
             return;
         }
@@ -402,7 +402,7 @@ void Vst2Logger::log_event(
                 overload{
                     [](const auto&) {},
                     [&](const DynamicSpeakerArrangement& speaker_arrangement) {
-                        message << "<" << speaker_arrangement.speakers.size()
+                        message << "<" << speaker_arrangement.speakers_.size()
                                 << " input_speakers>, ";
                     }},
                 *value_payload);
@@ -428,16 +428,16 @@ void Vst2Logger::log_event(
                 },
                 [&](const AEffect&) { message << "nullptr"; },
                 [&](const DynamicVstEvents& events) {
-                    message << "<" << events.events.size() << " midi_events";
-                    if (!events.sysex_data.empty()) {
-                        message << ", including " << events.sysex_data.size()
+                    message << "<" << events.events_.size() << " midi_events";
+                    if (!events.sysex_data_.empty()) {
+                        message << ", including " << events.sysex_data_.size()
                                 << " sysex_events>";
                     } else {
                         message << ">";
                     }
                 },
                 [&](const DynamicSpeakerArrangement& speaker_arrangement) {
-                    message << "<" << speaker_arrangement.speakers.size()
+                    message << "<" << speaker_arrangement.speakers_.size()
                             << " output_speakers>";
                 },
                 [&](const VstIOProperties&) { message << "<io_properties>"; },
@@ -469,7 +469,7 @@ void Vst2Logger::log_event_response(
     const Vst2EventResult::Payload& payload,
     const std::optional<Vst2EventResult::Payload>& value_payload,
     bool from_cache) {
-    if (logger.verbosity >= Logger::Verbosity::most_events) [[unlikely]] {
+    if (logger_.verbosity_ >= Logger::Verbosity::most_events) [[unlikely]] {
         if (should_filter_event(is_dispatch, opcode)) {
             return;
         }
@@ -490,7 +490,7 @@ void Vst2Logger::log_event_response(
                 overload{
                     [](const auto&) {},
                     [&](const DynamicSpeakerArrangement& speaker_arrangement) {
-                        message << ", <" << speaker_arrangement.speakers.size()
+                        message << ", <" << speaker_arrangement.speakers_.size()
                                 << " input_speakers>";
                     }},
                 *value_payload);
@@ -518,7 +518,7 @@ void Vst2Logger::log_event_response(
                             << " bytes>";
                 },
                 [&](const DynamicSpeakerArrangement& speaker_arrangement) {
-                    message << ", <" << speaker_arrangement.speakers.size()
+                    message << ", <" << speaker_arrangement.speakers_.size()
                             << " output_speakers>";
                 },
                 [&](const VstIOProperties&) { message << ", <io_properties>"; },
@@ -550,7 +550,7 @@ void Vst2Logger::log_event_response(
 
 bool Vst2Logger::should_filter_event(bool is_dispatch,
                                      int opcode) const noexcept {
-    if (logger.verbosity >= Logger::Verbosity::all_events) {
+    if (logger_.verbosity_ >= Logger::Verbosity::all_events) {
         return false;
     }
 

src/common/logging/vst2.h

@@ -44,7 +44,7 @@ class Vst2Logger {
     /**
      * @see Logger::log
      */
-    inline void log(const std::string& message) { logger.log(message); }
+    inline void log(const std::string& message) { logger_.log(message); }
 
     // The following functions are for logging specific events, they are only
     // enabled for verbosity levels higher than 1 (i.e. `Verbosity::events`)
@@ -75,13 +75,13 @@ class Vst2Logger {
      */
     template <invocable_returning<std::string> F>
     inline void log_trace(F&& fn) {
-        logger.log_trace(std::forward<F>(fn));
+        logger_.log_trace(std::forward<F>(fn));
     }
 
     /**
      * The underlying logger instance we're wrapping.
      */
-    Logger& logger;
+    Logger& logger_;
 
    private:
     /**

src/common/logging/vst3.cpp

@@ -29,10 +29,10 @@
 std::string format_bstream(const YaBStream& stream) {
     std::ostringstream formatted;
     formatted << "<IBStream* ";
-    if (stream.supports_stream_attributes && stream.attributes) {
+    if (stream.supports_stream_attributes_ && stream.attributes_) {
         formatted << "with meta data [";
         for (bool first = true;
-             const auto& key_type : stream.attributes->keys_and_types()) {
+             const auto& key_type : stream.attributes_->keys_and_types()) {
             if (!first) {
                 formatted << ", ";
             }
@@ -42,27 +42,27 @@ std::string format_bstream(const YaBStream& stream) {
         }
         formatted << "] ";
     }
-    if (stream.file_name) {
-        formatted << "for \"" << VST3::StringConvert::convert(*stream.file_name)
-                  << "\" ";
+    if (stream.file_name_) {
+        formatted << "for \""
+                  << VST3::StringConvert::convert(*stream.file_name_) << "\" ";
     }
     formatted << "containing " << stream.size() << " bytes>";
 
     return formatted.str();
 }
 
-Vst3Logger::Vst3Logger(Logger& generic_logger) : logger(generic_logger) {}
+Vst3Logger::Vst3Logger(Logger& generic_logger) : logger_(generic_logger) {}
 
 void Vst3Logger::log_query_interface(
     const char* where,
     tresult result,
     const std::optional<Steinberg::FUID>& uid) {
-    if (logger.verbosity >= Logger::Verbosity::all_events) [[unlikely]] {
+    if (logger_.verbosity_ >= Logger::Verbosity::all_events) [[unlikely]] {
         std::ostringstream message;
         std::string uid_string = uid ? format_uid(*uid) : "<unknown_pointer>";
 
         if (result == Steinberg::kResultOk) {
-            if (logger.verbosity >= Logger::Verbosity::most_events) {
+            if (logger_.verbosity_ >= Logger::Verbosity::most_events) {
                 message << "[query interface] " << where << ": " << uid_string;
                 log(message.str());
             }
@@ -518,7 +518,7 @@ bool Vst3Logger::log_request(
                    "busIndex = "
                 << request.bus_index << ", channel = " << request.channel
                 << ", list = ";
-        for (bool first = true; const auto& mapping : request.list.maps) {
+        for (bool first = true; const auto& mapping : request.list.maps_) {
             if (!first) {
                 message << ", ";
             }
@@ -1012,7 +1012,7 @@ bool Vst3Logger::log_request(
             std::ostringstream num_input_channels;
             num_input_channels << "[";
             for (bool is_first = true;
-                 const auto& buffers : request.data.inputs) {
+                 const auto& buffers : request.data.inputs_) {
                 num_input_channels << (is_first ? "" : ", ")
                                    << buffers.numChannels;
                 if (buffers.silenceFlags > 0 &&
@@ -1029,7 +1029,7 @@ bool Vst3Logger::log_request(
             std::ostringstream num_output_channels;
             num_output_channels << "[";
             for (bool is_first = true;
-                 const auto& buffers : request.data.outputs) {
+                 const auto& buffers : request.data.outputs_) {
                 num_output_channels << (is_first ? "" : ", ")
                                     << buffers.numChannels;
                 if (buffers.silenceFlags > 0 &&
@@ -1048,30 +1048,30 @@ bool Vst3Logger::log_request(
                        "input_channels = "
                     << num_input_channels.str()
                     << ", output_channels = " << num_output_channels.str()
-                    << ", num_samples = " << request.data.num_samples
+                    << ", num_samples = " << request.data.num_samples_
                     << ", input_parameter_changes = <IParameterChanges* for "
-                    << request.data.input_parameter_changes.num_parameters()
+                    << request.data.input_parameter_changes_.num_parameters()
                     << " parameters>, output_parameter_changes = "
-                    << (request.data.output_parameter_changes
+                    << (request.data.output_parameter_changes_
                             ? "<IParameterChanges*>"
                             : "nullptr")
                     << ", input_events = ";
-            if (request.data.input_events) {
+            if (request.data.input_events_) {
                 message << "<IEventList* with "
-                        << request.data.input_events->num_events()
+                        << request.data.input_events_->num_events()
                         << " events>";
             } else {
                 message << "<nullptr>";
             }
             message << ", output_events = "
-                    << (request.data.output_events ? "<IEventList*>"
-                                                   : "<nullptr>")
+                    << (request.data.output_events_ ? "<IEventList*>"
+                                                    : "<nullptr>")
                     << ", process_context = "
-                    << (request.data.process_context ? "<ProcessContext*>"
-                                                     : "<nullptr>")
-                    << ", process_mode = " << request.data.process_mode
+                    << (request.data.process_context_ ? "<ProcessContext*>"
+                                                      : "<nullptr>")
+                    << ", process_mode = " << request.data.process_mode_
                     << ", symbolic_sample_size = "
-                    << request.data.symbolic_sample_size << ">)";
+                    << request.data.symbolic_sample_size_ << ">)";
         });
 }
 
@@ -1607,7 +1607,7 @@ void Vst3Logger::log_response(
         message << response.result.string();
         if (response.result == Steinberg::kResultOk) {
             message << ", [";
-            for (bool first = true; const auto& mapping : response.list.maps) {
+            for (bool first = true; const auto& mapping : response.list.maps_) {
                 if (!first) {
                     message << ", ";
                 }

src/common/logging/vst3.h

@@ -35,7 +35,7 @@ class Vst3Logger {
     /**
      * @see Logger::log
      */
-    inline void log(const std::string& message) { logger.log(message); }
+    inline void log(const std::string& message) { logger_.log(message); }
 
     /**
      * Log calls to `FUnknown::queryInterface`. This will separately log about
@@ -350,10 +350,10 @@ class Vst3Logger {
      */
     template <invocable_returning<std::string> F>
     inline void log_trace(F&& fn) {
-        logger.log_trace(std::forward<F>(fn));
+        logger_.log_trace(std::forward<F>(fn));
     }
 
-    Logger& logger;
+    Logger& logger_;
 
    private:
     /**
@@ -367,7 +367,7 @@ class Vst3Logger {
     bool log_request_base(bool is_host_vst,
                           Logger::Verbosity min_verbosity,
                           F callback) {
-        if (logger.verbosity >= min_verbosity) [[unlikely]] {
+        if (logger_.verbosity_ >= min_verbosity) [[unlikely]] {
             std::ostringstream message;
             if (is_host_vst) {
                 message << "[host -> vst] >> ";