Build system switched to cmake (#17)

.github/workflows/cmake.yml

@@ -0,0 +1,48 @@
+name: CMake
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        build_type: [Release, Debug]
+    runs-on: ubuntu-latest
+    env:
+      BUILD_DIR: ${{github.workspace}}/build/${{matrix.build_type}}
+
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        submodules: recursive
+
+    - name: Configure CMake
+      run: cmake -B ${{env.BUILD_DIR}} -DCMAKE_BUILD_TYPE=${{matrix.build_type}}
+
+    - name: Build
+      run: cmake --build ${{env.BUILD_DIR}} --config ${{matrix.build_type}}
+
+    - name: Test
+      working-directory: ${{env.BUILD_DIR}}
+      run: ctest -C ${{env.BUILD_TYPE}}
+
+    - name: Generate coverage report
+      if: ${{matrix.build_type == 'Debug'}}
+      working-directory: ${{github.workspace}}
+      run: |
+        sudo apt-get install lcov
+        lcov --base-directory . --directory ${{env.BUILD_DIR}} -c -o coverage.info
+        lcov --remove coverage.info "test/*" -o coverage.info
+
+    - name: Upload coverage to Codecov
+      if: ${{matrix.build_type == 'Debug'}}
+      uses: codecov/codecov-action@v3
+      with:
+        fail_ci_if_error: true
+        verbose: true
+        files: coverage.info
+

.gitignore

@@ -35,6 +35,7 @@
 bin/
 
 # Coverage dir
+build/
 coverage/
 
 # Coverage/profiling artifacts

CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_policy(SET CMP0048 NEW)
+
+cmake_minimum_required(VERSION 3.9)
+
+project(cpp_result VERSION 0.1)
+
+include_directories(include)
+
+add_subdirectory(test)
+add_subdirectory(examples)
+
+enable_testing()

README.md

@@ -21,7 +21,7 @@ encapsulation.
 
 ## Build
 
-The library requires C++17.
+The library requires C++14.
 Makefile in the project root can be used to build and execute unit-tests.
 
 To build and execute tests the following make target can be used:

examples/CMakeLists.txt

@@ -0,0 +1,6 @@
+add_executable(
+    example
+    example.cpp
+)
+
+set_target_properties(example PROPERTIES CXX_STANDARD 14)

examples/example.cpp

@@ -50,6 +50,9 @@ class BackendClient {
     }
 };
 
+constexpr Result BackendClient::rpcError;
+constexpr Result BackendClient::wrongQuery;
+
 // shared error codes can be used
 constexpr uint8_t backendAccessErrorCode = 2;
 constexpr auto backendAccessError
@@ -89,6 +92,7 @@ AggregateResult retrieveData()
     auto result = backend_access::retrieveRemoteData();
     if (respp::is_success(result)) {
         // positive case
+        return {};
     } else {
         // append error from upper layer
         return result << dataRetrievalError;

include/respp/result.hpp

@@ -77,16 +77,15 @@ constexpr uint8_t sum_widths()
 template <typename Cat, typename C, typename... Cs>
 struct count_bits_before {
     static constexpr int value
-        = std::is_same_v<Cat, C>
-              ? 0
-              : (count_bits_before<Cat, Cs...>::value >= 0)
-                    ? C::bit_width + count_bits_before<Cat, Cs...>::value
-                    : -1;
+        = std::is_same<Cat, C>::value ? 0
+          : (count_bits_before<Cat, Cs...>::value >= 0)
+              ? C::bit_width + count_bits_before<Cat, Cs...>::value
+              : -1;
 };
 
 template <typename Cat, typename C>
 struct count_bits_before<Cat, C> {
-    static constexpr int value = std::is_same_v<Cat, C> ? 0 : -1;
+    static constexpr int value = std::is_same<Cat, C>::value ? 0 : -1;
 };
 
 template <typename Ut, uint8_t Offset, typename C>
@@ -144,18 +143,18 @@ struct result_t {
         bits_occupied_by_categories <= detail::sizeof_in_bits_v<Ut>,
         "The underlying type is too small to contain category");
 
-    static constexpr result_t success{0};
+    static constexpr result_t success{};
 
     underlaying_type result;
 
-    static constexpr result_t make(Cs const &... categories, Ut code)
+    static constexpr result_t make(Cs const &...categories, Ut code)
     {
         auto const r
             = detail::place_category<underlaying_type, 0>({}, categories...);
 
         constexpr auto bits_remaining_for_code
-            = detail::sizeof_in_bits_v<
-                  underlaying_type> - bits_occupied_by_categories;
+            = detail::sizeof_in_bits_v<underlaying_type>
+              - bits_occupied_by_categories;
         constexpr auto mask
             = ~detail::mask<underlaying_type, 0, bits_remaining_for_code>;
         return result_t{static_cast<underlaying_type>(r | (code & mask))};
@@ -167,6 +166,9 @@ struct result_t {
     }
 };
 
+template <typename Ut, typename... Cs>
+constexpr result_t<Ut, Cs...> result_t<Ut, Cs...>::success;
+
 template <typename Result>
 class error_iterator_t;
 
@@ -181,8 +183,8 @@ struct place_while_space_is_available {
             = sizeof(Ut) / sizeof(result_underlaying_type);
         for (auto shift_value = 0; shift_value < capacity; ++shift_value) {
             auto const shift_in_bits
-                = detail::sizeof_in_bits_v<
-                      result_underlaying_type> * shift_value;
+                = detail::sizeof_in_bits_v<result_underlaying_type>
+                  * shift_value;
             auto const slot_value = static_cast<result_underlaying_type>(
                 container >> shift_in_bits);
             if (!slot_value) {
@@ -203,17 +205,16 @@ struct replace_topmost {
         auto shift_value = 0;
         for (; shift_value < capacity - 1; ++shift_value) {
             auto const shift_in_bits
-                = detail::sizeof_in_bits_v<
-                      result_underlaying_type> * shift_value;
+                = detail::sizeof_in_bits_v<result_underlaying_type>
+                  * shift_value;
             auto const slot_value = static_cast<result_underlaying_type>(
                 container >> shift_in_bits);
             if (!slot_value) {
                 break;
             }
         }
         auto const shift_in_bits
-            = detail::sizeof_in_bits_v<
-                  typename Result::underlaying_type> * shift_value;
+            = detail::sizeof_in_bits_v<result_underlaying_type> * shift_value;
 
         container &= detail::generate_mask<Ut>(
             shift_in_bits, detail::sizeof_in_bits_v<result_underlaying_type>);
@@ -349,6 +350,10 @@ struct aggregate_result_t {
     }
 };
 
+template <typename Ut, typename Result, typename PlacementStrategy>
+constexpr aggregate_result_t<Ut, Result, PlacementStrategy>
+    aggregate_result_t<Ut, Result, PlacementStrategy>::success;
+
 template <typename CatToFind, typename Ut, typename... Cs>
 constexpr CatToFind get_category(result_t<Ut, Cs...> result)
 {

test/CMakeLists.txt

@@ -0,0 +1,26 @@
+add_executable(
+    unit-tests
+    result_test.cpp
+)
+
+enable_testing()
+
+include(FetchContent)
+FetchContent_Declare(
+    googletest
+    GIT_REPOSITORY https://github.com/google/googletest.git
+    GIT_TAG v1.14.0
+)
+
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+
+FetchContent_MakeAvailable(googletest)
+
+set_target_properties(unit-tests PROPERTIES CXX_STANDARD 14)
+target_link_libraries(unit-tests GTest::gtest_main)
+target_compile_options(unit-tests PRIVATE -O0 --coverage -g)
+target_link_options(unit-tests PRIVATE --coverage)
+
+include(GoogleTest)
+
+gtest_discover_tests(unit-tests)