refactor: Add conf as default serde

Author: caiopiccirillo

CMakeLists.txt

@@ -14,9 +14,22 @@ include(Coverage)
 copy_compile_commands()
 
 find_package(GTest CONFIG REQUIRED)
-find_package(nlohmann_json CONFIG REQUIRED)
 find_package(absl CONFIG REQUIRED)
 
+# Optional serializer back-ends
+option(CPPFIG_ENABLE_JSON "Enable JSON serializer (requires nlohmann-json)" OFF)
+
+# When building in-tree we always need JSON for the tests & benchmarks.
+# Detect whether nlohmann-json is available and enable automatically.
+find_package(nlohmann_json CONFIG QUIET)
+if(nlohmann_json_FOUND)
+    set(CPPFIG_ENABLE_JSON ON CACHE BOOL "" FORCE)
+    message(STATUS "nlohmann-json found — CPPFIG_ENABLE_JSON=ON")
+else()
+    message(STATUS "nlohmann-json not found — JSON serializer disabled")
+endif()
+# Future: option(CPPFIG_ENABLE_TOML "Enable TOML serializer" OFF)
+
 option(STRICT_BUILD "Enable warnings as errors" ON)
 
 if(STRICT_BUILD)

README.md

@@ -11,12 +11,12 @@ A modern, header-only C++20 configuration library with **compile-time type safet
 - **Compile-time type safety** - All type errors caught at compile time
 - **Zero macros** - Pure C++20 templates and concepts
 - **IDE-friendly** - Full autocompletion: `config.Get<settings::ServerPort>()`
-- **Hierarchical configuration** - Dot-notation paths create nested JSON
+- **Hierarchical configuration** - Dot-notation paths create nested structures
 - **Environment variable overrides** - Production-friendly configuration
 - **Validation** - Built-in validators with custom extensions
 - **Schema migration** - Automatically adds new settings to existing files
 - **Mockable** - GMock-compatible interfaces for unit testing
-- **Pluggable serialization** - JSON default, extensible to YAML/TOML
+- **Pluggable serialization** - Flat `.conf` default, JSON opt-in, extensible to YAML/TOML
 - **Thread-safe** - Opt-in `MultiThreadedPolicy` with reader-writer locking (zero overhead by default)
 
 ## Quick Start
@@ -67,8 +67,8 @@ using MySchema = cppfig::ConfigSchema<
 >;
 
 int main() {
-    // Create configuration manager
-    cppfig::Configuration<MySchema> config("config.json");
+    // Create configuration manager (.conf format by default)
+    cppfig::Configuration<MySchema> config("config.conf");
 
     // Load (creates file with defaults if missing)
     auto status = config.Load();
@@ -94,28 +94,42 @@ int main() {
 }
 ```
 
-### Generated JSON
+### Generated .conf
 
-```json
-{
-    "server": {
-        "port": 8080,
-        "host": "localhost"
-    },
-    "logging": {
-        "level": "info"
-    }
-}
+```conf
+server.port = 8080
+server.host = localhost
+logging.level = info
+```
+
+<details>
+<summary>Using JSON instead?</summary>
+
+```cpp
+#include <cppfig/cppfig.h>
+#include <cppfig/json.h>  // opt-in
+
+cppfig::Configuration<MySchema, cppfig::JsonSerializer> config("config.json");
+```
+
+Enable with `-DCPPFIG_ENABLE_JSON=ON` or vcpkg feature `"json"`.
+See [Serializers](docs/serializers.md) for details.
+</details>
 ```
 
 ## Installation
 
 ### Requirements
 
 - C++20 compiler (GCC 11+, Clang 14+)
-- [nlohmann/json](https://github.com/nlohmann/json)
 - [Abseil](https://github.com/abseil/abseil-cpp) (for `absl::Status`)
 
+### Optional Dependencies
+
+| Dependency | Feature | CMake Option |
+|------------|---------|-------------|
+| [nlohmann/json](https://github.com/nlohmann/json) | JSON serializer | `CPPFIG_ENABLE_JSON` |
+
 ### Header-Only Integration
 
 ```bash
@@ -127,13 +141,30 @@ cp -r cppfig/src/cppfig your_project/include/
 ```cmake
 add_subdirectory(cppfig)
 target_link_libraries(your_target PRIVATE cppfig)
+
+# Optional: enable JSON support
+set(CPPFIG_ENABLE_JSON ON)
 ```
 
 ### vcpkg
 
+Core (`.conf` only, no extra dependencies):
+
 ```bash
-# Dependencies
-vcpkg install nlohmann-json abseil
+vcpkg install abseil
+```
+
+With JSON support:
+
+```json
+{
+    "dependencies": [
+        {
+            "name": "cppfig",
+            "features": ["json"]
+        }
+    ]
+}
 ```
 
 ## Documentation
@@ -156,8 +187,8 @@ By default, `Configuration` uses `SingleThreadedPolicy` (zero overhead). For con
 
 ```cpp
 // Thread-safe configuration:
-cppfig::Configuration<MySchema, cppfig::JsonSerializer, cppfig::MultiThreadedPolicy>
-    config("config.json");
+cppfig::Configuration<MySchema, cppfig::ConfSerializer, cppfig::MultiThreadedPolicy>
+    config("config.conf");
 ```
 
 | Policy | Overhead | Use case |
@@ -221,20 +252,33 @@ cppfig::Min(1).And(cppfig::Max(100))
 ```cpp
 struct Point {
     int x, y;
+};
 
-    friend void to_json(nlohmann::json& j, const Point& p) {
-        j = {{"x", p.x}, {"y", p.y}};
+// Register with cppfig — works with any serializer
+template <>
+struct cppfig::ConfigTraits<Point> {
+    static auto Serialize(const Point& p) -> cppfig::Value {
+        auto obj = cppfig::Value::Object();
+        obj["x"] = cppfig::Value(p.x);
+        obj["y"] = cppfig::Value(p.y);
+        return obj;
     }
-    friend void from_json(const nlohmann::json& j, Point& p) {
-        j.at("x").get_to(p.x);
-        j.at("y").get_to(p.y);
+    static auto Deserialize(const cppfig::Value& v) -> std::optional<Point> {
+        try {
+            return Point{static_cast<int>(v["x"].Get<int64_t>()),
+                         static_cast<int>(v["y"].Get<int64_t>())};
+        } catch (...) {
+            return std::nullopt;
+        }
+    }
+    static auto ToString(const Point& p) -> std::string {
+        return "(" + std::to_string(p.x) + "," + std::to_string(p.y) + ")";
+    }
+    static auto FromString(std::string_view) -> std::optional<Point> {
+        return std::nullopt;
     }
 };
 
-// Register with cppfig
-template <>
-struct cppfig::ConfigTraits<Point> : cppfig::ConfigTraitsFromJsonAdl<Point> {};
-
 // Use in settings
 struct Origin {
     static constexpr std::string_view path = "origin";
@@ -243,6 +287,15 @@ struct Origin {
 };
 ```
 
+If you have the JSON feature enabled and your type already has nlohmann ADL functions, you can use the shortcut:
+
+```cpp
+#include <cppfig/json.h>
+
+template <>
+struct cppfig::ConfigTraits<Point> : cppfig::ConfigTraitsFromJsonAdl<Point> {};
+```
+
 ### Testing
 
 ```cpp
@@ -265,7 +318,7 @@ TEST(MyTest, UsesConfiguration) {
 
 ```cpp
 cppfig::Configuration<Schema,
-                       Serializer = JsonSerializer,
+                       Serializer = ConfSerializer,
                        ThreadPolicy = SingleThreadedPolicy>
 
 // Methods
@@ -280,6 +333,10 @@ auto GetFilePath() const -> std::string_view;
 // Thread policies
 cppfig::SingleThreadedPolicy   // Zero-overhead (default)
 cppfig::MultiThreadedPolicy    // std::shared_mutex reader-writer locking
+
+// Serializers
+cppfig::ConfSerializer         // Built-in flat .conf (default)
+cppfig::JsonSerializer         // Requires CPPFIG_ENABLE_JSON
 ```
 
 ### ConfigSchema
@@ -349,9 +406,12 @@ cppfig/
 │   ├── configuration.h   # Configuration class
 │   ├── schema.h          # ConfigSchema template
 │   ├── setting.h         # Setting concepts
-│   ├── traits.h          # Type traits
+│   ├── traits.h          # Type traits (Serialize/Deserialize)
+│   ├── value.h           # Core Value type
 │   ├── validator.h       # Validators
-│   ├── serializer.h      # Serialization
+│   ├── serializer.h      # Serializer concept
+│   ├── conf.h            # Built-in .conf serializer
+│   ├── json.h            # Optional JSON serializer
 │   ├── interface.h       # Mockable interfaces
 │   ├── diff.h            # Configuration diff
 │   ├── logging.h         # Logging utilities

benchmark/benchmark_main.cpp

@@ -1,5 +1,6 @@
 #include <benchmark/benchmark.h>
 #include <cppfig/cppfig.h>
+#include <cppfig/json.h>
 
 #include <cstdlib>
 #include <filesystem>
@@ -114,7 +115,7 @@ class BenchmarkFixture : public ::benchmark::Fixture {
     {
         std::filesystem::path temp_path = std::filesystem::temp_directory_path() / "cppfig_benchmark";
         temp_path += std::to_string(reinterpret_cast<uintptr_t>(this));
-        temp_path += ".json";
+        temp_path += ".conf";
         return temp_path.string();
     }
 
@@ -457,82 +458,100 @@ BENCHMARK_REGISTER_F(BenchmarkFixture, JsonSerializerParse);
 
 BENCHMARK_DEFINE_F(BenchmarkFixture, JsonSerializerStringify)(benchmark::State& state)
 {
-    nlohmann::json json = { { "benchmark",
-                              { { "string", "test" }, { "int", 42 }, { "double", 3.14159 }, { "bool", true }, { "validated", 50 } } } };
+    auto value = Value::Object();
+    auto benchmark_obj = Value::Object();
+    benchmark_obj["string"] = Value("test");
+    benchmark_obj["int"] = Value(42);
+    benchmark_obj["double"] = Value(3.14159);
+    benchmark_obj["bool"] = Value(true);
+    benchmark_obj["validated"] = Value(50);
+    value["benchmark"] = benchmark_obj;
 
     for (auto _ : state) {
-        auto result = JsonSerializer::Stringify(json);
+        auto result = JsonSerializer::Stringify(value);
         benchmark::DoNotOptimize(result);
     }
 }
 BENCHMARK_REGISTER_F(BenchmarkFixture, JsonSerializerStringify);
 
-BENCHMARK_DEFINE_F(BenchmarkFixture, JsonSerializerGetAtPath)(benchmark::State& state)
+BENCHMARK_DEFINE_F(BenchmarkFixture, ValueGetAtPath)(benchmark::State& state)
 {
-    nlohmann::json json = { { "database", { { "connection", { { "host", "localhost" }, { "port", 5432 } } } } } };
+    auto value = Value::Object();
+    auto database = Value::Object();
+    auto connection = Value::Object();
+    connection["host"] = Value("localhost");
+    connection["port"] = Value(5432);
+    database["connection"] = connection;
+    value["database"] = database;
     std::string path = "database.connection.host";
 
     for (auto _ : state) {
-        auto result = JsonSerializer::GetAtPath(json, path);
+        auto result = value.GetAtPath(path);
         benchmark::DoNotOptimize(result);
     }
 }
-BENCHMARK_REGISTER_F(BenchmarkFixture, JsonSerializerGetAtPath);
+BENCHMARK_REGISTER_F(BenchmarkFixture, ValueGetAtPath);
 
-BENCHMARK_DEFINE_F(BenchmarkFixture, JsonSerializerSetAtPath)(benchmark::State& state)
+BENCHMARK_DEFINE_F(BenchmarkFixture, ValueSetAtPath)(benchmark::State& state)
 {
-    nlohmann::json json = { { "database", { { "connection", { { "host", "localhost" }, { "port", 5432 } } } } } };
+    auto value = Value::Object();
+    auto database = Value::Object();
+    auto connection = Value::Object();
+    connection["host"] = Value("localhost");
+    connection["port"] = Value(5432);
+    database["connection"] = connection;
+    value["database"] = database;
     std::string path = "database.connection.host";
 
     for (auto _ : state) {
-        nlohmann::json json_copy = json;
-        JsonSerializer::SetAtPath(json_copy, path, "example.com");
-        benchmark::DoNotOptimize(json_copy);
+        Value value_copy = value;
+        value_copy.SetAtPath(path, Value("example.com"));
+        benchmark::DoNotOptimize(value_copy);
     }
 }
-BENCHMARK_REGISTER_F(BenchmarkFixture, JsonSerializerSetAtPath);
+BENCHMARK_REGISTER_F(BenchmarkFixture, ValueSetAtPath);
 
-BENCHMARK_DEFINE_F(BenchmarkFixture, TraitsToJsonInt)(benchmark::State& state)
+BENCHMARK_DEFINE_F(BenchmarkFixture, TraitsSerializeInt)(benchmark::State& state)
 {
     for (auto _ : state) {
-        auto json = ConfigTraits<int>::ToJson(42);
-        benchmark::DoNotOptimize(json);
+        auto val = ConfigTraits<int>::Serialize(42);
+        benchmark::DoNotOptimize(val);
     }
 }
-BENCHMARK_REGISTER_F(BenchmarkFixture, TraitsToJsonInt);
+BENCHMARK_REGISTER_F(BenchmarkFixture, TraitsSerializeInt);
 
-BENCHMARK_DEFINE_F(BenchmarkFixture, TraitsFromJsonInt)(benchmark::State& state)
+BENCHMARK_DEFINE_F(BenchmarkFixture, TraitsDeserializeInt)(benchmark::State& state)
 {
-    nlohmann::json json = 42;
+    Value val(42);
 
     for (auto _ : state) {
-        auto value = ConfigTraits<int>::FromJson(json);
-        benchmark::DoNotOptimize(value);
+        auto result = ConfigTraits<int>::Deserialize(val);
+        benchmark::DoNotOptimize(result);
     }
 }
-BENCHMARK_REGISTER_F(BenchmarkFixture, TraitsFromJsonInt);
+BENCHMARK_REGISTER_F(BenchmarkFixture, TraitsDeserializeInt);
 
-BENCHMARK_DEFINE_F(BenchmarkFixture, TraitsToJsonString)(benchmark::State& state)
+BENCHMARK_DEFINE_F(BenchmarkFixture, TraitsSerializeString)(benchmark::State& state)
 {
     std::string value = "benchmark_test_string";
 
     for (auto _ : state) {
-        auto json = ConfigTraits<std::string>::ToJson(value);
-        benchmark::DoNotOptimize(json);
+        auto val = ConfigTraits<std::string>::Serialize(value);
+        benchmark::DoNotOptimize(val);
     }
 }
-BENCHMARK_REGISTER_F(BenchmarkFixture, TraitsToJsonString);
+BENCHMARK_REGISTER_F(BenchmarkFixture, TraitsSerializeString);
 
-BENCHMARK_DEFINE_F(BenchmarkFixture, TraitsFromJsonString)(benchmark::State& state)
+BENCHMARK_DEFINE_F(BenchmarkFixture, TraitsDeserializeString)(benchmark::State& state)
 {
-    nlohmann::json json = "benchmark_test_string";
+    Value val("benchmark_test_string");
 
     for (auto _ : state) {
-        auto value = ConfigTraits<std::string>::FromJson(json);
-        benchmark::DoNotOptimize(value);
+        auto result = ConfigTraits<std::string>::Deserialize(val);
+        benchmark::DoNotOptimize(result);
     }
 }
-BENCHMARK_REGISTER_F(BenchmarkFixture, TraitsFromJsonString);
+BENCHMARK_REGISTER_F(BenchmarkFixture, TraitsDeserializeString);
 
 }  // namespace cppfig::bench