build(cmake): Allow ystdlib-cpp to be imported into other CMake projects as a library

CMake/ystdlib-config.cmake.in

@@ -0,0 +1,17 @@
+# gersemi: off
+# this file is preprocessed and should not be linted like a CMake file
+include(CMakeFindDependencyMacro)
+
+@PACKAGE_INIT@
+
+find_dependency(Boost REQUIRED)
+
+set_and_check(ystdlib_INCLUDE_DIR "@PACKAGE_ystdlib_INSTALL_INCLUDE_DIR@")
+
+check_required_components(ystdlib)
+
+# Avoid repeatedly including the targets
+if(NOT TARGET ystdlib::ystdlib)
+    include("${CMAKE_CURRENT_LIST_DIR}/ystdlib-targets.cmake")
+endif()
+# gersemi: on

CMake/ystdlib-cpp-helpers.cmake

@@ -28,8 +28,8 @@ endfunction()
 # Adds a c++20 interface library in the subdirectory NAME with the target NAME and alias
 # NAMESPACE::NAME. Libraries with multiple levels of namespace nesting are currently not supported.
 #
-# If `YSTDLIB_CPP_ENABLE_TESTS` is ON, builds the unit tests specific to the current library, and
-# links this library against the unified unit test target for the entire `ystdlib-cpp` project.
+# If `ystdlib_ENABLE_TESTS` is ON, builds the unit tests specific to the current library, and
+# links this library against the unified unit test target for the entire `ystdlib` project.
 #
 # @param {string} NAME
 # @param {string} NAMESPACE
@@ -40,7 +40,7 @@ endfunction()
 # @param {string[]} [PRIVATE_LINK_LIBRARIES]
 # @param {string[]} [TESTS_LINK_LIBRARIES]
 # @param {string[]} [BUILD_INCLUDE_DIR="${PROJECT_SOURCE_DIR}/src"] The list of include paths for
-# building the library and for external projects that builds `ystdlib-cpp` as a CMAKE subproject via
+# building the library and for external projects that builds `ystdlib` as a CMAKE subproject via
 # the add_subdirectory() function.
 function(cpp_library)
     set(options "")
@@ -96,12 +96,9 @@ function(cpp_library)
         endif()
         add_library(${arg_cpp_lib_NAME} INTERFACE)
         target_link_libraries(${arg_cpp_lib_NAME} INTERFACE ${arg_cpp_lib_PUBLIC_LINK_LIBRARIES})
-        target_include_directories(
-            ${arg_cpp_lib_NAME}
-            INTERFACE
-                "$<BUILD_INTERFACE:${arg_cpp_lib_BUILD_INCLUDE_DIR}>"
-        )
+
         target_compile_features(${arg_cpp_lib_NAME} INTERFACE cxx_std_20)
+
     else()
         # The library type is specified by `BUILD_SHARED_LIBS` if it is defined. Otherwise, the type
         # defaults to static.
@@ -119,17 +116,32 @@ function(cpp_library)
             PRIVATE
                 ${arg_cpp_lib_PRIVATE_LINK_LIBRARIES}
         )
-        target_include_directories(
-            ${arg_cpp_lib_NAME}
-            PUBLIC
-                "$<BUILD_INTERFACE:${arg_cpp_lib_BUILD_INCLUDE_DIR}>"
-        )
         target_compile_features(${arg_cpp_lib_NAME} PUBLIC cxx_std_20)
     endif()
 
     add_library(${_ALIAS_TARGET_NAME} ALIAS ${arg_cpp_lib_NAME})
 
-    if(YSTDLIB_CPP_ENABLE_TESTS)
+    # replaces header_include_directories
+    # replaces header installation
+    target_sources(
+        ${arg_cpp_lib_NAME}
+        PUBLIC
+        FILE_SET HEADERS
+        BASE_DIRS
+            "$<BUILD_INTERFACE:${arg_cpp_lib_BUILD_INCLUDE_DIR}>"
+            "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+        FILES
+            ${arg_cpp_lib_PUBLIC_HEADERS}
+    )
+
+    set_target_properties(
+        ${arg_cpp_lib_NAME}
+        PROPERTIES
+            LINKER_LANGUAGE
+                CXX
+    )
+
+    if(ystdlib_ENABLE_TESTS)
         # Build library-specific unit test target
         set(_UNIT_TEST_TARGET "unit-test-${arg_cpp_lib_NAME}")
         add_executable(${_UNIT_TEST_TARGET})
@@ -150,6 +162,13 @@ function(cpp_library)
                     ${CMAKE_BINARY_DIR}/testbin
         )
 
+        set_target_properties(
+            ${_UNIT_TEST_TARGET}
+            PROPERTIES
+                LINKER_LANGUAGE
+                    CXX
+        )
+
         # Link against unified unit test
         target_sources(${UNIFIED_UNIT_TEST_TARGET} PRIVATE ${arg_cpp_lib_TESTS_SOURCES})
         target_link_libraries(

CMakeLists.txt

@@ -1,33 +1,35 @@
-cmake_minimum_required(VERSION 3.22.1)
+cmake_minimum_required(VERSION 3.23)
 
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/CMake")
-include(ystdlib-cpp-helpers)
+set(ystdlib_VERSION "0.0.1" CACHE STRING "Project version.")
 
-project(YSTDLIB_CPP LANGUAGES CXX)
+project(ystdlib VERSION "${ystdlib_VERSION}" LANGUAGES CXX)
 
-set(YSTDLIB_CPP_VERSION "0.0.1" CACHE STRING "Project version.")
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/CMake")
+include(ystdlib-cpp-helpers)
+include(CMakePackageConfigHelpers)
+include(GNUInstallDirs)
 
 option(BUILD_SHARED_LIBS "Build using shared libraries." OFF)
-option(YSTDLIB_CPP_BUILD_TESTING "Build the testing tree for ystdlib-cpp." ON)
+option(ystdlib_BUILD_TESTING "Build the testing tree for ystdlib-cpp." ON)
 
 # Require compiler versions that support the C++20 features necessary for compiling ystdlib-cpp
 if("AppleClang" STREQUAL "${CMAKE_CXX_COMPILER_ID}")
-    set(YSTDLIB_CPP_CMAKE_CXX_COMPILER_MIN_VERSION "16")
+    set(ystdlib_CMAKE_CXX_COMPILER_MIN_VERSION "16")
 elseif("Clang" STREQUAL "${CMAKE_CXX_COMPILER_ID}")
-    set(YSTDLIB_CPP_CMAKE_CXX_COMPILER_MIN_VERSION "16")
+    set(ystdlib_CMAKE_CXX_COMPILER_MIN_VERSION "16")
 elseif("GNU" STREQUAL "${CMAKE_CXX_COMPILER_ID}")
-    set(YSTDLIB_CPP_CMAKE_CXX_COMPILER_MIN_VERSION "11")
+    set(ystdlib_CMAKE_CXX_COMPILER_MIN_VERSION "11")
 else()
     message(
         FATAL_ERROR
         "Unsupported compiler: ${CMAKE_CXX_COMPILER_ID}. Please use AppleClang, Clang, or GNU."
     )
 endif()
-if("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "${YSTDLIB_CPP_CMAKE_CXX_COMPILER_MIN_VERSION}")
+if("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "${ystdlib_CMAKE_CXX_COMPILER_MIN_VERSION}")
     message(
         FATAL_ERROR
         "${CMAKE_CXX_COMPILER_ID} version ${CMAKE_CXX_COMPILER_VERSION} is too low. Must be at \
-        least ${YSTDLIB_CPP_CMAKE_CXX_COMPILER_MIN_VERSION}."
+        least ${ystdlib_CMAKE_CXX_COMPILER_MIN_VERSION}."
     )
 endif()
 
@@ -39,7 +41,7 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS
     FORCE
 )
 
-if(YSTDLIB_CPP_IS_TOP_LEVEL)
+if(ystdlib_IS_TOP_LEVEL)
     # Include dependency settings if the project isn't being included as a subproject.
     # NOTE: We mark the file optional because if the user happens to have the dependencies
     # installed, this file is not necessary.
@@ -49,18 +51,16 @@ if(YSTDLIB_CPP_IS_TOP_LEVEL)
     include(CTest)
 endif()
 
-if(BUILD_TESTING AND YSTDLIB_CPP_BUILD_TESTING)
-    set(YSTDLIB_CPP_ENABLE_TESTS ON)
+if(BUILD_TESTING AND ystdlib_BUILD_TESTING)
+    set(ystdlib_ENABLE_TESTS ON)
 endif()
 
-find_package(outcome REQUIRED)
-if(outcome_FOUND)
-    message(STATUS "Found outcome.")
-else()
-    message(FATAL_ERROR "Could not find libraries for outcome.")
+find_package(Boost REQUIRED)
+if(Boost_FOUND)
+    message(STATUS "Found Boost ${Boost_VERSION}.")
 endif()
 
-if(YSTDLIB_CPP_ENABLE_TESTS)
+if(ystdlib_ENABLE_TESTS)
     find_package(Catch2 3.8.0 REQUIRED)
     if(Catch2_FOUND)
         message(STATUS "Found Catch2 ${Catch2_VERSION}.")
@@ -84,4 +84,50 @@ if(YSTDLIB_CPP_ENABLE_TESTS)
     catch_discover_tests(${UNIFIED_UNIT_TEST_TARGET} WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/testbin)
 endif()
 
+set(ystdlib_INSTALL_CONFIG_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/ystdlib)
+set(ystdlib_INSTALL_INCLUDE_DIR ${CMAKE_INSTALL_INCLUDEDIR})
+
 add_subdirectory(src/ystdlib)
+
+set(ystdlib_targets
+        containers
+        error_handling
+        io_interface
+        wrapped_facade_headers)
+
+foreach(install_target_name IN LISTS ystdlib_targets)
+
+    install(TARGETS
+        ${install_target_name}
+        EXPORT ystdlib-targets
+            LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+            FILE_SET HEADERS
+    )
+
+endforeach()
+
+
+install(EXPORT ystdlib-targets NAMESPACE ystdlib:: DESTINATION ${ystdlib_INSTALL_CONFIG_DIR})
+
+configure_package_config_file(
+    ${CMAKE_CURRENT_LIST_DIR}/CMake/ystdlib-config.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/ystdlib-config.cmake
+    INSTALL_DESTINATION ${ystdlib_INSTALL_CONFIG_DIR}
+    PATH_VARS
+        ystdlib_INSTALL_INCLUDE_DIR
+)
+
+write_basic_package_version_file(
+    ${CMAKE_CURRENT_BINARY_DIR}/ystdlib-config-version.cmake
+    COMPATIBILITY SameMajorVersion
+)
+
+install(
+    FILES
+        ${CMAKE_CURRENT_BINARY_DIR}/ystdlib-config.cmake
+        ${CMAKE_CURRENT_BINARY_DIR}/ystdlib-config-version.cmake
+    DESTINATION ${ystdlib_INSTALL_CONFIG_DIR}
+)
+

README.md

@@ -4,10 +4,13 @@ An open-source C++ library developed and used at YScope.
 # Usage
 
 ## Via CMake's add_subdirectory()
+> Note: this is not accurate in this branch, which is a work in progress to use ystdlib-cpp as a
+CMake library
+
 Clone `ystdlib-cpp` into your project. Then, in your project's `CMakeLists.txt`, add the following:
 ```cmake
-# Set `YSTDLIB_CPP_BUILD_TESTING` to an accepted `FALSE` class value to skip building unit tests.
-# option(YSTDLIB_CPP_BUILD_TESTING "" OFF)
+# Set `ystdlib_BUILD_TESTING` to an accepted `FALSE` class value to skip building unit tests.
+# option(ystdlib_BUILD_TESTING "" OFF)
 add_subdirectory(/path/to/ystdlib-cpp EXCLUDE_FROM_ALL)
 target_link_libraries(<target_name> <link_options>
     ystdlib::<lib_1> ystdlib::<lib_2> ... ystdlib::<lib_N>
@@ -64,7 +67,7 @@ task test-<lib_name>
 ```
 
 When generating a testing target, the CMake variable `BUILD_TESTING` is followed (unless overruled
-by setting `YSTDLIB_CPP_BUILD_TESTING` to false). By default, if built as a top-level project,
+by setting `ystdlib_BUILD_TESTING` to false). By default, if built as a top-level project,
 `BUILD_TESTING` is set to true and unit tests are built.
 
 ## Linting

examples/CMakeLists.txt

@@ -0,0 +1,30 @@
+cmake_minimum_required(VERSION 3.22.1)
+
+project(ystdlib-examples)
+
+include("${CMAKE_SOURCE_DIR}/../build/deps/cmake-settings/settings.cmake" REQUIRED)
+
+if(NOT DEFINED ystdlib_ROOT)
+    set(ystdlib_ROOT "${CMAKE_SOURCE_DIR}/../build/build_install")
+endif()
+find_package(ystdlib REQUIRED)
+
+add_library(
+    common
+    OBJECT
+    types.cpp
+    types.hpp
+    constants.hpp
+)
+target_link_libraries(common PRIVATE ystdlib::error_handling)
+add_executable(main main.cpp)
+
+target_compile_features(main PRIVATE cxx_std_20)
+target_compile_features(common PRIVATE cxx_std_20)
+
+target_link_libraries(
+    main
+    PRIVATE
+        ystdlib::error_handling
+        common
+)

examples/README.md

@@ -0,0 +1,9 @@
+cmake ..
+
+Run above command from examples/build
+
+Dependencies:
+
+After building main project, cd to build and run
+
+cmake --install . --prefix=build_install to have an install location

examples/constants.hpp

@@ -0,0 +1,18 @@
+#ifndef EXAMPLE_CONSTANTS_HPP
+#define EXAMPLE_CONSTANTS_HPP
+
+#include <array>
+#include <string_view>
+#include <system_error>
+
+namespace ystdlib::error_handling::test {
+constexpr std::string_view cAlwaysSuccessErrorCategoryName{"Always Success Error Code"};
+constexpr std::string_view cBinaryTestErrorCategoryName{"Binary Error Code"};
+constexpr std::string_view cSuccessErrorMsg{"Success"};
+constexpr std::string_view cFailureErrorMsg{"Failure"};
+constexpr std::string_view cUnrecognizedErrorCode{"Unrecognized Error Code"};
+constexpr std::array cFailureConditions{std::errc::not_connected, std::errc::timed_out};
+constexpr std::array cNoneFailureConditions{std::errc::broken_pipe, std::errc::address_in_use};
+}  // namespace ystdlib::error_handling::test
+
+#endif  // EXAMPLE_CONSTANTS_HPP

examples/main.cpp

@@ -0,0 +1,53 @@
+#include <algorithm>
+#include <string_view>
+#include <system_error>
+
+#include <ystdlib/error_handling/ErrorCode.hpp>
+
+#include "constants.hpp"
+#include "types.hpp"
+
+#include <cassert>
+#include <iostream>
+
+using namespace ystdlib::error_handling::test;
+
+int main() {
+    // Test error codes within the same error category
+    BinaryErrorCode const success{BinaryErrorCodeEnum::Success};
+    std::error_code const success_error_code{success};
+    assert((success == success_error_code));
+    assert((cSuccessErrorMsg == success_error_code.message()));
+    assert((BinaryErrorCode::get_category() == success_error_code.category()));
+    assert((cBinaryTestErrorCategoryName == success_error_code.category().name()));
+
+    BinaryErrorCode const failure{BinaryErrorCodeEnum::Failure};
+    std::error_code const failure_error_code{failure};
+    assert((failure == failure_error_code));
+    assert((cFailureErrorMsg == failure_error_code.message()));
+    assert((BinaryErrorCode::get_category() == failure_error_code.category()));
+    assert((cBinaryTestErrorCategoryName == failure_error_code.category().name()));
+
+    assert((success_error_code != failure_error_code));
+    assert((success_error_code.category() == failure_error_code.category()));
+
+    AlwaysSuccessErrorCode const always_success{AlwaysSuccessErrorCodeEnum::Success};
+    std::error_code const always_success_error_code{always_success};
+    assert((always_success_error_code == always_success));
+    assert((cSuccessErrorMsg == always_success_error_code.message()));
+    assert((AlwaysSuccessErrorCode::get_category() == always_success_error_code.category()));
+    assert((cAlwaysSuccessErrorCategoryName == always_success_error_code.category().name()));
+
+    // Compare error codes from different error category
+    // Error codes that have the same value or message won't be the same with each other if they are
+    // from different error categories.
+    assert((success_error_code.value() == always_success_error_code.value()));
+    assert((success_error_code.message() == always_success_error_code.message()));
+    assert((success_error_code.category() != always_success_error_code.category()));
+    assert((success_error_code != always_success_error_code));
+    assert((AlwaysSuccessErrorCode{AlwaysSuccessErrorCodeEnum::Success} != success_error_code));
+    assert((BinaryErrorCode{BinaryErrorCodeEnum::Success} != always_success_error_code));
+
+    std::cout << "test is good!" << std::endl;
+    return 0;
+}