Rename many things.

Author: kinyoklion

CONTRIBUTING.md

@@ -34,6 +34,16 @@ class BarBaz;
 DoTheFoo();
 Bar();
 ```
+
+**Methods**
+```c++
+struct Thing {
+    uint64_t Size(); // Getter
+    void DoTheFoo();
+};
+
+```
+
 **Constants**
 ```c++
 const int kFooBarBaz = 1;
@@ -58,6 +68,19 @@ In C++:
 file_name.cpp
 file_name.hpp
 ```
+
+**Divergence: getters**
+
+```c++
+struct Thing {
+    // Good
+    uint64_t Size();
+
+    //Bad
+    uint64_t size();
+};
+```
+
 ### C++ Standard
 
 C++17.

libs/client-sdk/include/launchdarkly/client_side/data_source_update_sink.hpp

@@ -20,7 +20,7 @@ struct ItemDescriptor {
     uint64_t version;
 
     /**
-     * The data item, or nullopt if this is a deleted item placeholder.
+     * The data item, or nullopt if this is a Deleted item placeholder.
      */
     std::optional<EvaluationResult> flag;
 
@@ -43,8 +43,8 @@ struct ItemDescriptor {
  */
 class IDataSourceUpdateSink {
    public:
-    virtual void init(std::unordered_map<std::string, ItemDescriptor> data) = 0;
-    virtual void upsert(std::string key, ItemDescriptor) = 0;
+    virtual void Init(std::unordered_map<std::string, ItemDescriptor> data) = 0;
+    virtual void Upsert(std::string key, ItemDescriptor item) = 0;
 
     // We could add this if we want to support data source status.
     // virtual void status(<something>)

libs/client-sdk/include/launchdarkly/client_side/flag_manager/detail/flag_change_event.hpp

@@ -14,37 +14,37 @@ class FlagValueChangeEvent {
      * The name of the flag that changed.
      * @return The name of the flag.
      */
-    [[nodiscard]] std::string const& flag_name() const;
+    [[nodiscard]] std::string const& FlagName() const;
 
     /**
      * Get the new value. If there was not an new value, because the flag was
-     * deleted, then the Value will be of a null type. Check the deleted method
+     * deleted, then the Value will be of a null type. Check the Deleted method
      * to see if a flag was deleted.
      *
      * @return The new value.
      */
-    [[nodiscard]] Value const& new_value() const;
+    [[nodiscard]] Value const& NewValue() const;
 
     /**
      * Get the old value. If there was not an old value, for instance a newly
      * created flag, then the Value will be of a null type.
      *
      * @return The new value.
      */
-    [[nodiscard]] Value const& old_value() const;
+    [[nodiscard]] Value const& OldValue() const;
 
     /**
-     * Will be true if the flag was deleted. In which case the new_value will
+     * Will be true if the flag was deleted. In which case the NewValue will
      * be of a null type.
      *
      * @return True if the flag was deleted.
      */
-    [[nodiscard]] bool deleted() const;
+    [[nodiscard]] bool Deleted() const;
 
     /**
      * Construct a flag changed event with a new and old value.
      *
-     * This is a change event for a flag that has not been deleted.
+     * This is a change event for a flag that has not been Deleted.
      *
      * @param new_value The new value.
      * @param old_value The old value.

libs/client-sdk/include/launchdarkly/client_side/flag_manager/detail/flag_manager.hpp

@@ -8,8 +8,8 @@ namespace launchdarkly::client_side::flag_manager::detail {
 
 class FlagManager {
    public:
-    void init(const std::unordered_map<std::string, ItemDescriptor>& data);
-    void upsert(const std::string& key, ItemDescriptor item);
+    void Init(const std::unordered_map<std::string, ItemDescriptor>& data);
+    void Upsert(const std::string& key, ItemDescriptor item);
 
     /**
      * Attempts to get a flag by key from the current flags.
@@ -18,14 +18,14 @@ class FlagManager {
      * @return A shared_ptr to the value if present. A null shared_ptr if the
      * item is not present.
      */
-    std::shared_ptr<ItemDescriptor> get(const std::string& flag_key) const;
+    std::shared_ptr<ItemDescriptor> Get(const std::string& flag_key) const;
 
     /**
      * Gets all the current flags.
      *
      * @return All of the current flags.
      */
-    std::unordered_map<std::string, std::shared_ptr<ItemDescriptor>> get_all()
+    std::unordered_map<std::string, std::shared_ptr<ItemDescriptor>> GetAll()
         const;
 
    private:

libs/client-sdk/include/launchdarkly/client_side/flag_manager/detail/flag_notifier.hpp

@@ -2,8 +2,8 @@
 
 #include <boost/signals2.hpp>
 
-#include "value.hpp"
 #include "launchdarkly/client_side/flag_manager/detail/flag_change_event.hpp"
+#include "value.hpp"
 
 namespace launchdarkly::client_side::flag_manager::detail {
 
@@ -14,7 +14,7 @@ namespace launchdarkly::client_side::flag_manager::detail {
  */
 class IConnection {
    public:
-    virtual void disconnect() = 0;
+    virtual void Disconnect() = 0;
 
     virtual ~IConnection() = default;
     IConnection(IConnection const& item) = delete;
@@ -38,16 +38,17 @@ class IFlagNotifier {
     // can use the same instance, and the lifetime is tied to how the consumer
     // uses the event.
     using ChangeHandler =
-        std::function<void(std::shared_ptr<FlagValueChangeEvent>)> const&;
+        std::function<void(std::shared_ptr<FlagValueChangeEvent>)>;
 
     /**
      * Listen for changes for the specific flag.
      * @param key The flag to listen to changes for.
      * @param signal The handler for the changes.
      * @return A connection which can be used to stop listening.
      */
-    virtual std::unique_ptr<IConnection> flag_change(std::string const& key,
-                                                     ChangeHandler handler) = 0;
+    virtual std::unique_ptr<IConnection> OnFlagChange(
+        std::string const& key,
+        ChangeHandler handler) = 0;
 
     virtual ~IFlagNotifier() = default;
     IFlagNotifier(IFlagNotifier const& item) = delete;

libs/client-sdk/include/launchdarkly/client_side/flag_manager/detail/flag_updater.hpp

@@ -15,8 +15,8 @@ namespace launchdarkly::client_side::flag_manager::detail {
 class FlagUpdater : public IDataSourceUpdateSink, public IFlagNotifier {
    public:
     FlagUpdater(FlagManager& flag_manager);
-    void init(std::unordered_map<std::string, ItemDescriptor> data) override;
-    void upsert(std::string key, ItemDescriptor item) override;
+    void Init(std::unordered_map<std::string, ItemDescriptor> data) override;
+    void Upsert(std::string key, ItemDescriptor item) override;
 
     /**
      * Listen for changes for the specific flag.
@@ -25,23 +25,23 @@ class FlagUpdater : public IDataSourceUpdateSink, public IFlagNotifier {
      * @return A Connection which can be used to stop listening for changes
      * to the flag using this handler.
      */
-    std::unique_ptr<IConnection> flag_change(
+    std::unique_ptr<IConnection> OnFlagChange(
         std::string const& key,
-        std::function<void(std::shared_ptr<FlagValueChangeEvent>)> const&
-            handler) override;
+        std::function<void(std::shared_ptr<FlagValueChangeEvent>)> handler)
+        override;
 
    private:
     class Connection : public IConnection {
        public:
         friend class FlagUpdater;
         Connection(boost::signals2::connection connection);
-        void disconnect() override;
+        void Disconnect() override;
 
        private:
         boost::signals2::connection connection_;
     };
 
-    bool has_listeners() const;
+    bool HasListeners() const;
 
     FlagManager& flag_manager_;
     std::unordered_map<
@@ -54,7 +54,7 @@ class FlagUpdater : public IDataSourceUpdateSink, public IFlagNotifier {
     // the mutex, which is more difficult to keep consistent over the code
     // lifetime.
     mutable std::recursive_mutex signal_mutex_;
-    void dispatch_event(FlagValueChangeEvent event);
+    void DispatchEvent(FlagValueChangeEvent event);
 };
 
 }  // namespace launchdarkly::client_side::flag_manager::detail

libs/client-sdk/src/data_sources/streaming_data_handler.cpp

@@ -108,7 +108,7 @@ StreamingDataHandler::MessageStatus StreamingDataHandler::handle_message(
             parsed);
 
         if (res.has_value()) {
-            handler_->init(res.value());
+            handler_->Init(res.value());
             return StreamingDataHandler::MessageStatus::kMessageHandled;
         }
         LD_LOG(logger_, LogLevel::kError)
@@ -126,7 +126,7 @@ StreamingDataHandler::MessageStatus StreamingDataHandler::handle_message(
         auto res = boost::json::value_to<
             tl::expected<StreamingDataHandler::PatchData, JsonError>>(parsed);
         if (res.has_value()) {
-            handler_->upsert(
+            handler_->Upsert(
                 res.value().key,
                 launchdarkly::client_side::ItemDescriptor(res.value().flag));
             return StreamingDataHandler::MessageStatus::kMessageHandled;
@@ -147,7 +147,7 @@ StreamingDataHandler::MessageStatus StreamingDataHandler::handle_message(
             tl::expected<StreamingDataHandler::DeleteData, JsonError>>(
             boost::json::parse(event.data()));
         if (res.has_value()) {
-            handler_->upsert(res.value().key,
+            handler_->Upsert(res.value().key,
                              ItemDescriptor(res.value().version));
             return StreamingDataHandler::MessageStatus::kMessageHandled;
         }

libs/client-sdk/src/flag_manager/flag_change_event.cpp

@@ -2,19 +2,19 @@
 
 namespace launchdarkly::client_side::flag_manager::detail {
 
-std::string const& FlagValueChangeEvent::flag_name() const {
+std::string const& FlagValueChangeEvent::FlagName() const {
     return flag_name_;
 }
 
-Value const& FlagValueChangeEvent::new_value() const {
+Value const& FlagValueChangeEvent::NewValue() const {
     return new_value_;
 }
 
-Value const& FlagValueChangeEvent::old_value() const {
+Value const& FlagValueChangeEvent::OldValue() const {
     return old_value_;
 }
 
-bool FlagValueChangeEvent::deleted() const {
+bool FlagValueChangeEvent::Deleted() const {
     return deleted_;
 }
 

libs/client-sdk/src/flag_manager/flag_manager.cpp

@@ -7,7 +7,7 @@ namespace launchdarkly::client_side::flag_manager::detail {
 // accessed, and which it is being used init is called, then we want the
 // flag being processed to be valid.
 
-void FlagManager::init(
+void FlagManager::Init(
     std::unordered_map<std::string, ItemDescriptor> const& data) {
     std::lock_guard lock{data_mutex_};
 
@@ -18,13 +18,13 @@ void FlagManager::init(
     }
 }
 
-void FlagManager::upsert(std::string const& key, ItemDescriptor item) {
+void FlagManager::Upsert(std::string const& key, ItemDescriptor item) {
     std::lock_guard lock{data_mutex_};
 
     data_[key] = std::make_shared<ItemDescriptor>(std::move(item));
 }
 
-std::shared_ptr<ItemDescriptor> FlagManager::get(
+std::shared_ptr<ItemDescriptor> FlagManager::Get(
     std::string const& flag_key) const {
     std::lock_guard lock{data_mutex_};
 
@@ -36,7 +36,7 @@ std::shared_ptr<ItemDescriptor> FlagManager::get(
 }
 
 std::unordered_map<std::string, std::shared_ptr<ItemDescriptor>>
-FlagManager::get_all() const {
+FlagManager::GetAll() const {
     std::lock_guard lock{data_mutex_};
 
     // Returns a copy of the map. (The descriptors are pointers and not shared).