mirror of
https://github.com/libSDL2pp/libSDL2pp.git
synced 2025-08-03 10:55:57 -04:00
Modernize way to set c++ standard, use c++17, switch to std::optional
This commit is contained in:
Dmitry Marakasov
parent
06d02479ae
commit
249719996a
12
.travis.yml
12
.travis.yml
@ -5,15 +5,11 @@ matrix:
|
||||
include:
|
||||
# Note that we stick some additional variations to some builds
|
||||
- compiler: gcc
|
||||
env: CXXSTD=c++11 BUILD_COVERAGE=yes
|
||||
- compiler: gcc
|
||||
env: CXXSTD=c++1y
|
||||
env: BUILD_COVERAGE=yes
|
||||
- compiler: clang
|
||||
env: CXXSTD=c++11
|
||||
env: BUILD_NOOPTLIBS=yes
|
||||
- compiler: clang
|
||||
env: CXXSTD=c++1y BUILD_NOOPTLIBS=yes
|
||||
- compiler: clang
|
||||
env: CXXSTD=c++1y BUILD_STATIC=yes
|
||||
env: BUILD_STATIC=yes
|
||||
before_install:
|
||||
- sudo apt-get update -qq
|
||||
- sudo apt-get install -qq cmake libsdl2-dev cppcheck doxygen pulseaudio graphviz
|
||||
@ -42,7 +38,7 @@ before_install:
|
||||
- export CXXFLAGS="${CXXFLAGS} -Werror"
|
||||
|
||||
script:
|
||||
- cmake . -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_VERBOSE_MAKEFILE=yes -DSDL2PP_WITH_WERROR=YES -DSDL2PP_CXXSTD=${CXXSTD} ${CMAKE_EXTRA_ARGS}
|
||||
- cmake . -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_VERBOSE_MAKEFILE=yes -DSDL2PP_WITH_WERROR=YES ${CMAKE_EXTRA_ARGS}
|
||||
- make
|
||||
- ctest -V
|
||||
- sudo make install
|
||||
|
||||
@ -11,7 +11,9 @@ SET(SDL2PP_PATCH_VERSION 1)
|
||||
|
||||
SET(SDL2PP_VERSION "${SDL2PP_MAJOR_VERSION}.${SDL2PP_MINOR_VERSION}.${SDL2PP_PATCH_VERSION}")
|
||||
|
||||
SET(SDL2PP_CXXSTD "c++11" CACHE STRING "Used c++ standard")
|
||||
set(CMAKE_CXX_STANDARD 17)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED YES)
|
||||
set(CMAKE_CXX_EXTENSIONS NO)
|
||||
|
||||
IF(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
|
||||
OPTION(SDL2PP_WITH_IMAGE "Enable SDL2_image support" ON)
|
||||
@ -70,7 +72,6 @@ ELSE(MSVC)
|
||||
SET(CMAKE_EXE_LINKER_FLAGS_COVERAGE "${CMAKE_EXE_LINKER_FLAGS_DEBUG} --coverage")
|
||||
SET(CMAKE_SHARED_LINKER_FLAGS_COVERAGE "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} --coverage")
|
||||
|
||||
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=${SDL2PP_CXXSTD}")
|
||||
SET(SDL2PP_WARNINGS "${SDL2PP_WARNINGS} -Wall -Wextra -pedantic")
|
||||
|
||||
IF(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
|
||||
@ -86,13 +87,6 @@ LIST(REMOVE_DUPLICATES SDL2_ALL_INCLUDE_DIRS)
|
||||
INCLUDE_DIRECTORIES(BEFORE ${PROJECT_SOURCE_DIR})
|
||||
INCLUDE_DIRECTORIES(SYSTEM ${SDL2_ALL_INCLUDE_DIRS})
|
||||
|
||||
INCLUDE(CheckCompile)
|
||||
CHECK_COMPILE(
|
||||
SDL2PP_WITH_EXPERIMENTAL_OPTIONAL
|
||||
"#include <experimental/optional>\nint main() { std::experimental::optional<int> o; return !o; }"
|
||||
"experimental/optional header"
|
||||
)
|
||||
|
||||
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SDL2PP_WARNINGS}")
|
||||
|
||||
# config.h
|
||||
|
||||
@ -31,6 +31,5 @@
|
||||
#cmakedefine SDL2PP_WITH_IMAGE
|
||||
#cmakedefine SDL2PP_WITH_TTF
|
||||
#cmakedefine SDL2PP_WITH_MIXER
|
||||
#cmakedefine SDL2PP_WITH_EXPERIMENTAL_OPTIONAL
|
||||
|
||||
#endif
|
||||
|
||||
@ -66,36 +66,17 @@
|
||||
///
|
||||
////////////////////////////////////////////////////////////
|
||||
|
||||
#if defined(SDL2PP_WITH_EXPERIMENTAL_OPTIONAL)
|
||||
|
||||
# include <experimental/optional>
|
||||
#include <optional>
|
||||
|
||||
namespace SDL2pp {
|
||||
|
||||
template<typename T>
|
||||
using Optional = std::experimental::optional<T>;
|
||||
using Optional = std::optional<T>;
|
||||
|
||||
using BadOptionalAccess = std::experimental::bad_optional_access;
|
||||
using BadOptionalAccess = std::bad_optional_access;
|
||||
|
||||
constexpr std::experimental::nullopt_t NullOpt = std::experimental::nullopt;
|
||||
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
# include <SDL2pp/external/libcpp_optional.hh>
|
||||
|
||||
namespace SDL2pp {
|
||||
|
||||
template<typename T>
|
||||
using Optional = sdl2pp_libcpp_optional::optional<T>;
|
||||
|
||||
using BadOptionalAccess = sdl2pp_libcpp_optional::bad_optional_access;
|
||||
|
||||
constexpr sdl2pp_libcpp_optional::nullopt_t NullOpt = sdl2pp_libcpp_optional::nullopt;
|
||||
constexpr std::nullopt_t NullOpt = std::nullopt;
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
518
SDL2pp/external/libcpp_optional.hh
vendored
518
SDL2pp/external/libcpp_optional.hh
vendored
@ -1,518 +0,0 @@
|
||||
// -*- C++ -*-
|
||||
//===-------------------------- optional ----------------------------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is dual licensed under the MIT and the University of Illinois Open
|
||||
// Source Licenses. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef SDL2PP_LIBCPP_OPTIONAL
|
||||
#define SDL2PP_LIBCPP_OPTIONAL
|
||||
|
||||
#include <cassert>
|
||||
#include <functional>
|
||||
#include <initializer_list>
|
||||
#include <new>
|
||||
#include <stdexcept>
|
||||
#include <type_traits>
|
||||
|
||||
namespace sdl2pp_libcpp_optional {
|
||||
|
||||
class bad_optional_access
|
||||
: public std::logic_error
|
||||
{
|
||||
public:
|
||||
explicit bad_optional_access(const std::string& __arg)
|
||||
: std::logic_error(__arg) {}
|
||||
explicit bad_optional_access(const char* __arg)
|
||||
: std::logic_error(__arg) {}
|
||||
// Remove explicitly defaulted copy constructor and assignment operator:
|
||||
// noexcept specification doesn't work well with libstdc++
|
||||
//bad_optional_access(const bad_optional_access&) noexcept = default;
|
||||
//bad_optional_access& operator=(const bad_optional_access&) noexcept = default;
|
||||
// Get the key function ~bad_optional_access() into the dylib even if not compiling for C++1y
|
||||
virtual ~bad_optional_access() noexcept {}
|
||||
};
|
||||
|
||||
struct in_place_t {};
|
||||
constexpr in_place_t in_place{};
|
||||
|
||||
struct nullopt_t
|
||||
{
|
||||
explicit constexpr nullopt_t(int) noexcept {}
|
||||
};
|
||||
|
||||
constexpr nullopt_t nullopt{0};
|
||||
|
||||
template <class _Tp, bool = std::is_trivially_destructible<_Tp>::value>
|
||||
class __optional_storage
|
||||
{
|
||||
protected:
|
||||
typedef _Tp value_type;
|
||||
union
|
||||
{
|
||||
char __null_state_;
|
||||
value_type __val_;
|
||||
};
|
||||
bool __engaged_ = false;
|
||||
|
||||
~__optional_storage()
|
||||
{
|
||||
if (__engaged_)
|
||||
__val_.~value_type();
|
||||
}
|
||||
|
||||
constexpr __optional_storage() noexcept
|
||||
: __null_state_('\0') {}
|
||||
|
||||
__optional_storage(const __optional_storage& __x)
|
||||
: __engaged_(__x.__engaged_)
|
||||
{
|
||||
if (__engaged_)
|
||||
::new(std::addressof(__val_)) value_type(__x.__val_);
|
||||
}
|
||||
|
||||
__optional_storage(__optional_storage&& __x)
|
||||
noexcept(std::is_nothrow_move_constructible<value_type>::value)
|
||||
: __engaged_(__x.__engaged_)
|
||||
{
|
||||
if (__engaged_)
|
||||
::new(std::addressof(__val_)) value_type(std::move(__x.__val_));
|
||||
}
|
||||
|
||||
constexpr __optional_storage(const value_type& __v)
|
||||
: __val_(__v),
|
||||
__engaged_(true) {}
|
||||
|
||||
constexpr __optional_storage(value_type&& __v)
|
||||
: __val_(std::move(__v)),
|
||||
__engaged_(true) {}
|
||||
|
||||
template <class... _Args>
|
||||
constexpr
|
||||
explicit __optional_storage(in_place_t, _Args&&... __args)
|
||||
: __val_(std::forward<_Args>(__args)...),
|
||||
__engaged_(true) {}
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
class __optional_storage<_Tp, true>
|
||||
{
|
||||
protected:
|
||||
typedef _Tp value_type;
|
||||
union
|
||||
{
|
||||
char __null_state_;
|
||||
value_type __val_;
|
||||
};
|
||||
bool __engaged_ = false;
|
||||
|
||||
constexpr __optional_storage() noexcept
|
||||
: __null_state_('\0') {}
|
||||
|
||||
__optional_storage(const __optional_storage& __x)
|
||||
: __engaged_(__x.__engaged_)
|
||||
{
|
||||
if (__engaged_)
|
||||
::new(std::addressof(__val_)) value_type(__x.__val_);
|
||||
}
|
||||
|
||||
__optional_storage(__optional_storage&& __x)
|
||||
noexcept(std::is_nothrow_move_constructible<value_type>::value)
|
||||
: __engaged_(__x.__engaged_)
|
||||
{
|
||||
if (__engaged_)
|
||||
::new(std::addressof(__val_)) value_type(std::move(__x.__val_));
|
||||
}
|
||||
|
||||
constexpr __optional_storage(const value_type& __v)
|
||||
: __val_(__v),
|
||||
__engaged_(true) {}
|
||||
|
||||
constexpr __optional_storage(value_type&& __v)
|
||||
: __val_(std::move(__v)),
|
||||
__engaged_(true) {}
|
||||
|
||||
template <class... _Args>
|
||||
constexpr
|
||||
explicit __optional_storage(in_place_t, _Args&&... __args)
|
||||
: __val_(std::forward<_Args>(__args)...),
|
||||
__engaged_(true) {}
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
class optional
|
||||
: private __optional_storage<_Tp>
|
||||
{
|
||||
typedef __optional_storage<_Tp> __base;
|
||||
public:
|
||||
typedef _Tp value_type;
|
||||
|
||||
static_assert(!std::is_reference<value_type>::value,
|
||||
"Instantiation of optional with a reference type is ill-formed.");
|
||||
static_assert(!std::is_same<typename std::remove_cv<value_type>::type, in_place_t>::value,
|
||||
"Instantiation of optional with a in_place_t type is ill-formed.");
|
||||
static_assert(!std::is_same<typename std::remove_cv<value_type>::type, nullopt_t>::value,
|
||||
"Instantiation of optional with a nullopt_t type is ill-formed.");
|
||||
static_assert(std::is_object<value_type>::value,
|
||||
"Instantiation of optional with a non-object type is undefined behavior.");
|
||||
static_assert(std::is_nothrow_destructible<value_type>::value,
|
||||
"Instantiation of optional with an object type that is not noexcept destructible is undefined behavior.");
|
||||
|
||||
constexpr optional() noexcept {}
|
||||
optional(const optional&) = default;
|
||||
optional(optional&&) = default;
|
||||
~optional() = default;
|
||||
constexpr optional(nullopt_t) noexcept {}
|
||||
constexpr optional(const value_type& __v)
|
||||
: __base(__v) {}
|
||||
constexpr optional(value_type&& __v)
|
||||
: __base(std::move(__v)) {}
|
||||
|
||||
template <class... _Args,
|
||||
class = typename std::enable_if
|
||||
<
|
||||
std::is_constructible<value_type, _Args...>::value
|
||||
>::type
|
||||
>
|
||||
constexpr
|
||||
explicit optional(in_place_t, _Args&&... __args)
|
||||
: __base(in_place, std::forward<_Args>(__args)...) {}
|
||||
|
||||
template <class _Up, class... _Args,
|
||||
class = typename std::enable_if
|
||||
<
|
||||
std::is_constructible<value_type, std::initializer_list<_Up>&, _Args...>::value
|
||||
>::type
|
||||
>
|
||||
constexpr
|
||||
explicit optional(in_place_t, std::initializer_list<_Up> __il, _Args&&... __args)
|
||||
: __base(in_place, __il, std::forward<_Args>(__args)...) {}
|
||||
|
||||
optional& operator=(nullopt_t) noexcept
|
||||
{
|
||||
if (this->__engaged_)
|
||||
{
|
||||
this->__val_.~value_type();
|
||||
this->__engaged_ = false;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
optional&
|
||||
operator=(const optional& __opt)
|
||||
{
|
||||
if (this->__engaged_ == __opt.__engaged_)
|
||||
{
|
||||
if (this->__engaged_)
|
||||
this->__val_ = __opt.__val_;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (this->__engaged_)
|
||||
this->__val_.~value_type();
|
||||
else
|
||||
::new(std::addressof(this->__val_)) value_type(__opt.__val_);
|
||||
this->__engaged_ = __opt.__engaged_;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
optional&
|
||||
operator=(optional&& __opt)
|
||||
noexcept(std::is_nothrow_move_assignable<value_type>::value &&
|
||||
std::is_nothrow_move_constructible<value_type>::value)
|
||||
{
|
||||
if (this->__engaged_ == __opt.__engaged_)
|
||||
{
|
||||
if (this->__engaged_)
|
||||
this->__val_ = std::move(__opt.__val_);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (this->__engaged_)
|
||||
this->__val_.~value_type();
|
||||
else
|
||||
::new(std::addressof(this->__val_)) value_type(std::move(__opt.__val_));
|
||||
this->__engaged_ = __opt.__engaged_;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class _Up,
|
||||
class = typename std::enable_if
|
||||
<
|
||||
std::is_same<typename std::remove_reference<_Up>::type, value_type>::value &&
|
||||
std::is_constructible<value_type, _Up>::value &&
|
||||
std::is_assignable<value_type&, _Up>::value
|
||||
>::type
|
||||
>
|
||||
optional&
|
||||
operator=(_Up&& __v)
|
||||
{
|
||||
if (this->__engaged_)
|
||||
this->__val_ = std::forward<_Up>(__v);
|
||||
else
|
||||
{
|
||||
::new(std::addressof(this->__val_)) value_type(std::forward<_Up>(__v));
|
||||
this->__engaged_ = true;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class... _Args,
|
||||
class = typename std::enable_if
|
||||
<
|
||||
std::is_constructible<value_type, _Args...>::value
|
||||
>::type
|
||||
>
|
||||
void
|
||||
emplace(_Args&&... __args)
|
||||
{
|
||||
*this = nullopt;
|
||||
::new(std::addressof(this->__val_)) value_type(std::forward<_Args>(__args)...);
|
||||
this->__engaged_ = true;
|
||||
}
|
||||
|
||||
template <class _Up, class... _Args,
|
||||
class = typename std::enable_if
|
||||
<
|
||||
std::is_constructible<value_type, std::initializer_list<_Up>&, _Args...>::value
|
||||
>::type
|
||||
>
|
||||
void
|
||||
emplace(std::initializer_list<_Up> __il, _Args&&... __args)
|
||||
{
|
||||
*this = nullopt;
|
||||
::new(std::addressof(this->__val_)) value_type(__il, std::forward<_Args>(__args)...);
|
||||
this->__engaged_ = true;
|
||||
}
|
||||
|
||||
void
|
||||
swap(optional& __opt)
|
||||
noexcept(std::is_nothrow_move_constructible<value_type>::value &&
|
||||
noexcept(std::swap(std::declval<_Tp&>(), std::declval<_Tp&>())))
|
||||
{
|
||||
using std::swap;
|
||||
if (this->__engaged_ == __opt.__engaged_)
|
||||
{
|
||||
if (this->__engaged_)
|
||||
swap(this->__val_, __opt.__val_);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (this->__engaged_)
|
||||
{
|
||||
::new(std::addressof(__opt.__val_)) value_type(std::move(this->__val_));
|
||||
this->__val_.~value_type();
|
||||
}
|
||||
else
|
||||
{
|
||||
::new(std::addressof(this->__val_)) value_type(std::move(__opt.__val_));
|
||||
__opt.__val_.~value_type();
|
||||
}
|
||||
swap(this->__engaged_, __opt.__engaged_);
|
||||
}
|
||||
}
|
||||
|
||||
value_type const*
|
||||
operator->() const
|
||||
{
|
||||
assert(this->__engaged_); // "optional operator-> called for disengaged value");
|
||||
return std::addressof(this->__val_);
|
||||
}
|
||||
|
||||
value_type*
|
||||
operator->()
|
||||
{
|
||||
assert(this->__engaged_); // "optional operator-> called for disengaged value");
|
||||
return std::addressof(this->__val_);
|
||||
}
|
||||
|
||||
const value_type&
|
||||
operator*() const
|
||||
{
|
||||
assert(this->__engaged_); // "optional operator* called for disengaged value");
|
||||
return this->__val_;
|
||||
}
|
||||
|
||||
value_type&
|
||||
operator*()
|
||||
{
|
||||
assert(this->__engaged_); // "optional operator* called for disengaged value");
|
||||
return this->__val_;
|
||||
}
|
||||
|
||||
constexpr explicit operator bool() const noexcept {return this->__engaged_;}
|
||||
|
||||
value_type const& value() const
|
||||
{
|
||||
if (!this->__engaged_)
|
||||
throw bad_optional_access("optional<T>::value: not engaged");
|
||||
return this->__val_;
|
||||
}
|
||||
|
||||
value_type& value()
|
||||
{
|
||||
if (!this->__engaged_)
|
||||
throw bad_optional_access("optional<T>::value: not engaged");
|
||||
return this->__val_;
|
||||
}
|
||||
|
||||
template <class _Up>
|
||||
constexpr value_type value_or(_Up&& __v) const&
|
||||
{
|
||||
static_assert(std::is_copy_constructible<value_type>::value,
|
||||
"optional<T>::value_or: T must be copy constructible");
|
||||
static_assert(std::is_convertible<_Up, value_type>::value,
|
||||
"optional<T>::value_or: U must be convertible to T");
|
||||
return this->__engaged_ ? this->__val_ :
|
||||
static_cast<value_type>(std::forward<_Up>(__v));
|
||||
}
|
||||
|
||||
template <class _Up>
|
||||
value_type value_or(_Up&& __v) &&
|
||||
{
|
||||
static_assert(std::is_move_constructible<value_type>::value,
|
||||
"optional<T>::value_or: T must be move constructible");
|
||||
static_assert(std::is_convertible<_Up, value_type>::value,
|
||||
"optional<T>::value_or: U must be convertible to T");
|
||||
return this->__engaged_ ? std::move(this->__val_) :
|
||||
static_cast<value_type>(std::forward<_Up>(__v));
|
||||
}
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
inline
|
||||
bool
|
||||
operator==(const optional<_Tp>& __x, const optional<_Tp>& __y)
|
||||
{
|
||||
if (static_cast<bool>(__x) != static_cast<bool>(__y))
|
||||
return false;
|
||||
if (!static_cast<bool>(__x))
|
||||
return true;
|
||||
return *__x == *__y;
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
inline
|
||||
bool
|
||||
operator<(const optional<_Tp>& __x, const optional<_Tp>& __y)
|
||||
{
|
||||
if (!static_cast<bool>(__y))
|
||||
return false;
|
||||
if (!static_cast<bool>(__x))
|
||||
return true;
|
||||
return std::less<_Tp>{}(*__x, *__y);
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
inline
|
||||
constexpr
|
||||
bool
|
||||
operator==(const optional<_Tp>& __x, nullopt_t) noexcept
|
||||
{
|
||||
return !static_cast<bool>(__x);
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
inline
|
||||
constexpr
|
||||
bool
|
||||
operator==(nullopt_t, const optional<_Tp>& __x) noexcept
|
||||
{
|
||||
return !static_cast<bool>(__x);
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
inline
|
||||
constexpr
|
||||
bool
|
||||
operator<(const optional<_Tp>&, nullopt_t) noexcept
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
inline
|
||||
constexpr
|
||||
bool
|
||||
operator<(nullopt_t, const optional<_Tp>& __x) noexcept
|
||||
{
|
||||
return static_cast<bool>(__x);
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
inline
|
||||
constexpr
|
||||
bool
|
||||
operator==(const optional<_Tp>& __x, const _Tp& __v)
|
||||
{
|
||||
return static_cast<bool>(__x) ? *__x == __v : false;
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
inline
|
||||
constexpr
|
||||
bool
|
||||
operator==(const _Tp& __v, const optional<_Tp>& __x)
|
||||
{
|
||||
return static_cast<bool>(__x) ? *__x == __v : false;
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
inline
|
||||
constexpr
|
||||
bool
|
||||
operator<(const optional<_Tp>& __x, const _Tp& __v)
|
||||
{
|
||||
return static_cast<bool>(__x) ? std::less<_Tp>{}(*__x, __v) : true;
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
inline
|
||||
constexpr
|
||||
bool
|
||||
operator<(const _Tp& __v, const optional<_Tp>& __x)
|
||||
{
|
||||
return static_cast<bool>(__x) ? std::less<_Tp>{}(__v, *__x) : false;
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
inline
|
||||
void
|
||||
swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))
|
||||
{
|
||||
__x.swap(__y);
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
inline
|
||||
constexpr
|
||||
optional<typename std::decay<_Tp>::type>
|
||||
make_optional(_Tp&& __v)
|
||||
{
|
||||
return optional<typename std::decay<_Tp>::type>(std::forward<_Tp>(__v));
|
||||
}
|
||||
|
||||
} // namespace sdl2pp_libcpp_optional
|
||||
|
||||
namespace std {
|
||||
|
||||
template <class _Tp>
|
||||
struct hash<sdl2pp_libcpp_optional::optional<_Tp> >
|
||||
{
|
||||
typedef sdl2pp_libcpp_optional::optional<_Tp> argument_type;
|
||||
typedef size_t result_type;
|
||||
|
||||
result_type operator()(const argument_type& __opt) const noexcept
|
||||
{
|
||||
return static_cast<bool>(__opt) ? std::hash<_Tp>()(*__opt) : 0;
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif // SDL2PP_LIBCPP_OPTIONAL
|
||||
Loading…
x
Reference in New Issue
Block a user