summaryrefslogtreecommitdiff
path: root/include/mbgl
diff options
context:
space:
mode:
Diffstat (limited to 'include/mbgl')
-rw-r--r--include/mbgl/style/layer.hpp4
-rw-r--r--include/mbgl/style/source.hpp4
-rw-r--r--include/mbgl/util/peer.hpp111
-rw-r--r--include/mbgl/util/unique_any.hpp271
4 files changed, 115 insertions, 275 deletions
diff --git a/include/mbgl/style/layer.hpp b/include/mbgl/style/layer.hpp
index 12494f5387..b5a4b63d2e 100644
--- a/include/mbgl/style/layer.hpp
+++ b/include/mbgl/style/layer.hpp
@@ -1,7 +1,7 @@
#pragma once
#include <mbgl/util/noncopyable.hpp>
-#include <mbgl/util/unique_any.hpp>
+#include <mbgl/util/peer.hpp>
#include <mbgl/util/immutable.hpp>
#include <mbgl/style/layer_type.hpp>
#include <mbgl/style/types.hpp>
@@ -132,7 +132,7 @@ public:
// For use in SDK bindings, which store a reference to a platform-native peer
// object here, so that separately-obtained references to this object share
// identical platform-native peers.
- util::unique_any peer;
+ util::peer peer;
};
} // namespace style
diff --git a/include/mbgl/style/source.hpp b/include/mbgl/style/source.hpp
index 2f2838ade8..dc3a8d73fb 100644
--- a/include/mbgl/style/source.hpp
+++ b/include/mbgl/style/source.hpp
@@ -2,7 +2,7 @@
#include <mbgl/util/noncopyable.hpp>
#include <mbgl/util/optional.hpp>
-#include <mbgl/util/unique_any.hpp>
+#include <mbgl/util/peer.hpp>
#include <mbgl/util/immutable.hpp>
#include <mbgl/style/types.hpp>
@@ -77,7 +77,7 @@ public:
// For use in SDK bindings, which store a reference to a platform-native peer
// object here, so that separately-obtained references to this object share
// identical platform-native peers.
- util::unique_any peer;
+ util::peer peer;
};
} // namespace style
diff --git a/include/mbgl/util/peer.hpp b/include/mbgl/util/peer.hpp
new file mode 100644
index 0000000000..a4abea0e88
--- /dev/null
+++ b/include/mbgl/util/peer.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <type_traits>
+#include <utility>
+
+namespace mbgl {
+namespace util {
+
+class peer {
+public:
+ peer() = default;
+ peer(const peer&) = delete;
+
+ peer(peer&& other)
+ : vtable(other.vtable)
+ {
+ if (vtable) {
+ vtable->move(other.storage, storage);
+ }
+ other.vtable = nullptr;
+ }
+
+ template <class T>
+ peer(T&& value) {
+ using _Vt = std::decay_t<T>;
+ vtable = get_vtable<_Vt>();
+ new (&storage) _Vt(std::forward<T>(value));
+ }
+
+ ~peer() {
+ reset();
+ }
+
+ peer& operator=(peer&& rhs) {
+ peer(std::move(rhs)).swap(*this);
+ return *this;
+ }
+
+ void reset() {
+ if (vtable) {
+ vtable->destroy(storage);
+ vtable = nullptr;
+ }
+ }
+
+ void swap(peer& rhs) {
+ if (this == &rhs) {
+ return;
+ } else {
+ peer tmp(std::move(rhs));
+ rhs.vtable = vtable;
+ if (rhs.vtable) {
+ rhs.vtable->move(storage, rhs.storage);
+ }
+ vtable = tmp.vtable;
+ if (vtable) {
+ vtable->move(tmp.storage, storage);
+ }
+ }
+ }
+
+ bool has_value() const {
+ return vtable != nullptr;
+ }
+
+ template <class T>
+ T& get() {
+ return reinterpret_cast<T&>(storage);
+ }
+
+ template <class T>
+ T&& take() {
+ reset();
+ return std::move(get<T>());
+ }
+
+private:
+ using storage_t = std::aligned_storage_t<2*sizeof(void*), alignof(void*)>;
+
+ struct vtable {
+ virtual ~vtable() = default;
+ virtual void move(storage_t&, storage_t&) = 0;
+ virtual void destroy(storage_t&) = 0;
+ };
+
+ template <class T>
+ struct vtable_impl : public vtable {
+ static_assert(sizeof(T) <= sizeof(storage_t), "peer object is too big");
+
+ void move(storage_t& src, storage_t& dst) override {
+ new (&dst) T(std::move(reinterpret_cast<T&>(src)));
+ destroy(src);
+ }
+
+ void destroy(storage_t& s) override {
+ reinterpret_cast<T&>(s).~T();
+ }
+ };
+
+ template <class T>
+ static vtable* get_vtable() {
+ static vtable_impl<T> vtable;
+ return &vtable;
+ }
+
+ vtable* vtable = nullptr;
+ storage_t storage;
+};
+
+} // namespace util
+} // namespace mbgl
diff --git a/include/mbgl/util/unique_any.hpp b/include/mbgl/util/unique_any.hpp
deleted file mode 100644
index c7dc8b38ea..0000000000
--- a/include/mbgl/util/unique_any.hpp
+++ /dev/null
@@ -1,271 +0,0 @@
-#pragma once
-
-#include <typeinfo>
-#include <type_traits>
-#include <stdexcept>
-namespace mbgl {
-namespace util {
-
-class bad_any_cast : public std::bad_cast {
-public:
- const char* what() const noexcept override {
- return "bad any_cast<>()";
- }
-};
-/**
- * A variant of `std::any` for non-copyable types.
- *
- * Use `unique_any` for non-copyable types (e.g. `std::unique_ptr<T>`)
- * or to ensure that no copies are made of copyable types that are
- * moved in.
- *
- * `uniqe_any` differs from `std::any` in that it does not support copy construction
- * or copy assignment. It also does not require the contained type to be copy
- * constructible.
- *
- * The `any_cast<T>()` methods work similar to `std::any_cast<T>()` except that
- * non-copyable types may only be cast to references.
- *
- * Example usage:
- * unique_any u1(3);
- * auto u2 = unique_any(std::move(u1)); // u1 is moved from
- * int i = any_cast<int>(u2);
- *
- * unique_any u2;
- * u2 = std::unique_ptr<int>(new int);
- * std::unique_ptr<int> iPtr = any_cast<std::unique_ptr<int>>(std::move(u2));
- *
- * Inspired by linb::any (https://github.com/thelink2012/any) and the
- * libc++ implementation (https://github.com/llvm-mirror/libcxx).
- */
-class unique_any final
-{
-public:
- unique_any() = default;
-
- //Copy constructor (deleted)
- unique_any(const unique_any& rhs) = delete;
-
- unique_any(unique_any&& rhs) : vtable(rhs.vtable) {
- if (vtable) {
- vtable->move(std::move(rhs.storage), storage);
- }
- rhs.vtable = nullptr;
- }
-
- // Constructs with a direct-initilizated object of type ValueType
- template <typename ValueType,
- typename _Vt = std::decay_t<ValueType>,
- typename = std::enable_if_t<!std::is_same<_Vt, unique_any>::value> >
- unique_any(ValueType&& value) {
- create(std::forward<ValueType>(value));
- }
-
- ~unique_any() {
- reset();
- }
-
- unique_any& operator=(unique_any&& rhs) {
- unique_any(std::move(rhs)).swap(*this);
- return *this;
- }
-
- template <class ValueType,
- typename = std::enable_if_t<!std::is_same<std::decay_t<ValueType>, unique_any>::value> >
- unique_any& operator=(ValueType&& rhs) {
- unique_any(std::forward<ValueType>(rhs)).swap(*this);
- return *this;
- }
-
- void reset() {
- if (vtable) {
- vtable->destroy(storage);
- vtable = nullptr;
- }
- }
-
- void swap(unique_any& rhs) {
- if (this == &rhs) {
- return;
- } else {
- unique_any tmp(std::move(rhs));
- rhs.vtable = vtable;
- if (rhs.vtable) {
- rhs.vtable->move(std::move(storage), rhs.storage);
- }
- vtable = tmp.vtable;
- if (vtable) {
- vtable->move(std::move(tmp.storage), storage);
- }
- }
- }
-
- const std::type_info& type() const {
- return !has_value()? typeid(void) : vtable->type();
- }
-
- bool has_value() const {
- return vtable != nullptr;
- }
-
-private:
-
- union Storage {
- using StackStorage = std::aligned_storage_t<3*sizeof(void*), std::alignment_of<void*>::value>;
- Storage() = default;
-
- void * dynamic { nullptr };
- StackStorage stack;
- };
-
- template<typename T>
- struct AllocateOnStack : std::integral_constant<bool,
- sizeof(T) <= sizeof(Storage::stack)
- && std::alignment_of<T>::value <= std::alignment_of<Storage::StackStorage>::value
- && std::is_nothrow_move_constructible<T>::value> {
- };
-
- struct VTable {
- virtual ~VTable() = default;
- virtual void move(Storage&& src, Storage& dest) = 0;
- virtual void destroy(Storage&) = 0;
- virtual const std::type_info& type() = 0;
- };
-
- template <typename ValueType>
- struct VTableHeap : public VTable {
- void move(Storage&& src, Storage& dest) override {
- dest.dynamic = src.dynamic;
- src.dynamic = nullptr;
- }
-
- void destroy(Storage& s) override {
- delete reinterpret_cast<ValueType*>(s.dynamic);
- }
-
- const std::type_info& type() override {
- return typeid(ValueType);
- }
- };
-
- template <typename ValueType>
- struct VTableStack : public VTable {
- void move(Storage&& src, Storage& dest) override {
- new (&dest.stack) ValueType(std::move(reinterpret_cast<ValueType&>(src.stack)));
- destroy(src);
- }
-
- void destroy(Storage& s) override {
- reinterpret_cast<ValueType&>(s.stack).~ValueType();
- }
-
- const std::type_info& type() override {
- return typeid(ValueType);
- }
- };
-
- template <typename ValueType>
- static VTable* vtableForType() {
- using VTableType = std::conditional_t<AllocateOnStack<ValueType>::value, VTableStack<ValueType>, VTableHeap<ValueType> >;
- static VTableType vtable;
- return &vtable;
- }
-
- template <typename ValueType, typename _Vt>
- std::enable_if_t<AllocateOnStack<_Vt>::value>
- createStorage(ValueType&& value) {
- new (&storage.stack) _Vt(std::forward<ValueType>(value));
- }
-
- template <typename ValueType, typename _Vt>
- std::enable_if_t<!AllocateOnStack<_Vt>::value>
- createStorage(ValueType&& value) {
- storage.dynamic = new _Vt(std::forward<ValueType>(value));
- }
-
- template <typename ValueType>
- void create(ValueType&& value) {
- using _Vt = std::decay_t<ValueType>;
- vtable = vtableForType<_Vt>();
- createStorage<ValueType, _Vt>(std::forward<ValueType>(value));
- }
-
- VTable* vtable { nullptr };
- Storage storage;
-
-protected:
- template<class ValueType>
- friend const ValueType* any_cast(const unique_any* operand) ;
-
- template<class ValueType>
- friend ValueType* any_cast(unique_any* operand) ;
-
- template<typename ValueType, typename _Vt = std::decay_t<ValueType> >
- ValueType* cast()
- {
- return reinterpret_cast<ValueType *>(
- AllocateOnStack<_Vt>::value ? &storage.stack : storage.dynamic);
- }
-};
-
-template<typename ValueType>
-inline const ValueType* any_cast(const unique_any* any)
-{
- return any_cast<ValueType>(const_cast<unique_any *>(any));
-}
-
-template<typename ValueType>
-inline ValueType* any_cast(unique_any* any)
-{
- if(any == nullptr || any->type() != typeid(ValueType))
- return nullptr;
- else
- return any->cast<ValueType>();
-}
-
-template<typename ValueType, typename _Vt = std::decay_t<ValueType> >
-inline ValueType any_cast(const unique_any& any)
-{
- static_assert(std::is_constructible<ValueType, const _Vt&>::value,
- "any_cast type can't construct copy of contained object");
- auto temp = any_cast<_Vt>(&any);
- if (temp == nullptr) {
- throw bad_any_cast();
- }
- return static_cast<ValueType>(*temp);
-}
-
-template<typename ValueType, typename _Vt = std::decay_t<ValueType> >
-inline ValueType any_cast(unique_any& any)
-{
- static_assert(std::is_constructible<ValueType, const _Vt&>::value,
- "any_cast type can't construct copy of contained object");
- auto temp = any_cast<_Vt>(&any);
- if (temp == nullptr) {
- throw bad_any_cast();
- }
- return static_cast<ValueType>(*temp);
-}
-
-template<typename ValueType, typename _Vt = std::remove_cv_t<ValueType> >
-inline ValueType any_cast(unique_any&& any)
-{
- auto temp = any_cast<_Vt>(&any);
- if (temp == nullptr) {
- throw bad_any_cast();
- }
- auto retValue = static_cast<ValueType>(std::move(*temp));
- any.reset();
- return std::move(retValue);
-}
-
-} // namespace util
-} // namespace mbgl
-
-namespace std {
-
-inline void swap(mbgl::util::unique_any& lhs, mbgl::util::unique_any& rhs) {
- lhs.swap(rhs);
-}
-
-} // namespace std