Skip to content

Commit b069b86

Browse files
kringkring
committed
Remove non-const version of getRootTile.
1 parent 396dfc1 commit b069b86

File tree

8 files changed

+88
-49
lines changed

8 files changed

+88
-49
lines changed

‎Cesium3DTilesSelection/include/Cesium3DTilesSelection/DebugTileStateDatabase.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -72,7 +72,7 @@ class DebugTileStateDatabase {
7272
void recordTileState(
7373
int32_t frameNumber,
7474
const Tile& tile,
75-
const std::unordered_map<Tile::Pointer, TileSelectionState>& states);
75+
const std::unordered_map<const Tile*, TileSelectionState>& states);
7676

7777
private:
7878
struct Impl;

‎Cesium3DTilesSelection/include/Cesium3DTilesSelection/Tileset.h

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -193,9 +193,6 @@ class CESIUM3DTILESSELECTION_API Tileset final {
193193
*
194194
* This may be `nullptr` if there is currently no root tile.
195195
*/
196-
Tile* getRootTile() noexcept;
197-
198-
/** @copydoc Tileset::getRootTile() */
199196
const Tile* getRootTile() const noexcept;
200197

201198
/**

‎Cesium3DTilesSelection/src/DebugTileStateDatabase.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -220,7 +220,7 @@ void DebugTileStateDatabase::recordTileState(
220220
void DebugTileStateDatabase::recordTileState(
221221
int32_t frameNumber,
222222
const Tile& tile,
223-
const std::unordered_map<Tile::Pointer, TileSelectionState>& states) {
223+
const std::unordered_map<const Tile*, TileSelectionState>& states) {
224224
int status = CESIUM_SQLITE(sqlite3_reset)(this->_pImpl->writeTileState.get());
225225
if (status != SQLITE_OK) {
226226
return;

‎Cesium3DTilesSelection/src/Tileset.cpp

Lines changed: 2 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -170,10 +170,6 @@ void Tileset::setShowCreditsOnScreen(bool showCreditsOnScreen) noexcept {
170170
}
171171
}
172172

173-
Tile* Tileset::getRootTile() noexcept {
174-
return this->_pTilesetContentManager->getRootTile();
175-
}
176-
177173
const Tile* Tileset::getRootTile() const noexcept {
178174
return this->_pTilesetContentManager->getRootTile();
179175
}
@@ -392,7 +388,7 @@ const ViewUpdateResult& Tileset::updateViewGroup(
392388

393389
ViewUpdateResult& result = viewGroup.getViewUpdateResult();
394390

395-
Tile* pRootTile = this->getRootTile();
391+
Tile* pRootTile = this->_pTilesetContentManager->getRootTile();
396392
if (!pRootTile) {
397393
return result;
398394
}
@@ -438,7 +434,7 @@ void Tileset::loadTiles() {
438434

439435
this->_asyncSystem.dispatchMainThreadTasks();
440436

441-
Tile* pRootTile = this->getRootTile();
437+
Tile* pRootTile = this->_pTilesetContentManager->getRootTile();
442438
if (!pRootTile) {
443439
// If the root tile is marked as ready, but doesn't actually exist, then
444440
// the tileset couldn't load. Fail any outstanding height requests.

‎Cesium3DTilesSelection/test/TestTileLoadRequester.cpp

Lines changed: 31 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -25,9 +25,9 @@ class TestTileLoadRequester : public TileLoadRequester {
2525

2626
Tile* getNextTileToLoadInWorkerThread() override {
2727
CESIUM_ASSERT(!this->_workerThread.empty());
28-
Tile* pResult = this->_workerThread.back();
28+
const Tile* pResult = this->_workerThread.back();
2929
this->_workerThread.pop_back();
30-
return pResult;
30+
return const_cast<Tile*>(pResult);
3131
}
3232

3333
bool hasMoreTilesToLoadInMainThread() const override {
@@ -36,32 +36,38 @@ class TestTileLoadRequester : public TileLoadRequester {
3636

3737
Tile* getNextTileToLoadInMainThread() override {
3838
CESIUM_ASSERT(!this->_mainThread.empty());
39-
Tile* pResult = this->_mainThread.back();
39+
const Tile* pResult = this->_mainThread.back();
4040
this->_mainThread.pop_back();
41-
return pResult;
41+
return const_cast<Tile*>(pResult);
4242
}
4343

4444
// Extra methods for testing
4545
void setWeight(double weight) { this->_weight = weight; }
46-
void setWorkerThreadQueue(const std::vector<Tile*>& newQueue) {
46+
void setWorkerThreadQueue(const std::vector<const Tile*>& newQueue) {
47+
std::span<Tile*> newQueueCast(
48+
const_cast<Tile**>(newQueue.data()),
49+
newQueue.size());
4750
this->_keepAlive.insert(
4851
this->_keepAlive.end(),
49-
newQueue.begin(),
50-
newQueue.end());
52+
newQueueCast.begin(),
53+
newQueueCast.end());
5154
this->_workerThread = newQueue;
5255
}
53-
void setMainThreadQueue(const std::vector<Tile*>& newQueue) {
56+
void setMainThreadQueue(const std::vector<const Tile*>& newQueue) {
57+
std::span<Tile*> newQueueCast(
58+
const_cast<Tile**>(newQueue.data()),
59+
newQueue.size());
5460
this->_keepAlive.insert(
5561
this->_keepAlive.end(),
56-
newQueue.begin(),
57-
newQueue.end());
62+
newQueueCast.begin(),
63+
newQueueCast.end());
5864
this->_mainThread = newQueue;
5965
}
6066

6167
private:
6268
double _weight = 1.0;
63-
std::vector<Tile*> _workerThread;
64-
std::vector<Tile*> _mainThread;
69+
std::vector<const Tile*> _workerThread;
70+
std::vector<const Tile*> _mainThread;
6571
std::vector<Tile::Pointer> _keepAlive;
6672
};
6773

@@ -104,7 +110,7 @@ TEST_CASE("TileLoadRequester") {
104110

105111
auto pTileset = EllipsoidTilesetLoader::createTileset(externals);
106112

107-
Tile* pRoot = pTileset->getRootTile();
113+
const Tile* pRoot = pTileset->getRootTile();
108114
REQUIRE(pRoot != nullptr);
109115
REQUIRE(pRoot->getChildren().size() == 2);
110116
REQUIRE(pRoot->getState() == TileLoadState::ContentLoaded);
@@ -113,7 +119,7 @@ TEST_CASE("TileLoadRequester") {
113119
TestTileLoadRequester requester;
114120
pTileset->registerLoadRequester(requester);
115121

116-
Tile* pToLoad = &pRoot->getChildren()[1];
122+
const Tile* pToLoad = &pRoot->getChildren()[1];
117123
CHECK(pToLoad->getState() == TileLoadState::Unloaded);
118124

119125
// loadTiles won't load the tile because nothing has requested it yet.
@@ -171,7 +177,7 @@ TEST_CASE("TileLoadRequester") {
171177
std::move(pRootTile),
172178
options);
173179

174-
Tile* pRoot = pTileset->getRootTile();
180+
const Tile* pRoot = pTileset->getRootTile();
175181
REQUIRE(pRoot != nullptr);
176182
REQUIRE(pRoot->getChildren().size() == 100);
177183

@@ -187,21 +193,23 @@ TEST_CASE("TileLoadRequester") {
187193
pTileset->registerLoadRequester(reqVeryLow);
188194
pTileset->registerLoadRequester(reqVeryHigh);
189195

190-
std::vector<Tile*> pointers(pRoot->getChildren().size());
196+
std::vector<const Tile*> pointers(pRoot->getChildren().size());
191197
std::transform(
192198
pRoot->getChildren().begin(),
193199
pRoot->getChildren().end(),
194200
pointers.begin(),
195-
[](Tile& tile) { return &tile; });
201+
[](const Tile& tile) { return &tile; });
196202

197203
reqNormal.setWorkerThreadQueue(
198-
std::vector<Tile*>(pointers.begin(), pointers.begin() + 20));
199-
reqExtra.setWorkerThreadQueue(
200-
std::vector<Tile*>(pointers.begin() + 20, pointers.begin() + 40));
201-
reqVeryLow.setWorkerThreadQueue(
202-
std::vector<Tile*>(pointers.begin() + 40, pointers.begin() + 60));
204+
std::vector<const Tile*>(pointers.begin(), pointers.begin() + 20));
205+
reqExtra.setWorkerThreadQueue(std::vector<const Tile*>(
206+
pointers.begin() + 20,
207+
pointers.begin() + 40));
208+
reqVeryLow.setWorkerThreadQueue(std::vector<const Tile*>(
209+
pointers.begin() + 40,
210+
pointers.begin() + 60));
203211
reqVeryHigh.setWorkerThreadQueue(
204-
std::vector<Tile*>(pointers.begin() + 80, pointers.end()));
212+
std::vector<const Tile*>(pointers.begin() + 80, pointers.end()));
205213

206214
std::vector<const TestTileLoadRequester*> requestersOutOfTiles;
207215

‎Cesium3DTilesSelection/test/TestTilesetSelectionAlgorithm.cpp

Lines changed: 11 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -765,10 +765,10 @@ TEST_CASE("Render any tiles even when one of children can't be rendered for "
765765
initializeTileset(tileset);
766766
ViewState viewState = zoomToTileset(tileset);
767767

768-
Tile* pTilesetJson = tileset.getRootTile();
768+
const Tile* pTilesetJson = tileset.getRootTile();
769769
REQUIRE(pTilesetJson);
770770
REQUIRE(pTilesetJson->getChildren().size() == 1);
771-
Tile* root = &pTilesetJson->getChildren()[0];
771+
const Tile* root = &pTilesetJson->getChildren()[0];
772772

773773
REQUIRE(!doesTileMeetSSE(viewState, *root, tileset));
774774
REQUIRE(root->getState() == TileLoadState::ContentLoading);
@@ -1206,10 +1206,11 @@ TEST_CASE("Makes metadata available once root tile is loaded") {
12061206
Tileset tileset(tilesetExternals, "tileset.json");
12071207
initializeTileset(tileset);
12081208

1209-
Tile* pRoot = tileset.getRootTile();
1209+
const Tile* pRoot = tileset.getRootTile();
12101210
REQUIRE(pRoot);
12111211

1212-
TileExternalContent* pExternal = pRoot->getContent().getExternalContent();
1212+
const TileExternalContent* pExternal =
1213+
pRoot->getContent().getExternalContent();
12131214
REQUIRE(pExternal);
12141215

12151216
const TilesetMetadata& metadata = pExternal->metadata;
@@ -1262,16 +1263,16 @@ TEST_CASE("Makes metadata available on external tilesets") {
12621263
Tileset tileset(tilesetExternals, "tileset.json");
12631264
initializeTileset(tileset);
12641265

1265-
Tile* pTilesetJson = tileset.getRootTile();
1266+
const Tile* pTilesetJson = tileset.getRootTile();
12661267
REQUIRE(pTilesetJson);
12671268
REQUIRE(pTilesetJson->getChildren().size() == 1);
12681269

1269-
Tile* pRoot = &pTilesetJson->getChildren()[0];
1270+
const Tile* pRoot = &pTilesetJson->getChildren()[0];
12701271
REQUIRE(pRoot);
12711272
REQUIRE(pRoot->getChildren().size() == 5);
1272-
Tile* pExternal = &pRoot->getChildren()[4];
1273+
const Tile* pExternal = &pRoot->getChildren()[4];
12731274

1274-
TileExternalContent* pExternalContent = nullptr;
1275+
const TileExternalContent* pExternalContent = nullptr;
12751276

12761277
for (int i = 0; i < 10 && pExternalContent == nullptr; ++i) {
12771278
ViewState zoomToTileViewState = zoomToTile(*pExternal);
@@ -1634,8 +1635,8 @@ void runUnconditionallyRefinedTestCase(const TilesetOptions& options) {
16341635
// On the first update, we should refine down to the grandchild tile, even
16351636
// though no tiles are loaded yet.
16361637
initializeTileset(tileset);
1637-
Tile& child = tileset.getRootTile()->getChildren()[0];
1638-
Tile& grandchild = child.getChildren()[0];
1638+
const Tile& child = tileset.getRootTile()->getChildren()[0];
1639+
const Tile& grandchild = child.getChildren()[0];
16391640

16401641
auto states = viewGroup.getTraversalState().slowlyGetCurrentStates();
16411642

‎CesiumUtility/include/CesiumUtility/IntrusivePointer.h

Lines changed: 16 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -18,8 +18,13 @@ namespace CesiumUtility {
1818
*
1919
* @tparam T The type of object controlled.
2020
*/
21-
template <class T> class IntrusivePointer final {
21+
template <typename T> class IntrusivePointer final {
2222
public:
23+
/**
24+
* @brief The type pointed to by this pointer.
25+
*/
26+
using element_type = T;
27+
2328
/**
2429
* @brief Default constructor.
2530
*/
@@ -70,6 +75,16 @@ template <class T> class IntrusivePointer final {
7075
*/
7176
~IntrusivePointer() noexcept { this->releaseReference(); }
7277

78+
/**
79+
* @brief Implicitly converts this implicit pointer to a raw pointer.
80+
*/
81+
operator T*() noexcept { return this->_p; }
82+
83+
/**
84+
* @brief Implicitly converts this implicit pointer to a raw pointer.
85+
*/
86+
operator const T*() const noexcept { return this->_p; }
87+
7388
/**
7489
* @brief Constructs a new instance and assigns it to this IntrusivePointer.
7590
* If this IntrusivePointer already points to another instance,

‎CesiumUtility/include/CesiumUtility/TreeTraversalState.h

Lines changed: 26 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -3,11 +3,15 @@
33
#include <CesiumUtility/Assert.h>
44

55
#include <cstddef>
6+
#include <memory>
7+
#include <type_traits>
68
#include <unordered_map>
79
#include <vector>
810

911
namespace CesiumUtility {
1012

13+
template <typename T> class IntrusivePointer;
14+
1115
/**
1216
* @brief Associates state (arbitrary data) with each node during partial,
1317
* depth-first traversal of a tree. Then, during a later traversal of a
@@ -34,6 +38,22 @@ namespace CesiumUtility {
3438
*/
3539
template <typename TNodePointer, typename TState> class TreeTraversalState {
3640
public:
41+
/**
42+
* @brief The instance type of the node.
43+
*/
44+
using TNodeInstance = std::remove_cvref_t<
45+
typename std::pointer_traits<TNodePointer>::element_type>;
46+
47+
/**
48+
* @brief A raw pointer to a node.
49+
*/
50+
using TRawNodePointer = TNodeInstance*;
51+
52+
/**
53+
* @brief A raw pointer to a const node.
54+
*/
55+
using TRawConstNodePointer = const TNodeInstance*;
56+
3757
/**
3858
* @brief Gets the total number of nodes that were visited in the previous
3959
* traversal.
@@ -297,7 +317,8 @@ template <typename TNodePointer, typename TState> class TreeTraversalState {
297317
*
298318
* @return The mapping of nodes to current traversal states.
299319
*/
300-
std::unordered_map<TNodePointer, TState> slowlyGetCurrentStates() const {
320+
std::unordered_map<TRawConstNodePointer, TState>
321+
slowlyGetCurrentStates() const {
301322
return this->slowlyGetStates(this->_currentTraversal);
302323
}
303324

@@ -309,7 +330,8 @@ template <typename TNodePointer, typename TState> class TreeTraversalState {
309330
*
310331
* @return The mapping of nodes to previous traversal states.
311332
*/
312-
std::unordered_map<TNodePointer, TState> slowlyGetPreviousStates() const {
333+
std::unordered_map<TRawConstNodePointer, TState>
334+
slowlyGetPreviousStates() const {
313335
return this->slowlyGetStates(this->_previousTraversal);
314336
}
315337

@@ -374,9 +396,9 @@ template <typename TNodePointer, typename TState> class TreeTraversalState {
374396
return this->_currentTraversal[size_t(currentIndex)];
375397
}
376398

377-
std::unordered_map<TNodePointer, TState>
399+
std::unordered_map<TRawConstNodePointer, TState>
378400
slowlyGetStates(const std::vector<TraversalData>& traversalData) const {
379-
std::unordered_map<TNodePointer, TState> result;
401+
std::unordered_map<TRawConstNodePointer, TState> result;
380402

381403
for (const TraversalData& data : traversalData) {
382404
result[data.pNode] = data.state;

0 commit comments

Comments
 (0)