merge develop

Author: liss-h

.github/workflows/code_testing.yaml

@@ -19,8 +19,6 @@ jobs:
           - os: ubuntu-24.04
             compiler: clang-20
 
-          - os: ubuntu-24.04
-            compiler: gcc-13
           - os: ubuntu-24.04
             compiler: gcc-14
     runs-on: ${{ matrix.config.os }}

CMakeLists.txt

@@ -2,11 +2,11 @@ cmake_minimum_required(VERSION 3.24)
 
 project(
   dice-template-library
-  VERSION 1.20.0
+  VERSION 1.21.0
   DESCRIPTION
     "This template library is a collection of template-oriented code that we, the Data Science Group at UPB, found pretty handy. It contains: `switch_cases` (Use runtime values in compile-time context), `integral_template_tuple` (Create a tuple-like structure that instantiates a template for a range of values), `integral_template_variant` (A wrapper type for `std::variant` guarantees to only contain variants of the form `T<IX>` and `for_{types,values,range}` (Compile time for loops for types, values or ranges))."
   HOMEPAGE_URL "https://dice-research.org/")
-set(POBR_VERSION 1)  # Persisted Object Binary Representation
+set(POBR_VERSION 2)  # Persisted Object Binary Representation
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/version.hpp.in ${CMAKE_CURRENT_SOURCE_DIR}/include/dice/template-library/version.hpp)
 
@@ -54,7 +54,7 @@ if (WITH_BOOST)
 endif ()
 
 set_target_properties(${PROJECT_NAME} PROPERTIES
-        CXX_STANDARD 20
+        CXX_STANDARD 23
         CXX_EXTENSIONS OFF
         CXX_STANDARD_REQUIRED ON
         )

README.md

@@ -27,6 +27,8 @@ It contains:
 - `inplace_polymorphic`: `std::variant`-like on-stack polymorphism based on `virtual` functions.
 - `type_list`: A variadic lists of types for metaprogramming.
 - `lazy_conditional`: Lazy conditional type selection that only instantiates the selected branch.
+- `format_to_ostream`: Provide an ostream `operator<<` overload for any type that is formattable with `std::format`.
+- `stdint`: User defined literals for fixed size integers.
 
 ## Usage
 
@@ -168,19 +170,36 @@ approach with `case_<bool, Provider>` helpers. Only the selected case's provider
 allowing you to use `static_assert(false)` in default cases that should never be reached.
 Examples can be found [here](examples/examples_lazy_conditional.cpp).
 
+
+### `format_to_ostream`
+Provide an ostream `operator<<` overload for any type that is formattable with `std::format`.
+Does not override preexisting `operator<<` implementations.
+
+The primary usage for this is for doctest tests, because doctest only supports output via `std::ostream` (not `std::format`).
+Note: for this to work it needs to be included **before** `<doctest/doctest.h>`.
+
+
+### `stdint`
+User defined literals for fixed size integers (e.g. `123_u64`).
+This is mainly useful for cross-platform applications where the common `123ul` is not always the same as `uint64_t{123}`.
+For instance, on macOS `uint64_t` is defined as `unsigned long long`, whereas on Linux it is defined as `unsigned long`.
+Even if both `unsigned long` and `unsigned long long` have the same size, they are still distinct types which can cause issues
+when a type is being deduced.
+
+
 ### Further Examples
 
 Compilable code examples can be found in [examples](./examples). The example build requires the cmake
 option `-DBUILD_EXAMPLES=ON` to be added.
 
 ## Requirements
 
-A C++20 compatible compiler. Code was only tested on x86_64.
+A C++23 compatible compiler. Code was only tested on x86_64.
 
 ## Include it in your projects
 ### Conan
 You can use it with [conan](https://conan.io/).
-To do so, you need to add `dice-template-library/1.20.0` to the `[requires]` section of your conan file.
+To do so, you need to add `dice-template-library/1.21.0` to the `[requires]` section of your conan file.
 
 ## Build and Run Tests and Examples
 

examples/CMakeLists.txt

@@ -1,4 +1,4 @@
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
@@ -162,4 +162,18 @@ add_executable(examples_lazy_conditional
 target_link_libraries(examples_lazy_conditional
         PRIVATE
         dice-template-library::dice-template-library
-)
+)
+
+add_executable(example_format_to_ostream
+        example_format_to_ostream.cpp)
+target_link_libraries(example_format_to_ostream
+        PRIVATE
+        dice-template-library::dice-template-library
+)
+
+add_executable(example_stdint
+        example_stdint.cpp)
+target_link_libraries(example_stdint
+        PRIVATE
+        dice-template-library::dice-template-library
+)

examples/example_format_to_ostream.cpp

@@ -0,0 +1,33 @@
+// Include the overload that makes it ostreamable.
+#include <dice/template-library/format_to_ostream.hpp>
+
+#include <format>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+// A type that has no std::ostream operator<< defined
+struct not_ostreamable {
+	int value;
+};
+
+template<>
+struct std::formatter<not_ostreamable> {
+	template<typename Ctx>
+	constexpr auto parse(Ctx &ctx) {
+		return ctx.begin();
+	}
+
+	template<typename Ctx>
+	auto format(not_ostreamable const &nos, Ctx &ctx) const {
+		// careful to pass `nos.value` instead of `nos` to the formatter to avoid infinite recursions.
+		return std::format_to(ctx.out(), "{}", nos.value);
+	}
+};
+
+
+int main() {
+	not_ostreamable e{1};
+	std::cout << e;
+}
+

examples/example_stdint.cpp

@@ -0,0 +1,13 @@
+#include <dice/template-library/stdint.hpp>
+
+#include <cassert>
+#include <cstdint>
+#include <type_traits>
+
+int main() {
+	using namespace dice::template_library::literals;
+
+	auto value = 123_u64;
+	static_assert(std::is_same_v<decltype(value), uint64_t>);
+	assert(value == 123);
+}

include/dice/template-library/format_to_ostream.hpp

@@ -0,0 +1,54 @@
+#ifndef DICE_TEMPLATELIBRARY_FORMAT_TO_OSTREAM
+#define DICE_TEMPLATELIBRARY_FORMAT_TO_OSTREAM
+
+/*!
+ * Note: This file does not use concepts/requires anywhere because their evaluation
+ * causes an infinite loop (compiler error: "evaluation of constraint depends on itself").
+ *
+ * Old-school SFINAE does not have this issue.
+ */
+
+#include <format>
+#include <iterator>
+#include <ostream>
+#include <string>
+#include <type_traits>
+
+namespace dice::template_library {
+
+    /**
+     * Detect if a type can be used with operator<< of an ostream.
+     *
+     * @tparam T type to check
+     * @tparam Char char-type of the ostream
+     * @tparam CharTraits char-traits-type of the ostream
+     */
+    template<typename T, typename Char, typename CharTraits, typename = void>
+    struct is_ostreamable : std::false_type {
+    };
+
+    template<typename T, typename Char, typename CharTraits>
+    struct is_ostreamable<T, Char, CharTraits, std::void_t<decltype(std::declval<std::basic_ostream<Char, CharTraits> &>() << std::declval<T const &>())>> : std::true_type {
+    };
+
+    template<typename T, typename Char, typename CharTraits>
+    inline constexpr bool is_ostreamable_v = is_ostreamable<T, Char, CharTraits>::value;
+
+} // namespace dice::template_library
+
+/**
+ * An overload for ostream operator<< for any type that is formattable with std::format
+ *
+ * @tparam Char char-type of the ostream and the formatter
+ * @tparam CharTraits char-traits-type of the ostream
+ * @param stream ostream
+ * @param value value to stream via std::formatter implementation
+ * @return stream
+ */
+template<typename T, typename Char = char, typename CharTraits = std::char_traits<char>, typename = std::enable_if_t<std::formattable<T, Char> && !dice::template_library::is_ostreamable_v<T, Char, CharTraits>>>
+std::basic_ostream<Char, CharTraits> &operator<<(std::basic_ostream<Char, CharTraits> &stream, T const &value) {
+    std::format_to(std::ostreambuf_iterator<Char, CharTraits>{stream}, "{}", value);
+    return stream;
+}
+
+#endif // DICE_TEMPLATELIBRARY_FORMAT_TO_OSTREAM