Merge branch 'dev'

Author: PacificViking

CMake/ystdlib-config.cmake.in

@@ -4,15 +4,9 @@ include(CMakeFindDependencyMacro)
 
 @PACKAGE_INIT@
 
-if(@Catch2_FOUND@)
-    find_dependency(Catch2)
-endif()
-
-if(@outcome_FOUND@)
-    find_dependency(outcome)
-endif()
+find_dependency(Boost REQUIRED)
 
-set_and_check(ystdlib_INCLUDE_DIR "@PACKAGE_YSTDLIB_INSTALL_INCLUDE_DIR@")
+set_and_check(ystdlib_INCLUDE_DIR "@PACKAGE_ystdlib_INSTALL_INCLUDE_DIR@")
 
 check_required_components(ystdlib)
 

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 "")
@@ -102,6 +102,12 @@ function(cpp_library)
                 "$<BUILD_INTERFACE:${arg_cpp_lib_BUILD_INCLUDE_DIR}>"
         )
         target_compile_features(${arg_cpp_lib_NAME} INTERFACE cxx_std_20)
+
+        # tells where headers are
+        target_include_directories(${arg_cpp_lib_NAME} INTERFACE 
+            # "$<INSTALL_INTERFACE:include/${arg_cpp_lib_NAME}>")
+            "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
+
     else()
         # The library type is specified by `BUILD_SHARED_LIBS` if it is defined. Otherwise, the type
         # defaults to static.
@@ -129,7 +135,22 @@ function(cpp_library)
 
     add_library(${_ALIAS_TARGET_NAME} ALIAS ${arg_cpp_lib_NAME})
 
-    if(YSTDLIB_CPP_ENABLE_TESTS)
+    # install headers
+    set(INSTALL_INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/ystdlib/${arg_cpp_lib_NAME}")
+    install(
+        FILES
+        ${arg_cpp_lib_PUBLIC_HEADERS}
+        DESTINATION "${INSTALL_INCLUDE_DIR}"
+    )
+
+    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 +171,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,35 +1,35 @@
 cmake_minimum_required(VERSION 3.22.1)
 
+set(ystdlib_VERSION "0.0.1" CACHE STRING "Project version.")
+
+project(ystdlib VERSION "${ystdlib_VERSION}" LANGUAGES CXX)
+
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/CMake")
 include(ystdlib-cpp-helpers)
 include(CMakePackageConfigHelpers)
 include(GNUInstallDirs)
 
-set(YSTDLIB_CPP_VERSION "0.0.1" CACHE STRING "Project version.")
-
-project(YSTDLIB_CPP VERSION "${YSTDLIB_CPP_VERSION}" LANGUAGES CXX)
-
 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()
 
@@ -41,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.
@@ -51,16 +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(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,60 +84,31 @@ 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})
+set(ystdlib_INSTALL_CONFIG_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/ystdlib)
+set(ystdlib_INSTALL_INCLUDE_DIR ${CMAKE_INSTALL_INCLUDEDIR})
 
-file(
-    GLOB_RECURSE SOURCE_FILES
-    CONFIGURE_DEPENDS
-    "${PROJECT_SOURCE_DIR}/src/*.cpp"
-    "${PROJECT_SOURCE_DIR}/src/*.hpp"
-    "${PROJECT_SOURCE_DIR}/src/*.h"
-)
-list(FILTER SOURCE_FILES EXCLUDE REGEX ".*test_*\..*")
-
-add_library(ystdlib ${SOURCE_FILES})
-add_library(ystdlib::ystdlib ALIAS ystdlib)
-
-target_include_directories(
-    ystdlib
-    PUBLIC
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
-        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-)
-
-target_compile_features(ystdlib PUBLIC cxx_std_20)
+add_subdirectory(src/ystdlib)
 
-set_target_properties(
-    ystdlib
-    PROPERTIES
-        LINKER_LANGUAGE
-            CXX
+install(TARGETS
+    containers
+    error_handling
+    io_interface
+    wrapped_facade_headers
+    EXPORT ystdlib-targets
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+        FILE_SET HEADERS
 )
 
-install(TARGETS ystdlib EXPORT ystdlib-targets)
-
-install(EXPORT ystdlib-targets NAMESPACE ystdlib:: DESTINATION ${YSTDLIB_INSTALL_CONFIG_DIR})
-
-install(
-    DIRECTORY
-        "${PROJECT_SOURCE_DIR}/src/ystdlib"
-    DESTINATION "${YSTDLIB_INSTALL_INCLUDE_DIR}"
-    FILES_MATCHING
-    PATTERN
-    "*.h"
-    PATTERN
-    "*.hpp"
-    PATTERN
-    "*.tpp"
-)
+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}
+    INSTALL_DESTINATION ${ystdlib_INSTALL_CONFIG_DIR}
     PATH_VARS
-        YSTDLIB_INSTALL_INCLUDE_DIR
+        ystdlib_INSTALL_INCLUDE_DIR
 )
 
 write_basic_package_version_file(
@@ -149,7 +120,6 @@ install(
     FILES
         ${CMAKE_CURRENT_BINARY_DIR}/ystdlib-config.cmake
         ${CMAKE_CURRENT_BINARY_DIR}/ystdlib-config-version.cmake
-    DESTINATION ${YSTDLIB_INSTALL_CONFIG_DIR}
+    DESTINATION ${ystdlib_INSTALL_CONFIG_DIR}
 )
 
-add_subdirectory(src/ystdlib)

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,41 @@
+cmake_minimum_required(VERSION 3.22.1)
+
+project(ystdlib-examples)
+
+if(ystdlib-examples_IS_TOP_LEVEL)
+    message("${CMAKE_SOURCE_DIR}/../build/deps/cmake-settings/settings.cmake")
+    include("${CMAKE_SOURCE_DIR}/../build/deps/cmake-settings/settings.cmake" OPTIONAL)
+endif()
+
+set(ystdlib_ROOT "${CMAKE_SOURCE_DIR}/../build/build_install")
+find_package(ystdlib REQUIRED)
+
+add_library(
+    common
+    OBJECT
+    types.cpp
+    types.hpp
+    constants.hpp
+)
+target_link_libraries(common PUBLIC ystdlib::error_handling)
+add_executable(main main.cpp)
+
+get_target_property(_type ystdlib::error_handling TYPE)
+get_target_property(_sources ystdlib::error_handling SOURCES)
+get_target_property(_includes ystdlib::error_handling INCLUDE_DIRECTORIES)
+get_target_property(_libs ystdlib::error_handling LINK_LIBRARIES)
+
+message(STATUS "Target Type: ${_type}")
+message(STATUS "Sources: ${_sources}")
+message(STATUS "Include Dirs: ${_includes}")
+message(STATUS "Linked Libraries: ${_libs}")
+
+target_compile_features(main PRIVATE cxx_std_20)
+target_compile_features(common PRIVATE cxx_std_20)
+
+target_link_libraries(
+    main
+    PUBLIC
+        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 YSTDLIB_ERROR_HANDLING_TEST_CONSTANTS_HPP
+#define YSTDLIB_ERROR_HANDLING_TEST_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  // YSTDLIB_ERROR_HANDLING_TEST_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;
+}