TheCloud/libSDL2pp
1
0
Fork 0
mirror of https://github.com/libSDL2pp/libSDL2pp.git synced 2025-08-03 10:55:57 -04:00
Code Issues Packages Projects Releases Wiki Activity

Switch to C++17

Browse Source 
- Use modern CMake way to set C++ standard
- Remove hacks around Optional, as std::optional is now available
This commit is contained in:
Dmitry Marakasov 2022-04-27 21:57:46 +03:00
parent 63485cc354
commit 0b74fbc7fb
8 changed files with 17 additions and 572 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
.github/workflows/ci.yml vendored
View File

@ -6,12 +6,10 @@ jobs:
strategy:
matrix:
include:
- { cxx: g++, std: c++11, features: "coverage" }
- { cxx: g++, std: c++1y, features: "" }
- { cxx: clang++, std: c++11, features: "" }
- { cxx: clang++, std: c++1y, features: "nooptlibs" }
- { cxx: clang++, std: c++1y, features: "static" }
name: ${{ matrix.cxx }} ${{ matrix.std }} ${{ matrix.features }}
- { cxx: g++, features: "coverage" }
- { cxx: clang++, features: "nooptlibs" }
- { cxx: clang++, features: "static" }
name: ${{ matrix.cxx }} ${{ matrix.features }}
steps:
- uses: actions/checkout@v2
- name: Set up environment
@ -53,7 +51,7 @@ jobs:
/sbin/start-stop-daemon --start --pidfile /tmp/custom_xvfb_99.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :99 -screen 0 800x600x24 -ac +extension GLX
- name: Configure
run: cmake . -DCMAKE_VERBOSE_MAKEFILE=yes -DCMAKE_INSTALL_PREFIX=/usr -DSDL2PP_CXXSTD=${{ matrix.std }} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} ${CMAKE_ARGS}
run: cmake . -DCMAKE_VERBOSE_MAKEFILE=yes -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} ${CMAKE_ARGS}
- name: Build
run: cmake --build .
- name: Run tests

17
CMakeLists.txt
View File

@ -11,7 +11,9 @@ set(SDL2PP_PATCH_VERSION 2)
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()
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
@ -143,10 +137,6 @@ set(LIBRARY_HEADERS
SDL2pp/Window.hh
)
set(LIBRARY_EXTERNAL_HEADERS
SDL2pp/external/libcpp_optional.hh
)
# optional sources
if(SDL2PP_WITH_TTF)
set(LIBRARY_SOURCES
@ -265,7 +255,6 @@ if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
${PROJECT_BINARY_DIR}/SDL2pp/Export.hh
DESTINATION include/SDL2pp
)
install(FILES ${LIBRARY_EXTERNAL_HEADERS} DESTINATION include/SDL2pp/external)
install(TARGETS SDL2pp
RUNTIME DESTINATION bin
LIBRARY DESTINATION lib

10
README.md
View File

@ -6,7 +6,7 @@
# libSDL2pp
This library provides C++11 bindings/wrapper for SDL2 and satellite libraries.
This library provides C++17 bindings/wrapper for SDL2 and satellite libraries.
## Synopsis
@ -125,7 +125,7 @@ methods. These classes support:
need to manually check return code after each function call)
* Method overloading, default arguments, method chaining allow shorter
and cleaner code
* C++11 move semantics support, which allow you to store SDL objects
* Move semantics support, which allow you to store SDL objects
in containers and pass/return them by value without noticeable overhead
Set of functional extensions above SDL2 is also available:
@ -137,9 +137,6 @@ Set of functional extensions above SDL2 is also available:
## Building
To build libSDL2pp, you need a compiler with C++11 support, for
example clang 3.4+ or gcc 4.8+.
Dependencies:
* [cmake](https://cmake.org/)
* [SDL2](https://libsdl.org/)
@ -157,7 +154,6 @@ Following variables may be supplied to CMake to affect build:
* ```SDL2PP_WITH_MIXER``` - enable SDL_mixer support (default ON)
* ```SDL2PP_WITH_TTF``` - enable SDL_ttf support (default ON)
* ```SDL2PP_WITH_WERROR``` - treat warnings as errors, useful for CI (default OFF)
* ```SDL2PP_CXXSTD``` - override C++ standard (default C++11). With C++1y some additional features are enabled such as usage of [[deprecated]] attribute and using stock experimental/optional from C++ standard library
* ```SDL2PP_WITH_EXAMPLES``` - enable building example programs (only for standalone build, default ON)
* ```SDL2PP_WITH_TESTS``` - enable building tests (only for standalone build, default ON)
* ```SDL2PP_STATIC``` - build static library instead of shared (only for standalone build, default OFF)
@ -232,7 +228,7 @@ any wrappers over non object-oriented SDL2 code, as these will not bring
any benefits over using plain C API. E.g. I see no point in implementing
SDL2pp::Delay() as it won't bring any convenience over SDL_Delay().
The same strongly applies to the SDL2 bits which duplicate C++11
The same strongly applies to the SDL2 bits which duplicate C++17
standard library, e.g. threads and atomic ops.
## Users

1
SDL2pp/Config.hh.in
View File

@ -31,6 +31,5 @@
#cmakedefine SDL2PP_WITH_IMAGE
#cmakedefine SDL2PP_WITH_TTF
#cmakedefine SDL2PP_WITH_MIXER
#cmakedefine SDL2PP_WITH_EXPERIMENTAL_OPTIONAL
#endif

27
SDL2pp/Optional.hh
View File

@ -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
View File

@ -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

2
exttests/cmake/CMakeLists.txt
View File

@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 2.8)
find_package(SDL2PP REQUIRED)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
set(CMAKE_CXX_STANDARD 17)
include_directories(${SDL2PP_INCLUDE_DIRS})
add_executable(cmake-ext-test ../../examples/sprites.cc)

2
exttests/pkg-config/Makefile
View File

@ -1,6 +1,6 @@
CXX?= g++
CXXFLAGS+= -std=c++11
CXXFLAGS+= -std=c++17
SDL2PP_CFLAGS= `pkg-config --cflags sdl2pp`
SDL2PP_LIBS= `pkg-config --libs sdl2pp`