tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[core] Use mapbox::base::TypeWrapper instead of utils::peer

Browse Source
This commit is contained in:
Mikhail Pozdnyakov
2019-09-09 18:35:23 +03:00
parent 5207a36074
commit 151ea331f8
10 changed files with 9 additions and 232 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
include/mbgl/style/layer.hpp
View File

@@ -1,12 +1,12 @@
#pragma once
#include <mbgl/util/peer.hpp>
#include <mbgl/util/immutable.hpp>
#include <mbgl/util/optional.hpp>
#include <mbgl/style/types.hpp>
#include <mbgl/style/conversion.hpp>
#include <mapbox/weak.hpp>
#include <mapbox/type_wrapper.hpp>
#include <cassert>
#include <memory>
@@ -121,7 +121,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::peer peer;
mapbox::base::TypeWrapper peer;
Layer(Immutable<Impl>);
const LayerTypeInfo* getTypeInfo() const noexcept;

4
include/mbgl/style/source.hpp
View File

@@ -2,11 +2,11 @@
#include <mbgl/util/noncopyable.hpp>
#include <mbgl/util/optional.hpp>
#include <mbgl/util/peer.hpp>
#include <mbgl/util/immutable.hpp>
#include <mbgl/style/types.hpp>
#include <mapbox/weak.hpp>
#include <mapbox/type_wrapper.hpp>
#include <memory>
#include <string>
@@ -79,7 +79,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::peer peer;
mapbox::base::TypeWrapper peer;
virtual mapbox::base::WeakPtr<Source> makeWeakPtr() = 0;
};

34
include/mbgl/util/peer.hpp
View File

@@ -1,34 +0,0 @@
#pragma once
#include <memory>
#include <type_traits>
#include <utility>
namespace mbgl {
namespace util {
class peer {
public:
peer() noexcept : storage(nullptr, noop_deleter) {}
template <class T>
peer(T&& value) noexcept : storage(new std::decay_t<T>(std::forward<T>(value)), cast_deleter<std::decay_t<T>>) {
static_assert(!std::is_same<peer, std::decay_t<T>>::value, "Peer must not wrap itself.");
}
bool has_value() const noexcept { return static_cast<bool>(storage); }
template <class T>
T& get() noexcept { return *reinterpret_cast<T*>(storage.get()); }
private:
template <typename T>
static void cast_deleter(void* ptr) noexcept { delete reinterpret_cast<T*>(ptr); }
static void noop_deleter(void*) noexcept {}
using storage_t = std::unique_ptr<void, void(*)(void*)>;
storage_t storage;
};
} // namespace util
} // namespace mbgl

2
platform/android/src/style/sources/source.cpp
View File

@@ -133,7 +133,7 @@ namespace android {
// Release the peer relationships. These will be re-established when the source is added to a map
assert(ownedSource->peer.has_value());
ownedSource->peer.get<std::unique_ptr<Source>>().release();
ownedSource->peer = util::peer();
ownedSource->peer = mapbox::base::TypeWrapper();
// Release the strong reference to the java peer
assert(javaPeer);

3
scripts/generate-file-lists.js
View File

@@ -144,7 +144,8 @@ generateFileList('vendor/mapbox-base-files.json',
'vendor/mapbox-base/mapbox/supercluster.hpp',
'vendor/mapbox-base/mapbox/geojson.hpp',
'vendor/mapbox-base/mapbox/jni.hpp',
'vendor/mapbox-base/mapbox/weak' ],
'vendor/mapbox-base/mapbox/weak',
'vendor/mapbox-base/mapbox/typewrapper' ],
vendorRegex, [ "include/*.hpp", "include/**/*.hpp", "include/**/*.h", "optional.hpp", ":!:include/jni/string_conversion.hpp" ]);
generateFileList('vendor/polylabel-files.json', [ 'vendor/polylabel' ], vendorRegex, [ "include/**/*.hpp" ]);
generateFileList('vendor/protozero-files.json', [ 'vendor/protozero' ], vendorRegex, [ "include/**/*.hpp" ]);

1
src/core-files.json
View File

@@ -479,7 +479,6 @@
"mbgl/util/logging.hpp": "include/mbgl/util/logging.hpp",
"mbgl/util/noncopyable.hpp": "include/mbgl/util/noncopyable.hpp",
"mbgl/util/optional.hpp": "include/mbgl/util/optional.hpp",
"mbgl/util/peer.hpp": "include/mbgl/util/peer.hpp",
"mbgl/util/platform.hpp": "include/mbgl/util/platform.hpp",
"mbgl/util/premultiply.hpp": "include/mbgl/util/premultiply.hpp",
"mbgl/util/projection.hpp": "include/mbgl/util/projection.hpp",

1
test/test-files.json
View File

@@ -93,7 +93,6 @@
"test/util/merge_lines.test.cpp",
"test/util/number_conversions.test.cpp",
"test/util/offscreen_texture.test.cpp",
"test/util/peer.test.cpp",
"test/util/position.test.cpp",
"test/util/projection.test.cpp",
"test/util/run_loop.test.cpp",

189
test/util/peer.test.cpp
View File

@@ -1,189 +0,0 @@
#include <mbgl/test/util.hpp>
#include <mbgl/util/peer.hpp>
using namespace mbgl::util;
class TestType {
public:
TestType() {
str[0] = 'a';
}
//Detect moves
TestType(TestType&& t): i1(t.i1+1), i2(t.i2+2) {
str[0] = t.str[0]+1;
}
TestType(const TestType&) = delete;
TestType& operator=(const TestType&) = delete;
int i1 = 0;
int i2 = 1;
char str[256];
};
bool IsStackAllocated (const peer& a, const void* obj1) {
auto a_ptr = (uintptr_t)(&a);
auto obj = (uintptr_t)(obj1);
return (obj >= a_ptr && obj < a_ptr + sizeof(peer));
};
TEST(Peer, Empty) {
EXPECT_FALSE(peer().has_value());
}
TEST(Peer, BasicTypes) {
peer i = 3;
EXPECT_TRUE(i.has_value());
EXPECT_TRUE(i.get<decltype(3)>() == 3);
auto iValue = i.get<decltype(3)>();
EXPECT_TRUE(iValue == 3);
EXPECT_TRUE(peer(4).has_value());
EXPECT_TRUE(peer(4).get<decltype(4)>() == 4);
peer f = 6.2f;
EXPECT_TRUE(f.has_value());
EXPECT_TRUE(f.get<decltype(6.2f)>() == 6.2f);
const float fValue = f.get<decltype(6.2f)>();
EXPECT_TRUE(fValue == 6.2f);
EXPECT_TRUE(peer(1.0f).has_value());
EXPECT_TRUE(peer(1.0f).get<decltype(1.0f)>() == 1.0f);
peer c = 'z';
EXPECT_TRUE(c.has_value());
EXPECT_TRUE(c.get<decltype('z')>() == 'z');
EXPECT_TRUE(peer('z').has_value());
EXPECT_TRUE(peer('z').get<decltype('z')>() == 'z');
}
TEST(Peer, BasicTypes_Move) {
peer i = 3;
EXPECT_TRUE(i.has_value());
peer f = 6.2f;
EXPECT_TRUE(f.has_value());
f = std::move(i);
EXPECT_FALSE(i.has_value());
EXPECT_TRUE(f.has_value());
EXPECT_TRUE(f.get<decltype(3)>() == 3);
}
TEST(Peer, SmallType) {
struct T {
T(int32_t* p_) : p(p_) {
(*p)++;
}
T(T&& t) noexcept : p(t.p) {
(*p)++;
}
~T() {
(*p)--;
}
T(const T&) = delete;
T& operator=(const T&) = delete;
int32_t* p;
};
int32_t p = 0;
{
peer u1 = peer(T(&p));
EXPECT_EQ(p, 1);
auto u2(std::move(u1));
EXPECT_EQ(p, 1);
}
EXPECT_EQ(p, 0);
}
TEST(Peer, LargeType) {
TestType t1;
peer u1 = peer(std::move(t1));
EXPECT_TRUE(u1.has_value());
//TestType should be moved into owning peer
EXPECT_EQ(u1.get<TestType>().i1, 1);
auto u2(std::move(u1));
EXPECT_FALSE(u1.has_value());
//TestType should not be moved when owning peer is moved;
EXPECT_EQ(u2.get<TestType>().i1, 1);
// TestType should not be moved out of owning peer
auto& t2 = u2.get<TestType>();
EXPECT_TRUE(u2.has_value());
EXPECT_EQ(t2.i1, 1);
}
TEST(Peer, Pointer) {
auto t1 = new TestType();
auto u1 = peer(std::move(t1));
EXPECT_TRUE(u1.has_value());
//Only the pointer should be moved
TestType * t2 = u1.get<TestType *>();
EXPECT_EQ(t2->i1, 0);
peer u2(4);
std::swap(u2, u1);
EXPECT_TRUE(u1.has_value());
EXPECT_TRUE(u2.has_value());
t2 = u2.get<TestType *>();
EXPECT_EQ(t2->i1, 0);
delete t2;
}
TEST(Peer, UniquePtr) {
auto t1 = std::make_unique<TestType>();
auto u1 = peer(std::move(t1));
EXPECT_EQ(t1.get(), nullptr);
EXPECT_TRUE(u1.has_value());
u1 = peer();
EXPECT_FALSE(u1.has_value());
peer u2;
auto* t3 = new TestType();
u2 = std::unique_ptr<TestType>(t3);
EXPECT_TRUE(u2.has_value());
}
TEST(Peer, SharedPtr) {
std::shared_ptr<int> shared(new int(3));
std::weak_ptr<int> weak = shared;
peer u1 = 0;
EXPECT_EQ(weak.use_count(), 1);
peer u2 = shared;
EXPECT_EQ(weak.use_count(), 2);
u1 = std::move(u2);
EXPECT_EQ(weak.use_count(), 2);
std::swap(u2, u1);
EXPECT_EQ(weak.use_count(), 2);
u2 = 0;
EXPECT_EQ(weak.use_count(), 1);
shared = nullptr;
EXPECT_EQ(weak.use_count(), 0);
}

2
vendor/mapbox-base vendored

Submodule vendor/mapbox-base updated: 51505b91b3...8ca46e8f8e

1
vendor/mapbox-base-files.json vendored
View File

@@ -93,6 +93,7 @@
"optional.hpp": "vendor/mapbox-base/mapbox/optional/optional.hpp",
"mapbox/pixelmatch.hpp": "vendor/mapbox-base/mapbox/pixelmatch-cpp/include/mapbox/pixelmatch.hpp",
"supercluster.hpp": "vendor/mapbox-base/mapbox/supercluster.hpp/include/supercluster.hpp",
"mapbox/type_wrapper.hpp": "vendor/mapbox-base/mapbox/typewrapper/include/mapbox/type_wrapper.hpp",
"mapbox/optional.hpp": "vendor/mapbox-base/mapbox/variant/include/mapbox/optional.hpp",
"mapbox/recursive_wrapper.hpp": "vendor/mapbox-base/mapbox/variant/include/mapbox/recursive_wrapper.hpp",
"mapbox/variant.hpp": "vendor/mapbox-base/mapbox/variant/include/mapbox/variant.hpp",