chore: linter and build fixes (#146)

## This PR
Moves all linter fixes from PR #139 here.

---------

Signed-off-by: NeaguGeorgiana23 <neagugeorgiana@google.com>

Author: NeaguGeorgiana23

README.md

@@ -122,21 +122,21 @@ openfeature::OpenFeatureAPI& api = openfeature::OpenFeatureAPI::GetInstance();
 // Set a global evaluation context
 openfeature::EvaluationContext global_ctx = openfeature::EvaluationContext::Builder()
     .WithAttribute("region", "us-east-1")
-    .build();
+    .Build();
 api.SetEvaluationContext(global_ctx);
 
 // Set a client-level evaluation context
 std::shared_ptr<openfeature::Client> client = api.GetClient();
 openfeature::EvaluationContext client_ctx = openfeature::EvaluationContext::Builder()
     .WithAttribute("app_version", "1.0.5")
-    .build();
+    .Build();
 client->SetEvaluationContext(client_ctx);
 
 // Provide an invocation-level evaluation context
 openfeature::EvaluationContext req_ctx = openfeature::EvaluationContext::Builder()
     .WithTargetingKey("session-id-12345")
     .WithAttribute("email", "user@example.com")
-    .build();
+    .Build();
 
 bool flag_value = client->GetBooleanValue("some-flag", false, req_ctx);
 ```

openfeature/client_api.cpp

@@ -12,7 +12,7 @@ namespace openfeature {
 ClientAPI::ClientAPI(ProviderRepository& repository, std::string_view domain)
     : provider_repository_(repository),
       domain_(domain),
-      evaluation_context_(EvaluationContext::Builder().build()) {}
+      evaluation_context_(EvaluationContext::Builder().Build()) {}
 
 Metadata ClientAPI::GetMetadata() { return Metadata{domain_}; }
 

openfeature/evaluation_context.cpp

@@ -15,9 +15,9 @@ std::optional<std::string_view> EvaluationContext::GetTargetingKey() const {
 }
 
 const std::any* EvaluationContext::GetValue(std::string_view key) const {
-  auto it = attributes_.find(std::string(key));
-  if (it != attributes_.end()) {
-    return &it->second;
+  auto iterator = attributes_.find(std::string(key));
+  if (iterator != attributes_.end()) {
+    return &iterator->second;
   }
   return nullptr;
 }
@@ -56,7 +56,7 @@ EvaluationContext EvaluationContext::Merge(
     }
   }
 
-  return builder.build();
+  return builder.Build();
 }
 
 EvaluationContext::Builder& EvaluationContext::Builder::WithTargetingKey(
@@ -76,8 +76,8 @@ EvaluationContext::Builder& EvaluationContext::Builder::WithAttribute(
   return this->WithAttribute(std::move(key), std::string(value));
 }
 
-EvaluationContext EvaluationContext::Builder::build() const {
-  return EvaluationContext(targeting_key_, attributes_);
+EvaluationContext EvaluationContext::Builder::Build() const {
+  return {targeting_key_, attributes_};
 }
 
 }  // namespace openfeature

openfeature/evaluation_context.h

@@ -50,8 +50,8 @@ class EvaluationContext::Builder {
   // Overload for const char* to ensure implicit conversion to std::string
   Builder& WithAttribute(std::string key, const char* value);
 
-  // The build() method creates the final, immutable EvaluationContext object.
-  EvaluationContext build() const;
+  // The Build() method creates the final, immutable EvaluationContext object.
+  EvaluationContext Build() const;
 
  private:
   std::optional<std::string> targeting_key_;

openfeature/global_context_manager.cpp

@@ -7,7 +7,7 @@
 namespace openfeature {
 
 GlobalContextManager::GlobalContextManager()
-    : global_evaluation_context_(EvaluationContext::Builder().build()) {}
+    : global_evaluation_context_(EvaluationContext::Builder().Build()) {}
 
 GlobalContextManager& GlobalContextManager::GetInstance() {
   static absl::NoDestructor<GlobalContextManager> instance;

openfeature/value.cpp

@@ -15,8 +15,8 @@ Value::Value(double value) : inner_value_(value) {}
 
 Value::Value(std::string value) : inner_value_(std::move(value)) {}
 
-Value::Value(const char* value) : inner_value_() {
-  if (value) {
+Value::Value(const char* value) {
+  if (value != nullptr) {
     inner_value_ = std::string(value);
   }
 }
@@ -32,12 +32,12 @@ Value::Value(std::chrono::system_clock::time_point value)
 
 Value::Value(const Value& other) {
   if (other.IsStructure()) {
-    auto& ptr = std::get<std::unique_ptr<std::map<std::string, Value>>>(
+    const auto& ptr = std::get<std::unique_ptr<std::map<std::string, Value>>>(
         other.inner_value_);
     inner_value_ = ptr ? std::make_unique<std::map<std::string, Value>>(*ptr)
                        : std::unique_ptr<std::map<std::string, Value>>(nullptr);
   } else if (other.IsList()) {
-    auto& ptr =
+    const auto& ptr =
         std::get<std::unique_ptr<std::vector<Value>>>(other.inner_value_);
     inner_value_ = ptr ? std::make_unique<std::vector<Value>>(*ptr)
                        : std::unique_ptr<std::vector<Value>>(nullptr);
@@ -57,7 +57,9 @@ Value::Value(const Value& other) {
 }
 
 Value& Value::operator=(const Value& other) {
-  if (this == &other) return *this;
+  if (this == &other) {
+    return *this;
+  }
   Value temp(other);
   std::swap(this->inner_value_, temp.inner_value_);
   return *this;
@@ -90,76 +92,98 @@ bool Value::IsDateTime() const {
 }
 
 std::optional<bool> Value::AsBool() const {
-  if (auto* v = std::get_if<bool>(&inner_value_)) return *v;
+  if (const auto* val = std::get_if<bool>(&inner_value_)) {
+    return *val;
+  }
   return std::nullopt;
 }
 
 std::optional<std::string> Value::AsString() const {
-  if (auto* v = std::get_if<std::string>(&inner_value_)) return *v;
+  if (const auto* val = std::get_if<std::string>(&inner_value_)) {
+    return *val;
+  }
   return std::nullopt;
 }
 
 std::optional<int64_t> Value::AsInt() const {
-  if (auto* v = std::get_if<int64_t>(&inner_value_)) return *v;
-  if (auto* v = std::get_if<double>(&inner_value_))
-    return static_cast<int64_t>(std::floor(*v + 0.5));
+  if (const auto* val = std::get_if<int64_t>(&inner_value_)) {
+    return *val;
+  }
+  if (const auto* val = std::get_if<double>(&inner_value_)) {
+    constexpr double kRoundingOffset = 0.5;
+    return static_cast<int64_t>(std::floor(*val + kRoundingOffset));
+  }
   return std::nullopt;
 }
 
 std::optional<double> Value::AsDouble() const {
-  if (auto* v = std::get_if<double>(&inner_value_)) return *v;
-  if (auto* v = std::get_if<int64_t>(&inner_value_))
-    return static_cast<double>(*v);
+  if (const auto* val = std::get_if<double>(&inner_value_)) {
+    return *val;
+  }
+  if (const auto* val = std::get_if<int64_t>(&inner_value_)) {
+    return static_cast<double>(*val);
+  }
   return std::nullopt;
 }
 
 std::optional<std::chrono::system_clock::time_point> Value::AsDateTime() const {
-  if (auto* v =
-          std::get_if<std::chrono::system_clock::time_point>(&inner_value_))
-    return *v;
+  if (const auto* val =
+          std::get_if<std::chrono::system_clock::time_point>(&inner_value_)) {
+    return *val;
+  }
   return std::nullopt;
 }
 
 const std::map<std::string, Value>* Value::AsStructure() const {
-  if (auto* v = std::get_if<std::unique_ptr<std::map<std::string, Value>>>(
-          &inner_value_)) {
-    return v->get();
+  if (const auto* val =
+          std::get_if<std::unique_ptr<std::map<std::string, Value>>>(
+              &inner_value_)) {
+    return val->get();
   }
   return nullptr;
 }
 
 const std::vector<Value>* Value::AsList() const {
-  if (auto* v =
+  if (const auto* val =
           std::get_if<std::unique_ptr<std::vector<Value>>>(&inner_value_)) {
-    return v->get();
+    return val->get();
   }
   return nullptr;
 }
 
 bool operator==(const Value& lhs, const Value& rhs) {
-  if (lhs.IsBool() && rhs.IsBool()) return lhs.AsBool() == rhs.AsBool();
+  if (lhs.IsBool() && rhs.IsBool()) {
+    return lhs.AsBool() == rhs.AsBool();
+  }
 
-  if (lhs.IsString() && rhs.IsString()) return lhs.AsString() == rhs.AsString();
+  if (lhs.IsString() && rhs.IsString()) {
+    return lhs.AsString() == rhs.AsString();
+  }
 
-  if (lhs.IsNumber() && rhs.IsNumber()) return lhs.AsDouble() == rhs.AsDouble();
+  if (lhs.IsNumber() && rhs.IsNumber()) {
+    return lhs.AsDouble() == rhs.AsDouble();
+  }
 
-  if (lhs.IsNull() && rhs.IsNull()) return true;
+  if (lhs.IsNull() && rhs.IsNull()) {
+    return true;
+  }
 
-  if (lhs.IsDateTime() && rhs.IsDateTime())
+  if (lhs.IsDateTime() && rhs.IsDateTime()) {
     return lhs.AsDateTime() == rhs.AsDateTime();
+  }
 
   if (lhs.IsStructure() && rhs.IsStructure()) {
     const auto* lhs_struct = lhs.AsStructure();
     const auto* rhs_struct = rhs.AsStructure();
-    if (lhs_struct && rhs_struct) {
+    if (lhs_struct != nullptr && rhs_struct != nullptr) {
       return *lhs_struct == *rhs_struct;
     }
     return lhs_struct == rhs_struct;
   }
   if (lhs.IsList() && rhs.IsList()) {
     const auto* lhs_list = lhs.AsList();
     const auto* rhs_list = rhs.AsList();
-    if (lhs_list && rhs_list) {
+    if (lhs_list != nullptr && rhs_list != nullptr) {
       return *lhs_list == *rhs_list;
     }
     return lhs_list == rhs_list;
@@ -170,4 +194,4 @@ bool operator==(const Value& lhs, const Value& rhs) {
 
 bool operator!=(const Value& lhs, const Value& rhs) { return !(lhs == rhs); }
 
-}  // namespace openfeature
+}  // namespace openfeature

openfeature/value.h

@@ -17,15 +17,15 @@ namespace openfeature {
 class Value {
  public:
   Value();
-  Value(bool value);
-  Value(int64_t value);
-  Value(int value);
-  Value(double value);
-  Value(std::string value);
-  Value(const char* value);
-  Value(const std::map<std::string, Value>& value);
-  Value(const std::vector<Value>& value);
-  Value(std::chrono::system_clock::time_point value);
+  explicit Value(bool value);
+  explicit Value(int64_t value);
+  explicit Value(int value);
+  explicit Value(double value);
+  explicit Value(std::string value);
+  explicit Value(const char* value);
+  explicit Value(const std::map<std::string, Value>& value);
+  explicit Value(const std::vector<Value>& value);
+  explicit Value(std::chrono::system_clock::time_point value);
 
   Value(const Value& other);
   Value& operator=(const Value& other);