note about c++20

Author: d-led

.github/workflows/ci.yml

@@ -44,6 +44,10 @@ jobs:
     - name: Run tests
       run: |
         ./scripts/test.sh
+    
+    - name: Run demo
+      run: |
+        ./scripts/run-demo.sh
         
     - name: Stop InfluxDB
       if: always()
@@ -157,6 +161,10 @@ jobs:
       run: |
         ./scripts/test.sh
     
+    - name: Run demo
+      run: |
+        ./scripts/run-demo.sh
+    
     - name: Stop InfluxDB
       if: always()
       run: |
@@ -215,6 +223,10 @@ jobs:
     - name: Run tests
       run: |
         scripts\test.bat
+    
+    - name: Run demo
+      run: |
+        scripts\run-demo.bat
         
     - name: Stop InfluxDB
       if: always()

README.md

@@ -4,9 +4,21 @@
 
 A modern C++20 [InfluxDB](https://www.influxdata.com/time-series-platform/influxdb/) client via [C++ REST SDK](https://github.com/Microsoft/cpprestsdk) + a C wrapper of the asynchronous API as a shared library.
 
+## C++ Standard Requirements
+
+**This project requires C++20 or later.**
+
+- Minimum compiler versions:
+  - GCC 11+
+  - Clang 14+
+  - MSVC 2019+ (19.29+) with `/std:c++20` or later
+- The project uses C++20
+- All dependencies are C++20 compatible
+- **Note:** The legacy C++03 version is available in the [`v0.0.1-legacy`](https://github.com/d-led/influxdb-cpp-rest/releases/tag/v0.0.1-legacy) tag
+
 See [the demo source](src/demo/main.cpp) for the current api example.
 
-The unbatched aprroach (and without connection reuse) may not be sufficient in some situations, as without batching, about 200 lines/sec can be inserted.
+The unbatched approach (and without connection reuse) may not be sufficient in some situations, as without batching, about 200 lines/sec can be inserted.
 
 A batching api leans towards thousands inserts per second. Behind the scenes, the API uses [RxCpp](https://github.com/Reactive-Extensions/RxCpp) and [cppformat](https://github.com/fmtlib/fmt).
 
@@ -19,25 +31,35 @@ A batching api leans towards thousands inserts per second. Behind the scenes, th
 ## Synchronous insertion
 
 ```cpp
-influxdb::api::simple_db simpledb("http://localhost:8086", "my_db");
+using namespace influxdb::api;
+using namespace std::string_literals;
+
+auto db = simple_db("http://localhost:8086"s, "my_db"s);
 db.insert(
-	line("log", key_value_pairs("my_tag", 42L), key_value_pairs("value", "hello world!")));
+    line("log"s, 
+         key_value_pairs("my_tag"s, 42L), 
+         key_value_pairs("value"s, "hello world!"s)));
 ```
 
 ## Asynchronous insertion
 
 The asynchronous API inserts the points on an active object with automatic batching, thus increasing throughput.
 
 ```cpp
-influxdb::async_api::simple_db asyncdb("http://localhost:8086", "my_db");
-
-for (int i = 0; i < 123456; i++) {
-  asyncdb.insert(
-    line(
-      "my_measurements",
-      key_value_pairs("my_count", i % MAX_VALUES_PER_TAG),
-      key_value_pairs("value", "hi!")
-    ));
+using namespace influxdb::api;  // For line, key_value_pairs
+using namespace std::string_literals;
+using async_db = influxdb::async_api::simple_db;  // Type alias to avoid ambiguity
+
+auto db = async_db("http://localhost:8086"s, "my_db"s);
+
+for (auto i = 0; i < 123456; ++i) {
+    db.insert(
+        line(
+            "my_measurements"s,
+            key_value_pairs("my_count"s, i % MAX_VALUES_PER_TAG),
+            key_value_pairs("value"s, "hi!"s)
+        )
+    );
 }
 ```
 
@@ -51,13 +73,15 @@ Timestamps can be added as the last parameter to the `line` constructor, and onl
 a serializable value on `TTimestamp::now()`. There is a default `std::chrono`-based implementation:
 
 ```cpp
-    line(
-      "my_measurements",
-      key_value_pairs("my_count", i % MAX_VALUES_PER_TAG),
-      key_value_pairs("value", "hi!"),
-      default_timestamp()
-//    ^^^^^^^^^^^^^^^^^^^
-    )
+using namespace influxdb::api;
+using namespace std::string_literals;
+
+line(
+    "my_measurements"s,
+    key_value_pairs("my_count"s, 42),
+    key_value_pairs("value"s, "hi!"s),
+    default_timestamp()  // Optional: uses std::chrono for timestamps
+)
 ```
 
 `MAX_VALUES_PER_TAG` for demo purposes here, as there [is such a maximum](https://docs.influxdata.com/influxdb/v1.4/administration/config#max-values-per-tag-100000) and it has to be observed by the clients.
@@ -67,17 +91,23 @@ a serializable value on `TTimestamp::now()`. There is a default `std::chrono`-ba
 Add lines using the `()` operator on the line:
 
 ```cpp
-  line
-    ("multiple", key_value_pairs("v1", 1), key_value_pairs())
-    ("multiple", key_value_pairs("v2", 2), key_value_pairs())
+using namespace influxdb::api;
+using namespace std::string_literals;
+
+line
+    ("multiple"s, key_value_pairs("v1"s, 1), key_value_pairs())
+    ("multiple"s, key_value_pairs("v2"s, 2), key_value_pairs())
 ```
 
 ## Query
 
 ```cpp
-influxdb::raw::db_utf8 raw_db("http://localhost:8086", "my_db");
-auto query = std::string("select count(*) from my_db..my_measurements");
-auto json_response = raw_db.get(query);
+using namespace influxdb::raw;
+using namespace std::string_literals;
+
+auto db = db_utf8("http://localhost:8086"s, "my_db"s);
+auto query = "select count(*) from my_db..my_measurements"s;
+auto json_response = db.get(query);
 ```
 
 &darr;
@@ -88,12 +118,15 @@ auto json_response = raw_db.get(query);
 
 ## Authentication
 
-Basic authentication can be used with all API variants
+Basic authentication can be used with all API variants:
 
 ```cpp
-influxdb::raw::db_utf8 raw_db("http://localhost:8086", "my_db");
-raw_db.with_authentication(username, password);
-auto query = ...
+using namespace influxdb::raw;
+using namespace std::string_literals;
+
+auto db = db_utf8("http://localhost:8086"s, "my_db"s);
+db.with_authentication("username"s, "password"s);
+auto response = db.get("select * from my_measurements");
 ```
 
 ## Error Handling

scripts/run-demo.bat

@@ -0,0 +1,34 @@
+@echo off
+setlocal enabledelayedexpansion
+
+set BUILD_DIR=%BUILD_DIR%
+if "%BUILD_DIR%"=="" set BUILD_DIR=build
+
+set BUILD_TYPE=%BUILD_TYPE%
+if "%BUILD_TYPE%"=="" set BUILD_TYPE=Release
+
+set BIN_DIR=%BUILD_DIR%\bin\%BUILD_TYPE%
+set BIN_DIR_ALT=%BUILD_DIR%\bin
+
+REM Build if not already built
+if not exist "%BIN_DIR%\demo.exe" if not exist "%BIN_DIR_ALT%\demo.exe" (
+    echo Building demo...
+    scripts\build.bat %BUILD_TYPE%
+)
+
+REM Find and run the demo
+if exist "%BIN_DIR%\demo.exe" (
+    echo Running %BIN_DIR%\demo.exe...
+    "%BIN_DIR%\demo.exe"
+    exit /b %errorlevel%
+)
+
+if exist "%BIN_DIR_ALT%\demo.exe" (
+    echo Running %BIN_DIR_ALT%\demo.exe...
+    "%BIN_DIR_ALT%\demo.exe"
+    exit /b %errorlevel%
+)
+
+echo ERROR: Demo executable not found. Build it first with: scripts\build.bat
+exit /b 1
+

scripts/run-demo.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+BUILD_DIR="${BUILD_DIR:-build}"
+BUILD_TYPE="${BUILD_TYPE:-Release}"
+
+# Build if not already built
+if [ ! -f "${BUILD_DIR}/bin/demo" ] && [ ! -f "${BUILD_DIR}/bin/${BUILD_TYPE}/demo" ] && [ ! -f "${BUILD_DIR}/${BUILD_TYPE}/bin/demo" ]; then
+    echo "Building demo..."
+    ./scripts/build.sh "${BUILD_TYPE}"
+fi
+
+# Find and run the demo
+for demo_path in "${BUILD_DIR}/bin/demo" "${BUILD_DIR}/bin/${BUILD_TYPE}/demo" "${BUILD_DIR}/${BUILD_TYPE}/bin/demo" "${BUILD_DIR}/demo"; do
+    if [ -f "${demo_path}" ] && [ -x "${demo_path}" ]; then
+        echo "Running ${demo_path}..."
+        "${demo_path}"
+        exit 0
+    fi
+done
+
+echo "ERROR: Demo executable not found. Build it first with: ./scripts/build.sh"
+exit 1
+

src/demo/main.cpp

@@ -8,31 +8,37 @@
 #include <iostream>
 #include <thread>
 #include <chrono>
+#include <string>
 
 using namespace influxdb::api;
+using namespace influxdb::raw;
+using namespace std::string_literals;
 
-int main(int argc, char* argv[])
+using async_db = influxdb::async_api::simple_db;
+
+int main(int, char**)
 {
-    try
-    {
-        const char* url = "http://localhost:8086";
-        influxdb::raw::db_utf8 db(url, "demo");
-        influxdb::api::simple_db api(url, "demo");
-        influxdb::async_api::simple_db async_api(url, "demo");
+    try {
+        const auto url = "http://localhost:8086"s;
+        const auto db_name = "demo"s;
+
+        auto db = db_utf8(url, db_name);
+        auto api = simple_db(url, db_name);
+        auto async_api = async_db(url, db_name);
 
         api.drop();
         api.create();
 
         // {"results":[{"series":[{"columns":["name"],"name":"databases","values":[["_internal"],["mydb"]]}]}]}
-        std::cout << db.get("show databases") << std::endl;
+        std::cout << db.get("show databases"s) << '\n';
 
-        async_api.insert(line("test", key_value_pairs(), key_value_pairs("value", 41)));
-        api.insert(line("test", key_value_pairs(), key_value_pairs("value", 42)));
+        async_api.insert(line("test"s, key_value_pairs(), key_value_pairs("value"s, 41)));
+        api.insert(line("test"s, key_value_pairs(), key_value_pairs("value"s, 42)));
 
         std::this_thread::sleep_for(std::chrono::milliseconds(101));
 
         // {"results":[{"series":[{"columns":["time","value"],"name":"test","values":[["2016-10-28T22:11:22.8110348Z",42]]}]}]}
-        std::cout << db.get("select * from demo..test") << std::endl;
+        std::cout << db.get("select * from demo..test"s) << '\n';
 
         // or if the async call passes through:
         // {"results":[{"series":[{"name":"test","columns":["time","value"],
@@ -44,13 +50,13 @@ int main(int argc, char* argv[])
         // multiple,v1=1i
         // multiple,v2=2i
         std::cout << line
-            ("multiple", key_value_pairs("v1", 1), key_value_pairs())
-            ("multiple", key_value_pairs("v2", 2), key_value_pairs())
-        .get() << std::endl;
+            ("multiple"s, key_value_pairs("v1"s, 1), key_value_pairs())
+            ("multiple"s, key_value_pairs("v2"s, 2), key_value_pairs())
+        .get() << '\n';
     }
-    catch (std::exception const& e)
-    {
-        std::cerr << e.what() << std::endl;
+    catch (const std::exception& e) {
+        std::cerr << e.what() << '\n';
+        return 1;
     }
 
     return 0;