build single header releases

Author: lukevalenty

.github/workflows/unit_tests.yml

@@ -10,7 +10,7 @@ env:
   BUILD_TYPE: Debug
 
 jobs:
-  build:
+  build_and_test:
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
@@ -70,3 +70,31 @@ jobs:
         # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
         run: ctest -C ${{env.BUILD_TYPE}}
 
+  release:
+    needs: build_and_test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      - name: Configure CMake
+        run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
+
+      - name: Build
+        # Build your program with the given configuration
+        run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --target release
+
+      - name: 'Upload Artifact'
+        uses: actions/upload-artifact@v3
+        with:
+          name: cib.hpp
+          path: build/cib.hpp
+
+      - name: Release
+        uses: softprops/[email protected]
+        if: startsWith(github.ref, 'refs/tags/')
+        with:
+          files: build/cib.hpp
+
+

CMakeLists.txt

@@ -16,4 +16,19 @@ target_include_directories(Cib
 
 target_sources(Cib
     INTERFACE
-        ${CMAKE_CURRENT_SOURCE_DIR}/include/cib/core.hpp)
+        ${CMAKE_CURRENT_SOURCE_DIR}/include/cib/cib.hpp)
+
+
+add_custom_command(
+    DEPENDS
+        ${CMAKE_SOURCE_DIR}/include/cib/*
+        ${CMAKE_SOURCE_DIR}/include/cib/detail/*
+    COMMAND
+        python3 ${CMAKE_SOURCE_DIR}/tools/gen_release_header.py ${CMAKE_SOURCE_DIR}/include/cib/cib.hpp > ${CMAKE_BINARY_DIR}/cib.hpp
+    OUTPUT
+        ${CMAKE_BINARY_DIR}/cib.hpp
+)
+
+add_custom_target(release
+    DEPENDS
+        ${CMAKE_BINARY_DIR}/cib.hpp)

include/cib/builder_meta.hpp

@@ -0,0 +1,42 @@
+#ifndef COMPILE_TIME_INIT_BUILD_BUILDER_META_HPP
+#define COMPILE_TIME_INIT_BUILD_BUILDER_META_HPP
+
+
+#include "detail/compiler.hpp"
+
+#include <utility>
+
+
+namespace cib {
+    template<
+        typename BuilderT,
+        typename InterfaceT>
+    struct builder_meta {
+        BuilderT builder();
+        InterfaceT interface();
+    };
+
+    namespace traits {
+        template<typename MetaT>
+        struct builder {
+            using type = decltype(std::declval<MetaT>().builder());
+        };
+
+        template<typename MetaT>
+        using builder_t = typename builder<MetaT>::type;
+
+        template<typename MetaT>
+        CIB_CONSTEXPR builder_t<MetaT> builder_v = {};
+
+        template<typename MetaT>
+        struct interface {
+            using type = decltype(std::declval<MetaT>().interface());
+        };
+
+        template<typename MetaT>
+        using interface_t = typename interface<MetaT>::type;
+    }
+}
+
+
+#endif //COMPILE_TIME_INIT_BUILD_BUILDER_META_HPP

include/cib/built.hpp

@@ -0,0 +1,19 @@
+#ifndef COMPILE_TIME_INIT_BUILD_BUILT_HPP
+#define COMPILE_TIME_INIT_BUILD_BUILT_HPP
+
+
+#include "builder_meta.hpp"
+
+
+namespace cib {
+    /**
+     * Pointer to a concrete built service.
+     *
+     * @tparam Tag Type name of the service.
+     */
+    template<typename Tag>
+    traits::interface_t<Tag> built;
+}
+
+
+#endif //COMPILE_TIME_INIT_BUILD_BUILT_HPP

include/cib/callback.hpp

@@ -0,0 +1,92 @@
+#ifndef COMPILE_TIME_INIT_BUILD_CALLBACK_HPP
+#define COMPILE_TIME_INIT_BUILD_CALLBACK_HPP
+
+
+#include "builder_meta.hpp"
+#include "detail/meta.hpp"
+#include "detail/compiler.hpp"
+
+#include <array>
+#include <type_traits>
+
+
+namespace cib {
+    /**
+     * Extension point/builder for simple callbacks.
+     *
+     * Modules can add their own callback function to this builder to be executed when
+     * the builder is executed with the same function arguments.
+     *
+     * @tparam Size
+     *      Maximum number of callbacks that may be registered.
+     *
+     * @tparam Args
+     *      List of argument types that must be passed into the callback when it is invoked.
+     */
+    template<int Size = 0, typename... Args>
+    struct callback {
+    private:
+        using func_ptr_t = void(*)(Args...);
+
+        std::array<func_ptr_t, Size> funcs;
+
+        template<typename BuilderValue>
+        static void run(Args... args) {
+            CIB_CONSTEXPR auto handlerBuilder = BuilderValue::value;
+            CIB_CONSTEXPR auto numFuncs = std::integral_constant<int, Size>{};
+
+            detail::for_each(numFuncs, [&](auto i){
+                CIB_CONSTEXPR auto func = handlerBuilder.funcs[i];
+                func(args...);
+            });
+        }
+
+    public:
+        CIB_CONSTEVAL callback() = default;
+
+        template<typename PrevFuncsT>
+        CIB_CONSTEVAL callback(
+            PrevFuncsT const & prev_funcs,
+            func_ptr_t new_func
+        )
+            : funcs{}
+        {
+            for (int i = 0; i < prev_funcs.size(); i++) {
+                funcs[i] = prev_funcs[i];
+            }
+
+            funcs[Size - 1] = new_func;
+        }
+
+        // cib uses "add(...)" to add features to service builders
+        CIB_CONSTEVAL auto add(func_ptr_t const & func) const {
+            return callback<Size + 1, Args...>{funcs, func};
+        }
+
+        /**
+         * Build and return a function pointer to the implemented callback builder. Used
+         * by cib library to automatically build an initialized builder. Do not call.
+         *
+         * @tparam BuilderValue
+         *      Struct that contains a "static constexpr auto value" field with the initialized
+         *      builder.
+         *
+         * @return
+         *      Function pointer to callback builder.
+         */
+        template<typename BuilderValue>
+        [[nodiscard]] CIB_CONSTEVAL static auto build() {
+            return run<BuilderValue>;
+        }
+    };
+
+    template<typename... Args>
+    struct callback_meta :
+        public cib::builder_meta<
+            callback<0, Args...>,
+            void(*)(Args...)>
+    {};
+}
+
+
+#endif //COMPILE_TIME_INIT_BUILD_CALLBACK_HPP

include/cib/cib.hpp

@@ -0,0 +1,47 @@
+#ifndef COMPILE_TIME_INIT_BUILD_CIB_HPP
+#define COMPILE_TIME_INIT_BUILD_CIB_HPP
+
+
+/*
+ * Boost Software License - Version 1.0 - August 17th, 2003
+ *
+ * Permission is hereby granted, free of charge, to any person or organization
+ * obtaining a copy of the software and accompanying documentation covered by
+ * this license (the "Software") to use, reproduce, display, distribute,
+ * execute, and transmit the Software, and to prepare derivative works of the
+ * Software, and to permit third-parties to whom the Software is furnished to
+ * do so, all subject to the following:
+ *
+ * The copyright notices in the Software and this entire statement, including
+ * the above license grant, this restriction and the following disclaimer,
+ * must be included in all copies of the Software, in whole or in part, and
+ * all derivative works of the Software, unless such copies or derivative
+ * works are solely in the form of machine-executable object code generated by
+ * a source language processor.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+ * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+ * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+
+/*
+ * cib - Compile-time Initialization and Build
+ * https://github.com/intel/compile-time-init-build
+ */
+
+
+#include "callback.hpp"
+#include "nexus.hpp"
+#include "built.hpp"
+#include "config.hpp"
+#include "detail/compiler.hpp"
+#include "detail/meta.hpp"
+#include "builder_meta.hpp"
+
+
+#endif //COMPILE_TIME_INIT_BUILD_CIB_HPP