feedc0de/expected
1
0
Fork 0
forked from TartanLlama/expected
Code Pull Requests Activity

Cmake love (#55)

Browse Source 
* Do CMake properly

* Remove uneeded file

* Add patch to version

* Init submodule in appveyor

* Use FetchContent

* Up CMake version requirement

* Use Xenial on Travis instead of Trusty

* Tidy traits

* Use Xenial repos
This commit is contained in:
Simon Brand
2019-06-25 11:20:05 +01:00
committed by GitHub
parent 1fb40294e6
commit 4f541d7221
20 changed files with 392 additions and 342 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.appveyor.yml
View File

@@ -3,6 +3,7 @@ os:
- Visual Studio 2017 - Visual Studio 2017
build_script: build_script:
- git submodule update --init --recursive
- mkdir build - mkdir build
- cd build - cd build
- cmake .. - cmake ..

3
.gitmodules vendored Normal file
View File

@@ -0,0 +1,3 @@
[submodule "cmake/tl-cmake"]
path = cmake/tl-cmake
url = https://github.com/TartanLlama/tl-cmake.git

18
.travis.yml
View File

@@ -1,6 +1,6 @@
language: cpp language: cpp
dist: trusty dist: xenial
sudo: false sudo: false
matrix: matrix:
@@ -97,7 +97,7 @@ matrix:
addons: addons:
apt: apt:
sources: sources:
- sourceline: "deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-3.9 main" - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-3.9 main"
key_url: "http://apt.llvm.org/llvm-snapshot.gpg.key" key_url: "http://apt.llvm.org/llvm-snapshot.gpg.key"
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
packages: packages:
@@ -108,7 +108,7 @@ matrix:
addons: addons:
apt: apt:
sources: sources:
- llvm-toolchain-trusty-4.0 - llvm-toolchain-xenial-4.0
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
packages: packages:
- clang++-4.0 - clang++-4.0
@@ -118,7 +118,7 @@ matrix:
addons: addons:
apt: apt:
sources: sources:
- llvm-toolchain-trusty-5.0 - llvm-toolchain-xenial-5.0
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
packages: packages:
- clang++-5.0 - clang++-5.0
@@ -128,7 +128,7 @@ matrix:
addons: addons:
apt: apt:
sources: sources:
- llvm-toolchain-trusty-6.0 - llvm-toolchain-xenial-6.0
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
packages: packages:
- clang++-6.0 - clang++-6.0
@@ -211,7 +211,7 @@ matrix:
addons: addons:
apt: apt:
sources: sources:
- sourceline: "deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-3.9 main" - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-3.9 main"
key_url: "http://apt.llvm.org/llvm-snapshot.gpg.key" key_url: "http://apt.llvm.org/llvm-snapshot.gpg.key"
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
packages: packages:
@@ -222,7 +222,7 @@ matrix:
addons: addons:
apt: apt:
sources: sources:
- llvm-toolchain-trusty-4.0 - llvm-toolchain-xenial-4.0
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
packages: packages:
- clang++-4.0 - clang++-4.0
@@ -232,7 +232,7 @@ matrix:
addons: addons:
apt: apt:
sources: sources:
- llvm-toolchain-trusty-5.0 - llvm-toolchain-xenial-5.0
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
packages: packages:
- clang++-5.0 - clang++-5.0
@@ -242,7 +242,7 @@ matrix:
addons: addons:
apt: apt:
sources: sources:
- llvm-toolchain-trusty-6.0 - llvm-toolchain-xenial-6.0
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
packages: packages:
- clang++-6.0 - clang++-6.0

21
CMakeLists.txt
View File

@@ -1,12 +1,23 @@
cmake_minimum_required(VERSION 3.0) cmake_minimum_required(VERSION 3.11)
project(expected) project(tl-expected VERSION 1.0.0 LANGUAGES CXX)
option(EXPECTED_ENABLE_TESTS "Enable tests." ON) option(EXPECTED_ENABLE_TESTS "Enable tests." ON)
add_library(expected INTERFACE) include(FetchContent)
target_sources(expected INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/tl/expected.hpp) FetchContent_Declare(
target_include_directories(expected INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/tl) tl_cmake
GIT_REPOSITORY https://github.com/TartanLlama/tl-cmake.git
)
FetchContent_GetProperties(tl_cmake)
if(NOT tl_cmake_POPULATED)
FetchContent_Populate(tl_cmake)
set(CMAKE_MODULE_PATH ${tl_cmake_SOURCE_DIR} ${CMAKE_MODULE_PATH})
endif()
include(add-tl)
tl_add_library(expected SOURCES
include/tl/expected.hpp)
# Prepare "Catch" library for other executables # Prepare "Catch" library for other executables
set(CATCH_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/test) set(CATCH_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/test)

1
cmake/tl-cmake Submodule

Submodule cmake/tl-cmake added at 284c6a3f0f

3
cmake/tl-expected-config.cmake.in Normal file
View File

@@ -0,0 +1,3 @@
@PACKAGE_INIT@
include("${CMAKE_CURRENT_LIST_DIR}/tl-expected-targets.cmake")

6
conanfile.py
View File

@@ -12,8 +12,8 @@ class ExpectedConan(ConanFile):
exports_sources = "*" exports_sources = "*"
def source(self): def source(self):
tools.replace_in_file('CMakeLists.txt', 'project(expected)', tools.replace_in_file('CMakeLists.txt', 'project(tl-expected)',
'''project(expected) '''project(tl-expected)
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup() conan_basic_setup()
''') ''')
@@ -31,4 +31,4 @@ conan_basic_setup()
self.run('%s/bin/tests' % self.build_folder) self.run('%s/bin/tests' % self.build_folder)
def package(self): def package(self):
self.copy('*.hpp', dst='include/tl', src='tl') self.copy('*.hpp', dst='include/tl', src='include/tl')

145
tl/expected.hpp → include/tl/expected.hpp
View File

@@ -14,8 +14,9 @@
#ifndef TL_EXPECTED_HPP #ifndef TL_EXPECTED_HPP
#define TL_EXPECTED_HPP #define TL_EXPECTED_HPP
#define TL_EXPECTED_VERSION_MAJOR 0 #define TL_EXPECTED_VERSION_MAJOR 1
#define TL_EXPECTED_VERSION_MINOR 2 #define TL_EXPECTED_VERSION_MINOR 0
#define TL_EXPECTED_VERSION_PATCH 0
#include <exception> #include <exception>
#include <functional> #include <functional>
@@ -234,24 +235,55 @@ template <class...> struct conjunction : std::true_type {};
template <class B> struct conjunction<B> : B {}; template <class B> struct conjunction<B> : B {};
template <class B, class... Bs> template <class B, class... Bs>
struct conjunction<B, Bs...> struct conjunction<B, Bs...>
: std::conditional<bool(B::value), conjunction<Bs...>, B>::type {}; : std::conditional<bool(B::value), conjunction<Bs...>, B>::type {};
#if defined(_LIBCPP_VERSION) && __cplusplus == 201103L
#define TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
#endif
// In C++11 mode, there's an issue in libc++'s std::mem_fn
// which results in a hard-error when using it in a noexcept expression
// in some cases. This is a check to workaround the common failing case.
#ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
template <class T> struct is_pointer_to_non_const_member_func : std::false_type {};
template <class T, class Ret, class... Args>
struct is_pointer_to_non_const_member_func<Ret(T::*) (Args...)> : std::true_type {};
template <class T, class Ret, class... Args>
struct is_pointer_to_non_const_member_func<Ret(T::*) (Args...)&> : std::true_type {};
template <class T, class Ret, class... Args>
struct is_pointer_to_non_const_member_func<Ret(T::*) (Args...) &&> : std::true_type {};
template <class T, class Ret, class... Args>
struct is_pointer_to_non_const_member_func<Ret(T::*) (Args...) volatile> : std::true_type {};
template <class T, class Ret, class... Args>
struct is_pointer_to_non_const_member_func<Ret(T::*) (Args...) volatile &> : std::true_type {};
template <class T, class Ret, class... Args>
struct is_pointer_to_non_const_member_func<Ret(T::*) (Args...) volatile &&> : std::true_type {};
template <class T> struct is_const_or_const_ref : std::false_type {};
template <class T> struct is_const_or_const_ref<T const&> : std::true_type {};
template <class T> struct is_const_or_const_ref<T const> : std::true_type {};
#endif
// std::invoke from C++17 // std::invoke from C++17
// https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround // https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround
template <typename Fn, typename... Args, template <typename Fn, typename... Args,
typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>{}>, #ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
int = 0> typename = enable_if_t<!(is_pointer_to_non_const_member_func<Fn>::value
constexpr auto invoke(Fn &&f, Args &&... args) noexcept( && is_const_or_const_ref<Args...>::value)>,
#endif
typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>::value>,
int = 0>
constexpr auto invoke(Fn && f, Args && ... args) noexcept(
noexcept(std::mem_fn(f)(std::forward<Args>(args)...))) noexcept(std::mem_fn(f)(std::forward<Args>(args)...)))
-> decltype(std::mem_fn(f)(std::forward<Args>(args)...)) { -> decltype(std::mem_fn(f)(std::forward<Args>(args)...)) {
return std::mem_fn(f)(std::forward<Args>(args)...); return std::mem_fn(f)(std::forward<Args>(args)...);
} }
template <typename Fn, typename... Args, template <typename Fn, typename... Args,
typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>{}>> typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>::value>>
constexpr auto invoke(Fn &&f, Args &&... args) noexcept( constexpr auto invoke(Fn && f, Args && ... args) noexcept(
noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...))) noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...)))
-> decltype(std::forward<Fn>(f)(std::forward<Args>(args)...)) { -> decltype(std::forward<Fn>(f)(std::forward<Args>(args)...)) {
return std::forward<Fn>(f)(std::forward<Args>(args)...); return std::forward<Fn>(f)(std::forward<Args>(args)...);
} }
@@ -260,8 +292,8 @@ template <class F, class, class... Us> struct invoke_result_impl;
template <class F, class... Us> template <class F, class... Us>
struct invoke_result_impl< struct invoke_result_impl<
F, decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...), void()), F, decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...), void()),
Us...> { Us...> {
using type = decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...)); using type = decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...));
}; };
@@ -279,68 +311,68 @@ template <class T, class U = T> struct is_nothrow_swappable : std::true_type {};
#else #else
// https://stackoverflow.com/questions/26744589/what-is-a-proper-way-to-implement-is-swappable-to-test-for-the-swappable-concept // https://stackoverflow.com/questions/26744589/what-is-a-proper-way-to-implement-is-swappable-to-test-for-the-swappable-concept
namespace swap_adl_tests { namespace swap_adl_tests {
// if swap ADL finds this then it would call std::swap otherwise (same // if swap ADL finds this then it would call std::swap otherwise (same
// signature) // signature)
struct tag {}; struct tag {};
template <class T> tag swap(T &, T &); template <class T> tag swap(T&, T&);
template <class T, std::size_t N> tag swap(T (&a)[N], T (&b)[N]); template <class T, std::size_t N> tag swap(T(&a)[N], T(&b)[N]);
// helper functions to test if an unqualified swap is possible, and if it // helper functions to test if an unqualified swap is possible, and if it
// becomes std::swap // becomes std::swap
template <class, class> std::false_type can_swap(...) noexcept(false); template <class, class> std::false_type can_swap(...) noexcept(false);
template <class T, class U, template <class T, class U,
class = decltype(swap(std::declval<T &>(), std::declval<U &>()))> class = decltype(swap(std::declval<T&>(), std::declval<U&>()))>
std::true_type can_swap(int) noexcept(noexcept(swap(std::declval<T &>(), std::true_type can_swap(int) noexcept(noexcept(swap(std::declval<T&>(),
std::declval<U &>()))); std::declval<U&>())));
template <class, class> std::false_type uses_std(...); template <class, class> std::false_type uses_std(...);
template <class T, class U> template <class T, class U>
std::is_same<decltype(swap(std::declval<T &>(), std::declval<U &>())), tag> std::is_same<decltype(swap(std::declval<T&>(), std::declval<U&>())), tag>
uses_std(int); uses_std(int);
template <class T> template <class T>
struct is_std_swap_noexcept struct is_std_swap_noexcept
: std::integral_constant<bool, : std::integral_constant<bool,
std::is_nothrow_move_constructible<T>::value && std::is_nothrow_move_constructible<T>::value&&
std::is_nothrow_move_assignable<T>::value> {}; std::is_nothrow_move_assignable<T>::value> {};
template <class T, std::size_t N> template <class T, std::size_t N>
struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {}; struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {};
template <class T, class U> template <class T, class U>
struct is_adl_swap_noexcept struct is_adl_swap_noexcept
: std::integral_constant<bool, noexcept(can_swap<T, U>(0))> {}; : std::integral_constant<bool, noexcept(can_swap<T, U>(0))> {};
} // namespace swap_adl_tests } // namespace swap_adl_tests
template <class T, class U = T> template <class T, class U = T>
struct is_swappable struct is_swappable
: std::integral_constant< : std::integral_constant<
bool, bool,
decltype(detail::swap_adl_tests::can_swap<T, U>(0))::value && decltype(detail::swap_adl_tests::can_swap<T, U>(0))::value &&
(!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value || (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value ||
(std::is_move_assignable<T>::value && (std::is_move_assignable<T>::value &&
std::is_move_constructible<T>::value))> {}; std::is_move_constructible<T>::value))> {};
template <class T, std::size_t N> template <class T, std::size_t N>
struct is_swappable<T[N], T[N]> struct is_swappable<T[N], T[N]>
: std::integral_constant< : std::integral_constant<
bool, bool,
decltype(detail::swap_adl_tests::can_swap<T[N], T[N]>(0))::value && decltype(detail::swap_adl_tests::can_swap<T[N], T[N]>(0))::value &&
(!decltype( (!decltype(
detail::swap_adl_tests::uses_std<T[N], T[N]>(0))::value || detail::swap_adl_tests::uses_std<T[N], T[N]>(0))::value ||
is_swappable<T, T>::value)> {}; is_swappable<T, T>::value)> {};
template <class T, class U = T> template <class T, class U = T>
struct is_nothrow_swappable struct is_nothrow_swappable
: std::integral_constant< : std::integral_constant<
bool, bool,
is_swappable<T, U>::value && is_swappable<T, U>::value &&
((decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value ((decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value
&&detail::swap_adl_tests::is_std_swap_noexcept<T>::value) || && detail::swap_adl_tests::is_std_swap_noexcept<T>::value) ||
(!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value && (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value &&
detail::swap_adl_tests::is_adl_swap_noexcept<T, detail::swap_adl_tests::is_adl_swap_noexcept<T,
U>::value))> { U>::value))> {
}; };
#endif #endif
#endif #endif
@@ -2442,5 +2474,4 @@ void swap(expected<T, E> &lhs,
} }
} // namespace tl } // namespace tl
#define TL_OPTIONAL_EXPECTED_MUTEX
#endif #endif

2
tests/assignment.cpp
View File

@@ -1,5 +1,5 @@
#include "catch.hpp" #include "catch.hpp"
#include "expected.hpp" #include <tl/expected.hpp>
TEST_CASE("Simple assignment", "[assignment.simple]") { TEST_CASE("Simple assignment", "[assignment.simple]") {
tl::expected<int, int> e1 = 42; tl::expected<int, int> e1 = 42;

2
tests/bases.cpp
View File

@@ -1,5 +1,5 @@
#include "catch.hpp" #include "catch.hpp"
#include "expected.hpp" #include <tl/expected.hpp>
#include <string> #include <string>

2
tests/constexpr.cpp
View File

@@ -1,5 +1,5 @@
#include "catch.hpp" #include "catch.hpp"
#include "expected.hpp" #include <tl/expected.hpp>
TEST_CASE("Constexpr", "[constexpr]") { TEST_CASE("Constexpr", "[constexpr]") {
//TODO //TODO

2
tests/constructors.cpp
View File

@@ -1,5 +1,5 @@
#include "catch.hpp" #include "catch.hpp"
#include "expected.hpp" #include <tl/expected.hpp>
#include <vector> #include <vector>
#include <type_traits> #include <type_traits>

2
tests/emplace.cpp
View File

@@ -1,5 +1,5 @@
#include "catch.hpp" #include "catch.hpp"
#include "expected.hpp" #include <tl/expected.hpp>
#include <memory> #include <memory>
#include <vector> #include <vector>
#include <tuple> #include <tuple>

2
tests/extensions.cpp
View File

@@ -1,5 +1,5 @@
#include "catch.hpp" #include "catch.hpp"
#include "expected.hpp" #include <tl/expected.hpp>
#define TOKENPASTE(x, y) x##y #define TOKENPASTE(x, y) x##y
#define TOKENPASTE2(x, y) TOKENPASTE(x, y) #define TOKENPASTE2(x, y) TOKENPASTE(x, y)

2
tests/issues.cpp
View File

@@ -1,5 +1,5 @@
#include "catch.hpp" #include "catch.hpp"
#include "expected.hpp" #include <tl/expected.hpp>
#include <string> #include <string>

2
tests/noexcept.cpp
View File

@@ -1,5 +1,5 @@
#include "catch.hpp" #include "catch.hpp"
#include "expected.hpp" #include <tl/expected.hpp>
TEST_CASE("Noexcept", "[noexcept]") { TEST_CASE("Noexcept", "[noexcept]") {
//TODO //TODO

2
tests/observers.cpp
View File

@@ -1,5 +1,5 @@
#include "catch.hpp" #include "catch.hpp"
#include "expected.hpp" #include <tl/expected.hpp>
struct move_detector { struct move_detector {
move_detector() = default; move_detector() = default;

2
tests/relops.cpp
View File

@@ -1,5 +1,5 @@
#include "catch.hpp" #include "catch.hpp"
#include "expected.hpp" #include <tl/expected.hpp>
TEST_CASE("Relational operators", "[relops]") { TEST_CASE("Relational operators", "[relops]") {
//TODO //TODO

2
tests/swap.cpp
View File

@@ -1,5 +1,5 @@
#include "catch.hpp" #include "catch.hpp"
#include "expected.hpp" #include <tl/expected.hpp>
struct no_throw { struct no_throw {
no_throw(std::string i) : i(i) {} no_throw(std::string i) : i(i) {}