evert/osb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'main' into small-fixes

Browse Source
This commit is contained in:
Kae 2024-02-20 09:49:42 +11:00 committed by GitHub
commit aa987a2177
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
274 changed files with 1455 additions and 1444 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
source/CMakeLists.txt
View File

@ -261,16 +261,20 @@ IF (STAR_COMPILER_GNU)
SET (CMAKE_CXX_FLAGS_RELEASE "-DNDEBUG -Ofast") SET (CMAKE_CXX_FLAGS_RELEASE "-DNDEBUG -Ofast")
ELSEIF (STAR_COMPILER_CLANG) ELSEIF (STAR_COMPILER_CLANG)
SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,-export_dynamic -Wall -Wextra -Wuninitialized -Wno-parentheses-equality -Wno-deprecated-declarations") SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wuninitialized -Wno-parentheses-equality -Wno-deprecated-declarations")
SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wl,-export_dynamic -Wall -Wextra -Wuninitialized -Wno-parentheses-equality -Wno-deprecated-declarations") SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wall -Wextra -Wuninitialized -Wno-parentheses-equality -Wno-deprecated-declarations")
IF (STAR_SYSTEM_MACOS) IF (STAR_SYSTEM_MACOS)
SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++") SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
SET (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-export_dynamic")
SET (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-export_dynamic")
SET (CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++17") SET (CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++17")
SET (CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++") SET (CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
ELSEIF () ELSEIF ()
SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthread -D_REENTRANT") SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthread -D_REENTRANT")
SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread -D_REENTRANT") SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread -D_REENTRANT")
SET (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--export_dynamic")
SET (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--export_dynamic")
ENDIF () ENDIF ()
SET (CMAKE_C_FLAGS_DEBUG "-g") SET (CMAKE_C_FLAGS_DEBUG "-g")

4
source/application/StarApplication.cpp
View File

@ -7,11 +7,11 @@ namespace Star {
void Application::startup(StringList const&) {} void Application::startup(StringList const&) {}
void Application::applicationInit(ApplicationControllerPtr appController) { void Application::applicationInit(ApplicationControllerPtr appController) {
m_appController = move(appController); m_appController = std::move(appController);
} }
void Application::renderInit(RendererPtr renderer) { void Application::renderInit(RendererPtr renderer) {
m_renderer = move(renderer); m_renderer = std::move(renderer);
} }
void Application::windowChanged(WindowMode, Vec2U) {} void Application::windowChanged(WindowMode, Vec2U) {}

14
source/application/StarMainApplication_sdl.cpp
View File

@ -206,7 +206,7 @@ ControllerButton controllerButtonFromSdlControllerButton(uint8_t button) {
class SdlPlatform { class SdlPlatform {
public: public:
SdlPlatform(ApplicationUPtr application, StringList cmdLineArgs) { SdlPlatform(ApplicationUPtr application, StringList cmdLineArgs) {
m_application = move(application); m_application = std::move(application);
// extract application path from command line args // extract application path from command line args
String applicationPath = cmdLineArgs.first(); String applicationPath = cmdLineArgs.first();
@ -215,7 +215,7 @@ public:
StringList platformArguments; StringList platformArguments;
eraseWhere(cmdLineArgs, [&platformArguments](String& argument) { eraseWhere(cmdLineArgs, [&platformArguments](String& argument) {
if (argument.beginsWith("+platform")) { if (argument.beginsWith("+platform")) {
platformArguments.append(move(argument)); platformArguments.append(std::move(argument));
return true; return true;
} }
return false; return false;
@ -461,7 +461,7 @@ private:
Maybe<String> string; Maybe<String> string;
if (SDL_HasClipboardText()) { if (SDL_HasClipboardText()) {
if (auto text = SDL_GetClipboardText()) { if (auto text = SDL_GetClipboardText()) {
if (*text != NULL) if (*text != '\0')
string.emplace(text); string.emplace(text);
SDL_free(text); SDL_free(text);
} }
@ -482,7 +482,7 @@ private:
} }
void setApplicationTitle(String title) override { void setApplicationTitle(String title) override {
parent->m_windowTitle = move(title); parent->m_windowTitle = std::move(title);
if (parent->m_sdlWindow) if (parent->m_sdlWindow)
SDL_SetWindowTitle(parent->m_sdlWindow, parent->m_windowTitle.utf8Ptr()); SDL_SetWindowTitle(parent->m_sdlWindow, parent->m_windowTitle.utf8Ptr());
} }
@ -817,10 +817,10 @@ private:
else else
operations = { FlipImageOperation{ FlipImageOperation::Mode::FlipY } }; operations = { FlipImageOperation{ FlipImageOperation::Mode::FlipY } };
auto newImage = std::make_shared<Image>(move(processImageOperations(operations, *image))); auto newImage = std::make_shared<Image>(processImageOperations(operations, *image));
// Fix fully transparent pixels inverting the underlying display pixel on Windows (allowing this could be made configurable per cursor later!) // Fix fully transparent pixels inverting the underlying display pixel on Windows (allowing this could be made configurable per cursor later!)
newImage->forEachPixel([](unsigned x, unsigned y, Vec4B& pixel) { if (!pixel[3]) pixel[0] = pixel[1] = pixel[2] = 0; }); newImage->forEachPixel([](unsigned x, unsigned y, Vec4B& pixel) { if (!pixel[3]) pixel[0] = pixel[1] = pixel[2] = 0; });
entry->image = move(newImage); entry->image = std::move(newImage);
auto size = entry->image->size(); auto size = entry->image->size();
@ -907,7 +907,7 @@ private:
int runMainApplication(ApplicationUPtr application, StringList cmdLineArgs) { int runMainApplication(ApplicationUPtr application, StringList cmdLineArgs) {
try { try {
{ {
SdlPlatform platform(move(application), move(cmdLineArgs)); SdlPlatform platform(std::move(application), std::move(cmdLineArgs));
platform.run(); platform.run();
} }
Logger::info("Application: stopped gracefully"); Logger::info("Application: stopped gracefully");

14
source/application/StarP2PNetworkingService_pc.cpp
View File

@ -19,9 +19,9 @@ PcP2PNetworkingService::PcP2PNetworkingService(PcPlatformServicesStatePtr state)
: m_callbackConnectionFailure(this, &PcP2PNetworkingService::steamOnConnectionFailure), : m_callbackConnectionFailure(this, &PcP2PNetworkingService::steamOnConnectionFailure),
m_callbackJoinRequested(this, &PcP2PNetworkingService::steamOnJoinRequested), m_callbackJoinRequested(this, &PcP2PNetworkingService::steamOnJoinRequested),
m_callbackSessionRequest(this, &PcP2PNetworkingService::steamOnSessionRequest), m_callbackSessionRequest(this, &PcP2PNetworkingService::steamOnSessionRequest),
m_state(move(state)) { m_state(std::move(state)) {
#else #else
: m_state(move(state)) { : m_state(std::move(state)) {
#endif #endif
#ifdef STAR_ENABLE_DISCORD_INTEGRATION #ifdef STAR_ENABLE_DISCORD_INTEGRATION
@ -224,7 +224,7 @@ Either<String, P2PSocketUPtr> PcP2PNetworkingService::connectToPeer(P2PNetworkin
if (type == "discord") { if (type == "discord") {
auto remoteUserId = lexicalCast<discord::UserId>(peerId.extract("_")); auto remoteUserId = lexicalCast<discord::UserId>(peerId.extract("_"));
auto lobbyId = lexicalCast<discord::LobbyId>(peerId.extract("_")); auto lobbyId = lexicalCast<discord::LobbyId>(peerId.extract("_"));
String lobbySecret = move(peerId); String lobbySecret = std::move(peerId);
return makeRight(discordConnectRemote(remoteUserId, lobbyId, lobbySecret)); return makeRight(discordConnectRemote(remoteUserId, lobbyId, lobbySecret));
} }
} }
@ -242,7 +242,7 @@ void PcP2PNetworkingService::addPendingJoin(String connectionString) {
if (connectionString.extract(":") != "connect") if (connectionString.extract(":") != "connect")
throw ApplicationException::format("malformed connection string '{}'", connectionString); throw ApplicationException::format("malformed connection string '{}'", connectionString);
String target = move(connectionString); String target = std::move(connectionString);
String targetType = target.extract("_"); String targetType = target.extract("_");
if (targetType == "address") if (targetType == "address")
@ -357,7 +357,7 @@ void PcP2PNetworkingService::steamReceiveAll() {
SteamNetworking()->ReadP2PPacket(data.ptr(), messageSize, &messageSize, &messageRemoteUser); SteamNetworking()->ReadP2PPacket(data.ptr(), messageSize, &messageSize, &messageRemoteUser);
if (auto openSocket = m_steamOpenSockets.value(messageRemoteUser.ConvertToUint64())) { if (auto openSocket = m_steamOpenSockets.value(messageRemoteUser.ConvertToUint64())) {
MutexLocker socketLocker(openSocket->mutex); MutexLocker socketLocker(openSocket->mutex);
openSocket->incoming.append(move(data)); openSocket->incoming.append(std::move(data));
} }
} }
} }
@ -474,7 +474,7 @@ P2PSocketUPtr PcP2PNetworkingService::discordConnectRemote(discord::UserId remot
} }
}); });
return unique_ptr<P2PSocket>(move(socket)); return unique_ptr<P2PSocket>(std::move(socket));
} }
void PcP2PNetworkingService::discordOnReceiveMessage(discord::LobbyId lobbyId, discord::UserId userId, discord::NetworkChannelId channel, uint8_t* data, uint32_t size) { void PcP2PNetworkingService::discordOnReceiveMessage(discord::LobbyId lobbyId, discord::UserId userId, discord::NetworkChannelId channel, uint8_t* data, uint32_t size) {
@ -507,7 +507,7 @@ void PcP2PNetworkingService::discordOnLobbyMemberConnect(discord::LobbyId lobbyI
socket->mode = DiscordSocketMode::Connected; socket->mode = DiscordSocketMode::Connected;
m_discordOpenSockets[userId] = socket.get(); m_discordOpenSockets[userId] = socket.get();
m_pendingIncomingConnections.append(move(socket)); m_pendingIncomingConnections.append(std::move(socket));
Logger::info("Accepted new discord connection from remote user {}", userId); Logger::info("Accepted new discord connection from remote user {}", userId);
} }
} }

2
source/application/StarPlatformServices_pc.cpp
View File

@ -118,7 +118,7 @@ PcPlatformServicesUPtr PcPlatformServices::create(String const& path, StringList
for (auto& argument : platformArguments) { for (auto& argument : platformArguments) {
if (argument.beginsWith("+platform:connect:")) { if (argument.beginsWith("+platform:connect:")) {
Logger::info("PC platform services joining from command line argument '{}'", argument); Logger::info("PC platform services joining from command line argument '{}'", argument);
p2pNetworkingService->addPendingJoin(move(argument)); p2pNetworkingService->addPendingJoin(std::move(argument));
} else { } else {
throw ApplicationException::format("Unrecognized PC platform services command line argument '{}'", argument); throw ApplicationException::format("Unrecognized PC platform services command line argument '{}'", argument);
} }

14
source/application/StarRenderer.cpp
View File

@ -19,7 +19,7 @@ RenderQuad::RenderQuad(Vec2F posA, Vec2F posB, Vec2F posC, Vec2F posD, Vec4B col
d = { posD, { 0, 0 }, color, param1 }; d = { posD, { 0, 0 }, color, param1 };
} }
RenderQuad::RenderQuad(TexturePtr tex, Vec2F minPosition, float textureScale, Vec4B color, float param1) : texture(move(tex)) { RenderQuad::RenderQuad(TexturePtr tex, Vec2F minPosition, float textureScale, Vec4B color, float param1) : texture(std::move(tex)) {
Vec2F size = Vec2F(texture->size()); Vec2F size = Vec2F(texture->size());
a = { minPosition, { 0, 0 }, color, param1}; a = { minPosition, { 0, 0 }, color, param1};
b = { { (minPosition[0] + size[0] * textureScale), minPosition[1] }, { size[0], 0 }, color, param1 }; b = { { (minPosition[0] + size[0] * textureScale), minPosition[1] }, { size[0], 0 }, color, param1 };
@ -27,7 +27,7 @@ RenderQuad::RenderQuad(TexturePtr tex, Vec2F minPosition, float textureScale, Ve
d = { { minPosition[0], (minPosition[1] + size[1] * textureScale) }, { 0, size[1] }, color, param1 }; d = { { minPosition[0], (minPosition[1] + size[1] * textureScale) }, { 0, size[1] }, color, param1 };
} }
RenderQuad::RenderQuad(TexturePtr tex, RectF const& screenCoords, Vec4B color, float param1) : texture(move(tex)) { RenderQuad::RenderQuad(TexturePtr tex, RectF const& screenCoords, Vec4B color, float param1) : texture(std::move(tex)) {
Vec2F size = Vec2F(texture->size()); Vec2F size = Vec2F(texture->size());
a = { screenCoords.min(), { 0, 0 }, color, param1 }; a = { screenCoords.min(), { 0, 0 }, color, param1 };
b = { { screenCoords.xMax(), screenCoords.yMin(), }, { size[0], 0.f }, color, param1 }; b = { { screenCoords.xMax(), screenCoords.yMin(), }, { size[0], 0.f }, color, param1 };
@ -35,7 +35,7 @@ RenderQuad::RenderQuad(TexturePtr tex, RectF const& screenCoords, Vec4B color, f
d = { { screenCoords.xMin(), screenCoords.yMax(), }, { 0.f, size[1] }, color, param1 }; d = { { screenCoords.xMin(), screenCoords.yMax(), }, { 0.f, size[1] }, color, param1 };
} }
RenderQuad::RenderQuad(TexturePtr tex, Vec2F posA, Vec2F uvA, Vec2F posB, Vec2F uvB, Vec2F posC, Vec2F uvC, Vec2F posD, Vec2F uvD, Vec4B color, float param1) : texture(move(tex)) { RenderQuad::RenderQuad(TexturePtr tex, Vec2F posA, Vec2F uvA, Vec2F posB, Vec2F uvB, Vec2F posC, Vec2F uvC, Vec2F posD, Vec2F uvD, Vec4B color, float param1) : texture(std::move(tex)) {
a = { posA, uvA, color, param1 }; a = { posA, uvA, color, param1 };
b = { posB, uvB, color, param1 }; b = { posB, uvB, color, param1 };
c = { posC, uvC, color, param1 }; c = { posC, uvC, color, param1 };
@ -43,7 +43,7 @@ RenderQuad::RenderQuad(TexturePtr tex, Vec2F posA, Vec2F uvA, Vec2F posB, Vec2F
} }
RenderQuad::RenderQuad(TexturePtr tex, RenderVertex vA, RenderVertex vB, RenderVertex vC, RenderVertex vD) RenderQuad::RenderQuad(TexturePtr tex, RenderVertex vA, RenderVertex vB, RenderVertex vC, RenderVertex vD)
: texture(move(tex)), a(move(vA)), b(move(vB)), c(move(vC)), d(move(vD)) {} : texture(std::move(tex)), a(std::move(vA)), b(std::move(vB)), c(std::move(vC)), d(std::move(vD)) {}
RenderQuad::RenderQuad(RectF const& rect, Vec4B color, float param1) RenderQuad::RenderQuad(RectF const& rect, Vec4B color, float param1)
: a{ rect.min(), {}, color, param1 } : a{ rect.min(), {}, color, param1 }
@ -64,18 +64,18 @@ RenderTriangle::RenderTriangle(Vec2F posA, Vec2F posB, Vec2F posC, Vec4B color,
c = { posC, { 0, 0 }, color, param1 }; c = { posC, { 0, 0 }, color, param1 };
} }
RenderTriangle::RenderTriangle(TexturePtr tex, Vec2F posA, Vec2F uvA, Vec2F posB, Vec2F uvB, Vec2F posC, Vec2F uvC, Vec4B color, float param1) : texture(move(tex)) { RenderTriangle::RenderTriangle(TexturePtr tex, Vec2F posA, Vec2F uvA, Vec2F posB, Vec2F uvB, Vec2F posC, Vec2F uvC, Vec4B color, float param1) : texture(std::move(tex)) {
a = { posA, uvA, color, param1 }; a = { posA, uvA, color, param1 };
b = { posB, uvB, color, param1 }; b = { posB, uvB, color, param1 };
c = { posC, uvC, color, param1 }; c = { posC, uvC, color, param1 };
} }
RenderQuad renderTexturedRect(TexturePtr texture, Vec2F minPosition, float textureScale, Vec4B color, float param1) { RenderQuad renderTexturedRect(TexturePtr texture, Vec2F minPosition, float textureScale, Vec4B color, float param1) {
return RenderQuad(move(texture), minPosition, textureScale, color, param1); return RenderQuad(std::move(texture), minPosition, textureScale, color, param1);
} }
RenderQuad renderTexturedRect(TexturePtr texture, RectF const& screenCoords, Vec4B color, float param1) { RenderQuad renderTexturedRect(TexturePtr texture, RectF const& screenCoords, Vec4B color, float param1) {
return RenderQuad(move(texture), screenCoords, color, param1); return RenderQuad(std::move(texture), screenCoords, color, param1);
} }
RenderQuad renderFlatRect(RectF const& rect, Vec4B color, float param1) { RenderQuad renderFlatRect(RectF const& rect, Vec4B color, float param1) {

12
source/application/StarRenderer_opengl20.cpp
View File

@ -416,7 +416,7 @@ List<RenderPrimitive>& OpenGl20Renderer::immediatePrimitives() {
} }
void OpenGl20Renderer::render(RenderPrimitive primitive) { void OpenGl20Renderer::render(RenderPrimitive primitive) {
m_immediatePrimitives.append(move(primitive)); m_immediatePrimitives.append(std::move(primitive));
} }
void OpenGl20Renderer::renderBuffer(RenderBufferPtr const& renderBuffer, Mat3F const& transformation) { void OpenGl20Renderer::renderBuffer(RenderBufferPtr const& renderBuffer, Mat3F const& transformation) {
@ -672,7 +672,7 @@ void OpenGl20Renderer::GlRenderBuffer::set(List<RenderPrimitive>& primitives) {
glBufferData(GL_ARRAY_BUFFER, accumulationBuffer.size(), accumulationBuffer.ptr(), GL_STREAM_DRAW); glBufferData(GL_ARRAY_BUFFER, accumulationBuffer.size(), accumulationBuffer.ptr(), GL_STREAM_DRAW);
} }
vertexBuffers.emplace_back(move(vb)); vertexBuffers.emplace_back(std::move(vb));
currentTextures.clear(); currentTextures.clear();
currentTextureSizes.clear(); currentTextureSizes.clear();
@ -701,7 +701,7 @@ void OpenGl20Renderer::GlRenderBuffer::set(List<RenderPrimitive>& primitives) {
if (auto gt = as<GlGroupedTexture>(texture.get())) if (auto gt = as<GlGroupedTexture>(texture.get()))
gt->incrementBufferUseCount(); gt->incrementBufferUseCount();
usedTextures.add(move(texture)); usedTextures.add(std::move(texture));
return {float(textureIndex), Vec2F(glTexture->glTextureCoordinateOffset())}; return {float(textureIndex), Vec2F(glTexture->glTextureCoordinateOffset())};
}; };
@ -723,14 +723,14 @@ void OpenGl20Renderer::GlRenderBuffer::set(List<RenderPrimitive>& primitives) {
Texture* lastTexture = nullptr; Texture* lastTexture = nullptr;
for (auto& primitive : primitives) { for (auto& primitive : primitives) {
if (auto tri = primitive.ptr<RenderTriangle>()) { if (auto tri = primitive.ptr<RenderTriangle>()) {
tie(textureIndex, textureOffset) = addCurrentTexture(move(tri->texture)); tie(textureIndex, textureOffset) = addCurrentTexture(std::move(tri->texture));
appendBufferVertex(tri->a, textureIndex, textureOffset); appendBufferVertex(tri->a, textureIndex, textureOffset);
appendBufferVertex(tri->b, textureIndex, textureOffset); appendBufferVertex(tri->b, textureIndex, textureOffset);
appendBufferVertex(tri->c, textureIndex, textureOffset); appendBufferVertex(tri->c, textureIndex, textureOffset);
} else if (auto quad = primitive.ptr<RenderQuad>()) { } else if (auto quad = primitive.ptr<RenderQuad>()) {
tie(textureIndex, textureOffset) = addCurrentTexture(move(quad->texture)); tie(textureIndex, textureOffset) = addCurrentTexture(std::move(quad->texture));
appendBufferVertex(quad->a, textureIndex, textureOffset); appendBufferVertex(quad->a, textureIndex, textureOffset);
appendBufferVertex(quad->b, textureIndex, textureOffset); appendBufferVertex(quad->b, textureIndex, textureOffset);
@ -742,7 +742,7 @@ void OpenGl20Renderer::GlRenderBuffer::set(List<RenderPrimitive>& primitives) {
} else if (auto poly = primitive.ptr<RenderPoly>()) { } else if (auto poly = primitive.ptr<RenderPoly>()) {
if (poly->vertexes.size() > 2) { if (poly->vertexes.size() > 2) {
tie(textureIndex, textureOffset) = addCurrentTexture(move(poly->texture)); tie(textureIndex, textureOffset) = addCurrentTexture(std::move(poly->texture));
for (size_t i = 1; i < poly->vertexes.size() - 1; ++i) { for (size_t i = 1; i < poly->vertexes.size() - 1; ++i) {
appendBufferVertex(poly->vertexes[0], textureIndex, textureOffset); appendBufferVertex(poly->vertexes[0], textureIndex, textureOffset);

6
source/application/StarTextureAtlas.hpp
View File

@ -33,6 +33,8 @@ public:
TextureAtlasSet(unsigned cellSize, unsigned atlasNumCells); TextureAtlasSet(unsigned cellSize, unsigned atlasNumCells);
virtual ~TextureAtlasSet() = default;
// The constant square size of all atlas textures // The constant square size of all atlas textures
Vec2U atlasTextureSize() const; Vec2U atlasTextureSize() const;
@ -88,6 +90,8 @@ private:
}; };
struct TextureEntry : Texture { struct TextureEntry : Texture {
virtual ~TextureEntry() = default;
Vec2U imageSize() const override; Vec2U imageSize() const override;
AtlasTextureHandle const& atlasTexture() const override; AtlasTextureHandle const& atlasTexture() const override;
@ -168,7 +172,7 @@ auto TextureAtlasSet<AtlasTextureHandle>::addTexture(Image const& image, bool bo
return nullptr; return nullptr;
auto textureEntry = make_shared<TextureEntry>(); auto textureEntry = make_shared<TextureEntry>();
textureEntry->textureImage = move(finalImage); textureEntry->textureImage = std::move(finalImage);
textureEntry->atlasPlacement = *placement; textureEntry->atlasPlacement = *placement;
m_textures.add(textureEntry); m_textures.add(textureEntry);

8
source/base/StarAnimatedPartSet.cpp
View File

@ -27,7 +27,7 @@ AnimatedPartSet::AnimatedPartSet(Json config) {
newState->transitionState = stateConfig.getString("transition", ""); newState->transitionState = stateConfig.getString("transition", "");
newState->stateProperties = stateConfig.getObject("properties", {}); newState->stateProperties = stateConfig.getObject("properties", {});
newState->stateFrameProperties = stateConfig.getObject("frameProperties", {}); newState->stateFrameProperties = stateConfig.getObject("frameProperties", {});
newStateType.states[stateName] = move(newState); newStateType.states[stateName] = std::move(newState);
} }
newStateType.states.sortByKey(); newStateType.states.sortByKey();
@ -38,7 +38,7 @@ AnimatedPartSet::AnimatedPartSet(Json config) {
if (newStateType.defaultState.empty() && !newStateType.states.empty()) if (newStateType.defaultState.empty() && !newStateType.states.empty())
newStateType.defaultState = newStateType.states.firstKey(); newStateType.defaultState = newStateType.states.firstKey();
m_stateTypes[stateTypeName] = move(newStateType); m_stateTypes[stateTypeName] = std::move(newStateType);
} }
// Sort state types by decreasing priority. // Sort state types by decreasing priority.
@ -61,13 +61,13 @@ AnimatedPartSet::AnimatedPartSet(Json config) {
auto const& stateConfig = partStatePair.second; auto const& stateConfig = partStatePair.second;
PartState partState = {stateConfig.getObject("properties", {}), stateConfig.getObject("frameProperties", {})}; PartState partState = {stateConfig.getObject("properties", {}), stateConfig.getObject("frameProperties", {})};
newPart.partStates[stateTypeName][stateName] = move(partState); newPart.partStates[stateTypeName][stateName] = std::move(partState);
} }
} }
newPart.activePart.partName = partPair.first; newPart.activePart.partName = partPair.first;
newPart.activePartDirty = true; newPart.activePartDirty = true;
m_parts[partName] = move(newPart); m_parts[partName] = std::move(newPart);
} }
for (auto const& pair : m_stateTypes) for (auto const& pair : m_stateTypes)

30
source/base/StarAssets.cpp
View File

@ -71,17 +71,17 @@ Maybe<RectU> FramesSpecification::getRect(String const& frame) const {
Assets::Assets(Settings settings, StringList assetSources) { Assets::Assets(Settings settings, StringList assetSources) {
const char* const AssetsPatchSuffix = ".patch"; const char* const AssetsPatchSuffix = ".patch";
m_settings = move(settings); m_settings = std::move(settings);
m_stopThreads = false; m_stopThreads = false;
m_assetSources = move(assetSources); m_assetSources = std::move(assetSources);
for (auto& sourcePath : m_assetSources) { for (auto& sourcePath : m_assetSources) {
Logger::info("Loading assets from: '{}'", sourcePath); Logger::info("Loading assets from: '{}'", sourcePath);
AssetSourcePtr source; AssetSourcePtr source;
if (File::isDirectory(sourcePath)) if (File::isDirectory(sourcePath))
source = make_shared<DirectoryAssetSource>(sourcePath, m_settings.pathIgnore); source = std::make_shared<DirectoryAssetSource>(sourcePath, m_settings.pathIgnore);
else else
source = make_shared<PackedAssetSource>(sourcePath); source = std::make_shared<PackedAssetSource>(sourcePath);
m_assetSourcePaths.add(sourcePath, source); m_assetSourcePaths.add(sourcePath, source);
@ -225,7 +225,7 @@ Json Assets::json(String const& path) const {
auto components = AssetPath::split(path); auto components = AssetPath::split(path);
validatePath(components, true, false); validatePath(components, true, false);
return as<JsonData>(getAsset(AssetId{AssetType::Json, move(components)}))->json; return as<JsonData>(getAsset(AssetId{AssetType::Json, std::move(components)}))->json;
} }
Json Assets::fetchJson(Json const& v, String const& dir) const { Json Assets::fetchJson(Json const& v, String const& dir) const {
@ -255,7 +255,7 @@ void Assets::queueImages(StringList const& paths) const {
auto components = AssetPath::split(path); auto components = AssetPath::split(path);
validatePath(components, true, true); validatePath(components, true, true);
return AssetId{AssetType::Image, move(components)}; return AssetId{AssetType::Image, std::move(components)};
})); }));
} }
@ -280,7 +280,7 @@ AudioConstPtr Assets::audio(String const& path) const {
auto components = AssetPath::split(path); auto components = AssetPath::split(path);
validatePath(components, false, false); validatePath(components, false, false);
return as<AudioData>(getAsset(AssetId{AssetType::Audio, move(components)}))->audio; return as<AudioData>(getAsset(AssetId{AssetType::Audio, std::move(components)}))->audio;
} }
void Assets::queueAudios(StringList const& paths) const { void Assets::queueAudios(StringList const& paths) const {
@ -288,7 +288,7 @@ void Assets::queueAudios(StringList const& paths) const {
const auto components = AssetPath::split(path); const auto components = AssetPath::split(path);
validatePath(components, false, false); validatePath(components, false, false);
return AssetId{AssetType::Audio, move(components)}; return AssetId{AssetType::Audio, std::move(components)};
})); }));
} }
@ -296,7 +296,7 @@ AudioConstPtr Assets::tryAudio(String const& path) const {
auto components = AssetPath::split(path); auto components = AssetPath::split(path);
validatePath(components, false, false); validatePath(components, false, false);
if (auto audioData = as<AudioData>(tryAsset(AssetId{AssetType::Audio, move(components)}))) if (auto audioData = as<AudioData>(tryAsset(AssetId{AssetType::Audio, std::move(components)})))
return audioData->audio; return audioData->audio;
else else
return {}; return {};
@ -306,14 +306,14 @@ FontConstPtr Assets::font(String const& path) const {
auto components = AssetPath::split(path); auto components = AssetPath::split(path);
validatePath(components, false, false); validatePath(components, false, false);
return as<FontData>(getAsset(AssetId{AssetType::Font, move(components)}))->font; return as<FontData>(getAsset(AssetId{AssetType::Font, std::move(components)}))->font;
} }
ByteArrayConstPtr Assets::bytes(String const& path) const { ByteArrayConstPtr Assets::bytes(String const& path) const {
auto components = AssetPath::split(path); auto components = AssetPath::split(path);
validatePath(components, false, false); validatePath(components, false, false);
return as<BytesData>(getAsset(AssetId{AssetType::Bytes, move(components)}))->bytes; return as<BytesData>(getAsset(AssetId{AssetType::Bytes, std::move(components)}))->bytes;
} }
IODevicePtr Assets::openFile(String const& path) const { IODevicePtr Assets::openFile(String const& path) const {
@ -386,7 +386,7 @@ bool Assets::BytesData::shouldPersist() const {
FramesSpecification Assets::parseFramesSpecification(Json const& frameConfig, String path) { FramesSpecification Assets::parseFramesSpecification(Json const& frameConfig, String path) {
FramesSpecification framesSpecification; FramesSpecification framesSpecification;
framesSpecification.framesFile = move(path); framesSpecification.framesFile = std::move(path);
if (frameConfig.contains("frameList")) { if (frameConfig.contains("frameList")) {
for (auto const& pair : frameConfig.get("frameList").toObject()) { for (auto const& pair : frameConfig.get("frameList").toObject()) {
@ -469,7 +469,7 @@ FramesSpecification Assets::parseFramesSpecification(Json const& frameConfig, St
if (!framesSpecification.frames.contains(value)) if (!framesSpecification.frames.contains(value))
throw AssetException(strf("No such frame '{}' found for alias '{}'", value, key)); throw AssetException(strf("No such frame '{}' found for alias '{}'", value, key));
framesSpecification.aliases[key] = move(value); framesSpecification.aliases[key] = std::move(value);
} }
} }
@ -866,7 +866,7 @@ shared_ptr<Assets::AssetData> Assets::loadImage(AssetPath const& path) const {
for (auto const& ref : referencePaths) { for (auto const& ref : referencePaths) {
auto components = AssetPath::split(ref); auto components = AssetPath::split(ref);
validatePath(components, true, false); validatePath(components, true, false);
auto refImage = as<ImageData>(loadAsset(AssetId{AssetType::Image, move(components)})); auto refImage = as<ImageData>(loadAsset(AssetId{AssetType::Image, std::move(components)}));
if (!refImage) if (!refImage)
return {}; return {};
references[ref] = refImage->image; references[ref] = refImage->image;
@ -881,7 +881,7 @@ shared_ptr<Assets::AssetData> Assets::loadImage(AssetPath const& path) const {
else else
processImageOperation(entry.operation, newImage, [&](String const& ref) { return references.get(ref).get(); }); processImageOperation(entry.operation, newImage, [&](String const& ref) { return references.get(ref).get(); });
}); });
newData->image = make_shared<Image>(move(newImage)); newData->image = make_shared<Image>(std::move(newImage));
return newData; return newData;
}); });

4
source/base/StarDirectoryAssetSource.cpp
View File

@ -62,7 +62,7 @@ void DirectoryAssetSource::setMetadata(JsonObject metadata) {
if (!m_metadataFile) if (!m_metadataFile)
m_metadataFile = String("/_metadata"); m_metadataFile = String("/_metadata");
m_metadata = move(metadata); m_metadata = std::move(metadata);
if (m_metadata.empty()) if (m_metadata.empty())
File::remove(toFilesystem(*m_metadataFile)); File::remove(toFilesystem(*m_metadataFile));
@ -88,7 +88,7 @@ void DirectoryAssetSource::scanAll(String const& assetDirectory, StringList& out
scanAll(assetPath + "/", output); scanAll(assetPath + "/", output);
} else { } else {
if (!shouldIgnore(assetPath)) if (!shouldIgnore(assetPath))
output.append(move(assetPath)); output.append(std::move(assetPath));
} }
} }
} }

2
source/base/StarMixer.cpp
View File

@ -218,7 +218,7 @@ void Mixer::setVolume(float volume, float rampTime) {
void Mixer::play(AudioInstancePtr sample) { void Mixer::play(AudioInstancePtr sample) {
MutexLocker locker(m_queueMutex); MutexLocker locker(m_queueMutex);
m_audios.add(move(sample), AudioState{List<float>(m_channels, 1.0f)}); m_audios.add(std::move(sample), AudioState{List<float>(m_channels, 1.0f)});
} }
void Mixer::stopAll(float rampTime) { void Mixer::stopAll(float rampTime) {

6
source/client/StarClientApplication.cpp
View File

@ -607,7 +607,7 @@ void ClientApplication::changeState(MainAppState newState) {
setError(strf("Cannot join peer: {}", result.left())); setError(strf("Cannot join peer: {}", result.left()));
return; return;
} else { } else {
packetSocket = P2PPacketSocket::open(move(result.right())); packetSocket = P2PPacketSocket::open(std::move(result.right()));
} }
} else { } else {
setError("Internal error, no p2p networking service when joining p2p networking peer"); setError("Internal error, no p2p networking service when joining p2p networking peer");
@ -616,7 +616,7 @@ void ClientApplication::changeState(MainAppState newState) {
} }
bool allowAssetsMismatch = m_root->configuration()->get("allowAssetsMismatch").toBool(); bool allowAssetsMismatch = m_root->configuration()->get("allowAssetsMismatch").toBool();
if (auto errorMessage = m_universeClient->connect(UniverseConnection(move(packetSocket)), allowAssetsMismatch, if (auto errorMessage = m_universeClient->connect(UniverseConnection(std::move(packetSocket)), allowAssetsMismatch,
multiPlayerConnection.account, multiPlayerConnection.password)) { multiPlayerConnection.account, multiPlayerConnection.password)) {
setError(*errorMessage); setError(*errorMessage);
return; return;
@ -951,7 +951,7 @@ void ClientApplication::updateRunning(float dt) {
if (m_universeServer) { if (m_universeServer) {
if (auto p2pNetworkingService = appController()->p2pNetworkingService()) { if (auto p2pNetworkingService = appController()->p2pNetworkingService()) {
for (auto& p2pClient : p2pNetworkingService->acceptP2PConnections()) for (auto& p2pClient : p2pNetworkingService->acceptP2PConnections())
m_universeServer->addClient(UniverseConnection(P2PPacketSocket::open(move(p2pClient)))); m_universeServer->addClient(UniverseConnection(P2PPacketSocket::open(std::move(p2pClient))));
} }
m_universeServer->setPause(m_mainInterface->escapeDialogOpen()); m_universeServer->setPause(m_mainInterface->escapeDialogOpen());

6
source/core/StarAStar.hpp
View File

@ -121,7 +121,7 @@ namespace AStar {
template <class Edge, class Node> template <class Edge, class Node>
void Search<Edge, Node>::start(Node startNode, Node goalNode) { void Search<Edge, Node>::start(Node startNode, Node goalNode) {
m_goal = move(goalNode); m_goal = std::move(goalNode);
m_nodeMeta.clear(); m_nodeMeta.clear();
m_openQueue = std::priority_queue<ScoredNode>(); m_openQueue = std::priority_queue<ScoredNode>();
m_openSet.clear(); m_openSet.clear();
@ -137,7 +137,7 @@ namespace AStar {
m_nodeMeta[startNode].score = startScore; m_nodeMeta[startNode].score = startScore;
m_openSet.insert(startNode); m_openSet.insert(startNode);
m_openQueue.push(ScoredNode{startScore, move(startNode)}); m_openQueue.push(ScoredNode{startScore, std::move(startNode)});
} }
template <class Edge, class Node> template <class Edge, class Node>
@ -251,7 +251,7 @@ namespace AStar {
template <class Edge, class Node> template <class Edge, class Node>
Maybe<Path<Edge>> const& Search<Edge, Node>::findPath(Node startNode, Node goalNode) { Maybe<Path<Edge>> const& Search<Edge, Node>::findPath(Node startNode, Node goalNode) {
start(move(startNode), move(goalNode)); start(std::move(startNode), std::move(goalNode));
explore(); explore();
return result(); return result();
} }

68
source/core/StarAlgorithm.hpp
View File

@ -14,7 +14,7 @@ template <typename ToType>
struct construct { struct construct {
template <typename... FromTypes> template <typename... FromTypes>
ToType operator()(FromTypes&&... fromTypes) const { ToType operator()(FromTypes&&... fromTypes) const {
return ToType(forward<FromTypes>(fromTypes)...); return ToType(std::forward<FromTypes>(fromTypes)...);
} }
}; };
@ -29,7 +29,7 @@ template <typename Func>
struct SwallowReturn { struct SwallowReturn {
template <typename... T> template <typename... T>
void operator()(T&&... args) { void operator()(T&&... args) {
func(forward<T>(args)...); func(std::forward<T>(args)...);
} }
Func func; Func func;
@ -37,7 +37,7 @@ struct SwallowReturn {
template <typename Func> template <typename Func>
SwallowReturn<Func> swallow(Func f) { SwallowReturn<Func> swallow(Func f) {
return SwallowReturn<Func>{move(f)}; return SwallowReturn<Func>{std::move(f)};
} }
struct Empty { struct Empty {
@ -58,18 +58,18 @@ struct FunctionComposer {
template <typename... T> template <typename... T>
decltype(auto) operator()(T&&... args) { decltype(auto) operator()(T&&... args) {
return f1(f2(forward<T>(args)...)); return f1(f2(std::forward<T>(args)...));
} }
}; };
template <typename FirstFunction, typename SecondFunction> template <typename FirstFunction, typename SecondFunction>
decltype(auto) compose(FirstFunction&& firstFunction, SecondFunction&& secondFunction) { decltype(auto) compose(FirstFunction&& firstFunction, SecondFunction&& secondFunction) {
return FunctionComposer<FirstFunction, SecondFunction>{move(forward<FirstFunction>(firstFunction)), move(forward<SecondFunction>(secondFunction))}; return FunctionComposer<FirstFunction, SecondFunction>{std::move(std::forward<FirstFunction>(firstFunction)), std::move(std::forward<SecondFunction>(secondFunction))};
} }
template <typename FirstFunction, typename SecondFunction, typename ThirdFunction, typename... RestFunctions> template <typename FirstFunction, typename SecondFunction, typename ThirdFunction, typename... RestFunctions>
decltype(auto) compose(FirstFunction firstFunction, SecondFunction secondFunction, ThirdFunction thirdFunction, RestFunctions... restFunctions) { decltype(auto) compose(FirstFunction firstFunction, SecondFunction secondFunction, ThirdFunction thirdFunction, RestFunctions... restFunctions) {
return compose(forward<FirstFunction>(firstFunction), compose(forward<SecondFunction>(secondFunction), compose(forward<ThirdFunction>(thirdFunction), forward<RestFunctions>(restFunctions)...))); return compose(std::forward<FirstFunction>(firstFunction), compose(std::forward<SecondFunction>(secondFunction), compose(std::forward<ThirdFunction>(thirdFunction), std::forward<RestFunctions>(restFunctions)...)));
} }
template <typename Container, typename Value, typename Function> template <typename Container, typename Value, typename Function>
@ -260,7 +260,7 @@ void sortByComputedValue(Container& container, Getter&& valueGetter, bool stable
template <typename Container, typename Getter> template <typename Container, typename Getter>
void stableSortByComputedValue(Container& container, Getter&& valueGetter) { void stableSortByComputedValue(Container& container, Getter&& valueGetter) {
return sortByComputedValue(container, forward<Getter>(valueGetter), true); return sortByComputedValue(container, std::forward<Getter>(valueGetter), true);
} }
template <typename Container> template <typename Container>
@ -293,7 +293,7 @@ template <typename OutContainer, typename InContainer, typename Function>
void transformInto(OutContainer& outContainer, InContainer&& inContainer, Function&& function) { void transformInto(OutContainer& outContainer, InContainer&& inContainer, Function&& function) {
for (auto&& elem : inContainer) { for (auto&& elem : inContainer) {
if (std::is_rvalue_reference<InContainer&&>::value) if (std::is_rvalue_reference<InContainer&&>::value)
outContainer.insert(outContainer.end(), function(move(elem))); outContainer.insert(outContainer.end(), function(std::move(elem)));
else else
outContainer.insert(outContainer.end(), function(elem)); outContainer.insert(outContainer.end(), function(elem));
} }
@ -302,7 +302,7 @@ void transformInto(OutContainer& outContainer, InContainer&& inContainer, Functi
template <typename OutContainer, typename InContainer, typename Function> template <typename OutContainer, typename InContainer, typename Function>
OutContainer transform(InContainer&& container, Function&& function) { OutContainer transform(InContainer&& container, Function&& function) {
OutContainer res; OutContainer res;
transformInto(res, forward<InContainer>(container), forward<Function>(function)); transformInto(res, std::forward<InContainer>(container), std::forward<Function>(function));
return res; return res;
} }
@ -326,7 +326,7 @@ OutputContainer zipWith(Function&& function, Container1 const& cont1, Container2
// default constructed state. // default constructed state.
template <typename T> template <typename T>
T take(T& t) { T take(T& t) {
T t2 = move(t); T t2 = std::move(t);
t = T(); t = T();
return t2; return t2;
} }
@ -356,7 +356,7 @@ public:
template <typename T> template <typename T>
OutputProxy& operator=(T&& value) { OutputProxy& operator=(T&& value) {
m_function(forward<T>(value)); m_function(std::forward<T>(value));
return *this; return *this;
} }
@ -365,7 +365,7 @@ public:
}; };
explicit FunctionOutputIterator(UnaryFunction f = UnaryFunction()) explicit FunctionOutputIterator(UnaryFunction f = UnaryFunction())
: m_function(move(f)) {} : m_function(std::move(f)) {}
OutputProxy operator*() { OutputProxy operator*() {
return OutputProxy(m_function); return OutputProxy(m_function);
@ -385,7 +385,7 @@ private:
template <typename UnaryFunction> template <typename UnaryFunction>
FunctionOutputIterator<UnaryFunction> makeFunctionOutputIterator(UnaryFunction f) { FunctionOutputIterator<UnaryFunction> makeFunctionOutputIterator(UnaryFunction f) {
return FunctionOutputIterator<UnaryFunction>(move(f)); return FunctionOutputIterator<UnaryFunction>(std::move(f));
} }
// Wraps a nullary function to produce an input iterator // Wraps a nullary function to produce an input iterator
@ -401,7 +401,7 @@ public:
typedef typename std::result_of<NullaryFunction()>::type FunctionReturnType; typedef typename std::result_of<NullaryFunction()>::type FunctionReturnType;
explicit FunctionInputIterator(NullaryFunction f = {}) explicit FunctionInputIterator(NullaryFunction f = {})
: m_function(move(f)) {} : m_function(std::move(f)) {}
FunctionReturnType operator*() { FunctionReturnType operator*() {
return m_function(); return m_function();
@ -421,7 +421,7 @@ private:
template <typename NullaryFunction> template <typename NullaryFunction>
FunctionInputIterator<NullaryFunction> makeFunctionInputIterator(NullaryFunction f) { FunctionInputIterator<NullaryFunction> makeFunctionInputIterator(NullaryFunction f) {
return FunctionInputIterator<NullaryFunction>(move(f)); return FunctionInputIterator<NullaryFunction>(std::move(f));
} }
template <typename Iterable> template <typename Iterable>
@ -449,14 +449,14 @@ ReverseWrapper<Iterable> reverseIterate(Iterable& list) {
template <typename Functor> template <typename Functor>
class FinallyGuard { class FinallyGuard {
public: public:
FinallyGuard(Functor functor) : functor(move(functor)), dismiss(false) {} FinallyGuard(Functor functor) : functor(std::move(functor)), dismiss(false) {}
FinallyGuard(FinallyGuard&& o) : functor(move(o.functor)), dismiss(o.dismiss) { FinallyGuard(FinallyGuard&& o) : functor(std::move(o.functor)), dismiss(o.dismiss) {
o.cancel(); o.cancel();
} }
FinallyGuard& operator=(FinallyGuard&& o) { FinallyGuard& operator=(FinallyGuard&& o) {
functor = move(o.functor); functor = std::move(o.functor);
dismiss = o.dismiss; dismiss = o.dismiss;
o.cancel(); o.cancel();
return *this; return *this;
@ -478,7 +478,7 @@ private:
template <typename Functor> template <typename Functor>
FinallyGuard<typename std::decay<Functor>::type> finally(Functor&& f) { FinallyGuard<typename std::decay<Functor>::type> finally(Functor&& f) {
return FinallyGuard<Functor>(forward<Functor>(f)); return FinallyGuard<Functor>(std::forward<Functor>(f));
} }
// Generates compile time sequences of indexes from MinIndex to MaxIndex // Generates compile time sequences of indexes from MinIndex to MaxIndex
@ -498,12 +498,12 @@ struct GenIndexSequence<Min, Min, S...> {
template <typename Function, typename Tuple, size_t... Indexes> template <typename Function, typename Tuple, size_t... Indexes>
decltype(auto) tupleUnpackFunctionIndexes(Function&& function, Tuple&& args, IndexSequence<Indexes...> const&) { decltype(auto) tupleUnpackFunctionIndexes(Function&& function, Tuple&& args, IndexSequence<Indexes...> const&) {
return function(get<Indexes>(forward<Tuple>(args))...); return function(get<Indexes>(std::forward<Tuple>(args))...);
} }
template <typename Function, typename Tuple> template <typename Function, typename Tuple>
decltype(auto) tupleUnpackFunction(Function&& function, Tuple&& args) { decltype(auto) tupleUnpackFunction(Function&& function, Tuple&& args) {
return tupleUnpackFunctionIndexes<Function, Tuple>(forward<Function>(function), forward<Tuple>(args), return tupleUnpackFunctionIndexes<Function, Tuple>(std::forward<Function>(function), std::forward<Tuple>(args),
typename GenIndexSequence<0, std::tuple_size<typename std::decay<Tuple>::type>::value>::type()); typename GenIndexSequence<0, std::tuple_size<typename std::decay<Tuple>::type>::value>::type());
} }
@ -512,12 +512,12 @@ decltype(auto) tupleUnpackFunction(Function&& function, Tuple&& args) {
template <typename Function, typename Tuple, size_t... Indexes> template <typename Function, typename Tuple, size_t... Indexes>
decltype(auto) tupleApplyFunctionIndexes(Function&& function, Tuple&& args, IndexSequence<Indexes...> const&) { decltype(auto) tupleApplyFunctionIndexes(Function&& function, Tuple&& args, IndexSequence<Indexes...> const&) {
return make_tuple(function(get<Indexes>(forward<Tuple>(args)))...); return make_tuple(function(get<Indexes>(std::forward<Tuple>(args)))...);
} }
template <typename Function, typename Tuple> template <typename Function, typename Tuple>
decltype(auto) tupleApplyFunction(Function&& function, Tuple&& args) { decltype(auto) tupleApplyFunction(Function&& function, Tuple&& args) {
return tupleApplyFunctionIndexes<Function, Tuple>(forward<Function>(function), forward<Tuple>(args), return tupleApplyFunctionIndexes<Function, Tuple>(std::forward<Function>(function), std::forward<Tuple>(args),
typename GenIndexSequence<0, std::tuple_size<typename std::decay<Tuple>::type>::value>::type()); typename GenIndexSequence<0, std::tuple_size<typename std::decay<Tuple>::type>::value>::type());
} }
@ -530,35 +530,35 @@ void tupleCallFunctionCaller(Function&&, Tuple&&) {}
template <typename Tuple, typename Function, typename First, typename... Rest> template <typename Tuple, typename Function, typename First, typename... Rest>
void tupleCallFunctionCaller(Tuple&& t, Function&& function) { void tupleCallFunctionCaller(Tuple&& t, Function&& function) {
tupleCallFunctionCaller<Tuple, Function, Rest...>(forward<Tuple>(t), forward<Function>(function)); tupleCallFunctionCaller<Tuple, Function, Rest...>(std::forward<Tuple>(t), std::forward<Function>(function));
function(get<sizeof...(Rest)>(forward<Tuple>(t))); function(get<sizeof...(Rest)>(std::forward<Tuple>(t)));
} }
template <typename Tuple, typename Function, typename... T> template <typename Tuple, typename Function, typename... T>
void tupleCallFunctionExpander(Tuple&& t, Function&& function, tuple<T...> const&) { void tupleCallFunctionExpander(Tuple&& t, Function&& function, tuple<T...> const&) {
tupleCallFunctionCaller<Tuple, Function, T...>(forward<Tuple>(t), forward<Function>(function)); tupleCallFunctionCaller<Tuple, Function, T...>(std::forward<Tuple>(t), std::forward<Function>(function));
} }
template <typename Tuple, typename Function> template <typename Tuple, typename Function>
void tupleCallFunction(Tuple&& t, Function&& function) { void tupleCallFunction(Tuple&& t, Function&& function) {
tupleCallFunctionExpander<Tuple, Function>(forward<Tuple>(t), forward<Function>(function), forward<Tuple>(t)); tupleCallFunctionExpander<Tuple, Function>(std::forward<Tuple>(t), std::forward<Function>(function), std::forward<Tuple>(t));
} }
// Get a subset of a tuple // Get a subset of a tuple
template <typename Tuple, size_t... Indexes> template <typename Tuple, size_t... Indexes>
decltype(auto) subTupleIndexes(Tuple&& t, IndexSequence<Indexes...> const&) { decltype(auto) subTupleIndexes(Tuple&& t, IndexSequence<Indexes...> const&) {
return make_tuple(get<Indexes>(forward<Tuple>(t))...); return make_tuple(get<Indexes>(std::forward<Tuple>(t))...);
} }
template <size_t Min, size_t Size, typename Tuple> template <size_t Min, size_t Size, typename Tuple>
decltype(auto) subTuple(Tuple&& t) { decltype(auto) subTuple(Tuple&& t) {
return subTupleIndexes(forward<Tuple>(t), GenIndexSequence<Min, Size>::type()); return subTupleIndexes(std::forward<Tuple>(t), GenIndexSequence<Min, Size>::type());
} }
template <size_t Trim, typename Tuple> template <size_t Trim, typename Tuple>
decltype(auto) trimTuple(Tuple&& t) { decltype(auto) trimTuple(Tuple&& t) {
return subTupleIndexes(forward<Tuple>(t), typename GenIndexSequence<Trim, std::tuple_size<typename std::decay<Tuple>::type>::value>::type()); return subTupleIndexes(std::forward<Tuple>(t), typename GenIndexSequence<Trim, std::tuple_size<typename std::decay<Tuple>::type>::value>::type());
} }
// Unpack a parameter expansion into a container // Unpack a parameter expansion into a container
@ -568,14 +568,14 @@ void unpackVariadicImpl(Container&) {}
template <typename Container, typename TFirst, typename... TRest> template <typename Container, typename TFirst, typename... TRest>
void unpackVariadicImpl(Container& container, TFirst&& tfirst, TRest&&... trest) { void unpackVariadicImpl(Container& container, TFirst&& tfirst, TRest&&... trest) {
container.insert(container.end(), forward<TFirst>(tfirst)); container.insert(container.end(), std::forward<TFirst>(tfirst));
unpackVariadicImpl(container, forward<TRest>(trest)...); unpackVariadicImpl(container, std::forward<TRest>(trest)...);
} }
template <typename Container, typename... T> template <typename Container, typename... T>
Container unpackVariadic(T&&... t) { Container unpackVariadic(T&&... t) {
Container c; Container c;
unpackVariadicImpl(c, forward<T>(t)...); unpackVariadicImpl(c, std::forward<T>(t)...);
return c; return c;
} }
@ -587,7 +587,7 @@ void callFunctionVariadic(Function&&) {}
template <typename Function, typename Arg1, typename... ArgRest> template <typename Function, typename Arg1, typename... ArgRest>
void callFunctionVariadic(Function&& function, Arg1&& arg1, ArgRest&&... argRest) { void callFunctionVariadic(Function&& function, Arg1&& arg1, ArgRest&&... argRest) {
function(arg1); function(arg1);
callFunctionVariadic(forward<Function>(function), forward<ArgRest>(argRest)...); callFunctionVariadic(std::forward<Function>(function), std::forward<ArgRest>(argRest)...);
} }
template <typename... Rest> template <typename... Rest>

12
source/core/StarAssetPath.cpp
View File

@ -133,18 +133,18 @@ bool AssetPath::operator==(AssetPath const& rhs) const {
} }
AssetPath::AssetPath(const char* path) { AssetPath::AssetPath(const char* path) {
*this = move(AssetPath::split(path)); *this = AssetPath::split(path);
} }
AssetPath::AssetPath(String const& path) { AssetPath::AssetPath(String const& path) {
*this = move(AssetPath::split(path)); *this = AssetPath::split(path);
} }
AssetPath::AssetPath(String&& basePath, Maybe<String>&& subPath, DirectivesGroup&& directives) { AssetPath::AssetPath(String&& basePath, Maybe<String>&& subPath, DirectivesGroup&& directives) {
this->basePath = move(basePath); this->basePath = std::move(basePath);
this->subPath = move(subPath); this->subPath = std::move(subPath);
this->directives = move(directives); this->directives = std::move(directives);
} }
AssetPath::AssetPath(String const& basePath, Maybe<String> const& subPath, DirectivesGroup const& directives) { AssetPath::AssetPath(String const& basePath, Maybe<String> const& subPath, DirectivesGroup const& directives) {
@ -176,7 +176,7 @@ DataStream& operator>>(DataStream& ds, AssetPath& path) {
String string; String string;
ds.read(string); ds.read(string);
path = move(string); path = std::move(string);
return ds; return ds;
} }

10
source/core/StarAtomicSharedPtr.hpp
View File

@ -47,11 +47,11 @@ AtomicSharedPtr<T>::AtomicSharedPtr(AtomicSharedPtr const& p)
template <typename T> template <typename T>
AtomicSharedPtr<T>::AtomicSharedPtr(AtomicSharedPtr&& p) AtomicSharedPtr<T>::AtomicSharedPtr(AtomicSharedPtr&& p)
: m_ptr(move(p.m_ptr)) {} : m_ptr(std::move(p.m_ptr)) {}
template <typename T> template <typename T>
AtomicSharedPtr<T>::AtomicSharedPtr(SharedPtr p) AtomicSharedPtr<T>::AtomicSharedPtr(SharedPtr p)
: m_ptr(move(p)) {} : m_ptr(std::move(p)) {}
template <typename T> template <typename T>
auto AtomicSharedPtr<T>::load() const -> SharedPtr { auto AtomicSharedPtr<T>::load() const -> SharedPtr {
@ -68,7 +68,7 @@ auto AtomicSharedPtr<T>::weak() const -> WeakPtr {
template <typename T> template <typename T>
void AtomicSharedPtr<T>::store(SharedPtr p) { void AtomicSharedPtr<T>::store(SharedPtr p) {
SpinLocker locker(m_lock); SpinLocker locker(m_lock);
m_ptr = move(p); m_ptr = std::move(p);
} }
template <typename T> template <typename T>
@ -105,14 +105,14 @@ AtomicSharedPtr<T>& AtomicSharedPtr<T>::operator=(AtomicSharedPtr const& p) {
template <typename T> template <typename T>
AtomicSharedPtr<T>& AtomicSharedPtr<T>::operator=(AtomicSharedPtr&& p) { AtomicSharedPtr<T>& AtomicSharedPtr<T>::operator=(AtomicSharedPtr&& p) {
SpinLocker locker(m_lock); SpinLocker locker(m_lock);
m_ptr = move(p.m_ptr); m_ptr = std::move(p.m_ptr);
return *this; return *this;
} }
template <typename T> template <typename T>
AtomicSharedPtr<T>& AtomicSharedPtr<T>::operator=(SharedPtr p) { AtomicSharedPtr<T>& AtomicSharedPtr<T>::operator=(SharedPtr p) {
SpinLocker locker(m_lock); SpinLocker locker(m_lock);
m_ptr = move(p); m_ptr = std::move(p);
return *this; return *this;
} }

12
source/core/StarAudio.cpp
View File

@ -129,7 +129,7 @@ namespace {
for (size_t i = 0; i < pcmData->size() / 2; ++i) for (size_t i = 0; i < pcmData->size() / 2; ++i)
fromByteOrder(ByteOrder::LittleEndian, pcmData->ptr() + i * 2, 2); fromByteOrder(ByteOrder::LittleEndian, pcmData->ptr() + i * 2, 2);
return WaveData{move(pcmData), wavChannels, wavSampleRate}; return WaveData{std::move(pcmData), wavChannels, wavSampleRate};
} }
} }
@ -276,7 +276,7 @@ public:
UncompressedAudioImpl(ByteArrayConstPtr data, unsigned channels, unsigned sampleRate) { UncompressedAudioImpl(ByteArrayConstPtr data, unsigned channels, unsigned sampleRate) {
m_channels = channels; m_channels = channels;
m_sampleRate = sampleRate; m_sampleRate = sampleRate;
m_audioData = move(data); m_audioData = std::move(data);
m_memoryFile.reset(m_audioData->ptr(), m_audioData->size()); m_memoryFile.reset(m_audioData->ptr(), m_audioData->size());
} }
@ -335,7 +335,7 @@ Audio::Audio(IODevicePtr device) {
if (isUncompressed(device)) { if (isUncompressed(device)) {
WaveData data = parseWav(device); WaveData data = parseWav(device);
m_uncompressed = make_shared<UncompressedAudioImpl>(move(data.byteArray), data.channels, data.sampleRate); m_uncompressed = make_shared<UncompressedAudioImpl>(std::move(data.byteArray), data.channels, data.sampleRate);
} else { } else {
m_compressed = make_shared<CompressedAudioImpl>(device); m_compressed = make_shared<CompressedAudioImpl>(device);
if (!m_compressed->open()) if (!m_compressed->open())
@ -348,7 +348,7 @@ Audio::Audio(Audio const& audio) {
} }
Audio::Audio(Audio&& audio) { Audio::Audio(Audio&& audio) {
operator=(move(audio)); operator=(std::move(audio));
} }
Audio& Audio::operator=(Audio const& audio) { Audio& Audio::operator=(Audio const& audio) {
@ -365,8 +365,8 @@ Audio& Audio::operator=(Audio const& audio) {
} }
Audio& Audio::operator=(Audio&& audio) { Audio& Audio::operator=(Audio&& audio) {
m_compressed = move(audio.m_compressed); m_compressed = std::move(audio.m_compressed);
m_uncompressed = move(audio.m_uncompressed); m_uncompressed = std::move(audio.m_uncompressed);
return *this; return *this;
} }

80
source/core/StarBTree.hpp
View File

@ -284,18 +284,18 @@ template <typename Base>
template <typename Visitor> template <typename Visitor>
void BTreeMixin<Base>::forEach(Key const& lower, Key const& upper, Visitor&& visitor) { void BTreeMixin<Base>::forEach(Key const& lower, Key const& upper, Visitor&& visitor) {
if (Base::rootIsLeaf()) if (Base::rootIsLeaf())
forEach(Base::loadLeaf(Base::rootPointer()), lower, upper, forward<Visitor>(visitor)); forEach(Base::loadLeaf(Base::rootPointer()), lower, upper, std::forward<Visitor>(visitor));
else else
forEach(Base::loadIndex(Base::rootPointer()), lower, upper, forward<Visitor>(visitor)); forEach(Base::loadIndex(Base::rootPointer()), lower, upper, std::forward<Visitor>(visitor));
} }
template <typename Base> template <typename Base>
template <typename Visitor> template <typename Visitor>
void BTreeMixin<Base>::forAll(Visitor&& visitor) { void BTreeMixin<Base>::forAll(Visitor&& visitor) {
if (Base::rootIsLeaf()) if (Base::rootIsLeaf())
forAll(Base::loadLeaf(Base::rootPointer()), forward<Visitor>(visitor)); forAll(Base::loadLeaf(Base::rootPointer()), std::forward<Visitor>(visitor));
else else
forAll(Base::loadIndex(Base::rootPointer()), forward<Visitor>(visitor)); forAll(Base::loadIndex(Base::rootPointer()), std::forward<Visitor>(visitor));
} }
template <typename Base> template <typename Base>
@ -303,9 +303,9 @@ template <typename Visitor, typename ErrorHandler>
void BTreeMixin<Base>::recoverAll(Visitor&& visitor, ErrorHandler&& error) { void BTreeMixin<Base>::recoverAll(Visitor&& visitor, ErrorHandler&& error) {
try { try {
if (Base::rootIsLeaf()) if (Base::rootIsLeaf())
recoverAll(Base::loadLeaf(Base::rootPointer()), forward<Visitor>(visitor), forward<ErrorHandler>(error)); recoverAll(Base::loadLeaf(Base::rootPointer()), std::forward<Visitor>(visitor), std::forward<ErrorHandler>(error));
else else
recoverAll(Base::loadIndex(Base::rootPointer()), forward<Visitor>(visitor), forward<ErrorHandler>(error)); recoverAll(Base::loadIndex(Base::rootPointer()), std::forward<Visitor>(visitor), std::forward<ErrorHandler>(error));
} catch (std::exception const& e) { } catch (std::exception const& e) {
error("Error loading root index or leaf node", e); error("Error loading root index or leaf node", e);
} }
@ -317,17 +317,17 @@ void BTreeMixin<Base>::forAllNodes(Visitor&& visitor) {
if (Base::rootIsLeaf()) if (Base::rootIsLeaf())
visitor(Base::loadLeaf(Base::rootPointer())); visitor(Base::loadLeaf(Base::rootPointer()));
else else
forAllNodes(Base::loadIndex(Base::rootPointer()), forward<Visitor>(visitor)); forAllNodes(Base::loadIndex(Base::rootPointer()), std::forward<Visitor>(visitor));
} }
template <typename Base> template <typename Base>
bool BTreeMixin<Base>::insert(Key k, Data data) { bool BTreeMixin<Base>::insert(Key k, Data data) {
return modify(DataElement{move(k), move(data)}, InsertAction); return modify(DataElement{std::move(k), std::move(data)}, InsertAction);
} }
template <typename Base> template <typename Base>
bool BTreeMixin<Base>::remove(Key k) { bool BTreeMixin<Base>::remove(Key k) {
return modify(DataElement{move(k), Data()}, RemoveAction); return modify(DataElement{std::move(k), Data()}, RemoveAction);
} }
template <typename Base> template <typename Base>
@ -422,7 +422,7 @@ bool BTreeMixin<Base>::LeafCounter::operator()(Leaf const&) {
template <typename Base> template <typename Base>
BTreeMixin<Base>::ModifyInfo::ModifyInfo(ModifyAction a, DataElement e) BTreeMixin<Base>::ModifyInfo::ModifyInfo(ModifyAction a, DataElement e)
: targetElement(move(e)), action(a) { : targetElement(std::move(e)), action(a) {
found = false; found = false;
state = Done; state = Done;
} }
@ -466,9 +466,9 @@ auto BTreeMixin<Base>::forEach(Index const& index, Key const& lower, Key const&
Key lastKey; Key lastKey;
if (Base::indexLevel(index) == 0) if (Base::indexLevel(index) == 0)
lastKey = forEach(Base::loadLeaf(Base::indexPointer(index, i)), lower, upper, forward<Visitor>(o)); lastKey = forEach(Base::loadLeaf(Base::indexPointer(index, i)), lower, upper, std::forward<Visitor>(o));
else else
lastKey = forEach(Base::loadIndex(Base::indexPointer(index, i)), lower, upper, forward<Visitor>(o)); lastKey = forEach(Base::loadIndex(Base::indexPointer(index, i)), lower, upper, std::forward<Visitor>(o));
if (!(lastKey < upper)) if (!(lastKey < upper))
return lastKey; return lastKey;
@ -483,9 +483,9 @@ auto BTreeMixin<Base>::forEach(Index const& index, Key const& lower, Key const&
continue; continue;
if (Base::indexLevel(index) == 0) if (Base::indexLevel(index) == 0)
lastKey = forEach(Base::loadLeaf(Base::indexPointer(index, i)), lower, upper, forward<Visitor>(o)); lastKey = forEach(Base::loadLeaf(Base::indexPointer(index, i)), lower, upper, std::forward<Visitor>(o));
else else
lastKey = forEach(Base::loadIndex(Base::indexPointer(index, i)), lower, upper, forward<Visitor>(o)); lastKey = forEach(Base::loadIndex(Base::indexPointer(index, i)), lower, upper, std::forward<Visitor>(o));
if (!(lastKey < upper)) if (!(lastKey < upper))
break; break;
@ -530,9 +530,9 @@ auto BTreeMixin<Base>::forAll(Index const& index, Visitor&& o) -> Key {
continue; continue;
if (Base::indexLevel(index) == 0) if (Base::indexLevel(index) == 0)
lastKey = forAll(Base::loadLeaf(Base::indexPointer(index, i)), forward<Visitor>(o)); lastKey = forAll(Base::loadLeaf(Base::indexPointer(index, i)), std::forward<Visitor>(o));
else else
lastKey = forAll(Base::loadIndex(Base::indexPointer(index, i)), forward<Visitor>(o)); lastKey = forAll(Base::loadIndex(Base::indexPointer(index, i)), std::forward<Visitor>(o));
} }
return lastKey; return lastKey;
@ -550,7 +550,7 @@ auto BTreeMixin<Base>::forAll(Leaf const& leaf, Visitor&& o) -> Key {
} }
if (auto nextLeafPointer = Base::nextLeaf(leaf)) if (auto nextLeafPointer = Base::nextLeaf(leaf))
return forAll(Base::loadLeaf(*nextLeafPointer), forward<Visitor>(o)); return forAll(Base::loadLeaf(*nextLeafPointer), std::forward<Visitor>(o));
else else
return Base::leafKey(leaf, Base::leafElementCount(leaf) - 1); return Base::leafKey(leaf, Base::leafElementCount(leaf) - 1);
} }
@ -562,13 +562,13 @@ void BTreeMixin<Base>::recoverAll(Index const& index, Visitor&& visitor, ErrorHa
for (size_t i = 0; i < Base::indexPointerCount(index); ++i) { for (size_t i = 0; i < Base::indexPointerCount(index); ++i) {
if (Base::indexLevel(index) == 0) { if (Base::indexLevel(index) == 0) {
try { try {
recoverAll(Base::loadLeaf(Base::indexPointer(index, i)), forward<Visitor>(visitor), forward<ErrorHandler>(error)); recoverAll(Base::loadLeaf(Base::indexPointer(index, i)), std::forward<Visitor>(visitor), std::forward<ErrorHandler>(error));
} catch (std::exception const& e) { } catch (std::exception const& e) {
error("Error loading leaf node", e); error("Error loading leaf node", e);
} }
} else { } else {
try { try {
recoverAll(Base::loadIndex(Base::indexPointer(index, i)), forward<Visitor>(visitor), forward<ErrorHandler>(error)); recoverAll(Base::loadIndex(Base::indexPointer(index, i)), std::forward<Visitor>(visitor), std::forward<ErrorHandler>(error));
} catch (std::exception const& e) { } catch (std::exception const& e) {
error("Error loading index node", e); error("Error loading index node", e);
} }
@ -608,7 +608,7 @@ void BTreeMixin<Base>::modify(Leaf& leafNode, ModifyInfo& info) {
return; return;
if (info.action == InsertAction) if (info.action == InsertAction)
Base::leafInsert(leafNode, i, info.targetElement.key, move(info.targetElement.data)); Base::leafInsert(leafNode, i, info.targetElement.key, std::move(info.targetElement.data));
auto splitResult = Base::leafSplit(leafNode); auto splitResult = Base::leafSplit(leafNode);
if (splitResult) { if (splitResult) {
@ -677,26 +677,26 @@ void BTreeMixin<Base>::modify(Index& indexNode, ModifyInfo& info) {
} else if (Base::leafElementCount(rightLeaf) == 0) { } else if (Base::leafElementCount(rightLeaf) == 0) {
// Leaves merged. // Leaves merged.
Base::setNextLeaf(leftLeaf, Base::nextLeaf(rightLeaf)); Base::setNextLeaf(leftLeaf, Base::nextLeaf(rightLeaf));
Base::deleteLeaf(move(rightLeaf)); Base::deleteLeaf(std::move(rightLeaf));
// Replace two sibling pointer elements with one pointing to merged // Replace two sibling pointer elements with one pointing to merged
// leaf. // leaf.
if (left != 0) if (left != 0)
Base::indexUpdateKeyBefore(indexNode, left, Base::leafKey(leftLeaf, 0)); Base::indexUpdateKeyBefore(indexNode, left, Base::leafKey(leftLeaf, 0));
Base::indexUpdatePointer(indexNode, left, Base::storeLeaf(move(leftLeaf))); Base::indexUpdatePointer(indexNode, left, Base::storeLeaf(std::move(leftLeaf)));
Base::indexRemoveBefore(indexNode, right); Base::indexRemoveBefore(indexNode, right);
selfUpdated = true; selfUpdated = true;
} else { } else {
// Leaves shifted. // Leaves shifted.
Base::indexUpdatePointer(indexNode, left, Base::storeLeaf(move(leftLeaf))); Base::indexUpdatePointer(indexNode, left, Base::storeLeaf(std::move(leftLeaf)));
// Right leaf first key changes on shift, so always need to update // Right leaf first key changes on shift, so always need to update
// left index node. // left index node.
Base::indexUpdateKeyBefore(indexNode, right, Base::leafKey(rightLeaf, 0)); Base::indexUpdateKeyBefore(indexNode, right, Base::leafKey(rightLeaf, 0));
Base::indexUpdatePointer(indexNode, right, Base::storeLeaf(move(rightLeaf))); Base::indexUpdatePointer(indexNode, right, Base::storeLeaf(std::move(rightLeaf)));
selfUpdated = true; selfUpdated = true;
} }
@ -725,25 +725,25 @@ void BTreeMixin<Base>::modify(Index& indexNode, ModifyInfo& info) {
} else if (Base::indexPointerCount(rightIndex) == 0) { } else if (Base::indexPointerCount(rightIndex) == 0) {
// Indexes merged. // Indexes merged.
Base::deleteIndex(move(rightIndex)); Base::deleteIndex(std::move(rightIndex));
// Replace two sibling pointer elements with one pointing to merged // Replace two sibling pointer elements with one pointing to merged
// index. // index.
if (left != 0) if (left != 0)
Base::indexUpdateKeyBefore(indexNode, left, getLeftKey(leftIndex)); Base::indexUpdateKeyBefore(indexNode, left, getLeftKey(leftIndex));
Base::indexUpdatePointer(indexNode, left, Base::storeIndex(move(leftIndex))); Base::indexUpdatePointer(indexNode, left, Base::storeIndex(std::move(leftIndex)));
Base::indexRemoveBefore(indexNode, right); Base::indexRemoveBefore(indexNode, right);
selfUpdated = true; selfUpdated = true;
} else { } else {
// Indexes shifted. // Indexes shifted.
Base::indexUpdatePointer(indexNode, left, Base::storeIndex(move(leftIndex))); Base::indexUpdatePointer(indexNode, left, Base::storeIndex(std::move(leftIndex)));
// Right index first key changes on shift, so always need to update // Right index first key changes on shift, so always need to update
// right index node. // right index node.
Key keyForRight = getLeftKey(rightIndex); Key keyForRight = getLeftKey(rightIndex);
Base::indexUpdatePointer(indexNode, right, Base::storeIndex(move(rightIndex))); Base::indexUpdatePointer(indexNode, right, Base::storeIndex(std::move(rightIndex)));
Base::indexUpdateKeyBefore(indexNode, right, keyForRight); Base::indexUpdateKeyBefore(indexNode, right, keyForRight);
selfUpdated = true; selfUpdated = true;
@ -752,19 +752,19 @@ void BTreeMixin<Base>::modify(Index& indexNode, ModifyInfo& info) {
} }
if (info.state == LeafSplit) { if (info.state == LeafSplit) {
Base::indexUpdatePointer(indexNode, i, Base::storeLeaf(move(lowerLeaf))); Base::indexUpdatePointer(indexNode, i, Base::storeLeaf(std::move(lowerLeaf)));
Base::indexInsertAfter(indexNode, i, info.newKey, info.newPointer); Base::indexInsertAfter(indexNode, i, info.newKey, info.newPointer);
selfUpdated = true; selfUpdated = true;
} }
if (info.state == IndexSplit) { if (info.state == IndexSplit) {
Base::indexUpdatePointer(indexNode, i, Base::storeIndex(move(lowerIndex))); Base::indexUpdatePointer(indexNode, i, Base::storeIndex(std::move(lowerIndex)));
Base::indexInsertAfter(indexNode, i, info.newKey, info.newPointer); Base::indexInsertAfter(indexNode, i, info.newKey, info.newPointer);
selfUpdated = true; selfUpdated = true;
} }
if (info.state == LeafNeedsUpdate) { if (info.state == LeafNeedsUpdate) {
Pointer lowerLeafPointer = Base::storeLeaf(move(lowerLeaf)); Pointer lowerLeafPointer = Base::storeLeaf(std::move(lowerLeaf));
if (lowerLeafPointer != Base::indexPointer(indexNode, i)) { if (lowerLeafPointer != Base::indexPointer(indexNode, i)) {
Base::indexUpdatePointer(indexNode, i, lowerLeafPointer); Base::indexUpdatePointer(indexNode, i, lowerLeafPointer);
selfUpdated = true; selfUpdated = true;
@ -772,7 +772,7 @@ void BTreeMixin<Base>::modify(Index& indexNode, ModifyInfo& info) {
} }
if (info.state == IndexNeedsUpdate) { if (info.state == IndexNeedsUpdate) {
Pointer lowerIndexPointer = Base::storeIndex(move(lowerIndex)); Pointer lowerIndexPointer = Base::storeIndex(std::move(lowerIndex));
if (lowerIndexPointer != Base::indexPointer(indexNode, i)) { if (lowerIndexPointer != Base::indexPointer(indexNode, i)) {
Base::indexUpdatePointer(indexNode, i, lowerIndexPointer); Base::indexUpdatePointer(indexNode, i, lowerIndexPointer);
selfUpdated = true; selfUpdated = true;
@ -796,7 +796,7 @@ void BTreeMixin<Base>::modify(Index& indexNode, ModifyInfo& info) {
template <typename Base> template <typename Base>
bool BTreeMixin<Base>::modify(DataElement e, ModifyAction action) { bool BTreeMixin<Base>::modify(DataElement e, ModifyAction action) {
ModifyInfo info(action, move(e)); ModifyInfo info(action, std::move(e));
Leaf lowerLeaf; Leaf lowerLeaf;
Index lowerIndex; Index lowerIndex;
@ -816,7 +816,7 @@ bool BTreeMixin<Base>::modify(DataElement e, ModifyAction action) {
// removes until setNewRoot) // removes until setNewRoot)
Pointer pointer = Base::indexPointer(lowerIndex, 0); Pointer pointer = Base::indexPointer(lowerIndex, 0);
size_t level = Base::indexLevel(lowerIndex); size_t level = Base::indexLevel(lowerIndex);
Base::deleteIndex(move(lowerIndex)); Base::deleteIndex(std::move(lowerIndex));
Base::setNewRoot(pointer, level == 0); Base::setNewRoot(pointer, level == 0);
} else { } else {
// Else just update. // Else just update.
@ -833,24 +833,24 @@ bool BTreeMixin<Base>::modify(DataElement e, ModifyAction action) {
Index newRoot; Index newRoot;
if (info.state == IndexSplit) { if (info.state == IndexSplit) {
auto rootIndexLevel = Base::indexLevel(lowerIndex) + 1; auto rootIndexLevel = Base::indexLevel(lowerIndex) + 1;
newRoot = Base::createIndex(Base::storeIndex(move(lowerIndex))); newRoot = Base::createIndex(Base::storeIndex(std::move(lowerIndex)));
Base::setIndexLevel(newRoot, rootIndexLevel); Base::setIndexLevel(newRoot, rootIndexLevel);
} else { } else {
newRoot = Base::createIndex(Base::storeLeaf(move(lowerLeaf))); newRoot = Base::createIndex(Base::storeLeaf(std::move(lowerLeaf)));
Base::setIndexLevel(newRoot, 0); Base::setIndexLevel(newRoot, 0);
} }
Base::indexInsertAfter(newRoot, 0, info.newKey, info.newPointer); Base::indexInsertAfter(newRoot, 0, info.newKey, info.newPointer);
Base::setNewRoot(Base::storeIndex(move(newRoot)), false); Base::setNewRoot(Base::storeIndex(std::move(newRoot)), false);
} }
if (info.state == IndexNeedsUpdate) { if (info.state == IndexNeedsUpdate) {
Pointer newRootPointer = Base::storeIndex(move(lowerIndex)); Pointer newRootPointer = Base::storeIndex(std::move(lowerIndex));
if (newRootPointer != Base::rootPointer()) if (newRootPointer != Base::rootPointer())
Base::setNewRoot(newRootPointer, false); Base::setNewRoot(newRootPointer, false);
} }
if (info.state == LeafNeedsUpdate) { if (info.state == LeafNeedsUpdate) {
Pointer newRootPointer = Base::storeLeaf(move(lowerLeaf)); Pointer newRootPointer = Base::storeLeaf(std::move(lowerLeaf));
if (newRootPointer != Base::rootPointer()) if (newRootPointer != Base::rootPointer())
Base::setNewRoot(newRootPointer, true); Base::setNewRoot(newRootPointer, true);
} }
@ -876,7 +876,7 @@ void BTreeMixin<Base>::forAllNodes(Index const& index, Visitor&& visitor) {
for (size_t i = 0; i < Base::indexPointerCount(index); ++i) { for (size_t i = 0; i < Base::indexPointerCount(index); ++i) {
if (Base::indexLevel(index) != 0) { if (Base::indexLevel(index) != 0) {
forAllNodes(Base::loadIndex(Base::indexPointer(index, i)), forward<Visitor>(visitor)); forAllNodes(Base::loadIndex(Base::indexPointer(index, i)), std::forward<Visitor>(visitor));
} else { } else {
if (!visitor(Base::loadLeaf(Base::indexPointer(index, i)))) if (!visitor(Base::loadLeaf(Base::indexPointer(index, i))))
return; return;

12
source/core/StarBTreeDatabase.cpp
View File

@ -58,7 +58,7 @@ String BTreeDatabase::contentIdentifier() const {
void BTreeDatabase::setContentIdentifier(String contentIdentifier) { void BTreeDatabase::setContentIdentifier(String contentIdentifier) {
WriteLocker writeLocker(m_lock); WriteLocker writeLocker(m_lock);
checkIfOpen("setContentIdentifier", false); checkIfOpen("setContentIdentifier", false);
m_contentIdentifier = move(contentIdentifier); m_contentIdentifier = std::move(contentIdentifier);
} }
uint32_t BTreeDatabase::indexCacheSize() const { uint32_t BTreeDatabase::indexCacheSize() const {
@ -91,7 +91,7 @@ IODevicePtr BTreeDatabase::ioDevice() const {
void BTreeDatabase::setIODevice(IODevicePtr device) { void BTreeDatabase::setIODevice(IODevicePtr device) {
WriteLocker writeLocker(m_lock); WriteLocker writeLocker(m_lock);
checkIfOpen("setIODevice", false); checkIfOpen("setIODevice", false);
m_device = move(device); m_device = std::move(device);
} }
bool BTreeDatabase::isOpen() const { bool BTreeDatabase::isOpen() const {
@ -188,12 +188,12 @@ void BTreeDatabase::forEach(ByteArray const& lower, ByteArray const& upper, func
ReadLocker readLocker(m_lock); ReadLocker readLocker(m_lock);
checkKeySize(lower); checkKeySize(lower);
checkKeySize(upper); checkKeySize(upper);
m_impl.forEach(lower, upper, move(v)); m_impl.forEach(lower, upper, std::move(v));
} }
void BTreeDatabase::forAll(function<void(ByteArray, ByteArray)> v) { void BTreeDatabase::forAll(function<void(ByteArray, ByteArray)> v) {
ReadLocker readLocker(m_lock); ReadLocker readLocker(m_lock);
m_impl.forAll(move(v)); m_impl.forAll(std::move(v));
} }
bool BTreeDatabase::insert(ByteArray const& k, ByteArray const& data) { bool BTreeDatabase::insert(ByteArray const& k, ByteArray const& data) {
@ -445,7 +445,7 @@ ByteArray const& BTreeDatabase::LeafNode::data(size_t i) const {
} }
void BTreeDatabase::LeafNode::insert(size_t i, ByteArray k, ByteArray d) { void BTreeDatabase::LeafNode::insert(size_t i, ByteArray k, ByteArray d) {
elements.insertAt(i, Element{move(k), move(d)}); elements.insertAt(i, Element{std::move(k), std::move(d)});
} }
void BTreeDatabase::LeafNode::remove(size_t i) { void BTreeDatabase::LeafNode::remove(size_t i) {
@ -855,7 +855,7 @@ auto BTreeDatabase::BTreeImpl::leafData(Leaf const& leaf, size_t i) -> Data {
} }
void BTreeDatabase::BTreeImpl::leafInsert(Leaf& leaf, size_t i, Key k, Data d) { void BTreeDatabase::BTreeImpl::leafInsert(Leaf& leaf, size_t i, Key k, Data d) {
leaf->insert(i, move(k), move(d)); leaf->insert(i, std::move(k), std::move(d));
} }
void BTreeDatabase::BTreeImpl::leafRemove(Leaf& leaf, size_t i) { void BTreeDatabase::BTreeImpl::leafRemove(Leaf& leaf, size_t i) {

4
source/core/StarBlockAllocator.hpp
View File

@ -142,7 +142,7 @@ T* BlockAllocator<T, BlockSize>::allocate(size_t n) {
auto sortedPosition = std::lower_bound(m_data->blocks.begin(), m_data->blocks.end(), block.get(), [](std::unique_ptr<Block> const& a, Block* b) { auto sortedPosition = std::lower_bound(m_data->blocks.begin(), m_data->blocks.end(), block.get(), [](std::unique_ptr<Block> const& a, Block* b) {
return a.get() < b; return a.get() < b;
}); });
m_data->blocks.insert(sortedPosition, move(block)); m_data->blocks.insert(sortedPosition, std::move(block));
} }
} }
@ -183,7 +183,7 @@ void BlockAllocator<T, BlockSize>::deallocate(T* p, size_t n) {
template <typename T, size_t BlockSize> template <typename T, size_t BlockSize>
template <typename... Args> template <typename... Args>
void BlockAllocator<T, BlockSize>::construct(pointer p, Args&&... args) const { void BlockAllocator<T, BlockSize>::construct(pointer p, Args&&... args) const {
new (p) T(forward<Args>(args)...); new (p) T(std::forward<Args>(args)...);
} }
template <typename T, size_t BlockSize> template <typename T, size_t BlockSize>

10
source/core/StarBuffer.cpp
View File

@ -17,7 +17,7 @@ Buffer::Buffer(size_t initialSize)
Buffer::Buffer(ByteArray b) Buffer::Buffer(ByteArray b)
: Buffer() { : Buffer() {
reset(move(b)); reset(std::move(b));
} }
Buffer::Buffer(Buffer const& buffer) Buffer::Buffer(Buffer const& buffer)
@ -27,7 +27,7 @@ Buffer::Buffer(Buffer const& buffer)
Buffer::Buffer(Buffer&& buffer) Buffer::Buffer(Buffer&& buffer)
: Buffer() { : Buffer() {
operator=(move(buffer)); operator=(std::move(buffer));
} }
StreamOffset Buffer::pos() { StreamOffset Buffer::pos() {
@ -106,7 +106,7 @@ ByteArray const& Buffer::data() const {
} }
ByteArray Buffer::takeData() { ByteArray Buffer::takeData() {
ByteArray ret = move(m_bytes); ByteArray ret = std::move(m_bytes);
reset(0); reset(0);
return ret; return ret;
} }
@ -143,7 +143,7 @@ void Buffer::reset(size_t newSize) {
void Buffer::reset(ByteArray b) { void Buffer::reset(ByteArray b) {
m_pos = 0; m_pos = 0;
m_bytes = move(b); m_bytes = std::move(b);
} }
Buffer& Buffer::operator=(Buffer const& buffer) { Buffer& Buffer::operator=(Buffer const& buffer) {
@ -156,7 +156,7 @@ Buffer& Buffer::operator=(Buffer const& buffer) {
Buffer& Buffer::operator=(Buffer&& buffer) { Buffer& Buffer::operator=(Buffer&& buffer) {
IODevice::operator=(buffer); IODevice::operator=(buffer);
m_pos = buffer.m_pos; m_pos = buffer.m_pos;
m_bytes = move(buffer.m_bytes); m_bytes = std::move(buffer.m_bytes);
buffer.m_pos = 0; buffer.m_pos = 0;
buffer.m_bytes = ByteArray(); buffer.m_bytes = ByteArray();

2
source/core/StarByteArray.cpp
View File

@ -43,7 +43,7 @@ ByteArray::ByteArray(ByteArray const& b)
ByteArray::ByteArray(ByteArray&& b) noexcept ByteArray::ByteArray(ByteArray&& b) noexcept
: ByteArray() { : ByteArray() {
operator=(move(b)); operator=(std::move(b));
} }
ByteArray::~ByteArray() { ByteArray::~ByteArray() {

2
source/core/StarColor.cpp
View File

@ -625,7 +625,7 @@ Vec4B Color::hexToVec4B(StringView s) {
throw ColorException(strf("Improper size {} for hex string '{}' in Color::hexToVec4B", s.utf8Size(), s), false); throw ColorException(strf("Improper size {} for hex string '{}' in Color::hexToVec4B", s.utf8Size(), s), false);
} }
return Vec4B(move(cbytes)); return Vec4B(std::move(cbytes));
} }
} }

4
source/core/StarCompression.cpp
View File

@ -108,7 +108,7 @@ CompressedFile::CompressedFile()
CompressedFile::CompressedFile(String filename) CompressedFile::CompressedFile(String filename)
: IODevice(IOMode::Closed), m_file(0), m_compression(MediumCompression) { : IODevice(IOMode::Closed), m_file(0), m_compression(MediumCompression) {
setFilename(move(filename)); setFilename(std::move(filename));
} }
CompressedFile::~CompressedFile() { CompressedFile::~CompressedFile() {
@ -172,7 +172,7 @@ size_t CompressedFile::write(const char* data, size_t len) {
void CompressedFile::setFilename(String filename) { void CompressedFile::setFilename(String filename) {
if (isOpen()) if (isOpen())
throw IOException("Cannot call setFilename while CompressedFile is open"); throw IOException("Cannot call setFilename while CompressedFile is open");
m_filename = move(filename); m_filename = std::move(filename);
} }
void CompressedFile::setCompression(CompressionLevel compression) { void CompressedFile::setCompression(CompressionLevel compression) {

2
source/core/StarDataStream.cpp
View File

@ -294,7 +294,7 @@ DataStream& DataStream::operator>>(ByteArray& d) {
DataStream& DataStream::operator>>(String& s) { DataStream& DataStream::operator>>(String& s) {
std::string string; std::string string;
operator>>(string); operator>>(string);
s = move(string); s = std::move(string);
return *this; return *this;
} }

2
source/core/StarDataStream.hpp
View File

@ -358,7 +358,7 @@ void DataStream::readMapContainer(Container& map, ReadFunction function) {
typename Container::key_type key; typename Container::key_type key;
typename Container::mapped_type mapped; typename Container::mapped_type mapped;
function(*this, key, mapped); function(*this, key, mapped);
map.insert(make_pair(move(key), move(mapped))); map.insert(make_pair(std::move(key), std::move(mapped)));
} }
} }

6
source/core/StarDataStreamDevices.cpp
View File

@ -3,7 +3,7 @@
namespace Star { namespace Star {
DataStreamFunctions::DataStreamFunctions(function<size_t(char*, size_t)> reader, function<size_t(char const*, size_t)> writer) DataStreamFunctions::DataStreamFunctions(function<size_t(char*, size_t)> reader, function<size_t(char const*, size_t)> writer)
: m_reader(move(reader)), m_writer(move(writer)) {} : m_reader(std::move(reader)), m_writer(std::move(writer)) {}
void DataStreamFunctions::readData(char* data, size_t len) { void DataStreamFunctions::readData(char* data, size_t len) {
if (!m_reader) if (!m_reader)
@ -18,7 +18,7 @@ void DataStreamFunctions::writeData(char const* data, size_t len) {
} }
DataStreamIODevice::DataStreamIODevice(IODevicePtr device) DataStreamIODevice::DataStreamIODevice(IODevicePtr device)
: m_device(move(device)) {} : m_device(std::move(device)) {}
IODevicePtr const& DataStreamIODevice::device() const { IODevicePtr const& DataStreamIODevice::device() const {
return m_device; return m_device;
@ -119,7 +119,7 @@ void DataStreamBuffer::reset(size_t newSize) {
} }
void DataStreamBuffer::reset(ByteArray b) { void DataStreamBuffer::reset(ByteArray b) {
m_buffer->reset(move(b)); m_buffer->reset(std::move(b));
} }
void DataStreamBuffer::readData(char* data, size_t len) { void DataStreamBuffer::readData(char* data, size_t len) {

20
source/core/StarDataStreamDevices.hpp
View File

@ -184,66 +184,66 @@ ByteArray DataStreamBuffer::serializeMapContainer(T const& t, WriteFunction writ
template <typename T> template <typename T>
void DataStreamBuffer::deserialize(T& t, ByteArray data) { void DataStreamBuffer::deserialize(T& t, ByteArray data) {
DataStreamBuffer ds(move(data)); DataStreamBuffer ds(std::move(data));
ds.read(t); ds.read(t);
} }
template <typename T> template <typename T>
void DataStreamBuffer::deserializeContainer(T& t, ByteArray data) { void DataStreamBuffer::deserializeContainer(T& t, ByteArray data) {
DataStreamBuffer ds(move(data)); DataStreamBuffer ds(std::move(data));
ds.readContainer(t); ds.readContainer(t);
} }
template <typename T, typename ReadFunction> template <typename T, typename ReadFunction>
void DataStreamBuffer::deserializeContainer(T& t, ByteArray data, ReadFunction readFunction) { void DataStreamBuffer::deserializeContainer(T& t, ByteArray data, ReadFunction readFunction) {
DataStreamBuffer ds(move(data)); DataStreamBuffer ds(std::move(data));
ds.readContainer(t, readFunction); ds.readContainer(t, readFunction);
} }
template <typename T> template <typename T>
void DataStreamBuffer::deserializeMapContainer(T& t, ByteArray data) { void DataStreamBuffer::deserializeMapContainer(T& t, ByteArray data) {
DataStreamBuffer ds(move(data)); DataStreamBuffer ds(std::move(data));
ds.readMapContainer(t); ds.readMapContainer(t);
} }
template <typename T, typename ReadFunction> template <typename T, typename ReadFunction>
void DataStreamBuffer::deserializeMapContainer(T& t, ByteArray data, ReadFunction readFunction) { void DataStreamBuffer::deserializeMapContainer(T& t, ByteArray data, ReadFunction readFunction) {
DataStreamBuffer ds(move(data)); DataStreamBuffer ds(std::move(data));
ds.readMapContainer(t, readFunction); ds.readMapContainer(t, readFunction);
} }
template <typename T> template <typename T>
T DataStreamBuffer::deserialize(ByteArray data) { T DataStreamBuffer::deserialize(ByteArray data) {
T t; T t;
deserialize(t, move(data)); deserialize(t, std::move(data));
return t; return t;
} }
template <typename T> template <typename T>
T DataStreamBuffer::deserializeContainer(ByteArray data) { T DataStreamBuffer::deserializeContainer(ByteArray data) {
T t; T t;
deserializeContainer(t, move(data)); deserializeContainer(t, std::move(data));
return t; return t;
} }
template <typename T, typename ReadFunction> template <typename T, typename ReadFunction>
T DataStreamBuffer::deserializeContainer(ByteArray data, ReadFunction readFunction) { T DataStreamBuffer::deserializeContainer(ByteArray data, ReadFunction readFunction) {
T t; T t;
deserializeContainer(t, move(data), readFunction); deserializeContainer(t, std::move(data), readFunction);
return t; return t;
} }
template <typename T> template <typename T>
T DataStreamBuffer::deserializeMapContainer(ByteArray data) { T DataStreamBuffer::deserializeMapContainer(ByteArray data) {
T t; T t;
deserializeMapContainer(t, move(data)); deserializeMapContainer(t, std::move(data));
return t; return t;
} }
template <typename T, typename ReadFunction> template <typename T, typename ReadFunction>
T DataStreamBuffer::deserializeMapContainer(ByteArray data, ReadFunction readFunction) { T DataStreamBuffer::deserializeMapContainer(ByteArray data, ReadFunction readFunction) {
T t; T t;
deserializeMapContainer(t, move(data), readFunction); deserializeMapContainer(t, std::move(data), readFunction);
return t; return t;
} }

2
source/core/StarDataStreamExtra.hpp
View File

@ -293,7 +293,7 @@ void readMaybe(DataStream& ds, Maybe<T>& maybe, ReadFunction&& readFunction) {
if (set) { if (set) {
T t; T t;
readFunction(ds, t); readFunction(ds, t);
maybe = move(t); maybe = std::move(t);
} else { } else {
maybe.reset(); maybe.reset();
} }

30
source/core/StarDirectives.cpp
View File

@ -7,7 +7,7 @@
namespace Star { namespace Star {
Directives::Entry::Entry(ImageOperation&& newOperation, size_t strBegin, size_t strLength) { Directives::Entry::Entry(ImageOperation&& newOperation, size_t strBegin, size_t strLength) {
operation = move(newOperation); operation = std::move(newOperation);
begin = strBegin; begin = strBegin;
length = strLength; length = strLength;
} }
@ -43,8 +43,8 @@ bool Directives::Shared::empty() const {
} }
Directives::Shared::Shared(List<Entry>&& givenEntries, String&& givenString, StringView givenPrefix) { Directives::Shared::Shared(List<Entry>&& givenEntries, String&& givenString, StringView givenPrefix) {
entries = move(givenEntries); entries = std::move(givenEntries);
string = move(givenString); string = std::move(givenString);
prefix = givenPrefix; prefix = givenPrefix;
hash = XXH3_64bits(string.utf8Ptr(), string.utf8Size()); hash = XXH3_64bits(string.utf8Ptr(), string.utf8Size());
} }
@ -56,7 +56,7 @@ Directives::Directives(String const& directives) {
} }
Directives::Directives(String&& directives) { Directives::Directives(String&& directives) {
parse(move(directives)); parse(std::move(directives));
} }
Directives::Directives(const char* directives) { Directives::Directives(const char* directives) {
@ -64,7 +64,7 @@ Directives::Directives(const char* directives) {
} }
Directives::Directives(Directives&& directives) { Directives::Directives(Directives&& directives) {
*this = move(directives); *this = std::move(directives);
} }
Directives::Directives(Directives const& directives) { Directives::Directives(Directives const& directives) {
@ -87,7 +87,7 @@ Directives& Directives::operator=(String&& s) {
return *this; return *this;
} }
parse(move(s)); parse(std::move(s));
return *this; return *this;
} }
@ -100,7 +100,7 @@ Directives& Directives::operator=(const char* s) {
} }
Directives& Directives::operator=(Directives&& other) { Directives& Directives::operator=(Directives&& other) {
shared = move(other.shared); shared = std::move(other.shared);
return *this; return *this;
} }
@ -132,7 +132,7 @@ void Directives::parse(String&& directives) {
if (beg == 0) { if (beg == 0) {
try { try {
ImageOperation operation = imageOperationFromString(split); ImageOperation operation = imageOperationFromString(split);
newList.emplace_back(move(operation), beg, end); newList.emplace_back(std::move(operation), beg, end);
} }
catch (StarException const& e) { catch (StarException const& e) {
prefix = split; prefix = split;
@ -141,7 +141,7 @@ void Directives::parse(String&& directives) {
} }
else { else {
ImageOperation operation = NullImageOperation(); ImageOperation operation = NullImageOperation();
newList.emplace_back(move(operation), beg, end); newList.emplace_back(std::move(operation), beg, end);
} }
} }
}); });
@ -151,7 +151,7 @@ void Directives::parse(String&& directives) {
return; return;
} }
shared = std::make_shared<Shared const>(move(newList), move(directives), prefix); shared = std::make_shared<Shared const>(std::move(newList), std::move(directives), prefix);
if (view.size() < 1000) { // Pre-load short enough directives if (view.size() < 1000) { // Pre-load short enough directives
for (auto& entry : shared->entries) for (auto& entry : shared->entries)
entry.loadOperation(*shared); entry.loadOperation(*shared);
@ -219,7 +219,7 @@ DataStream& operator>>(DataStream& ds, Directives& directives) {
String string; String string;
ds.read(string); ds.read(string);
directives.parse(move(string)); directives.parse(std::move(string));
return ds; return ds;
} }
@ -240,7 +240,7 @@ DirectivesGroup::DirectivesGroup(String const& directives) : m_count(0) {
Directives parsed(directives); Directives parsed(directives);
if (parsed) { if (parsed) {
m_directives.emplace_back(move(parsed)); m_directives.emplace_back(std::move(parsed));
m_count = m_directives.back().size(); m_count = m_directives.back().size();
} }
} }
@ -250,9 +250,9 @@ DirectivesGroup::DirectivesGroup(String&& directives) : m_count(0) {
return; return;
} }
Directives parsed(move(directives)); Directives parsed(std::move(directives));
if (parsed) { if (parsed) {
m_directives.emplace_back(move(parsed)); m_directives.emplace_back(std::move(parsed));
m_count = m_directives.back().size(); m_count = m_directives.back().size();
} }
} }
@ -372,7 +372,7 @@ DataStream& operator>>(DataStream& ds, DirectivesGroup& directivesGroup) {
String string; String string;
ds.read(string); ds.read(string);
directivesGroup = DirectivesGroup(move(string)); directivesGroup = DirectivesGroup(std::move(string));
return ds; return ds;
} }

24
source/core/StarEither.hpp
View File

@ -85,12 +85,12 @@ private:
template <typename Value> template <typename Value>
EitherLeftValue<Value> makeLeft(Value value) { EitherLeftValue<Value> makeLeft(Value value) {
return {move(value)}; return {std::move(value)};
} }
template <typename Value> template <typename Value>
EitherRightValue<Value> makeRight(Value value) { EitherRightValue<Value> makeRight(Value value) {
return {move(value)}; return {std::move(value)};
} }
template <typename Left, typename Right> template <typename Left, typename Right>
@ -98,21 +98,21 @@ Either<Left, Right>::Either() {}
template <typename Left, typename Right> template <typename Left, typename Right>
Either<Left, Right>::Either(EitherLeftValue<Left> left) Either<Left, Right>::Either(EitherLeftValue<Left> left)
: m_value(move(left)) {} : m_value(std::move(left)) {}
template <typename Left, typename Right> template <typename Left, typename Right>
Either<Left, Right>::Either(EitherRightValue<Right> right) Either<Left, Right>::Either(EitherRightValue<Right> right)
: m_value(move(right)) {} : m_value(std::move(right)) {}
template <typename Left, typename Right> template <typename Left, typename Right>
template <typename T> template <typename T>
Either<Left, Right>::Either(EitherLeftValue<T> left) Either<Left, Right>::Either(EitherLeftValue<T> left)
: Either(LeftType{move(left.value)}) {} : Either(LeftType{std::move(left.value)}) {}
template <typename Left, typename Right> template <typename Left, typename Right>
template <typename T> template <typename T>
Either<Left, Right>::Either(EitherRightValue<T> right) Either<Left, Right>::Either(EitherRightValue<T> right)
: Either(RightType{move(right.value)}) {} : Either(RightType{std::move(right.value)}) {}
template <typename Left, typename Right> template <typename Left, typename Right>
Either<Left, Right>::Either(Either const& rhs) Either<Left, Right>::Either(Either const& rhs)
@ -120,7 +120,7 @@ Either<Left, Right>::Either(Either const& rhs)
template <typename Left, typename Right> template <typename Left, typename Right>
Either<Left, Right>::Either(Either&& rhs) Either<Left, Right>::Either(Either&& rhs)
: m_value(move(rhs.m_value)) {} : m_value(std::move(rhs.m_value)) {}
template <typename Left, typename Right> template <typename Left, typename Right>
Either<Left, Right>& Either<Left, Right>::operator=(Either const& rhs) { Either<Left, Right>& Either<Left, Right>::operator=(Either const& rhs) {
@ -130,21 +130,21 @@ Either<Left, Right>& Either<Left, Right>::operator=(Either const& rhs) {
template <typename Left, typename Right> template <typename Left, typename Right>
Either<Left, Right>& Either<Left, Right>::operator=(Either&& rhs) { Either<Left, Right>& Either<Left, Right>::operator=(Either&& rhs) {
m_value = move(rhs.m_value); m_value = std::move(rhs.m_value);
return *this; return *this;
} }
template <typename Left, typename Right> template <typename Left, typename Right>
template <typename T> template <typename T>
Either<Left, Right>& Either<Left, Right>::operator=(EitherLeftValue<T> left) { Either<Left, Right>& Either<Left, Right>::operator=(EitherLeftValue<T> left) {
m_value = LeftType{move(left.value)}; m_value = LeftType{std::move(left.value)};
return *this; return *this;
} }
template <typename Left, typename Right> template <typename Left, typename Right>
template <typename T> template <typename T>
Either<Left, Right>& Either<Left, Right>::operator=(EitherRightValue<T> right) { Either<Left, Right>& Either<Left, Right>::operator=(EitherRightValue<T> right) {
m_value = RightType{move(right.value)}; m_value = RightType{std::move(right.value)};
return *this; return *this;
} }
@ -160,12 +160,12 @@ bool Either<Left, Right>::isRight() const {
template <typename Left, typename Right> template <typename Left, typename Right>
void Either<Left, Right>::setLeft(Left left) { void Either<Left, Right>::setLeft(Left left) {
m_value = LeftType{move(left)}; m_value = LeftType{std::move(left)};
} }
template <typename Left, typename Right> template <typename Left, typename Right>
void Either<Left, Right>::setRight(Right right) { void Either<Left, Right>::setRight(Right right) {
m_value = RightType{move(right)}; m_value = RightType{std::move(right)};
} }
template <typename Left, typename Right> template <typename Left, typename Right>

10
source/core/StarException.hpp
View File

@ -79,18 +79,18 @@ void fatalException(std::exception const& e, bool showStackTrace);
class ClassName : public BaseName { \ class ClassName : public BaseName { \
public: \ public: \
template <typename... Args> \ template <typename... Args> \
static ClassName format(fmt::format_string<Args...> fmt, Args const&... args) { \ static ClassName format(fmt::format_string<Args...> fmt, Args const&... args) { \
return ClassName(strf(fmt, args...)); \ return ClassName(strf(fmt, args...)); \
} \ } \
ClassName() : BaseName(#ClassName, std::string()) {} \ ClassName() : BaseName(#ClassName, std::string()) {} \
explicit ClassName(std::string message, bool genStackTrace = true) : BaseName(#ClassName, move(message), genStackTrace) {} \ explicit ClassName(std::string message, bool genStackTrace = true) : BaseName(#ClassName, std::move(message), genStackTrace) {} \
explicit ClassName(std::exception const& cause) : BaseName(#ClassName, std::string(), cause) {} \ explicit ClassName(std::exception const& cause) : BaseName(#ClassName, std::string(), cause) {} \
ClassName(std::string message, std::exception const& cause) : BaseName(#ClassName, move(message), cause) {} \ ClassName(std::string message, std::exception const& cause) : BaseName(#ClassName, std::move(message), cause) {} \
\ \
protected: \ protected: \
ClassName(char const* type, std::string message, bool genStackTrace = true) : BaseName(type, move(message), genStackTrace) {} \ ClassName(char const* type, std::string message, bool genStackTrace = true) : BaseName(type, std::move(message), genStackTrace) {} \
ClassName(char const* type, std::string message, std::exception const& cause) \ ClassName(char const* type, std::string message, std::exception const& cause) \
: BaseName(type, move(message), cause) {} \ : BaseName(type, std::move(message), cause) {} \
} }
STAR_EXCEPTION(OutOfRangeException, StarException); STAR_EXCEPTION(OutOfRangeException, StarException);

12
source/core/StarException_unix.cpp
View File

@ -18,7 +18,7 @@ inline StackCapture captureStack() {
} }
OutputProxy outputStack(StackCapture stack) { OutputProxy outputStack(StackCapture stack) {
return OutputProxy([stack = move(stack)](std::ostream & os) { return OutputProxy([stack = std::move(stack)](std::ostream & os) {
char** symbols = backtrace_symbols(stack.first.ptr(), stack.second); char** symbols = backtrace_symbols(stack.first.ptr(), stack.second);
for (size_t i = 0; i < stack.second; ++i) { for (size_t i = 0; i < stack.second; ++i) {
os << symbols[i]; os << symbols[i];
@ -39,13 +39,13 @@ StarException::StarException() noexcept
StarException::~StarException() noexcept {} StarException::~StarException() noexcept {}
StarException::StarException(std::string message, bool genStackTrace) noexcept StarException::StarException(std::string message, bool genStackTrace) noexcept
: StarException("StarException", move(message), genStackTrace) {} : StarException("StarException", std::move(message), genStackTrace) {}
StarException::StarException(std::exception const& cause) noexcept StarException::StarException(std::exception const& cause) noexcept
: StarException("StarException", std::string(), cause) {} : StarException("StarException", std::string(), cause) {}
StarException::StarException(std::string message, std::exception const& cause) noexcept StarException::StarException(std::string message, std::exception const& cause) noexcept
: StarException("StarException", move(message), cause) {} : StarException("StarException", std::move(message), cause) {}
const char* StarException::what() const throw() { const char* StarException::what() const throw() {
if (m_whatBuffer.empty()) { if (m_whatBuffer.empty()) {
@ -68,11 +68,11 @@ StarException::StarException(char const* type, std::string message, bool genStac
} }
}; };
m_printException = bind(printException, _1, _2, type, move(message), genStackTrace ? captureStack() : Maybe<StackCapture>()); m_printException = bind(printException, _1, _2, type, std::move(message), genStackTrace ? captureStack() : Maybe<StackCapture>());
} }
StarException::StarException(char const* type, std::string message, std::exception const& cause) noexcept StarException::StarException(char const* type, std::string message, std::exception const& cause) noexcept
: StarException(type, move(message)) { : StarException(type, std::move(message)) {
auto printException = [](std::ostream& os, bool fullStacktrace, function<void(std::ostream&, bool)> self, function<void(std::ostream&, bool)> cause) { auto printException = [](std::ostream& os, bool fullStacktrace, function<void(std::ostream&, bool)> self, function<void(std::ostream&, bool)> cause) {
self(os, fullStacktrace); self(os, fullStacktrace);
os << std::endl << "Caused by: "; os << std::endl << "Caused by: ";
@ -88,7 +88,7 @@ StarException::StarException(char const* type, std::string message, std::excepti
}, _1, _2, std::string(cause.what())); }, _1, _2, std::string(cause.what()));
} }
m_printException = bind(printException, _1, _2, m_printException, move(printCause)); m_printException = bind(printException, _1, _2, m_printException, std::move(printCause));
} }
std::string printException(std::exception const& e, bool fullStacktrace) { std::string printException(std::exception const& e, bool fullStacktrace) {

12
source/core/StarException_windows.cpp
View File

@ -117,7 +117,7 @@ inline StackCapture captureStack() {
} }
OutputProxy outputStack(StackCapture stack) { OutputProxy outputStack(StackCapture stack) {
return OutputProxy([stack = move(stack)](std::ostream & os) { return OutputProxy([stack = std::move(stack)](std::ostream & os) {
HANDLE process = GetCurrentProcess(); HANDLE process = GetCurrentProcess();
g_dbgHelpLock.lock(); g_dbgHelpLock.lock();
for (size_t i = 0; i < stack.second; ++i) { for (size_t i = 0; i < stack.second; ++i) {
@ -146,13 +146,13 @@ StarException::StarException() noexcept : StarException(std::string("StarExcepti
StarException::~StarException() noexcept {} StarException::~StarException() noexcept {}
StarException::StarException(std::string message, bool genStackTrace) noexcept : StarException("StarException", move(message), genStackTrace) {} StarException::StarException(std::string message, bool genStackTrace) noexcept : StarException("StarException", std::move(message), genStackTrace) {}
StarException::StarException(std::exception const& cause) noexcept StarException::StarException(std::exception const& cause) noexcept
: StarException("StarException", std::string(), cause) {} : StarException("StarException", std::string(), cause) {}
StarException::StarException(std::string message, std::exception const& cause) noexcept StarException::StarException(std::string message, std::exception const& cause) noexcept
: StarException("StarException", move(message), cause) {} : StarException("StarException", std::move(message), cause) {}
const char* StarException::what() const throw() { const char* StarException::what() const throw() {
if (m_whatBuffer.empty()) { if (m_whatBuffer.empty()) {
@ -176,11 +176,11 @@ StarException::StarException(char const* type, std::string message, bool genStac
} }
}; };
m_printException = bind(printException, _1, _2, type, move(message), genStackTrace ? captureStack() : Maybe<StackCapture>()); m_printException = bind(printException, _1, _2, type, std::move(message), genStackTrace ? captureStack() : Maybe<StackCapture>());
} }
StarException::StarException(char const* type, std::string message, std::exception const& cause) noexcept StarException::StarException(char const* type, std::string message, std::exception const& cause) noexcept
: StarException(type, move(message)) { : StarException(type, std::move(message)) {
auto printException = [](std::ostream& os, auto printException = [](std::ostream& os,
bool fullStacktrace, bool fullStacktrace,
function<void(std::ostream&, bool)> self, function<void(std::ostream&, bool)> self,
@ -199,7 +199,7 @@ StarException::StarException(char const* type, std::string message, std::excepti
}, _1, _2, std::string(cause.what())); }, _1, _2, std::string(cause.what()));
} }
m_printException = bind(printException, _1, _2, m_printException, move(printCause)); m_printException = bind(printException, _1, _2, m_printException, std::move(printCause));
} }
std::string printException(std::exception const& e, bool fullStacktrace) { std::string printException(std::exception const& e, bool fullStacktrace) {

4
source/core/StarFile.cpp
View File

@ -124,7 +124,7 @@ File::File()
} }
File::File(String filename) File::File(String filename)
: IODevice(IOMode::Closed), m_filename(move(filename)), m_file(0) {} : IODevice(IOMode::Closed), m_filename(std::move(filename)), m_file(0) {}
File::~File() { File::~File() {
close(); close();
@ -190,7 +190,7 @@ String File::fileName() const {
void File::setFilename(String filename) { void File::setFilename(String filename) {
if (isOpen()) if (isOpen())
throw IOException("Cannot call setFilename while File is open"); throw IOException("Cannot call setFilename while File is open");
m_filename = move(filename); m_filename = std::move(filename);
} }
void File::remove() { void File::remove() {

16
source/core/StarFlatHashMap.hpp
View File

@ -290,12 +290,12 @@ FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::FlatHashMap(FlatHashMap const
template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::FlatHashMap(FlatHashMap&& other) FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::FlatHashMap(FlatHashMap&& other)
: FlatHashMap(move(other), other.m_table.getAllocator()) {} : FlatHashMap(std::move(other), other.m_table.getAllocator()) {}
template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::FlatHashMap(FlatHashMap&& other, allocator_type const& alloc) FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::FlatHashMap(FlatHashMap&& other, allocator_type const& alloc)
: FlatHashMap(alloc) { : FlatHashMap(alloc) {
operator=(move(other)); operator=(std::move(other));
} }
template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
@ -326,7 +326,7 @@ auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::operator=(FlatHashMap co
template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::operator=(FlatHashMap&& other) -> FlatHashMap& { auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::operator=(FlatHashMap&& other) -> FlatHashMap& {
m_table = move(other.m_table); m_table = std::move(other.m_table);
return *this; return *this;
} }
@ -391,7 +391,7 @@ auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::insert(value_type const&
template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
template <typename T, typename> template <typename T, typename>
auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::insert(T&& value) -> pair<iterator, bool> { auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::insert(T&& value) -> pair<iterator, bool> {
auto res = m_table.insert(TableValue(forward<T&&>(value))); auto res = m_table.insert(TableValue(std::forward<T&&>(value)));
return {iterator{res.first}, res.second}; return {iterator{res.first}, res.second};
} }
@ -403,7 +403,7 @@ auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::insert(const_iterator hi
template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
template <typename T, typename> template <typename T, typename>
auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::insert(const_iterator, T&& value) -> iterator { auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::insert(const_iterator, T&& value) -> iterator {
return insert(forward<T&&>(value)).first; return insert(std::forward<T&&>(value)).first;
} }
template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
@ -422,13 +422,13 @@ void FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::insert(initializer_list<
template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
template <typename... Args> template <typename... Args>
auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::emplace(Args&&... args) -> pair<iterator, bool> { auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::emplace(Args&&... args) -> pair<iterator, bool> {
return insert(TableValue(forward<Args>(args)...)); return insert(TableValue(std::forward<Args>(args)...));
} }
template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
template <typename... Args> template <typename... Args>
auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::emplace_hint(const_iterator hint, Args&&... args) -> iterator { auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::emplace_hint(const_iterator hint, Args&&... args) -> iterator {
return insert(hint, TableValue(forward<Args>(args)...)); return insert(hint, TableValue(std::forward<Args>(args)...));
} }
template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>
@ -480,7 +480,7 @@ auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::operator[](key_type&& ke
auto i = m_table.find(key); auto i = m_table.find(key);
if (i != m_table.end()) if (i != m_table.end())
return i->second; return i->second;
return m_table.insert({move(key), mapped_type()}).first->second; return m_table.insert({std::move(key), mapped_type()}).first->second;
} }
template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Mapped, typename Hash, typename Equals, typename Allocator>

10
source/core/StarFlatHashSet.hpp
View File

@ -277,12 +277,12 @@ FlatHashSet<Key, Hash, Equals, Allocator>::FlatHashSet(FlatHashSet const& other,
template <typename Key, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Hash, typename Equals, typename Allocator>
FlatHashSet<Key, Hash, Equals, Allocator>::FlatHashSet(FlatHashSet&& other) FlatHashSet<Key, Hash, Equals, Allocator>::FlatHashSet(FlatHashSet&& other)
: FlatHashSet(move(other), other.m_table.getAllocator()) {} : FlatHashSet(std::move(other), other.m_table.getAllocator()) {}
template <typename Key, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Hash, typename Equals, typename Allocator>
FlatHashSet<Key, Hash, Equals, Allocator>::FlatHashSet(FlatHashSet&& other, allocator_type const& alloc) FlatHashSet<Key, Hash, Equals, Allocator>::FlatHashSet(FlatHashSet&& other, allocator_type const& alloc)
: FlatHashSet(alloc) { : FlatHashSet(alloc) {
operator=(move(other)); operator=(std::move(other));
} }
template <typename Key, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Hash, typename Equals, typename Allocator>
@ -312,7 +312,7 @@ FlatHashSet<Key, Hash, Equals, Allocator>& FlatHashSet<Key, Hash, Equals, Alloca
template <typename Key, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Hash, typename Equals, typename Allocator>
FlatHashSet<Key, Hash, Equals, Allocator>& FlatHashSet<Key, Hash, Equals, Allocator>::operator=(FlatHashSet&& other) { FlatHashSet<Key, Hash, Equals, Allocator>& FlatHashSet<Key, Hash, Equals, Allocator>::operator=(FlatHashSet&& other) {
m_table = move(other.m_table); m_table = std::move(other.m_table);
return *this; return *this;
} }
@ -376,7 +376,7 @@ auto FlatHashSet<Key, Hash, Equals, Allocator>::insert(value_type const& value)
template <typename Key, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Hash, typename Equals, typename Allocator>
auto FlatHashSet<Key, Hash, Equals, Allocator>::insert(value_type&& value) -> pair<iterator, bool> { auto FlatHashSet<Key, Hash, Equals, Allocator>::insert(value_type&& value) -> pair<iterator, bool> {
auto res = m_table.insert(move(value)); auto res = m_table.insert(std::move(value));
return {iterator{res.first}, res.second}; return {iterator{res.first}, res.second};
} }
@ -387,7 +387,7 @@ auto FlatHashSet<Key, Hash, Equals, Allocator>::insert(const_iterator i, value_t
template <typename Key, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Hash, typename Equals, typename Allocator>
auto FlatHashSet<Key, Hash, Equals, Allocator>::insert(const_iterator, value_type&& value) -> iterator { auto FlatHashSet<Key, Hash, Equals, Allocator>::insert(const_iterator, value_type&& value) -> iterator {
return insert(move(value)).first; return insert(std::move(value)).first;
} }
template <typename Key, typename Hash, typename Equals, typename Allocator> template <typename Key, typename Hash, typename Equals, typename Allocator>

16
source/core/StarFlatHashTable.hpp
View File

@ -138,7 +138,7 @@ template <typename Value, typename Key, typename GetKey, typename Hash, typename
FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::Bucket::Bucket(Bucket&& rhs) { FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::Bucket::Bucket(Bucket&& rhs) {
this->hash = rhs.hash; this->hash = rhs.hash;
if (auto o = rhs.valuePtr()) if (auto o = rhs.valuePtr())
new (&this->value) Value(move(*o)); new (&this->value) Value(std::move(*o));
} }
template <typename Value, typename Key, typename GetKey, typename Hash, typename Equals, typename Allocator> template <typename Value, typename Key, typename GetKey, typename Hash, typename Equals, typename Allocator>
@ -160,9 +160,9 @@ template <typename Value, typename Key, typename GetKey, typename Hash, typename
auto FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::Bucket::operator=(Bucket&& rhs) -> Bucket& { auto FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::Bucket::operator=(Bucket&& rhs) -> Bucket& {
if (auto o = rhs.valuePtr()) { if (auto o = rhs.valuePtr()) {
if (auto s = valuePtr()) if (auto s = valuePtr())
*s = move(*o); *s = std::move(*o);
else else
new (&this->value) Value(move(*o)); new (&this->value) Value(std::move(*o));
} else { } else {
if (auto s = valuePtr()) if (auto s = valuePtr())
s->~Value(); s->~Value();
@ -174,9 +174,9 @@ auto FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::Bucket::operato
template <typename Value, typename Key, typename GetKey, typename Hash, typename Equals, typename Allocator> template <typename Value, typename Key, typename GetKey, typename Hash, typename Equals, typename Allocator>
void FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::Bucket::setFilled(size_t hash, Value value) { void FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::Bucket::setFilled(size_t hash, Value value) {
if (auto s = valuePtr()) if (auto s = valuePtr())
*s = move(value); *s = std::move(value);
else else
new (&this->value) Value(move(value)); new (&this->value) Value(std::move(value));
this->hash = hash | FilledHashBit; this->hash = hash | FilledHashBit;
} }
@ -370,7 +370,7 @@ auto FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::insert(Value va
currentBucket = hashBucket(currentBucket + 1); currentBucket = hashBucket(currentBucket + 1);
} else { } else {
target.setFilled(hash, move(value)); target.setFilled(hash, std::move(value));
++m_filledCount; ++m_filledCount;
if (insertedBucket == NPos) if (insertedBucket == NPos)
insertedBucket = currentBucket; insertedBucket = currentBucket;
@ -392,7 +392,7 @@ auto FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::erase(const_ite
if (auto nextPtr = nextBucket->valuePtr()) { if (auto nextPtr = nextBucket->valuePtr()) {
if (bucketError(nextBucketIndex, nextBucket->hash) > 0) { if (bucketError(nextBucketIndex, nextBucket->hash) > 0) {
currentBucket->hash = nextBucket->hash; currentBucket->hash = nextBucket->hash;
*currentBucket->valuePtr() = move(*nextPtr); *currentBucket->valuePtr() = std::move(*nextPtr);
currentBucketIndex = nextBucketIndex; currentBucketIndex = nextBucketIndex;
currentBucket = nextBucket; currentBucket = nextBucket;
} else { } else {
@ -548,7 +548,7 @@ void FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::checkCapacity(s
for (auto& entry : oldBuckets) { for (auto& entry : oldBuckets) {
if (auto ptr = entry.valuePtr()) if (auto ptr = entry.valuePtr())
insert(move(*ptr)); insert(std::move(*ptr));
} }
} }

2
source/core/StarFont.cpp
View File

@ -130,7 +130,7 @@ std::pair<Image, Vec2I> Font::render(String::Char c) {
} }
} }
return { move(image), {slot->bitmap_left - 1, (slot->bitmap_top - height) + (m_pixelSize / 4) - 1} }; return { std::move(image), {slot->bitmap_left - 1, (slot->bitmap_top - height) + (m_pixelSize / 4) - 1} };
} }
} }

16
source/core/StarHostAddress.cpp
View File

@ -20,7 +20,7 @@ Either<String, HostAddress> HostAddress::lookup(String const& address) {
try { try {
HostAddress ha; HostAddress ha;
ha.set(address); ha.set(address);
return makeRight(move(ha)); return makeRight(std::move(ha));
} catch (NetworkException const& e) { } catch (NetworkException const& e) {
return makeLeft(String(e.what())); return makeLeft(String(e.what()));
} }
@ -35,7 +35,7 @@ HostAddress::HostAddress(String const& address) {
if (a.isLeft()) if (a.isLeft())
throw NetworkException(a.left().takeUtf8()); throw NetworkException(a.left().takeUtf8());
else else
*this = move(a.right()); *this = std::move(a.right());
} }
NetworkMode HostAddress::mode() const { NetworkMode HostAddress::mode() const {
@ -211,9 +211,9 @@ size_t hash<HostAddress>::operator()(HostAddress const& address) const {
Either<String, HostAddressWithPort> HostAddressWithPort::lookup(String const& address, uint16_t port) { Either<String, HostAddressWithPort> HostAddressWithPort::lookup(String const& address, uint16_t port) {
auto hostAddress = HostAddress::lookup(address); auto hostAddress = HostAddress::lookup(address);
if (hostAddress.isLeft()) if (hostAddress.isLeft())
return makeLeft(move(hostAddress.left())); return makeLeft(std::move(hostAddress.left()));
else else
return makeRight(HostAddressWithPort(move(hostAddress.right()), port)); return makeRight(HostAddressWithPort(std::move(hostAddress.right()), port));
} }
Either<String, HostAddressWithPort> HostAddressWithPort::lookupWithPort(String const& address) { Either<String, HostAddressWithPort> HostAddressWithPort::lookupWithPort(String const& address) {
@ -228,9 +228,9 @@ Either<String, HostAddressWithPort> HostAddressWithPort::lookupWithPort(String c
auto hostAddress = HostAddress::lookup(host); auto hostAddress = HostAddress::lookup(host);
if (hostAddress.isLeft()) if (hostAddress.isLeft())
return makeLeft(move(hostAddress.left())); return makeLeft(std::move(hostAddress.left()));
return makeRight(HostAddressWithPort(move(hostAddress.right()), *portNum)); return makeRight(HostAddressWithPort(std::move(hostAddress.right()), *portNum));
} }
HostAddressWithPort::HostAddressWithPort() : m_port(0) {} HostAddressWithPort::HostAddressWithPort() : m_port(0) {}
@ -247,14 +247,14 @@ HostAddressWithPort::HostAddressWithPort(String const& address, uint16_t port) {
auto a = lookup(address, port); auto a = lookup(address, port);
if (a.isLeft()) if (a.isLeft())
throw NetworkException(a.left().takeUtf8()); throw NetworkException(a.left().takeUtf8());
*this = move(a.right()); *this = std::move(a.right());
} }
HostAddressWithPort::HostAddressWithPort(String const& address) { HostAddressWithPort::HostAddressWithPort(String const& address) {
auto a = lookupWithPort(address); auto a = lookupWithPort(address);
if (a.isLeft()) if (a.isLeft())
throw NetworkException(a.left().takeUtf8()); throw NetworkException(a.left().takeUtf8());
*this = move(a.right()); *this = std::move(a.right());
} }
HostAddress HostAddressWithPort::address() const { HostAddress HostAddressWithPort::address() const {

2
source/core/StarIdMap.hpp
View File

@ -101,7 +101,7 @@ auto IdMapWrapper<BaseMap>::nextId() -> IdType {
template <typename BaseMap> template <typename BaseMap>
void IdMapWrapper<BaseMap>::add(IdType id, MappedType mappedType) { void IdMapWrapper<BaseMap>::add(IdType id, MappedType mappedType) {
if (!BaseMap::insert(make_pair(move(id), move(mappedType))).second) if (!BaseMap::insert(make_pair(std::move(id), std::move(mappedType))).second)
throw IdMapException::format("IdMapWrapper::add(id, value) called with pre-existing id '{}'", outputAny(id)); throw IdMapException::format("IdMapWrapper::add(id, value) called with pre-existing id '{}'", outputAny(id));
} }

2
source/core/StarImage.cpp
View File

@ -219,7 +219,7 @@ Image::Image(Image const& image) : Image() {
} }
Image::Image(Image&& image) : Image() { Image::Image(Image&& image) : Image() {
operator=(move(image)); operator=(std::move(image));
} }
Image& Image::operator=(Image const& image) { Image& Image::operator=(Image const& image) {

2
source/core/StarImageProcessing.cpp
View File

@ -201,7 +201,7 @@ ImageOperation imageOperationFromString(StringView string) {
else if (!which || (ptr != end && ++ptr != end)) else if (!which || (ptr != end && ++ptr != end))
throw ImageOperationException(strf("Improper size for hex string '{}' in imageOperationFromString", StringView(hexPtr, hexLen)), false); throw ImageOperationException(strf("Improper size for hex string '{}' in imageOperationFromString", StringView(hexPtr, hexLen)), false);
else // we're in A of A=B. In vanilla only A=B pairs are evaluated, so only throw an exception if B is also there. else // we're in A of A=B. In vanilla only A=B pairs are evaluated, so only throw an exception if B is also there.
return move(operation); return operation;
which = !which; which = !which;

4
source/core/StarInterpolation.hpp
View File

@ -369,7 +369,7 @@ Pos inverseLinearInterpolateLower(Iterator begin, Iterator end, Pos t, Comp&& co
if (begin == end || std::next(begin) == end) if (begin == end || std::next(begin) == end)
return Pos(); return Pos();
Iterator i = std::lower_bound(std::next(begin), std::prev(end), t, forward<Comp>(comp)); Iterator i = std::lower_bound(std::next(begin), std::prev(end), t, std::forward<Comp>(comp));
--i; --i;
Pos min = posGetter(*i); Pos min = posGetter(*i);
@ -396,7 +396,7 @@ Pos inverseLinearInterpolateUpper(Iterator begin, Iterator end, Pos t, Comp&& co
if (begin == end || std::next(begin) == end) if (begin == end || std::next(begin) == end)
return Pos(); return Pos();
Iterator i = std::upper_bound(std::next(begin), std::prev(end), t, forward<Comp>(comp)); Iterator i = std::upper_bound(std::next(begin), std::prev(end), t, std::forward<Comp>(comp));
--i; --i;
Pos min = posGetter(*i); Pos min = posGetter(*i);

4
source/core/StarIterator.hpp
View File

@ -137,7 +137,7 @@ public:
} }
void insert(value_type v) { void insert(value_type v) {
curr = ++cont.insert(curr, move(v)); curr = ++cont.insert(curr, std::move(v));
direction = -1; direction = -1;
} }
@ -178,7 +178,7 @@ public:
} }
void setValue(value_type v) const { void setValue(value_type v) const {
value() = move(v); value() = std::move(v);
} }
value_ref next() { value_ref next() {

16
source/core/StarJson.cpp
View File

@ -745,7 +745,7 @@ Maybe<JsonObject> Json::optQueryObject(String const& path) const {
Json Json::set(String key, Json value) const { Json Json::set(String key, Json value) const {
auto map = toObject(); auto map = toObject();
map[move(key)] = move(value); map[std::move(key)] = std::move(value);
return map; return map;
} }
@ -760,31 +760,31 @@ Json Json::erasePath(String path) const {
Json Json::setAll(JsonObject values) const { Json Json::setAll(JsonObject values) const {
auto map = toObject(); auto map = toObject();
for (auto& p : values) for (auto& p : values)
map[move(p.first)] = move(p.second); map[std::move(p.first)] = std::move(p.second);
return map; return map;
} }
Json Json::eraseKey(String key) const { Json Json::eraseKey(String key) const {
auto map = toObject(); auto map = toObject();
map.erase(move(key)); map.erase(std::move(key));
return map; return map;
} }
Json Json::set(size_t index, Json value) const { Json Json::set(size_t index, Json value) const {
auto array = toArray(); auto array = toArray();
array[index] = move(value); array[index] = std::move(value);
return array; return array;
} }
Json Json::insert(size_t index, Json value) const { Json Json::insert(size_t index, Json value) const {
auto array = toArray(); auto array = toArray();
array.insertAt(index, move(value)); array.insertAt(index, std::move(value));
return array; return array;
} }
Json Json::append(Json value) const { Json Json::append(Json value) const {
auto array = toArray(); auto array = toArray();
array.append(move(value)); array.append(std::move(value));
return array; return array;
} }
@ -927,7 +927,7 @@ DataStream& operator>>(DataStream& os, Json& v) {
for (size_t i = 0; i < s; ++i) for (size_t i = 0; i < s; ++i)
l.append(os.read<Json>()); l.append(os.read<Json>());
v = move(l); v = std::move(l);
} else if (type == Json::Type::Object) { } else if (type == Json::Type::Object) {
JsonObject m; JsonObject m;
size_t s = os.readVlqU(); size_t s = os.readVlqU();
@ -936,7 +936,7 @@ DataStream& operator>>(DataStream& os, Json& v) {
m[k] = os.read<Json>(); m[k] = os.read<Json>();
} }
v = move(m); v = std::move(m);
} }
return os; return os;

10
source/core/StarJsonBuilder.cpp
View File

@ -15,12 +15,12 @@ void JsonBuilderStream::endObject() {
JsonObject object; JsonObject object;
while (true) { while (true) {
if (isSentry()) { if (isSentry()) {
set(Json(move(object))); set(Json(std::move(object)));
return; return;
} else { } else {
Json v = pop(); Json v = pop();
String k = pop().toString(); String k = pop().toString();
if (!object.insert(k, move(v)).second) if (!object.insert(k, std::move(v)).second)
throw JsonParsingException(strf("Json object contains a duplicate entry for key '{}'", k)); throw JsonParsingException(strf("Json object contains a duplicate entry for key '{}'", k));
} }
} }
@ -35,7 +35,7 @@ void JsonBuilderStream::endArray() {
while (true) { while (true) {
if (isSentry()) { if (isSentry()) {
array.reverse(); array.reverse();
set(Json(move(array))); set(Json(std::move(array)));
return; return;
} else { } else {
array.append(pop()); array.append(pop());
@ -81,7 +81,7 @@ Json JsonBuilderStream::takeTop() {
} }
void JsonBuilderStream::push(Json v) { void JsonBuilderStream::push(Json v) {
m_stack.append(move(v)); m_stack.append(std::move(v));
} }
Json JsonBuilderStream::pop() { Json JsonBuilderStream::pop() {
@ -89,7 +89,7 @@ Json JsonBuilderStream::pop() {
} }
void JsonBuilderStream::set(Json v) { void JsonBuilderStream::set(Json v) {
m_stack.last() = move(v); m_stack.last() = std::move(v);
} }
void JsonBuilderStream::pushSentry() { void JsonBuilderStream::pushSentry() {

2
source/core/StarJsonExtra.cpp
View File

@ -372,7 +372,7 @@ List<Color> jsonToColorList(Json const& v) {
List<Directives> jsonToDirectivesList(Json const& v) { List<Directives> jsonToDirectivesList(Json const& v) {
List<Directives> result; List<Directives> result;
for (auto const& entry : v.iterateArray()) for (auto const& entry : v.iterateArray())
result.append(move(entry.toString())); result.append(entry.toString());
return result; return result;
} }

6
source/core/StarJsonExtra.hpp
View File

@ -262,7 +262,7 @@ MapType jsonToMapK(Json const& v, KeyConverter&& keyConvert) {
template <typename MapType, typename ValueConverter> template <typename MapType, typename ValueConverter>
MapType jsonToMapV(Json const& v, ValueConverter&& valueConvert) { MapType jsonToMapV(Json const& v, ValueConverter&& valueConvert) {
return jsonToMapKV<MapType>(v, construct<typename MapType::key_type>(), forward<ValueConverter>(valueConvert)); return jsonToMapKV<MapType>(v, construct<typename MapType::key_type>(), std::forward<ValueConverter>(valueConvert));
} }
template <typename MapType> template <typename MapType>
@ -281,12 +281,12 @@ Json jsonFromMapKV(MapType const& map, KeyConverter&& keyConvert, ValueConverter
template <typename MapType, typename KeyConverter> template <typename MapType, typename KeyConverter>
Json jsonFromMapK(MapType const& map, KeyConverter&& keyConvert) { Json jsonFromMapK(MapType const& map, KeyConverter&& keyConvert) {
return jsonFromMapKV<MapType>(map, forward<KeyConverter>(keyConvert), construct<Json>()); return jsonFromMapKV<MapType>(map, std::forward<KeyConverter>(keyConvert), construct<Json>());
} }
template <typename MapType, typename ValueConverter> template <typename MapType, typename ValueConverter>
Json jsonFromMapV(MapType const& map, ValueConverter&& valueConvert) { Json jsonFromMapV(MapType const& map, ValueConverter&& valueConvert) {
return jsonFromMapKV<MapType>(map, construct<String>(), forward<ValueConverter>(valueConvert)); return jsonFromMapKV<MapType>(map, construct<String>(), std::forward<ValueConverter>(valueConvert));
} }
template <typename MapType> template <typename MapType>

2
source/core/StarJsonParser.hpp
View File

@ -462,7 +462,7 @@ private:
} }
void error(std::string msg) { void error(std::string msg) {
m_error = move(msg); m_error = std::move(msg);
throw ParsingException(); throw ParsingException();
} }

2
source/core/StarJsonRpc.cpp
View File

@ -13,7 +13,7 @@ JsonRpc::JsonRpc() {
void JsonRpc::registerHandler(String const& handler, JsonRpcRemoteFunction func) { void JsonRpc::registerHandler(String const& handler, JsonRpcRemoteFunction func) {
if (m_handlers.contains(handler)) if (m_handlers.contains(handler))
throw JsonRpcException(strf("Handler by that name already exists '{}'", handler)); throw JsonRpcException(strf("Handler by that name already exists '{}'", handler));
m_handlers.add(handler, move(func)); m_handlers.add(handler, std::move(func));
} }
void JsonRpc::registerHandlers(JsonRpcHandlers const& handlers) { void JsonRpc::registerHandlers(JsonRpcHandlers const& handlers) {

2
source/core/StarLexicalCast.hpp
View File

@ -30,7 +30,7 @@ Maybe<Type> maybeLexicalCast(StringView s, std::ios_base::fmtflags flags = std::
if (stream >> ch) if (stream >> ch)
return {}; return {};
return move(result); return result;
} }
template <typename Type> template <typename Type>

54
source/core/StarList.hpp
View File

@ -451,7 +451,7 @@ void ListMixin<BaseList>::appendAll(Container&& list) {
template <typename BaseList> template <typename BaseList>
template <class... Args> template <class... Args>
auto ListMixin<BaseList>::emplaceAppend(Args&&... args) -> reference { auto ListMixin<BaseList>::emplaceAppend(Args&&... args) -> reference {
Base::emplace_back(forward<Args>(args)...); Base::emplace_back(std::forward<Args>(args)...);
return *prev(Base::end()); return *prev(Base::end());
} }
@ -558,13 +558,13 @@ size_t ListMixin<BaseList>::remove(const_reference e) {
template <typename BaseList> template <typename BaseList>
template <typename Filter> template <typename Filter>
void ListMixin<BaseList>::filter(Filter&& filter) { void ListMixin<BaseList>::filter(Filter&& filter) {
Star::filter(*this, forward<Filter>(filter)); Star::filter(*this, std::forward<Filter>(filter));
} }
template <typename BaseList> template <typename BaseList>
template <typename Comparator> template <typename Comparator>
void ListMixin<BaseList>::insertSorted(value_type e, Comparator&& comparator) { void ListMixin<BaseList>::insertSorted(value_type e, Comparator&& comparator) {
auto i = std::upper_bound(Base::begin(), Base::end(), e, forward<Comparator>(comparator)); auto i = std::upper_bound(Base::begin(), Base::end(), e, std::forward<Comparator>(comparator));
Base::insert(i, std::move(e)); Base::insert(i, std::move(e));
} }
@ -577,7 +577,7 @@ void ListMixin<BaseList>::insertSorted(value_type e) {
template <typename BaseList> template <typename BaseList>
template <typename Comparator> template <typename Comparator>
bool ListMixin<BaseList>::containsSorted(value_type const& e, Comparator&& comparator) { bool ListMixin<BaseList>::containsSorted(value_type const& e, Comparator&& comparator) {
auto range = std::equal_range(Base::begin(), Base::end(), e, forward<Comparator>(comparator)); auto range = std::equal_range(Base::begin(), Base::end(), e, std::forward<Comparator>(comparator));
return range.first != range.second; return range.first != range.second;
} }
@ -611,7 +611,7 @@ void ListMixin<BaseList>::transform(Function&& function) {
template <typename BaseList> template <typename BaseList>
template <typename Function> template <typename Function>
bool ListMixin<BaseList>::any(Function&& function) const { bool ListMixin<BaseList>::any(Function&& function) const {
return Star::any(*this, forward<Function>(function)); return Star::any(*this, std::forward<Function>(function));
} }
template <typename BaseList> template <typename BaseList>
@ -622,7 +622,7 @@ bool ListMixin<BaseList>::any() const {
template <typename BaseList> template <typename BaseList>
template <typename Function> template <typename Function>
bool ListMixin<BaseList>::all(Function&& function) const { bool ListMixin<BaseList>::all(Function&& function) const {
return Star::all(*this, forward<Function>(function)); return Star::all(*this, std::forward<Function>(function));
} }
template <typename BaseList> template <typename BaseList>
@ -633,7 +633,7 @@ bool ListMixin<BaseList>::all() const {
template <typename BaseList> template <typename BaseList>
template <typename Comparator> template <typename Comparator>
void RandomAccessListMixin<BaseList>::sort(Comparator&& comparator) { void RandomAccessListMixin<BaseList>::sort(Comparator&& comparator) {
Star::sort(*this, forward<Comparator>(comparator)); Star::sort(*this, std::forward<Comparator>(comparator));
} }
template <typename BaseList> template <typename BaseList>
@ -790,7 +790,7 @@ void FrontModifyingListMixin<BaseList>::prependAll(Container&& list) {
template <typename BaseList> template <typename BaseList>
template <class... Args> template <class... Args>
auto FrontModifyingListMixin<BaseList>::emplacePrepend(Args&&... args) -> reference { auto FrontModifyingListMixin<BaseList>::emplacePrepend(Args&&... args) -> reference {
Base::emplace_front(forward<Args>(args)...); Base::emplace_front(std::forward<Args>(args)...);
return *Base::begin(); return *Base::begin();
} }
@ -839,7 +839,7 @@ template <typename Element, typename Allocator>
template <typename Filter> template <typename Filter>
auto List<Element, Allocator>::filtered(Filter&& filter) const -> List { auto List<Element, Allocator>::filtered(Filter&& filter) const -> List {
List list(*this); List list(*this);
list.filter(forward<Filter>(filter)); list.filter(std::forward<Filter>(filter));
return list; return list;
} }
@ -847,7 +847,7 @@ template <typename Element, typename Allocator>
template <typename Comparator> template <typename Comparator>
auto List<Element, Allocator>::sorted(Comparator&& comparator) const -> List { auto List<Element, Allocator>::sorted(Comparator&& comparator) const -> List {
List list(*this); List list(*this);
list.sort(forward<Comparator>(comparator)); list.sort(std::forward<Comparator>(comparator));
return list; return list;
} }
@ -863,7 +863,7 @@ template <typename Function>
auto List<Element, Allocator>::transformed(Function&& function) { auto List<Element, Allocator>::transformed(Function&& function) {
List<typename std::decay<decltype(std::declval<Function>()(std::declval<reference>()))>::type> res; List<typename std::decay<decltype(std::declval<Function>()(std::declval<reference>()))>::type> res;
res.reserve(Base::size()); res.reserve(Base::size());
transformInto(res, *this, forward<Function>(function)); transformInto(res, *this, std::forward<Function>(function));
return res; return res;
} }
@ -872,7 +872,7 @@ template <typename Function>
auto List<Element, Allocator>::transformed(Function&& function) const { auto List<Element, Allocator>::transformed(Function&& function) const {
List<typename std::decay<decltype(std::declval<Function>()(std::declval<const_reference>()))>::type> res; List<typename std::decay<decltype(std::declval<Function>()(std::declval<const_reference>()))>::type> res;
res.reserve(Base::size()); res.reserve(Base::size());
transformInto(res, *this, forward<Function>(function)); transformInto(res, *this, std::forward<Function>(function));
return res; return res;
} }
@ -899,7 +899,7 @@ template <typename Element, size_t MaxSize>
template <typename Comparator> template <typename Comparator>
auto StaticList<Element, MaxSize>::sorted(Comparator&& comparator) const -> StaticList { auto StaticList<Element, MaxSize>::sorted(Comparator&& comparator) const -> StaticList {
StaticList list(*this); StaticList list(*this);
list.sort(forward<Comparator>(comparator)); list.sort(std::forward<Comparator>(comparator));
return list; return list;
} }
@ -914,7 +914,7 @@ template <typename Element, size_t MaxSize>
template <typename Function> template <typename Function>
auto StaticList<Element, MaxSize>::transformed(Function&& function) { auto StaticList<Element, MaxSize>::transformed(Function&& function) {
StaticList<typename std::decay<decltype(std::declval<Function>()(std::declval<reference>()))>::type, MaxSize> res; StaticList<typename std::decay<decltype(std::declval<Function>()(std::declval<reference>()))>::type, MaxSize> res;
transformInto(res, *this, forward<Function>(function)); transformInto(res, *this, std::forward<Function>(function));
return res; return res;
} }
@ -922,7 +922,7 @@ template <typename Element, size_t MaxSize>
template <typename Function> template <typename Function>
auto StaticList<Element, MaxSize>::transformed(Function&& function) const { auto StaticList<Element, MaxSize>::transformed(Function&& function) const {
StaticList<typename std::decay<decltype(std::declval<Function>()(std::declval<const_reference>()))>::type, MaxSize> res; StaticList<typename std::decay<decltype(std::declval<Function>()(std::declval<const_reference>()))>::type, MaxSize> res;
transformInto(res, *this, forward<Function>(function)); transformInto(res, *this, std::forward<Function>(function));
return res; return res;
} }
@ -941,7 +941,7 @@ template <typename Element, size_t MaxStackSize>
template <typename Filter> template <typename Filter>
auto SmallList<Element, MaxStackSize>::filtered(Filter&& filter) const -> SmallList { auto SmallList<Element, MaxStackSize>::filtered(Filter&& filter) const -> SmallList {
SmallList list(*this); SmallList list(*this);
list.filter(forward<Filter>(filter)); list.filter(std::forward<Filter>(filter));
return list; return list;
} }
@ -949,7 +949,7 @@ template <typename Element, size_t MaxStackSize>
template <typename Comparator> template <typename Comparator>
auto SmallList<Element, MaxStackSize>::sorted(Comparator&& comparator) const -> SmallList { auto SmallList<Element, MaxStackSize>::sorted(Comparator&& comparator) const -> SmallList {
SmallList list(*this); SmallList list(*this);
list.sort(forward<Comparator>(comparator)); list.sort(std::forward<Comparator>(comparator));
return list; return list;
} }
@ -964,7 +964,7 @@ template <typename Element, size_t MaxStackSize>
template <typename Function> template <typename Function>
auto SmallList<Element, MaxStackSize>::transformed(Function&& function) { auto SmallList<Element, MaxStackSize>::transformed(Function&& function) {
SmallList<typename std::decay<decltype(std::declval<Function>()(std::declval<reference>()))>::type, MaxStackSize> res; SmallList<typename std::decay<decltype(std::declval<Function>()(std::declval<reference>()))>::type, MaxStackSize> res;
transformInto(res, *this, forward<Function>(function)); transformInto(res, *this, std::forward<Function>(function));
return res; return res;
} }
@ -972,7 +972,7 @@ template <typename Element, size_t MaxStackSize>
template <typename Function> template <typename Function>
auto SmallList<Element, MaxStackSize>::transformed(Function&& function) const { auto SmallList<Element, MaxStackSize>::transformed(Function&& function) const {
SmallList<typename std::decay<decltype(std::declval<Function>()(std::declval<const_reference>()))>::type, MaxStackSize> res; SmallList<typename std::decay<decltype(std::declval<Function>()(std::declval<const_reference>()))>::type, MaxStackSize> res;
transformInto(res, *this, forward<Function>(function)); transformInto(res, *this, std::forward<Function>(function));
return res; return res;
} }
@ -991,7 +991,7 @@ template <typename Element, typename Allocator>
template <typename Filter> template <typename Filter>
Deque<Element, Allocator> Deque<Element, Allocator>::filtered(Filter&& filter) const { Deque<Element, Allocator> Deque<Element, Allocator>::filtered(Filter&& filter) const {
Deque l(*this); Deque l(*this);
l.filter(forward<Filter>(filter)); l.filter(std::forward<Filter>(filter));
return l; return l;
} }
@ -999,7 +999,7 @@ template <typename Element, typename Allocator>
template <typename Comparator> template <typename Comparator>
Deque<Element, Allocator> Deque<Element, Allocator>::sorted(Comparator&& comparator) const { Deque<Element, Allocator> Deque<Element, Allocator>::sorted(Comparator&& comparator) const {
Deque l(*this); Deque l(*this);
l.sort(forward<Comparator>(comparator)); l.sort(std::forward<Comparator>(comparator));
return l; return l;
} }
@ -1013,13 +1013,13 @@ Deque<Element, Allocator> Deque<Element, Allocator>::sorted() const {
template <typename Element, typename Allocator> template <typename Element, typename Allocator>
template <typename Function> template <typename Function>
auto Deque<Element, Allocator>::transformed(Function&& function) { auto Deque<Element, Allocator>::transformed(Function&& function) {
return Star::transform<Deque<decltype(std::declval<Function>()(std::declval<reference>()))>>(*this, forward<Function>(function)); return Star::transform<Deque<decltype(std::declval<Function>()(std::declval<reference>()))>>(*this, std::forward<Function>(function));
} }
template <typename Element, typename Allocator> template <typename Element, typename Allocator>
template <typename Function> template <typename Function>
auto Deque<Element, Allocator>::transformed(Function&& function) const { auto Deque<Element, Allocator>::transformed(Function&& function) const {
return Star::transform<Deque<decltype(std::declval<Function>()(std::declval<const_reference>()))>>(*this, forward<Function>(function)); return Star::transform<Deque<decltype(std::declval<Function>()(std::declval<const_reference>()))>>(*this, std::forward<Function>(function));
} }
template <typename Element, typename Allocator> template <typename Element, typename Allocator>
@ -1064,7 +1064,7 @@ template <typename Element, typename Allocator>
template <typename Filter> template <typename Filter>
LinkedList<Element, Allocator> LinkedList<Element, Allocator>::filtered(Filter&& filter) const { LinkedList<Element, Allocator> LinkedList<Element, Allocator>::filtered(Filter&& filter) const {
LinkedList list(*this); LinkedList list(*this);
list.filter(forward<Filter>(filter)); list.filter(std::forward<Filter>(filter));
return list; return list;
} }
@ -1072,7 +1072,7 @@ template <typename Element, typename Allocator>
template <typename Comparator> template <typename Comparator>
LinkedList<Element, Allocator> LinkedList<Element, Allocator>::sorted(Comparator&& comparator) const { LinkedList<Element, Allocator> LinkedList<Element, Allocator>::sorted(Comparator&& comparator) const {
LinkedList l(*this); LinkedList l(*this);
l.sort(forward<Comparator>(comparator)); l.sort(std::forward<Comparator>(comparator));
return l; return l;
} }
@ -1086,13 +1086,13 @@ LinkedList<Element, Allocator> LinkedList<Element, Allocator>::sorted() const {
template <typename Element, typename Allocator> template <typename Element, typename Allocator>
template <typename Function> template <typename Function>
auto LinkedList<Element, Allocator>::transformed(Function&& function) { auto LinkedList<Element, Allocator>::transformed(Function&& function) {
return Star::transform<LinkedList<decltype(std::declval<Function>()(std::declval<reference>()))>>(*this, forward<Function>(function)); return Star::transform<LinkedList<decltype(std::declval<Function>()(std::declval<reference>()))>>(*this, std::forward<Function>(function));
} }
template <typename Element, typename Allocator> template <typename Element, typename Allocator>
template <typename Function> template <typename Function>
auto LinkedList<Element, Allocator>::transformed(Function&& function) const { auto LinkedList<Element, Allocator>::transformed(Function&& function) const {
return Star::transform<LinkedList<decltype(std::declval<Function>()(std::declval<const_reference>()))>>(*this, forward<Function>(function)); return Star::transform<LinkedList<decltype(std::declval<Function>()(std::declval<const_reference>()))>>(*this, std::forward<Function>(function));
} }
template <typename BaseList> template <typename BaseList>

6
source/core/StarListener.cpp
View File

@ -5,7 +5,7 @@ namespace Star {
Listener::~Listener() {} Listener::~Listener() {}
CallbackListener::CallbackListener(function<void()> callback) CallbackListener::CallbackListener(function<void()> callback)
: callback(move(callback)) {} : callback(std::move(callback)) {}
void CallbackListener::trigger() { void CallbackListener::trigger() {
if (callback) if (callback)
@ -16,12 +16,12 @@ TrackerListener::TrackerListener() : triggered(false) {}
void ListenerGroup::addListener(ListenerWeakPtr listener) { void ListenerGroup::addListener(ListenerWeakPtr listener) {
MutexLocker locker(m_mutex); MutexLocker locker(m_mutex);
m_listeners.insert(move(listener)); m_listeners.insert(std::move(listener));
} }
void ListenerGroup::removeListener(ListenerWeakPtr listener) { void ListenerGroup::removeListener(ListenerWeakPtr listener) {
MutexLocker locker(m_mutex); MutexLocker locker(m_mutex);
m_listeners.erase(move(listener)); m_listeners.erase(std::move(listener));
} }
void ListenerGroup::clearExpiredListeners() { void ListenerGroup::clearExpiredListeners() {

10
source/core/StarLockFile_unix.cpp
View File

@ -12,16 +12,16 @@ namespace Star {
int64_t const LockFile::MaximumSleepMillis; int64_t const LockFile::MaximumSleepMillis;
Maybe<LockFile> LockFile::acquireLock(String const& filename, int64_t lockTimeout) { Maybe<LockFile> LockFile::acquireLock(String const& filename, int64_t lockTimeout) {
LockFile lock(move(filename)); LockFile lock(std::move(filename));
if (lock.lock(lockTimeout)) if (lock.lock(lockTimeout))
return lock; return lock;
return {}; return {};
} }
LockFile::LockFile(String const& filename) : m_filename(move(filename)) {} LockFile::LockFile(String const& filename) : m_filename(std::move(filename)) {}
LockFile::LockFile(LockFile&& lockFile) { LockFile::LockFile(LockFile&& lockFile) {
operator=(move(lockFile)); operator=(std::move(lockFile));
} }
LockFile::~LockFile() { LockFile::~LockFile() {
@ -29,8 +29,8 @@ LockFile::~LockFile() {
} }
LockFile& LockFile::operator=(LockFile&& lockFile) { LockFile& LockFile::operator=(LockFile&& lockFile) {
m_filename = move(lockFile.m_filename); m_filename = std::move(lockFile.m_filename);
m_handle = move(lockFile.m_handle); m_handle = std::move(lockFile.m_handle);
return *this; return *this;
} }

12
source/core/StarLockFile_windows.cpp
View File

@ -11,16 +11,16 @@ namespace Star {
int64_t const LockFile::MaximumSleepMillis; int64_t const LockFile::MaximumSleepMillis;
Maybe<LockFile> LockFile::acquireLock(String const& filename, int64_t lockTimeout) { Maybe<LockFile> LockFile::acquireLock(String const& filename, int64_t lockTimeout) {
LockFile lock(move(filename)); LockFile lock(std::move(filename));
if (lock.lock(lockTimeout)) if (lock.lock(lockTimeout))
return move(lock); return std::move(lock);
return {}; return {};
} }
LockFile::LockFile(String const& filename) : m_filename(move(filename)) {} LockFile::LockFile(String const& filename) : m_filename(std::move(filename)) {}
LockFile::LockFile(LockFile&& lockFile) { LockFile::LockFile(LockFile&& lockFile) {
operator=(move(lockFile)); operator=(std::move(lockFile));
} }
LockFile::~LockFile() { LockFile::~LockFile() {
@ -28,8 +28,8 @@ LockFile::~LockFile() {
} }
LockFile& LockFile::operator=(LockFile&& lockFile) { LockFile& LockFile::operator=(LockFile&& lockFile) {
m_filename = move(lockFile.m_filename); m_filename = std::move(lockFile.m_filename);
m_handle = move(lockFile.m_handle); m_handle = std::move(lockFile.m_handle);
return *this; return *this;
} }

6
source/core/StarLogging.cpp
View File

@ -212,9 +212,9 @@ void SpatialLogger::clear() {
decltype(s_logText) logText; decltype(s_logText) logText;
{ {
MutexLocker locker(s_mutex); MutexLocker locker(s_mutex);
lines = move(s_lines); lines = std::move(s_lines);
points = move(s_points); points = std::move(s_points);
logText = move(s_logText); logText = std::move(s_logText);
} // Move while locked to deallocate contents while unlocked. } // Move while locked to deallocate contents while unlocked.
} }

4
source/core/StarLruCache.hpp
View File

@ -105,9 +105,9 @@ template <typename OrderedMapType>
void LruCacheBase<OrderedMapType>::set(Key const& key, Value value) { void LruCacheBase<OrderedMapType>::set(Key const& key, Value value) {
auto i = m_map.find(key); auto i = m_map.find(key);
if (i == m_map.end()) { if (i == m_map.end()) {
m_map.add(key, move(value)); m_map.add(key, std::move(value));
} else { } else {
i->second = move(value); i->second = std::move(value);
m_map.toBack(i); m_map.toBack(i);
} }
} }

28
source/core/StarLua.cpp
View File

@ -76,7 +76,7 @@ StringMap<LuaDetail::LuaWrappedFunction> const& LuaCallbacks::callbacks() const
} }
bool LuaContext::containsPath(String path) const { bool LuaContext::containsPath(String path) const {
return engine().contextGetPath(handleIndex(), move(path)) != LuaNil; return engine().contextGetPath(handleIndex(), std::move(path)) != LuaNil;
} }
void LuaContext::load(char const* contents, size_t size, char const* name) { void LuaContext::load(char const* contents, size_t size, char const* name) {
@ -92,7 +92,7 @@ void LuaContext::load(ByteArray const& contents, String const& name) {
} }
void LuaContext::setRequireFunction(RequireFunction requireFunction) { void LuaContext::setRequireFunction(RequireFunction requireFunction) {
engine().setContextRequire(handleIndex(), move(requireFunction)); engine().setContextRequire(handleIndex(), std::move(requireFunction));
} }
void LuaContext::setCallbacks(String const& tableName, LuaCallbacks const& callbacks) const { void LuaContext::setCallbacks(String const& tableName, LuaCallbacks const& callbacks) const {
@ -162,11 +162,11 @@ Maybe<Json> LuaConverter<Json>::to(LuaEngine&, LuaValue const& v) {
} }
LuaValue LuaConverter<JsonObject>::from(LuaEngine& engine, JsonObject v) { LuaValue LuaConverter<JsonObject>::from(LuaEngine& engine, JsonObject v) {
return engine.luaFrom<Json>(Json(move(v))); return engine.luaFrom<Json>(Json(std::move(v)));
} }
Maybe<JsonObject> LuaConverter<JsonObject>::to(LuaEngine& engine, LuaValue v) { Maybe<JsonObject> LuaConverter<JsonObject>::to(LuaEngine& engine, LuaValue v) {
auto j = engine.luaTo<Json>(move(v)); auto j = engine.luaTo<Json>(std::move(v));
if (j.type() == Json::Type::Object) { if (j.type() == Json::Type::Object) {
return j.toObject(); return j.toObject();
} else if (j.type() == Json::Type::Array) { } else if (j.type() == Json::Type::Array) {
@ -179,11 +179,11 @@ Maybe<JsonObject> LuaConverter<JsonObject>::to(LuaEngine& engine, LuaValue v) {
} }
LuaValue LuaConverter<JsonArray>::from(LuaEngine& engine, JsonArray v) { LuaValue LuaConverter<JsonArray>::from(LuaEngine& engine, JsonArray v) {
return engine.luaFrom<Json>(Json(move(v))); return engine.luaFrom<Json>(Json(std::move(v)));
} }
Maybe<JsonArray> LuaConverter<JsonArray>::to(LuaEngine& engine, LuaValue v) { Maybe<JsonArray> LuaConverter<JsonArray>::to(LuaEngine& engine, LuaValue v) {
auto j = engine.luaTo<Json>(move(v)); auto j = engine.luaTo<Json>(std::move(v));
if (j.type() == Json::Type::Array) { if (j.type() == Json::Type::Array) {
return j.toArray(); return j.toArray();
} else if (j.type() == Json::Type::Object) { } else if (j.type() == Json::Type::Object) {
@ -839,7 +839,7 @@ void LuaEngine::tableIterate(int handleIndex, function<bool(LuaValue key, LuaVal
LuaValue value = popLuaValue(m_state); LuaValue value = popLuaValue(m_state);
bool cont = false; bool cont = false;
try { try {
cont = iterator(move(key), move(value)); cont = iterator(std::move(key), std::move(value));
} catch (...) { } catch (...) {
lua_pop(m_state, 2); lua_pop(m_state, 2);
throw; throw;
@ -881,7 +881,7 @@ void LuaEngine::setContextRequire(int handleIndex, LuaContext::RequireFunction r
pushHandle(m_state, handleIndex); pushHandle(m_state, handleIndex);
auto funcUserdata = (LuaContext::RequireFunction*)lua_newuserdata(m_state, sizeof(LuaContext::RequireFunction)); auto funcUserdata = (LuaContext::RequireFunction*)lua_newuserdata(m_state, sizeof(LuaContext::RequireFunction));
new (funcUserdata) LuaContext::RequireFunction(move(requireFunction)); new (funcUserdata) LuaContext::RequireFunction(std::move(requireFunction));
lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_requireFunctionMetatableRegistryId); lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_requireFunctionMetatableRegistryId);
lua_setmetatable(m_state, -2); lua_setmetatable(m_state, -2);
@ -1076,7 +1076,7 @@ LuaFunction LuaEngine::createWrappedFunction(LuaDetail::LuaWrappedFunction funct
lua_checkstack(m_state, 2); lua_checkstack(m_state, 2);
auto funcUserdata = (LuaDetail::LuaWrappedFunction*)lua_newuserdata(m_state, sizeof(LuaDetail::LuaWrappedFunction)); auto funcUserdata = (LuaDetail::LuaWrappedFunction*)lua_newuserdata(m_state, sizeof(LuaDetail::LuaWrappedFunction));
new (funcUserdata) LuaDetail::LuaWrappedFunction(move(function)); new (funcUserdata) LuaDetail::LuaWrappedFunction(std::move(function));
lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_wrappedFunctionMetatableRegistryId); lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_wrappedFunctionMetatableRegistryId);
lua_setmetatable(m_state, -2); lua_setmetatable(m_state, -2);
@ -1400,7 +1400,7 @@ Maybe<Json> LuaDetail::tableToJsonContainer(LuaTable const& table) {
if (auto i = asInteger(key)) { if (auto i = asInteger(key)) {
intEntries[*i] = jsonValue.take(); intEntries[*i] = jsonValue.take();
} else { } else {
auto stringKey = table.engine().luaMaybeTo<String>(move(key)); auto stringKey = table.engine().luaMaybeTo<String>(std::move(key));
if (!stringKey) { if (!stringKey) {
failedConversion = true; failedConversion = true;
return false; return false;
@ -1420,12 +1420,12 @@ Maybe<Json> LuaDetail::tableToJsonContainer(LuaTable const& table) {
if (interpretAsList) { if (interpretAsList) {
JsonArray list; JsonArray list;
for (auto& p : intEntries) for (auto& p : intEntries)
list.set(p.first - 1, move(p.second)); list.set(p.first - 1, std::move(p.second));
return Json(move(list)); return Json(std::move(list));
} else { } else {
for (auto& p : intEntries) for (auto& p : intEntries)
stringEntries[toString(p.first)] = move(p.second); stringEntries[toString(p.first)] = std::move(p.second);
return Json(move(stringEntries)); return Json(std::move(stringEntries));
} }
} }

162
source/core/StarLua.hpp
View File

@ -856,7 +856,7 @@ struct LuaConverter<std::string> {
} }
static Maybe<std::string> to(LuaEngine& engine, LuaValue v) { static Maybe<std::string> to(LuaEngine& engine, LuaValue v) {
return engine.luaTo<String>(move(v)).takeUtf8(); return engine.luaTo<String>(std::move(v)).takeUtf8();
} }
}; };
@ -887,12 +887,12 @@ struct LuaConverter<Directives> {
template <> template <>
struct LuaConverter<LuaString> { struct LuaConverter<LuaString> {
static LuaValue from(LuaEngine&, LuaString v) { static LuaValue from(LuaEngine&, LuaString v) {
return LuaValue(move(v)); return LuaValue(std::move(v));
} }
static Maybe<LuaString> to(LuaEngine& engine, LuaValue v) { static Maybe<LuaString> to(LuaEngine& engine, LuaValue v) {
if (v.is<LuaString>()) if (v.is<LuaString>())
return LuaString(move(v.get<LuaString>())); return LuaString(std::move(v.get<LuaString>()));
if (v.is<LuaInt>()) if (v.is<LuaInt>())
return engine.createString(toString(v.get<LuaInt>())); return engine.createString(toString(v.get<LuaInt>()));
if (v.is<LuaFloat>()) if (v.is<LuaFloat>())
@ -909,7 +909,7 @@ struct LuaValueConverter {
static Maybe<T> to(LuaEngine&, LuaValue v) { static Maybe<T> to(LuaEngine&, LuaValue v) {
if (auto p = v.ptr<T>()) { if (auto p = v.ptr<T>()) {
return move(*p); return std::move(*p);
} }
return {}; return {};
} }
@ -967,7 +967,7 @@ struct LuaConverter<Maybe<T>> {
static Maybe<Maybe<T>> to(LuaEngine& engine, LuaValue&& v) { static Maybe<Maybe<T>> to(LuaEngine& engine, LuaValue&& v) {
if (v != LuaNil) { if (v != LuaNil) {
if (auto conv = engine.luaMaybeTo<T>(move(v))) if (auto conv = engine.luaMaybeTo<T>(std::move(v)))
return conv; return conv;
else else
return {}; return {};
@ -991,8 +991,8 @@ struct LuaMapConverter {
T result; T result;
bool failed = false; bool failed = false;
table->iterate([&result, &failed, &engine](LuaValue key, LuaValue value) { table->iterate([&result, &failed, &engine](LuaValue key, LuaValue value) {
auto contKey = engine.luaMaybeTo<typename T::key_type>(move(key)); auto contKey = engine.luaMaybeTo<typename T::key_type>(std::move(key));
auto contValue = engine.luaMaybeTo<typename T::mapped_type>(move(value)); auto contValue = engine.luaMaybeTo<typename T::mapped_type>(std::move(value));
if (!contKey || !contValue) { if (!contKey || !contValue) {
failed = true; failed = true;
return false; return false;
@ -1026,7 +1026,7 @@ struct LuaContainerConverter {
failed = true; failed = true;
return false; return false;
} }
auto contVal = engine.luaMaybeTo<typename T::value_type>(move(value)); auto contVal = engine.luaMaybeTo<typename T::value_type>(std::move(value));
if (!contVal) { if (!contVal) {
failed = true; failed = true;
return false; return false;
@ -1086,7 +1086,7 @@ struct LuaConverter<JsonArray> {
namespace LuaDetail { namespace LuaDetail {
inline LuaHandle::LuaHandle(LuaEnginePtr engine, int handleIndex) inline LuaHandle::LuaHandle(LuaEnginePtr engine, int handleIndex)
: engine(move(engine)), handleIndex(handleIndex) {} : engine(std::move(engine)), handleIndex(handleIndex) {}
inline LuaHandle::~LuaHandle() { inline LuaHandle::~LuaHandle() {
if (engine) if (engine)
@ -1213,7 +1213,7 @@ namespace LuaDetail {
struct ArgGet { struct ArgGet {
static T get(LuaEngine& engine, size_t argc, LuaValue* argv, size_t index) { static T get(LuaEngine& engine, size_t argc, LuaValue* argv, size_t index) {
if (index < argc) if (index < argc)
return engine.luaTo<T>(move(argv[index])); return engine.luaTo<T>(std::move(argv[index]));
return engine.luaTo<T>(LuaNil); return engine.luaTo<T>(LuaNil);
} }
}; };
@ -1226,7 +1226,7 @@ namespace LuaDetail {
LuaVariadic<T> subargs(argc - index); LuaVariadic<T> subargs(argc - index);
for (size_t i = index; i < argc; ++i) for (size_t i = index; i < argc; ++i)
subargs[i - index] = engine.luaTo<T>(move(argv[i])); subargs[i - index] = engine.luaTo<T>(std::move(argv[i]));
return subargs; return subargs;
} }
}; };
@ -1235,14 +1235,14 @@ namespace LuaDetail {
struct FunctionWrapper { struct FunctionWrapper {
template <typename Function, size_t... Indexes> template <typename Function, size_t... Indexes>
static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) { static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) { return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
return toWrappedReturn(engine, (Return const&)func(ArgGet<Args>::get(engine, argc, argv, Indexes)...)); return toWrappedReturn(engine, (Return const&)func(ArgGet<Args>::get(engine, argc, argv, Indexes)...));
}; };
} }
template <typename Function> template <typename Function>
static LuaWrappedFunction wrap(Function func) { static LuaWrappedFunction wrap(Function func) {
return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type()); return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
} }
}; };
@ -1250,7 +1250,7 @@ namespace LuaDetail {
struct FunctionWrapper<void, Args...> { struct FunctionWrapper<void, Args...> {
template <typename Function, size_t... Indexes> template <typename Function, size_t... Indexes>
static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) { static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) { return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
func(ArgGet<Args>::get(engine, argc, argv, Indexes)...); func(ArgGet<Args>::get(engine, argc, argv, Indexes)...);
return LuaFunctionReturn(); return LuaFunctionReturn();
}; };
@ -1258,7 +1258,7 @@ namespace LuaDetail {
template <typename Function> template <typename Function>
static LuaWrappedFunction wrap(Function func) { static LuaWrappedFunction wrap(Function func) {
return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type()); return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
} }
}; };
@ -1266,14 +1266,14 @@ namespace LuaDetail {
struct FunctionWrapper<Return, LuaEngine, Args...> { struct FunctionWrapper<Return, LuaEngine, Args...> {
template <typename Function, size_t... Indexes> template <typename Function, size_t... Indexes>
static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) { static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) { return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
return toWrappedReturn(engine, (Return const&)func(engine, ArgGet<Args>::get(engine, argc, argv, Indexes)...)); return toWrappedReturn(engine, (Return const&)func(engine, ArgGet<Args>::get(engine, argc, argv, Indexes)...));
}; };
} }
template <typename Function> template <typename Function>
static LuaWrappedFunction wrap(Function func) { static LuaWrappedFunction wrap(Function func) {
return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type()); return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
} }
}; };
@ -1281,7 +1281,7 @@ namespace LuaDetail {
struct FunctionWrapper<void, LuaEngine, Args...> { struct FunctionWrapper<void, LuaEngine, Args...> {
template <typename Function, size_t... Indexes> template <typename Function, size_t... Indexes>
static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) { static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) { return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
func(engine, ArgGet<Args>::get(engine, argc, argv, Indexes)...); func(engine, ArgGet<Args>::get(engine, argc, argv, Indexes)...);
return LuaFunctionReturn(); return LuaFunctionReturn();
}; };
@ -1289,31 +1289,31 @@ namespace LuaDetail {
template <typename Function> template <typename Function>
static LuaWrappedFunction wrap(Function func) { static LuaWrappedFunction wrap(Function func) {
return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type()); return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
} }
}; };
template <typename Return, typename... Args, typename Function> template <typename Return, typename... Args, typename Function>
LuaWrappedFunction wrapFunctionWithSignature(Function&& func) { LuaWrappedFunction wrapFunctionWithSignature(Function&& func) {
return FunctionWrapper<Return, typename std::decay<Args>::type...>::wrap(forward<Function>(func)); return FunctionWrapper<Return, typename std::decay<Args>::type...>::wrap(std::forward<Function>(func));
} }
template <typename Return, typename Function, typename... Args> template <typename Return, typename Function, typename... Args>
LuaWrappedFunction wrapFunctionArgs(Function&& func, VariadicTypedef<Args...> const&) { LuaWrappedFunction wrapFunctionArgs(Function&& func, VariadicTypedef<Args...> const&) {
return wrapFunctionWithSignature<Return, Args...>(forward<Function>(func)); return wrapFunctionWithSignature<Return, Args...>(std::forward<Function>(func));
} }
template <typename Function> template <typename Function>
LuaWrappedFunction wrapFunction(Function&& func) { LuaWrappedFunction wrapFunction(Function&& func) {
return wrapFunctionArgs<typename FunctionTraits<Function>::Return>( return wrapFunctionArgs<typename FunctionTraits<Function>::Return>(
forward<Function>(func), typename FunctionTraits<Function>::Args()); std::forward<Function>(func), typename FunctionTraits<Function>::Args());
} }
template <typename Return, typename T, typename... Args> template <typename Return, typename T, typename... Args>
struct MethodWrapper { struct MethodWrapper {
template <typename Function, size_t... Indexes> template <typename Function, size_t... Indexes>
static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) { static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) mutable { return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) mutable {
if (argc == 0) if (argc == 0)
throw LuaException("No object argument passed to wrapped method"); throw LuaException("No object argument passed to wrapped method");
return toWrappedReturn(engine, return toWrappedReturn(engine,
@ -1323,7 +1323,7 @@ namespace LuaDetail {
template <typename Function> template <typename Function>
static LuaWrappedFunction wrap(Function&& func) { static LuaWrappedFunction wrap(Function&& func) {
return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type()); return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
} }
}; };
@ -1331,7 +1331,7 @@ namespace LuaDetail {
struct MethodWrapper<void, T, Args...> { struct MethodWrapper<void, T, Args...> {
template <typename Function, size_t... Indexes> template <typename Function, size_t... Indexes>
static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) { static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) { return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
if (argc == 0) if (argc == 0)
throw LuaException("No object argument passed to wrapped method"); throw LuaException("No object argument passed to wrapped method");
func(argv[0].get<LuaUserData>().get<T>(), ArgGet<Args>::get(engine, argc - 1, argv + 1, Indexes)...); func(argv[0].get<LuaUserData>().get<T>(), ArgGet<Args>::get(engine, argc - 1, argv + 1, Indexes)...);
@ -1341,7 +1341,7 @@ namespace LuaDetail {
template <typename Function> template <typename Function>
static LuaWrappedFunction wrap(Function func) { static LuaWrappedFunction wrap(Function func) {
return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type()); return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
} }
}; };
@ -1349,7 +1349,7 @@ namespace LuaDetail {
struct MethodWrapper<Return, T, LuaEngine, Args...> { struct MethodWrapper<Return, T, LuaEngine, Args...> {
template <typename Function, size_t... Indexes> template <typename Function, size_t... Indexes>
static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) { static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) { return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
if (argc == 0) if (argc == 0)
throw LuaException("No object argument passed to wrapped method"); throw LuaException("No object argument passed to wrapped method");
return toWrappedReturn( return toWrappedReturn(
@ -1360,7 +1360,7 @@ namespace LuaDetail {
template <typename Function> template <typename Function>
static LuaWrappedFunction wrap(Function func) { static LuaWrappedFunction wrap(Function func) {
return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type()); return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
} }
}; };
@ -1368,7 +1368,7 @@ namespace LuaDetail {
struct MethodWrapper<void, T, LuaEngine, Args...> { struct MethodWrapper<void, T, LuaEngine, Args...> {
template <typename Function, size_t... Indexes> template <typename Function, size_t... Indexes>
static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) { static LuaWrappedFunction wrapIndexes(Function func, IndexSequence<Indexes...> const&) {
return [func = move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) { return [func = std::move(func)](LuaEngine& engine, size_t argc, LuaValue* argv) {
if (argc == 0) if (argc == 0)
throw LuaException("No object argument passed to wrapped method"); throw LuaException("No object argument passed to wrapped method");
func(argv[0].get<LuaUserData>().get<T>(), engine, ArgGet<Args>::get(engine, argc - 1, argv + 1, Indexes)...); func(argv[0].get<LuaUserData>().get<T>(), engine, ArgGet<Args>::get(engine, argc - 1, argv + 1, Indexes)...);
@ -1378,24 +1378,24 @@ namespace LuaDetail {
template <typename Function> template <typename Function>
static LuaWrappedFunction wrap(Function func) { static LuaWrappedFunction wrap(Function func) {
return wrapIndexes(forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type()); return wrapIndexes(std::forward<Function>(func), typename GenIndexSequence<0, sizeof...(Args)>::type());
} }
}; };
template <typename Return, typename... Args, typename Function> template <typename Return, typename... Args, typename Function>
LuaWrappedFunction wrapMethodWithSignature(Function&& func) { LuaWrappedFunction wrapMethodWithSignature(Function&& func) {
return MethodWrapper<Return, typename std::decay<Args>::type...>::wrap(forward<Function>(func)); return MethodWrapper<Return, typename std::decay<Args>::type...>::wrap(std::forward<Function>(func));
} }
template <typename Return, typename Function, typename... Args> template <typename Return, typename Function, typename... Args>
LuaWrappedFunction wrapMethodArgs(Function&& func, VariadicTypedef<Args...> const&) { LuaWrappedFunction wrapMethodArgs(Function&& func, VariadicTypedef<Args...> const&) {
return wrapMethodWithSignature<Return, Args...>(forward<Function>(func)); return wrapMethodWithSignature<Return, Args...>(std::forward<Function>(func));
} }
template <typename Function> template <typename Function>
LuaWrappedFunction wrapMethod(Function&& func) { LuaWrappedFunction wrapMethod(Function&& func) {
return wrapMethodArgs<typename FunctionTraits<Function>::Return>( return wrapMethodArgs<typename FunctionTraits<Function>::Return>(
forward<Function>(func), typename FunctionTraits<Function>::Args()); std::forward<Function>(func), typename FunctionTraits<Function>::Args());
} }
template <typename Ret, typename... Args> template <typename Ret, typename... Args>
@ -1405,8 +1405,8 @@ namespace LuaDetail {
struct TableIteratorWrapper<bool, LuaEngine&, Key, Value> { struct TableIteratorWrapper<bool, LuaEngine&, Key, Value> {
template <typename Function> template <typename Function>
static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) { static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) {
return [&engine, func = move(func)](LuaValue key, LuaValue value) -> bool { return [&engine, func = std::move(func)](LuaValue key, LuaValue value) -> bool {
return func(engine, engine.luaTo<Key>(move(key)), engine.luaTo<Value>(move(value))); return func(engine, engine.luaTo<Key>(std::move(key)), engine.luaTo<Value>(std::move(value)));
}; };
} }
}; };
@ -1415,8 +1415,8 @@ namespace LuaDetail {
struct TableIteratorWrapper<void, LuaEngine&, Key, Value> { struct TableIteratorWrapper<void, LuaEngine&, Key, Value> {
template <typename Function> template <typename Function>
static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) { static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) {
return [&engine, func = move(func)](LuaValue key, LuaValue value) -> bool { return [&engine, func = std::move(func)](LuaValue key, LuaValue value) -> bool {
func(engine, engine.luaTo<Key>(move(key)), engine.luaTo<Value>(move(value))); func(engine, engine.luaTo<Key>(std::move(key)), engine.luaTo<Value>(std::move(value)));
return true; return true;
}; };
} }
@ -1426,8 +1426,8 @@ namespace LuaDetail {
struct TableIteratorWrapper<bool, Key, Value> { struct TableIteratorWrapper<bool, Key, Value> {
template <typename Function> template <typename Function>
static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) { static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) {
return [&engine, func = move(func)](LuaValue key, LuaValue value) -> bool { return [&engine, func = std::move(func)](LuaValue key, LuaValue value) -> bool {
return func(engine.luaTo<Key>(move(key)), engine.luaTo<Value>(move(value))); return func(engine.luaTo<Key>(std::move(key)), engine.luaTo<Value>(std::move(value)));
}; };
} }
}; };
@ -1436,8 +1436,8 @@ namespace LuaDetail {
struct TableIteratorWrapper<void, Key, Value> { struct TableIteratorWrapper<void, Key, Value> {
template <typename Function> template <typename Function>
static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) { static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) {
return [&engine, func = move(func)](LuaValue key, LuaValue value) -> bool { return [&engine, func = std::move(func)](LuaValue key, LuaValue value) -> bool {
func(engine.luaTo<Key>(move(key)), engine.luaTo<Value>(move(value))); func(engine.luaTo<Key>(std::move(key)), engine.luaTo<Value>(std::move(value)));
return true; return true;
}; };
} }
@ -1445,19 +1445,19 @@ namespace LuaDetail {
template <typename Return, typename... Args, typename Function> template <typename Return, typename... Args, typename Function>
function<bool(LuaValue, LuaValue)> wrapTableIteratorWithSignature(LuaEngine& engine, Function&& func) { function<bool(LuaValue, LuaValue)> wrapTableIteratorWithSignature(LuaEngine& engine, Function&& func) {
return TableIteratorWrapper<Return, typename std::decay<Args>::type...>::wrap(engine, forward<Function>(func)); return TableIteratorWrapper<Return, typename std::decay<Args>::type...>::wrap(engine, std::forward<Function>(func));
} }
template <typename Return, typename Function, typename... Args> template <typename Return, typename Function, typename... Args>
function<bool(LuaValue, LuaValue)> wrapTableIteratorArgs( function<bool(LuaValue, LuaValue)> wrapTableIteratorArgs(
LuaEngine& engine, Function&& func, VariadicTypedef<Args...> const&) { LuaEngine& engine, Function&& func, VariadicTypedef<Args...> const&) {
return wrapTableIteratorWithSignature<Return, Args...>(engine, forward<Function>(func)); return wrapTableIteratorWithSignature<Return, Args...>(engine, std::forward<Function>(func));
} }
template <typename Function> template <typename Function>
function<bool(LuaValue, LuaValue)> wrapTableIterator(LuaEngine& engine, Function&& func) { function<bool(LuaValue, LuaValue)> wrapTableIterator(LuaEngine& engine, Function&& func) {
return wrapTableIteratorArgs<typename FunctionTraits<Function>::Return>( return wrapTableIteratorArgs<typename FunctionTraits<Function>::Return>(
engine, forward<Function>(func), typename FunctionTraits<Function>::Args()); engine, std::forward<Function>(func), typename FunctionTraits<Function>::Args());
} }
// Like lua_setfield / lua_getfield but raw. // Like lua_setfield / lua_getfield but raw.
@ -1520,7 +1520,7 @@ LuaVariadic<typename std::decay<Container>::type::value_type> luaUnpack(Containe
LuaVariadic<typename std::decay<Container>::type::value_type> ret; LuaVariadic<typename std::decay<Container>::type::value_type> ret;
if (std::is_rvalue_reference<Container&&>::value) { if (std::is_rvalue_reference<Container&&>::value) {
for (auto& e : c) for (auto& e : c)
ret.append(move(e)); ret.append(std::move(e));
} else { } else {
for (auto const& e : c) for (auto const& e : c)
ret.append(e); ret.append(e);
@ -1535,7 +1535,7 @@ LuaTupleReturn<Types...>::LuaTupleReturn(Types const&... args)
template <typename... Types> template <typename... Types>
template <typename... UTypes> template <typename... UTypes>
LuaTupleReturn<Types...>::LuaTupleReturn(UTypes&&... args) LuaTupleReturn<Types...>::LuaTupleReturn(UTypes&&... args)
: Base(move(args)...) {} : Base(std::move(args)...) {}
template <typename... Types> template <typename... Types>
template <typename... UTypes> template <typename... UTypes>
@ -1548,7 +1548,7 @@ LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn const& rhs)
template <typename... Types> template <typename... Types>
LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn&& rhs) LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn&& rhs)
: Base(move(rhs)) {} : Base(std::move(rhs)) {}
template <typename... Types> template <typename... Types>
template <typename... UTypes> template <typename... UTypes>
@ -1558,7 +1558,7 @@ LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn<UTypes...> const& rhs)
template <typename... Types> template <typename... Types>
template <typename... UTypes> template <typename... UTypes>
LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn<UTypes...>&& rhs) LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn<UTypes...>&& rhs)
: Base(move(rhs)) {} : Base(std::move(rhs)) {}
template <typename... Types> template <typename... Types>
LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn const& rhs) { LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn const& rhs) {
@ -1568,7 +1568,7 @@ LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn con
template <typename... Types> template <typename... Types>
LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn&& rhs) { LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn&& rhs) {
Base::operator=(move(rhs)); Base::operator=(std::move(rhs));
return *this; return *this;
} }
@ -1582,7 +1582,7 @@ LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn<UTy
template <typename... Types> template <typename... Types>
template <typename... UTypes> template <typename... UTypes>
LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn<UTypes...>&& rhs) { LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn<UTypes...>&& rhs) {
Base::operator=((tuple<UTypes...> && )move(rhs)); Base::operator=((tuple<UTypes...> && )std::move(rhs));
return *this; return *this;
} }
@ -1593,10 +1593,10 @@ LuaTupleReturn<Types&...> luaTie(Types&... args) {
template <typename... Types> template <typename... Types>
LuaTupleReturn<typename std::decay<Types>::type...> luaTupleReturn(Types&&... args) { LuaTupleReturn<typename std::decay<Types>::type...> luaTupleReturn(Types&&... args) {
return LuaTupleReturn<typename std::decay<Types>::type...>(forward<Types>(args)...); return LuaTupleReturn<typename std::decay<Types>::type...>(std::forward<Types>(args)...);
} }
inline LuaReference::LuaReference(LuaDetail::LuaHandle handle) : m_handle(move(handle)) {} inline LuaReference::LuaReference(LuaDetail::LuaHandle handle) : m_handle(std::move(handle)) {}
inline bool LuaReference::operator==(LuaReference const& rhs) const { inline bool LuaReference::operator==(LuaReference const& rhs) const {
return tie(m_handle.engine, m_handle.handleIndex) == tie(rhs.m_handle.engine, rhs.m_handle.handleIndex); return tie(m_handle.engine, m_handle.handleIndex) == tie(rhs.m_handle.engine, rhs.m_handle.handleIndex);
@ -1688,7 +1688,7 @@ inline bool operator!=(String const& s1, LuaString const& s2) {
template <typename T, typename K> template <typename T, typename K>
T LuaTable::get(K key) const { T LuaTable::get(K key) const {
return engine().luaTo<T>(engine().tableGet(false, handleIndex(), engine().luaFrom(move(key)))); return engine().luaTo<T>(engine().tableGet(false, handleIndex(), engine().luaFrom(std::move(key))));
} }
template <typename T> template <typename T>
@ -1698,17 +1698,17 @@ T LuaTable::get(char const* key) const {
template <typename T, typename K> template <typename T, typename K>
void LuaTable::set(K key, T value) const { void LuaTable::set(K key, T value) const {
engine().tableSet(false, handleIndex(), engine().luaFrom(move(key)), engine().luaFrom(move(value))); engine().tableSet(false, handleIndex(), engine().luaFrom(std::move(key)), engine().luaFrom(std::move(value)));
} }
template <typename T> template <typename T>
void LuaTable::set(char const* key, T value) const { void LuaTable::set(char const* key, T value) const {
engine().tableSet(false, handleIndex(), key, engine().luaFrom(move(value))); engine().tableSet(false, handleIndex(), key, engine().luaFrom(std::move(value)));
} }
template <typename K> template <typename K>
bool LuaTable::contains(K key) const { bool LuaTable::contains(K key) const {
return engine().tableGet(false, handleIndex(), engine().luaFrom(move(key))) != LuaNil; return engine().tableGet(false, handleIndex(), engine().luaFrom(std::move(key))) != LuaNil;
} }
template <typename K> template <typename K>
@ -1718,12 +1718,12 @@ void LuaTable::remove(K key) const {
template <typename Function> template <typename Function>
void LuaTable::iterate(Function&& function) const { void LuaTable::iterate(Function&& function) const {
return engine().tableIterate(handleIndex(), LuaDetail::wrapTableIterator(engine(), forward<Function>(function))); return engine().tableIterate(handleIndex(), LuaDetail::wrapTableIterator(engine(), std::forward<Function>(function)));
} }
template <typename Return, typename... Args, typename Function> template <typename Return, typename... Args, typename Function>
void LuaTable::iterateWithSignature(Function&& func) const { void LuaTable::iterateWithSignature(Function&& func) const {
return engine().tableIterate(handleIndex(), LuaDetail::wrapTableIteratorWithSignature<Return, Args...>(engine(), forward<Function>(func))); return engine().tableIterate(handleIndex(), LuaDetail::wrapTableIteratorWithSignature<Return, Args...>(engine(), std::forward<Function>(func)));
} }
template <typename T, typename K> template <typename T, typename K>
@ -1779,27 +1779,27 @@ T& LuaUserData::get() const {
template <typename Function> template <typename Function>
void LuaCallbacks::registerCallback(String name, Function&& func) { void LuaCallbacks::registerCallback(String name, Function&& func) {
if (!m_callbacks.insert(name, LuaDetail::wrapFunction(forward<Function>(func))).second) if (!m_callbacks.insert(name, LuaDetail::wrapFunction(std::forward<Function>(func))).second)
throw LuaException::format("Lua callback '{}' was registered twice", name); throw LuaException::format("Lua callback '{}' was registered twice", name);
} }
template <typename Return, typename... Args, typename Function> template <typename Return, typename... Args, typename Function>
void LuaCallbacks::registerCallbackWithSignature(String name, Function&& func) { void LuaCallbacks::registerCallbackWithSignature(String name, Function&& func) {
if (!m_callbacks.insert(name, LuaDetail::wrapFunctionWithSignature<Return, Args...>(forward<Function>(func))).second) if (!m_callbacks.insert(name, LuaDetail::wrapFunctionWithSignature<Return, Args...>(std::forward<Function>(func))).second)
throw LuaException::format("Lua callback '{}' was registered twice", name); throw LuaException::format("Lua callback '{}' was registered twice", name);
} }
template <typename T> template <typename T>
template <typename Function> template <typename Function>
void LuaMethods<T>::registerMethod(String name, Function&& func) { void LuaMethods<T>::registerMethod(String name, Function&& func) {
if (!m_methods.insert(name, LuaDetail::wrapMethod(forward<Function>(move(func)))).second) if (!m_methods.insert(name, LuaDetail::wrapMethod(std::forward<Function>(std::move(func)))).second)
throw LuaException::format("Lua method '{}' was registered twice", name); throw LuaException::format("Lua method '{}' was registered twice", name);
} }
template <typename T> template <typename T>
template <typename Return, typename... Args, typename Function> template <typename Return, typename... Args, typename Function>
void LuaMethods<T>::registerMethodWithSignature(String name, Function&& func) { void LuaMethods<T>::registerMethodWithSignature(String name, Function&& func) {
if (!m_methods.insert(name, LuaDetail::wrapMethodWithSignature<Return, Args...>(forward<Function>(move(func)))) if (!m_methods.insert(name, LuaDetail::wrapMethodWithSignature<Return, Args...>(std::forward<Function>(std::move(func))))
.second) .second)
throw LuaException::format("Lua method '{}' was registered twice", name); throw LuaException::format("Lua method '{}' was registered twice", name);
} }
@ -1811,12 +1811,12 @@ StringMap<LuaDetail::LuaWrappedFunction> const& LuaMethods<T>::methods() const {
template <typename T> template <typename T>
T LuaContext::getPath(String path) const { T LuaContext::getPath(String path) const {
return engine().luaTo<T>(engine().contextGetPath(handleIndex(), move(path))); return engine().luaTo<T>(engine().contextGetPath(handleIndex(), std::move(path)));
} }
template <typename T> template <typename T>
void LuaContext::setPath(String key, T value) { void LuaContext::setPath(String key, T value) {
engine().contextSetPath(handleIndex(), move(key), engine().luaFrom<T>(move(value))); engine().contextSetPath(handleIndex(), std::move(key), engine().luaFrom<T>(std::move(value)));
} }
template <typename Ret> template <typename Ret>
@ -1834,7 +1834,7 @@ Ret LuaContext::invokePath(String const& key, Args const&... args) const {
template <typename T> template <typename T>
LuaValue LuaContext::luaFrom(T&& t) { LuaValue LuaContext::luaFrom(T&& t) {
return engine().luaFrom(forward<T>(t)); return engine().luaFrom(std::forward<T>(t));
} }
template <typename T> template <typename T>
@ -1844,7 +1844,7 @@ LuaValue LuaContext::luaFrom(T const& t) {
template <typename T> template <typename T>
Maybe<T> LuaContext::luaMaybeTo(LuaValue&& v) { Maybe<T> LuaContext::luaMaybeTo(LuaValue&& v) {
return engine().luaFrom(move(v)); return engine().luaFrom(std::move(v));
} }
template <typename T> template <typename T>
@ -1854,7 +1854,7 @@ Maybe<T> LuaContext::luaMaybeTo(LuaValue const& v) {
template <typename T> template <typename T>
T LuaContext::luaTo(LuaValue&& v) { T LuaContext::luaTo(LuaValue&& v) {
return engine().luaTo<T>(move(v)); return engine().luaTo<T>(std::move(v));
} }
template <typename T> template <typename T>
@ -1874,17 +1874,17 @@ LuaTable LuaContext::createArrayTable(Container const& array) {
template <typename Function> template <typename Function>
LuaFunction LuaContext::createFunction(Function&& func) { LuaFunction LuaContext::createFunction(Function&& func) {
return engine().createFunction(forward<Function>(func)); return engine().createFunction(std::forward<Function>(func));
} }
template <typename Return, typename... Args, typename Function> template <typename Return, typename... Args, typename Function>
LuaFunction LuaContext::createFunctionWithSignature(Function&& func) { LuaFunction LuaContext::createFunctionWithSignature(Function&& func) {
return engine().createFunctionWithSignature<Return, Args...>(forward<Function>(func)); return engine().createFunctionWithSignature<Return, Args...>(std::forward<Function>(func));
} }
template <typename T> template <typename T>
LuaUserData LuaContext::createUserData(T t) { LuaUserData LuaContext::createUserData(T t) {
return engine().createUserData(move(t)); return engine().createUserData(std::move(t));
} }
template <typename T> template <typename T>
@ -1894,7 +1894,7 @@ LuaMethods<T> LuaUserDataMethods<T>::make() {
template <typename T> template <typename T>
LuaValue LuaUserDataConverter<T>::from(LuaEngine& engine, T t) { LuaValue LuaUserDataConverter<T>::from(LuaEngine& engine, T t) {
return engine.createUserData(move(t)); return engine.createUserData(std::move(t));
} }
template <typename T> template <typename T>
@ -1908,7 +1908,7 @@ Maybe<T> LuaUserDataConverter<T>::to(LuaEngine&, LuaValue const& v) {
template <typename T> template <typename T>
LuaValue LuaEngine::luaFrom(T&& t) { LuaValue LuaEngine::luaFrom(T&& t) {
return LuaConverter<typename std::decay<T>::type>::from(*this, forward<T>(t)); return LuaConverter<typename std::decay<T>::type>::from(*this, std::forward<T>(t));
} }
template <typename T> template <typename T>
@ -1918,7 +1918,7 @@ LuaValue LuaEngine::luaFrom(T const& t) {
template <typename T> template <typename T>
Maybe<T> LuaEngine::luaMaybeTo(LuaValue&& v) { Maybe<T> LuaEngine::luaMaybeTo(LuaValue&& v) {
return LuaConverter<T>::to(*this, move(v)); return LuaConverter<T>::to(*this, std::move(v));
} }
template <typename T> template <typename T>
@ -1928,7 +1928,7 @@ Maybe<T> LuaEngine::luaMaybeTo(LuaValue const& v) {
template <typename T> template <typename T>
T LuaEngine::luaTo(LuaValue&& v) { T LuaEngine::luaTo(LuaValue&& v) {
if (auto res = luaMaybeTo<T>(move(v))) if (auto res = luaMaybeTo<T>(std::move(v)))
return res.take(); return res.take();
throw LuaConversionException::format("Error converting LuaValue to type '{}'", typeid(T).name()); throw LuaConversionException::format("Error converting LuaValue to type '{}'", typeid(T).name());
} }
@ -1961,12 +1961,12 @@ LuaTable LuaEngine::createArrayTable(Container const& array) {
template <typename Function> template <typename Function>
LuaFunction LuaEngine::createFunction(Function&& func) { LuaFunction LuaEngine::createFunction(Function&& func) {
return createWrappedFunction(LuaDetail::wrapFunction(forward<Function>(func))); return createWrappedFunction(LuaDetail::wrapFunction(std::forward<Function>(func)));
} }
template <typename Return, typename... Args, typename Function> template <typename Return, typename... Args, typename Function>
LuaFunction LuaEngine::createFunctionWithSignature(Function&& func) { LuaFunction LuaEngine::createFunctionWithSignature(Function&& func) {
return createWrappedFunction(LuaDetail::wrapFunctionWithSignature<Return, Args...>(forward<Function>(func))); return createWrappedFunction(LuaDetail::wrapFunctionWithSignature<Return, Args...>(std::forward<Function>(func)));
} }
template <typename... Args> template <typename... Args>
@ -2026,7 +2026,7 @@ Maybe<LuaDetail::LuaFunctionReturn> LuaEngine::resumeThread(int handleIndex, Arg
LuaVariadic<LuaValue> ret(returnValues); LuaVariadic<LuaValue> ret(returnValues);
for (int i = returnValues - 1; i >= 0; --i) for (int i = returnValues - 1; i >= 0; --i)
ret[i] = popLuaValue(threadState); ret[i] = popLuaValue(threadState);
return LuaDetail::LuaFunctionReturn(move(ret)); return LuaDetail::LuaFunctionReturn(std::move(ret));
} }
} }
@ -2071,7 +2071,7 @@ LuaUserData LuaEngine::createUserData(T t) {
lua_checkstack(m_state, 2); lua_checkstack(m_state, 2);
new (lua_newuserdata(m_state, sizeof(T))) T(move(t)); new (lua_newuserdata(m_state, sizeof(T))) T(std::move(t));
lua_rawgeti(m_state, LUA_REGISTRYINDEX, typeMetatable); lua_rawgeti(m_state, LUA_REGISTRYINDEX, typeMetatable);
lua_setmetatable(m_state, -2); lua_setmetatable(m_state, -2);
@ -2083,7 +2083,7 @@ template <typename T, typename K>
T LuaEngine::getGlobal(K key) { T LuaEngine::getGlobal(K key) {
lua_checkstack(m_state, 1); lua_checkstack(m_state, 1);
lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_scriptDefaultEnvRegistryId); lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_scriptDefaultEnvRegistryId);
pushLuaValue(m_state, luaFrom(move(key))); pushLuaValue(m_state, luaFrom(std::move(key)));
lua_rawget(m_state, -2); lua_rawget(m_state, -2);
LuaValue v = popLuaValue(m_state); LuaValue v = popLuaValue(m_state);
@ -2109,8 +2109,8 @@ void LuaEngine::setGlobal(K key, T value) {
lua_checkstack(m_state, 1); lua_checkstack(m_state, 1);
lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_scriptDefaultEnvRegistryId); lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_scriptDefaultEnvRegistryId);
pushLuaValue(m_state, luaFrom(move(key))); pushLuaValue(m_state, luaFrom(std::move(key)));
pushLuaValue(m_state, luaFrom(move(value))); pushLuaValue(m_state, luaFrom(std::move(value)));
lua_rawset(m_state, -3); lua_rawset(m_state, -3);
lua_pop(m_state, 1); lua_pop(m_state, 1);

22
source/core/StarLuaConverters.hpp
View File

@ -33,8 +33,8 @@ template <typename T1, typename T2>
struct LuaConverter<pair<T1, T2>> { struct LuaConverter<pair<T1, T2>> {
static LuaValue from(LuaEngine& engine, pair<T1, T2>&& v) { static LuaValue from(LuaEngine& engine, pair<T1, T2>&& v) {
auto t = engine.createTable(); auto t = engine.createTable();
t.set(1, move(v.first)); t.set(1, std::move(v.first));
t.set(2, move(v.second)); t.set(2, std::move(v.second));
return t; return t;
} }
@ -46,7 +46,7 @@ struct LuaConverter<pair<T1, T2>> {
} }
static Maybe<pair<T1, T2>> to(LuaEngine& engine, LuaValue const& v) { static Maybe<pair<T1, T2>> to(LuaEngine& engine, LuaValue const& v) {
if (auto table = engine.luaMaybeTo<LuaTable>(move(v))) { if (auto table = engine.luaMaybeTo<LuaTable>(std::move(v))) {
auto p1 = engine.luaMaybeTo<T1>(table->get(1)); auto p1 = engine.luaMaybeTo<T1>(table->get(1));
auto p2 = engine.luaMaybeTo<T2>(table->get(2)); auto p2 = engine.luaMaybeTo<T2>(table->get(2));
if (p1 && p2) if (p1 && p2)
@ -173,7 +173,7 @@ struct LuaConverter<Variant<FirstType, RestTypes...>> {
} }
static LuaValue from(LuaEngine& engine, Variant<FirstType, RestTypes...>&& variant) { static LuaValue from(LuaEngine& engine, Variant<FirstType, RestTypes...>&& variant) {
return variant.call([&engine](auto& a) { return luaFrom(engine, move(a)); }); return variant.call([&engine](auto& a) { return luaFrom(engine, std::move(a)); });
} }
static Maybe<Variant<FirstType, RestTypes...>> to(LuaEngine& engine, LuaValue const& v) { static Maybe<Variant<FirstType, RestTypes...>> to(LuaEngine& engine, LuaValue const& v) {
@ -194,7 +194,7 @@ struct LuaConverter<Variant<FirstType, RestTypes...>> {
} }
static Maybe<Variant<FirstType, RestTypes...>> to(LuaEngine& engine, LuaValue&& v) { static Maybe<Variant<FirstType, RestTypes...>> to(LuaEngine& engine, LuaValue&& v) {
return checkTypeTo<FirstType, RestTypes...>(engine, move(v)); return checkTypeTo<FirstType, RestTypes...>(engine, std::move(v));
} }
template <typename CheckType1, typename CheckType2, typename... CheckTypeRest> template <typename CheckType1, typename CheckType2, typename... CheckTypeRest>
@ -202,12 +202,12 @@ struct LuaConverter<Variant<FirstType, RestTypes...>> {
if (auto t1 = engine.luaMaybeTo<CheckType1>(v)) if (auto t1 = engine.luaMaybeTo<CheckType1>(v))
return t1; return t1;
else else
return checkTypeTo<CheckType2, CheckTypeRest...>(engine, move(v)); return checkTypeTo<CheckType2, CheckTypeRest...>(engine, std::move(v));
} }
template <typename Type> template <typename Type>
static Maybe<Variant<FirstType, RestTypes...>> checkTypeTo(LuaEngine& engine, LuaValue&& v) { static Maybe<Variant<FirstType, RestTypes...>> checkTypeTo(LuaEngine& engine, LuaValue&& v) {
return engine.luaMaybeTo<Type>(move(v)); return engine.luaMaybeTo<Type>(std::move(v));
} }
}; };
@ -226,7 +226,7 @@ struct LuaConverter<MVariant<Types...>> {
static LuaValue from(LuaEngine& engine, MVariant<Types...>&& variant) { static LuaValue from(LuaEngine& engine, MVariant<Types...>&& variant) {
LuaValue value; LuaValue value;
variant.call([&value, &engine](auto& a) { variant.call([&value, &engine](auto& a) {
value = luaFrom(engine, move(a)); value = luaFrom(engine, std::move(a));
}); });
return value; return value;
} }
@ -253,7 +253,7 @@ struct LuaConverter<MVariant<Types...>> {
static Maybe<MVariant<Types...>> to(LuaEngine& engine, LuaValue&& v) { static Maybe<MVariant<Types...>> to(LuaEngine& engine, LuaValue&& v) {
if (v == LuaNil) if (v == LuaNil)
return MVariant<Types...>(); return MVariant<Types...>();
return checkTypeTo<Types...>(engine, move(v)); return checkTypeTo<Types...>(engine, std::move(v));
} }
template <typename CheckType1, typename CheckType2, typename... CheckTypeRest> template <typename CheckType1, typename CheckType2, typename... CheckTypeRest>
@ -261,12 +261,12 @@ struct LuaConverter<MVariant<Types...>> {
if (auto t1 = engine.luaMaybeTo<CheckType1>(v)) if (auto t1 = engine.luaMaybeTo<CheckType1>(v))
return t1; return t1;
else else
return checkTypeTo<CheckType2, CheckTypeRest...>(engine, move(v)); return checkTypeTo<CheckType2, CheckTypeRest...>(engine, std::move(v));
} }
template <typename CheckType> template <typename CheckType>
static Maybe<MVariant<Types...>> checkTypeTo(LuaEngine& engine, LuaValue&& v) { static Maybe<MVariant<Types...>> checkTypeTo(LuaEngine& engine, LuaValue&& v) {
return engine.luaMaybeTo<CheckType>(move(v)); return engine.luaMaybeTo<CheckType>(std::move(v));
} }
}; };

12
source/core/StarMap.hpp
View File

@ -172,7 +172,7 @@ auto MapMixin<BaseMap>::maybeTake(key_type const& k) -> Maybe<mapped_type> {
if (i != Base::end()) { if (i != Base::end()) {
mapped_type v = std::move(i->second); mapped_type v = std::move(i->second);
Base::erase(i); Base::erase(i);
return move(v); return v;
} }
return {}; return {};
@ -198,7 +198,7 @@ template <typename BaseMap>
auto MapMixin<BaseMap>::value(key_type const& k, mapped_type d) const -> mapped_type { auto MapMixin<BaseMap>::value(key_type const& k, mapped_type d) const -> mapped_type {
const_iterator i = Base::find(k); const_iterator i = Base::find(k);
if (i == Base::end()) if (i == Base::end())
return std::move(d); return d;
else else
return i->second; return i->second;
} }
@ -260,12 +260,12 @@ auto MapMixin<BaseMap>::hasValue(mapped_type const& v) const -> bool {
template <typename BaseMap> template <typename BaseMap>
auto MapMixin<BaseMap>::insert(key_type k, mapped_type v) -> pair<iterator, bool> { auto MapMixin<BaseMap>::insert(key_type k, mapped_type v) -> pair<iterator, bool> {
return Base::insert(value_type(move(k), move(v))); return Base::insert(value_type(std::move(k), std::move(v)));
} }
template <typename BaseMap> template <typename BaseMap>
auto MapMixin<BaseMap>::add(key_type k, mapped_type v) -> mapped_type& { auto MapMixin<BaseMap>::add(key_type k, mapped_type v) -> mapped_type& {
auto pair = Base::insert(value_type(move(k), move(v))); auto pair = Base::insert(value_type(std::move(k), std::move(v)));
if (!pair.second) if (!pair.second)
throw MapException(strf("Entry with key '{}' already present.", outputAny(k))); throw MapException(strf("Entry with key '{}' already present.", outputAny(k)));
else else
@ -276,10 +276,10 @@ template <typename BaseMap>
auto MapMixin<BaseMap>::set(key_type k, mapped_type v) -> mapped_type& { auto MapMixin<BaseMap>::set(key_type k, mapped_type v) -> mapped_type& {
auto i = Base::find(k); auto i = Base::find(k);
if (i != Base::end()) { if (i != Base::end()) {
i->second = move(v); i->second = std::move(v);
return i->second; return i->second;
} else { } else {
return Base::insert(value_type(move(k), move(v))).first->second; return Base::insert(value_type(std::move(k), std::move(v))).first->second;
} }
} }

12
source/core/StarMaybe.hpp
View File

@ -118,7 +118,7 @@ Maybe<T>::Maybe(T const& t)
template <typename T> template <typename T>
Maybe<T>::Maybe(T&& t) Maybe<T>::Maybe(T&& t)
: Maybe() { : Maybe() {
new (&m_data) T(forward<T>(t)); new (&m_data) T(std::forward<T>(t));
m_initialized = true; m_initialized = true;
} }
@ -135,7 +135,7 @@ template <typename T>
Maybe<T>::Maybe(Maybe&& rhs) Maybe<T>::Maybe(Maybe&& rhs)
: Maybe() { : Maybe() {
if (rhs.m_initialized) { if (rhs.m_initialized) {
new (&m_data) T(move(rhs.m_data)); new (&m_data) T(std::move(rhs.m_data));
m_initialized = true; m_initialized = true;
rhs.reset(); rhs.reset();
} }
@ -308,7 +308,7 @@ T Maybe<T>::take() {
if (!m_initialized) if (!m_initialized)
throw InvalidMaybeAccessException(); throw InvalidMaybeAccessException();
T val(move(m_data)); T val(std::move(m_data));
reset(); reset();
@ -318,7 +318,7 @@ T Maybe<T>::take() {
template <typename T> template <typename T>
bool Maybe<T>::put(T& t) { bool Maybe<T>::put(T& t) {
if (m_initialized) { if (m_initialized) {
t = move(m_data); t = std::move(m_data);
reset(); reset();
@ -335,7 +335,7 @@ void Maybe<T>::set(T const& t) {
template <typename T> template <typename T>
void Maybe<T>::set(T&& t) { void Maybe<T>::set(T&& t) {
emplace(forward<T>(t)); emplace(std::forward<T>(t));
} }
template <typename T> template <typename T>
@ -343,7 +343,7 @@ template <typename... Args>
void Maybe<T>::emplace(Args&&... t) { void Maybe<T>::emplace(Args&&... t) {
reset(); reset();
new (&m_data) T(forward<Args>(t)...); new (&m_data) T(std::forward<Args>(t)...);
m_initialized = true; m_initialized = true;
} }

18
source/core/StarMultiArray.hpp
View File

@ -326,14 +326,14 @@ void MultiArray<Element, Rank>::set(IndexArray const& index, Element element) {
throw MultiArrayException(strf("Out of bounds on MultiArray::set({})", index)); throw MultiArrayException(strf("Out of bounds on MultiArray::set({})", index));
} }
m_data[storageIndex(index)] = move(element); m_data[storageIndex(index)] = std::move(element);
} }
template <typename Element, size_t Rank> template <typename Element, size_t Rank>
Element MultiArray<Element, Rank>::get(IndexArray const& index, Element def) { Element MultiArray<Element, Rank>::get(IndexArray const& index, Element def) {
for (size_t i = Rank; i != 0; --i) { for (size_t i = Rank; i != 0; --i) {
if (index[i - 1] >= m_shape[i - 1]) if (index[i - 1] >= m_shape[i - 1])
return move(def); return std::move(def);
} }
return m_data[storageIndex(index)]; return m_data[storageIndex(index)];
@ -346,7 +346,7 @@ void MultiArray<Element, Rank>::setResize(IndexArray const& index, Element eleme
newShape[i] = std::max(m_shape[i], index[i] + 1); newShape[i] = std::max(m_shape[i], index[i] + 1);
resize(newShape); resize(newShape);
m_data[storageIndex(index)] = move(element); m_data[storageIndex(index)] = std::move(element);
} }
template <typename Element, size_t Rank> template <typename Element, size_t Rank>
@ -369,26 +369,26 @@ template <typename Element, size_t Rank>
template <typename OpType> template <typename OpType>
void MultiArray<Element, Rank>::forEach(IndexArray const& min, SizeArray const& size, OpType&& op) { void MultiArray<Element, Rank>::forEach(IndexArray const& min, SizeArray const& size, OpType&& op) {
IndexArray index; IndexArray index;
subForEach(min, size, forward<OpType>(op), index, 0, 0); subForEach(min, size, std::forward<OpType>(op), index, 0, 0);
} }
template <typename Element, size_t Rank> template <typename Element, size_t Rank>
template <typename OpType> template <typename OpType>
void MultiArray<Element, Rank>::forEach(IndexArray const& min, SizeArray const& size, OpType&& op) const { void MultiArray<Element, Rank>::forEach(IndexArray const& min, SizeArray const& size, OpType&& op) const {
IndexArray index; IndexArray index;
subForEach(min, size, forward<OpType>(op), index, 0, 0); subForEach(min, size, std::forward<OpType>(op), index, 0, 0);
} }
template <typename Element, size_t Rank> template <typename Element, size_t Rank>
template <typename OpType> template <typename OpType>
void MultiArray<Element, Rank>::forEach(OpType&& op) { void MultiArray<Element, Rank>::forEach(OpType&& op) {
forEach(IndexArray::filled(0), size(), forward<OpType>(op)); forEach(IndexArray::filled(0), size(), std::forward<OpType>(op));
} }
template <typename Element, size_t Rank> template <typename Element, size_t Rank>
template <typename OpType> template <typename OpType>
void MultiArray<Element, Rank>::forEach(OpType&& op) const { void MultiArray<Element, Rank>::forEach(OpType&& op) const {
forEach(IndexArray::filled(0), size(), forward<OpType>(op)); forEach(IndexArray::filled(0), size(), std::forward<OpType>(op));
} }
template <typename Element, size_t Rank> template <typename Element, size_t Rank>
@ -461,7 +461,7 @@ void MultiArray<Element, Rank>::subForEach(IndexArray const& min, SizeArray cons
if (dim == Rank - 1) if (dim == Rank - 1)
op(index, m_data[offset + i]); op(index, m_data[offset + i]);
else else
subForEach(min, size, forward<OpType>(op), index, (offset + i) * m_shape[dim + 1], dim + 1); subForEach(min, size, std::forward<OpType>(op), index, (offset + i) * m_shape[dim + 1], dim + 1);
} }
} }
@ -475,7 +475,7 @@ void MultiArray<Element, Rank>::subForEach(IndexArray const& min, SizeArray cons
if (dim == Rank - 1) if (dim == Rank - 1)
op(index, m_data[offset + i]); op(index, m_data[offset + i]);
else else
subForEach(min, size, forward<OpType>(op), index, (offset + i) * m_shape[dim + 1], dim + 1); subForEach(min, size, std::forward<OpType>(op), index, (offset + i) * m_shape[dim + 1], dim + 1);
} }
} }

10
source/core/StarNetElementBasicFields.hpp
View File

@ -155,7 +155,7 @@ void NetElementBasicField<T>::set(T const& value) {
template <typename T> template <typename T>
void NetElementBasicField<T>::push(T value) { void NetElementBasicField<T>::push(T value) {
m_value = move(value); m_value = std::move(value);
updated(); updated();
m_latestUpdateVersion = m_netVersion ? m_netVersion->current() : 0; m_latestUpdateVersion = m_netVersion ? m_netVersion->current() : 0;
if (m_pendingInterpolatedValues) if (m_pendingInterpolatedValues)
@ -251,14 +251,14 @@ void NetElementBasicField<T>::readNetDelta(DataStream& ds, float interpolationTi
// case, this is an error or the step tracking is wildly off, so just clear // case, this is an error or the step tracking is wildly off, so just clear
// any other incoming values. // any other incoming values.
if (interpolationTime > 0.0f && (m_pendingInterpolatedValues->empty() || interpolationTime >= m_pendingInterpolatedValues->last().first)) { if (interpolationTime > 0.0f && (m_pendingInterpolatedValues->empty() || interpolationTime >= m_pendingInterpolatedValues->last().first)) {
m_pendingInterpolatedValues->append({interpolationTime, move(t)}); m_pendingInterpolatedValues->append({interpolationTime, std::move(t)});
} else { } else {
m_value = move(t); m_value = std::move(t);
m_pendingInterpolatedValues->clear(); m_pendingInterpolatedValues->clear();
updated(); updated();
} }
} else { } else {
m_value = move(t); m_value = std::move(t);
updated(); updated();
} }
} }
@ -314,7 +314,7 @@ NetElementData<T>::NetElementData()
template <typename T> template <typename T>
NetElementData<T>::NetElementData(function<void(DataStream&, T&)> reader, function<void(DataStream&, T const&)> writer) NetElementData<T>::NetElementData(function<void(DataStream&, T&)> reader, function<void(DataStream&, T const&)> writer)
: m_reader(move(reader)), m_writer(move(writer)) {} : m_reader(std::move(reader)), m_writer(std::move(writer)) {}
template <typename T> template <typename T>
void NetElementData<T>::readData(DataStream& ds, T& v) const { void NetElementData<T>::readData(DataStream& ds, T& v) const {

46
source/core/StarNetElementContainers.hpp
View File

@ -124,7 +124,7 @@ void NetElementMapWrapper<BaseMap>::initNetVersion(NetElementVersion const* vers
m_changeDataLastVersion = 0; m_changeDataLastVersion = 0;
for (auto& change : Star::take(m_pendingChangeData)) for (auto& change : Star::take(m_pendingChangeData))
applyChange(move(change.second)); applyChange(std::move(change.second));
addChangeData(ClearChange()); addChangeData(ClearChange());
for (auto const& p : *this) for (auto const& p : *this)
@ -140,7 +140,7 @@ template <typename BaseMap>
void NetElementMapWrapper<BaseMap>::disableNetInterpolation() { void NetElementMapWrapper<BaseMap>::disableNetInterpolation() {
m_interpolationEnabled = false; m_interpolationEnabled = false;
for (auto& change : Star::take(m_pendingChangeData)) for (auto& change : Star::take(m_pendingChangeData))
applyChange(move(change.second)); applyChange(std::move(change.second));
} }
template <typename BaseMap> template <typename BaseMap>
@ -175,7 +175,7 @@ void NetElementMapWrapper<BaseMap>::netLoad(DataStream& ds) {
for (uint64_t i = 0; i < count; ++i) { for (uint64_t i = 0; i < count; ++i) {
auto change = readChange(ds); auto change = readChange(ds);
addChangeData(change); addChangeData(change);
applyChange(move(change)); applyChange(std::move(change));
} }
m_updated = true; m_updated = true;
@ -219,9 +219,9 @@ void NetElementMapWrapper<BaseMap>::readNetDelta(DataStream& ds, float interpola
addChangeData(change); addChangeData(change);
if (m_interpolationEnabled && interpolationTime > 0.0f) if (m_interpolationEnabled && interpolationTime > 0.0f)
addPendingChangeData(move(change), interpolationTime); addPendingChangeData(std::move(change), interpolationTime);
else else
applyChange(move(change)); applyChange(std::move(change));
} else { } else {
throw IOException("Improper delta code received in NetElementMapWrapper::readNetDelta"); throw IOException("Improper delta code received in NetElementMapWrapper::readNetDelta");
} }
@ -252,7 +252,7 @@ template <typename BaseMap>
auto NetElementMapWrapper<BaseMap>::insert(value_type v) -> pair<const_iterator, bool> { auto NetElementMapWrapper<BaseMap>::insert(value_type v) -> pair<const_iterator, bool> {
auto res = BaseMap::insert(v); auto res = BaseMap::insert(v);
if (res.second) { if (res.second) {
addChangeData(SetChange{move(v.first), move(v.second)}); addChangeData(SetChange{std::move(v.first), std::move(v.second)});
m_updated = true; m_updated = true;
} }
return res; return res;
@ -260,12 +260,12 @@ auto NetElementMapWrapper<BaseMap>::insert(value_type v) -> pair<const_iterator,
template <typename BaseMap> template <typename BaseMap>
auto NetElementMapWrapper<BaseMap>::insert(key_type k, mapped_type v) -> pair<const_iterator, bool> { auto NetElementMapWrapper<BaseMap>::insert(key_type k, mapped_type v) -> pair<const_iterator, bool> {
return insert(value_type(move(k), move(v))); return insert(value_type(std::move(k), std::move(v)));
} }
template <typename BaseMap> template <typename BaseMap>
void NetElementMapWrapper<BaseMap>::add(key_type k, mapped_type v) { void NetElementMapWrapper<BaseMap>::add(key_type k, mapped_type v) {
if (!insert(value_type(move(k), move(v))).second) if (!insert(value_type(std::move(k), std::move(v))).second)
throw MapException::format("Entry with key '{}' already present.", outputAny(k)); throw MapException::format("Entry with key '{}' already present.", outputAny(k));
} }
@ -274,13 +274,13 @@ void NetElementMapWrapper<BaseMap>::set(key_type k, mapped_type v) {
auto i = BaseMap::find(k); auto i = BaseMap::find(k);
if (i != BaseMap::end()) { if (i != BaseMap::end()) {
if (!(i->second == v)) { if (!(i->second == v)) {
addChangeData(SetChange{move(k), v}); addChangeData(SetChange{std::move(k), v});
i->second = move(v); i->second = std::move(v);
m_updated = true; m_updated = true;
} }
} else { } else {
addChangeData(SetChange{k, v}); addChangeData(SetChange{k, v});
BaseMap::insert(value_type(move(k), move(v))); BaseMap::insert(value_type(std::move(k), std::move(v)));
m_updated = true; m_updated = true;
} }
} }
@ -289,11 +289,11 @@ template <typename BaseMap>
void NetElementMapWrapper<BaseMap>::push(key_type k, mapped_type v) { void NetElementMapWrapper<BaseMap>::push(key_type k, mapped_type v) {
auto i = BaseMap::find(k); auto i = BaseMap::find(k);
if (i != BaseMap::end()) { if (i != BaseMap::end()) {
addChangeData(SetChange(move(k), v)); addChangeData(SetChange(std::move(k), v));
i->second = move(v); i->second = std::move(v);
} else { } else {
addChangeData(SetChange(k, v)); addChangeData(SetChange(k, v));
BaseMap::insert(value_type(move(k), move(v))); BaseMap::insert(value_type(std::move(k), std::move(v)));
} }
m_updated = true; m_updated = true;
} }
@ -322,7 +322,7 @@ auto NetElementMapWrapper<BaseMap>::take(key_type const& k) -> mapped_type {
auto i = BaseMap::find(k); auto i = BaseMap::find(k);
if (i == BaseMap::end()) if (i == BaseMap::end())
throw MapException::format("Key '{}' not found in Map::take()", outputAny(k)); throw MapException::format("Key '{}' not found in Map::take()", outputAny(k));
auto m = move(i->second); auto m = std::move(i->second);
erase(i); erase(i);
return m; return m;
} }
@ -332,9 +332,9 @@ auto NetElementMapWrapper<BaseMap>::maybeTake(key_type const& k) -> Maybe<mapped
auto i = BaseMap::find(k); auto i = BaseMap::find(k);
if (i == BaseMap::end()) if (i == BaseMap::end())
return {}; return {};
auto m = move(i->second); auto m = std::move(i->second);
erase(i); erase(i);
return Maybe<mapped_type>(move(m)); return Maybe<mapped_type>(std::move(m));
} }
template <typename BaseMap> template <typename BaseMap>
@ -368,7 +368,7 @@ void NetElementMapWrapper<BaseMap>::reset(BaseMap values) {
} }
} }
BaseMap::operator=(move(values)); BaseMap::operator=(std::move(values));
} }
template <typename BaseMap> template <typename BaseMap>
@ -420,7 +420,7 @@ void NetElementMapWrapper<BaseMap>::addChangeData(ElementChange change) {
uint64_t currentVersion = m_netVersion ? m_netVersion->current() : 0; uint64_t currentVersion = m_netVersion ? m_netVersion->current() : 0;
starAssert(m_changeData.empty() || m_changeData.last().first <= currentVersion); starAssert(m_changeData.empty() || m_changeData.last().first <= currentVersion);
m_changeData.append({currentVersion, move(change)}); m_changeData.append({currentVersion, std::move(change)});
m_changeDataLastVersion = max<int64_t>((int64_t)currentVersion - MaxChangeDataVersions, 0); m_changeDataLastVersion = max<int64_t>((int64_t)currentVersion - MaxChangeDataVersions, 0);
while (!m_changeData.empty() && m_changeData.first().first < m_changeDataLastVersion) while (!m_changeData.empty() && m_changeData.first().first < m_changeDataLastVersion)
@ -431,17 +431,17 @@ template <typename BaseMap>
void NetElementMapWrapper<BaseMap>::addPendingChangeData(ElementChange change, float interpolationTime) { void NetElementMapWrapper<BaseMap>::addPendingChangeData(ElementChange change, float interpolationTime) {
if (!m_pendingChangeData.empty() && interpolationTime < m_pendingChangeData.last().first) { if (!m_pendingChangeData.empty() && interpolationTime < m_pendingChangeData.last().first) {
for (auto& change : Star::take(m_pendingChangeData)) for (auto& change : Star::take(m_pendingChangeData))
applyChange(move(change.second)); applyChange(std::move(change.second));
} }
m_pendingChangeData.append({interpolationTime, move(change)}); m_pendingChangeData.append({interpolationTime, std::move(change)});
} }
template <typename BaseMap> template <typename BaseMap>
void NetElementMapWrapper<BaseMap>::applyChange(ElementChange change) { void NetElementMapWrapper<BaseMap>::applyChange(ElementChange change) {
if (auto set = change.template ptr<SetChange>()) if (auto set = change.template ptr<SetChange>())
BaseMap::set(move(set->key), move(set->value)); BaseMap::set(std::move(set->key), std::move(set->value));
else if (auto remove = change.template ptr<RemoveChange>()) else if (auto remove = change.template ptr<RemoveChange>())
BaseMap::remove(move(remove->key)); BaseMap::remove(std::move(remove->key));
else else
BaseMap::clear(); BaseMap::clear();
m_updated = true; m_updated = true;

10
source/core/StarNetElementDynamicGroup.hpp
View File

@ -91,7 +91,7 @@ auto NetElementDynamicGroup<Element>::addNetElement(ElementPtr element) -> Eleme
readyElement(element); readyElement(element);
DataStreamBuffer storeBuffer; DataStreamBuffer storeBuffer;
element->netStore(storeBuffer); element->netStore(storeBuffer);
auto id = m_idMap.add(move(element)); auto id = m_idMap.add(std::move(element));
addChangeData(ElementAddition(id, storeBuffer.takeData())); addChangeData(ElementAddition(id, storeBuffer.takeData()));
@ -192,7 +192,7 @@ void NetElementDynamicGroup<Element>::netLoad(DataStream& ds) {
element->netLoad(storeBuffer); element->netLoad(storeBuffer);
readyElement(element); readyElement(element);
m_idMap.add(id, move(element)); m_idMap.add(id, std::move(element));
addChangeData(ElementAddition(id, storeBuffer.takeData())); addChangeData(ElementAddition(id, storeBuffer.takeData()));
} }
} }
@ -256,10 +256,10 @@ void NetElementDynamicGroup<Element>::readNetDelta(DataStream& ds, float interpo
m_idMap.clear(); m_idMap.clear();
} else if (auto addition = changeUpdate.template ptr<ElementAddition>()) { } else if (auto addition = changeUpdate.template ptr<ElementAddition>()) {
ElementPtr element = make_shared<Element>(); ElementPtr element = make_shared<Element>();
DataStreamBuffer storeBuffer(move(get<1>(*addition))); DataStreamBuffer storeBuffer(std::move(get<1>(*addition)));
element->netLoad(storeBuffer); element->netLoad(storeBuffer);
readyElement(element); readyElement(element);
m_idMap.add(get<0>(*addition), move(element)); m_idMap.add(get<0>(*addition), std::move(element));
} else if (auto removal = changeUpdate.template ptr<ElementRemoval>()) { } else if (auto removal = changeUpdate.template ptr<ElementRemoval>()) {
m_idMap.remove(*removal); m_idMap.remove(*removal);
} }
@ -296,7 +296,7 @@ void NetElementDynamicGroup<Element>::addChangeData(ElementChange change) {
uint64_t currentVersion = m_netVersion ? m_netVersion->current() : 0; uint64_t currentVersion = m_netVersion ? m_netVersion->current() : 0;
starAssert(m_changeData.empty() || m_changeData.last().first <= currentVersion); starAssert(m_changeData.empty() || m_changeData.last().first <= currentVersion);
m_changeData.append({currentVersion, move(change)}); m_changeData.append({currentVersion, std::move(change)});
m_changeDataLastVersion = max<int64_t>((int64_t)currentVersion - MaxChangeDataVersions, 0); m_changeDataLastVersion = max<int64_t>((int64_t)currentVersion - MaxChangeDataVersions, 0);
while (!m_changeData.empty() && m_changeData.first().first < m_changeDataLastVersion) while (!m_changeData.empty() && m_changeData.first().first < m_changeDataLastVersion)

2
source/core/StarNetElementFloatFields.hpp
View File

@ -92,7 +92,7 @@ void NetElementFloating<T>::setFixedPointBase(Maybe<T> fixedPointBase) {
template <typename T> template <typename T>
void NetElementFloating<T>::setInterpolator(function<T(T, T, T)> interpolator) { void NetElementFloating<T>::setInterpolator(function<T(T, T, T)> interpolator) {
m_interpolator = move(interpolator); m_interpolator = std::move(interpolator);
} }
template <typename T> template <typename T>

8
source/core/StarNetElementSignal.hpp
View File

@ -71,7 +71,7 @@ template <typename Signal>
void NetElementSignal<Signal>::disableNetInterpolation() { void NetElementSignal<Signal>::disableNetInterpolation() {
m_netInterpolationEnabled = false; m_netInterpolationEnabled = false;
for (auto& p : take(m_pendingSignals)) for (auto& p : take(m_pendingSignals))
send(move(p.second)); send(std::move(p.second));
} }
template <typename Signal> template <typename Signal>
@ -112,11 +112,11 @@ void NetElementSignal<Signal>::readNetDelta(DataStream& ds, float interpolationT
if (m_netInterpolationEnabled && interpolationTime > 0.0f) { if (m_netInterpolationEnabled && interpolationTime > 0.0f) {
if (!m_pendingSignals.empty() && m_pendingSignals.last().first > interpolationTime) { if (!m_pendingSignals.empty() && m_pendingSignals.last().first > interpolationTime) {
for (auto& p : take(m_pendingSignals)) for (auto& p : take(m_pendingSignals))
send(move(p.second)); send(std::move(p.second));
} }
m_pendingSignals.append({interpolationTime, move(s)}); m_pendingSignals.append({interpolationTime, std::move(s)});
} else { } else {
send(move(s)); send(std::move(s));
} }
} }
} }

4
source/core/StarNetElementSyncGroup.cpp
View File

@ -68,11 +68,11 @@ void NetElementSyncGroup::netElementsNeedLoad(bool) {}
void NetElementSyncGroup::netElementsNeedStore() {} void NetElementSyncGroup::netElementsNeedStore() {}
void NetElementCallbackGroup::setNeedsLoadCallback(function<void(bool)> needsLoadCallback) { void NetElementCallbackGroup::setNeedsLoadCallback(function<void(bool)> needsLoadCallback) {
m_netElementsNeedLoad = move(needsLoadCallback); m_netElementsNeedLoad = std::move(needsLoadCallback);
} }
void NetElementCallbackGroup::setNeedsStoreCallback(function<void()> needsStoreCallback) { void NetElementCallbackGroup::setNeedsStoreCallback(function<void()> needsStoreCallback) {
m_netElementsNeedStore = move(needsStoreCallback); m_netElementsNeedStore = std::move(needsStoreCallback);
} }
void NetElementCallbackGroup::netElementsNeedLoad(bool load) { void NetElementCallbackGroup::netElementsNeedLoad(bool load) {

2
source/core/StarNetElementTop.hpp
View File

@ -68,7 +68,7 @@ void NetElementTop<BaseNetElement>::readNetState(ByteArray data, float interpola
BaseNetElement::blankNetDelta(interpolationTime); BaseNetElement::blankNetDelta(interpolationTime);
} else { } else {
DataStreamBuffer ds(move(data)); DataStreamBuffer ds(std::move(data));
if (ds.read<bool>()) if (ds.read<bool>())
BaseNetElement::netLoad(ds); BaseNetElement::netLoad(ds);

2
source/core/StarObserverStream.hpp
View File

@ -61,7 +61,7 @@ void ObserverStream<T>::setHistoryLimit(uint64_t historyLimit) {
template <typename T> template <typename T>
void ObserverStream<T>::add(T value) { void ObserverStream<T>::add(T value) {
m_values.append({m_nextStep, move(value)}); m_values.append({m_nextStep, std::move(value)});
tick(1); tick(1);
} }

18
source/core/StarOptionParser.cpp
View File

@ -4,29 +4,29 @@
namespace Star { namespace Star {
void OptionParser::setCommandName(String commandName) { void OptionParser::setCommandName(String commandName) {
m_commandName = move(commandName); m_commandName = std::move(commandName);
} }
void OptionParser::setSummary(String summary) { void OptionParser::setSummary(String summary) {
m_summary = move(summary); m_summary = std::move(summary);
} }
void OptionParser::setAdditionalHelp(String help) { void OptionParser::setAdditionalHelp(String help) {
m_additionalHelp = move(help); m_additionalHelp = std::move(help);
} }
void OptionParser::addSwitch(String const& flag, String description) { void OptionParser::addSwitch(String const& flag, String description) {
if (!m_options.insert(flag, Switch{flag, move(description)}).second) if (!m_options.insert(flag, Switch{flag, std::move(description)}).second)
throw OptionParserException::format("Duplicate switch '-{}' added", flag); throw OptionParserException::format("Duplicate switch '-{}' added", flag);
} }
void OptionParser::addParameter(String const& flag, String argument, RequirementMode requirementMode, String description) { void OptionParser::addParameter(String const& flag, String argument, RequirementMode requirementMode, String description) {
if (!m_options.insert(flag, Parameter{flag, move(argument), requirementMode, move(description)}).second) if (!m_options.insert(flag, Parameter{flag, std::move(argument), requirementMode, std::move(description)}).second)
throw OptionParserException::format("Duplicate flag '-{}' added", flag); throw OptionParserException::format("Duplicate flag '-{}' added", flag);
} }
void OptionParser::addArgument(String argument, RequirementMode requirementMode, String description) { void OptionParser::addArgument(String argument, RequirementMode requirementMode, String description) {
m_arguments.append(Argument{move(argument), requirementMode, move(description)}); m_arguments.append(Argument{std::move(argument), requirementMode, std::move(description)});
} }
pair<OptionParser::Options, StringList> OptionParser::parseOptions(StringList const& arguments) const { pair<OptionParser::Options, StringList> OptionParser::parseOptions(StringList const& arguments) const {
@ -51,7 +51,7 @@ pair<OptionParser::Options, StringList> OptionParser::parseOptions(StringList co
} }
if (option->is<Switch>()) { if (option->is<Switch>()) {
result.switches.add(move(flag)); result.switches.add(std::move(flag));
} else { } else {
auto const& parameter = option->get<Parameter>(); auto const& parameter = option->get<Parameter>();
if (!it.hasNext()) { if (!it.hasNext()) {
@ -63,7 +63,7 @@ pair<OptionParser::Options, StringList> OptionParser::parseOptions(StringList co
errors.append(strf("Option with argument '-{}' specified multiple times", flag)); errors.append(strf("Option with argument '-{}' specified multiple times", flag));
continue; continue;
} }
result.parameters[move(flag)].append(move(val)); result.parameters[std::move(flag)].append(std::move(val));
} }
} else { } else {
@ -96,7 +96,7 @@ pair<OptionParser::Options, StringList> OptionParser::parseOptions(StringList co
errors.append(strf( errors.append(strf(
"Too many positional arguments given, expected at most {} got {}", maximumArguments, result.arguments.size())); "Too many positional arguments given, expected at most {} got {}", maximumArguments, result.arguments.size()));
return {move(result), move(errors)}; return {std::move(result), std::move(errors)};
} }
void OptionParser::printHelp(std::ostream& os) const { void OptionParser::printHelp(std::ostream& os) const {

18
source/core/StarOrderedMap.hpp
View File

@ -192,7 +192,7 @@ OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::OrderedMapWrapper(Inp
template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs> template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::OrderedMapWrapper(initializer_list<value_type> list) { OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::OrderedMapWrapper(initializer_list<value_type> list) {
for (value_type v : list) for (value_type v : list)
insert(move(v)); insert(std::move(v));
} }
template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs> template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
@ -242,7 +242,7 @@ template <template <typename...> class Map, typename Key, typename Value, typena
auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::value(key_type const& k, mapped_type d) const -> mapped_type { auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::value(key_type const& k, mapped_type d) const -> mapped_type {
auto i = m_map.find(k); auto i = m_map.find(k);
if (i == m_map.end()) if (i == m_map.end())
return move(d); return d;
else else
return i->second->second; return i->second->second;
} }
@ -335,7 +335,7 @@ auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insert(value_typ
template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs> template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insert(key_type k, mapped_type v) -> pair<iterator, bool> { auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insert(key_type k, mapped_type v) -> pair<iterator, bool> {
return insert(value_type(move(k), move(v))); return insert(value_type(std::move(k), std::move(v)));
} }
template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs> template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
@ -352,12 +352,12 @@ auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insertFront(valu
template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs> template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insertFront(key_type k, mapped_type v) -> pair<iterator, bool> { auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insertFront(key_type k, mapped_type v) -> pair<iterator, bool> {
return insertFront(value_type(move(k), move(v))); return insertFront(value_type(std::move(k), std::move(v)));
} }
template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs> template <template <typename...> class Map, typename Key, typename Value, typename Allocator, typename... MapArgs>
auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::add(key_type k, mapped_type v) -> mapped_type& { auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::add(key_type k, mapped_type v) -> mapped_type& {
auto pair = insert(value_type(move(k), move(v))); auto pair = insert(value_type(std::move(k), std::move(v)));
if (!pair.second) if (!pair.second)
throw MapException(strf("Entry with key '{}' already present.", outputAny(k))); throw MapException(strf("Entry with key '{}' already present.", outputAny(k)));
else else
@ -368,10 +368,10 @@ template <template <typename...> class Map, typename Key, typename Value, typena
auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::set(key_type k, mapped_type v) -> mapped_type& { auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::set(key_type k, mapped_type v) -> mapped_type& {
auto i = find(k); auto i = find(k);
if (i != end()) { if (i != end()) {
i->second = move(v); i->second = std::move(v);
return i->second; return i->second;
} else { } else {
return insert(value_type(move(k), move(v))).first->second; return insert(value_type(std::move(k), std::move(v))).first->second;
} }
} }
@ -575,11 +575,11 @@ template <template <typename...> class Map, typename Key, typename Value, typena
auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insert(iterator pos, value_type v) -> iterator { auto OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::insert(iterator pos, value_type v) -> iterator {
auto i = m_map.find(v.first); auto i = m_map.find(v.first);
if (i == m_map.end()) { if (i == m_map.end()) {
iterator orderIt = m_order.insert(pos, move(v)); iterator orderIt = m_order.insert(pos, std::move(v));
m_map.insert(typename MapType::value_type(std::cref(orderIt->first), orderIt)); m_map.insert(typename MapType::value_type(std::cref(orderIt->first), orderIt));
return orderIt; return orderIt;
} else { } else {
i->second->second = move(v.second); i->second->second = std::move(v.second);
m_order.splice(pos, m_order, i->second); m_order.splice(pos, m_order, i->second);
return i->second; return i->second;
} }

2
source/core/StarOrderedSet.hpp
View File

@ -167,7 +167,7 @@ template <template <typename...> class Map, typename Value, typename Allocator,
auto OrderedSetWrapper<Map, Value, Allocator, Args...>::values() const -> List<value_type> { auto OrderedSetWrapper<Map, Value, Allocator, Args...>::values() const -> List<value_type> {
List<value_type> values; List<value_type> values;
for (auto p : *this) for (auto p : *this)
values.append(move(p)); values.append(std::move(p));
return values; return values;
} }

2
source/core/StarOutputProxy.hpp
View File

@ -49,7 +49,7 @@ struct OutputProxy {
typedef function<void(std::ostream&)> PrintFunction; typedef function<void(std::ostream&)> PrintFunction;
OutputProxy(PrintFunction p) OutputProxy(PrintFunction p)
: print(move(p)) {} : print(std::move(p)) {}
PrintFunction print; PrintFunction print;
}; };

8
source/core/StarParametricFunction.hpp
View File

@ -125,8 +125,8 @@ ParametricTable<IndexType, ValueType>::ParametricTable(PairContainer indexValueP
}); });
for (auto const& pair : indexValuePairs) { for (auto const& pair : indexValuePairs) {
m_indexes.push_back(move(std::get<0>(pair))); m_indexes.push_back(std::move(std::get<0>(pair)));
m_values.push_back(move(std::get<1>(pair))); m_values.push_back(std::move(std::get<1>(pair)));
} }
for (size_t i = 0; i < size() - 1; ++i) { for (size_t i = 0; i < size() - 1; ++i) {
@ -138,8 +138,8 @@ ParametricTable<IndexType, ValueType>::ParametricTable(PairContainer indexValueP
template <typename IndexType, typename ValueType> template <typename IndexType, typename ValueType>
size_t ParametricTable<IndexType, ValueType>::addPoint(IndexType index, ValueType value) { size_t ParametricTable<IndexType, ValueType>::addPoint(IndexType index, ValueType value) {
size_t insertLocation = std::distance(m_indexes.begin(), std::upper_bound(m_indexes.begin(), m_indexes.end(), index)); size_t insertLocation = std::distance(m_indexes.begin(), std::upper_bound(m_indexes.begin(), m_indexes.end(), index));
m_indexes.insert(m_indexes.begin() + insertLocation, move(index)); m_indexes.insert(m_indexes.begin() + insertLocation, std::move(index));
m_values.insert(m_values.begin() + insertLocation, move(value)); m_values.insert(m_values.begin() + insertLocation, std::move(value));
return insertLocation; return insertLocation;
} }

10
source/core/StarPerlin.hpp
View File

@ -210,7 +210,7 @@ Perlin<Float>::Perlin(Perlin const& perlin) {
template <typename Float> template <typename Float>
Perlin<Float>::Perlin(Perlin&& perlin) { Perlin<Float>::Perlin(Perlin&& perlin) {
*this = move(perlin); *this = std::move(perlin);
} }
template <typename Float> template <typename Float>
@ -261,10 +261,10 @@ Perlin<Float>& Perlin<Float>::operator=(Perlin&& perlin) {
m_offset = perlin.m_offset; m_offset = perlin.m_offset;
m_gain = perlin.m_gain; m_gain = perlin.m_gain;
p = move(perlin.p); p = std::move(perlin.p);
g3 = move(perlin.g3); g3 = std::move(perlin.g3);
g2 = move(perlin.g2); g2 = std::move(perlin.g2);
g1 = move(perlin.g1); g1 = std::move(perlin.g1);
return *this; return *this;
} }

10
source/core/StarPoly.hpp
View File

@ -186,7 +186,7 @@ Polygon<DataType> Polygon<DataType>::convexHull(VertexList points) {
upper.removeLast(); upper.removeLast();
lower.removeLast(); lower.removeLast();
lower.appendAll(take(upper)); lower.appendAll(take(upper));
return Polygon<DataType>(move(lower)); return Polygon<DataType>(std::move(lower));
} }
template <typename DataType> template <typename DataType>
@ -218,7 +218,7 @@ Polygon<DataType> Polygon<DataType>::clip(Polygon inputPoly, Polygon convexClipP
} }
} }
return Polygon(move(outputVertexes)); return Polygon(std::move(outputVertexes));
} }
template <typename DataType> template <typename DataType>
@ -230,7 +230,7 @@ Polygon<DataType>::Polygon(Polygon const& rhs)
template <typename DataType> template <typename DataType>
Polygon<DataType>::Polygon(Polygon&& rhs) Polygon<DataType>::Polygon(Polygon&& rhs)
: m_vertexes(move(rhs.m_vertexes)) {} : m_vertexes(std::move(rhs.m_vertexes)) {}
template <typename DataType> template <typename DataType>
template <typename DataType2> template <typename DataType2>
@ -303,7 +303,7 @@ void Polygon<DataType>::deduplicateVertexes(float maxDistance) {
if (vmagSquared(newVertexes.first() - newVertexes.last()) <= distSquared) if (vmagSquared(newVertexes.first() - newVertexes.last()) <= distSquared)
newVertexes.removeLast(); newVertexes.removeLast();
m_vertexes = move(newVertexes); m_vertexes = std::move(newVertexes);
} }
template <typename DataType> template <typename DataType>
@ -426,7 +426,7 @@ Polygon<DataType>& Polygon<DataType>::operator=(Polygon const& rhs) {
template <typename DataType> template <typename DataType>
Polygon<DataType>& Polygon<DataType>::operator=(Polygon&& rhs) { Polygon<DataType>& Polygon<DataType>::operator=(Polygon&& rhs) {
m_vertexes = move(rhs.m_vertexes); m_vertexes = std::move(rhs.m_vertexes);
return *this; return *this;
} }

2
source/core/StarPythonic.hpp
View File

@ -599,7 +599,7 @@ template <typename ResultContainer, typename Iterable>
ResultContainer enumerateConstruct(Iterable&& list) { ResultContainer enumerateConstruct(Iterable&& list) {
ResultContainer res; ResultContainer res;
for (auto el : enumerateIterator(list)) for (auto el : enumerateIterator(list))
res.push_back(move(el)); res.push_back(std::move(el));
return res; return res;
} }

2
source/core/StarRefPtr.hpp
View File

@ -278,7 +278,7 @@ RefPtr<Type1 const> as(RefPtr<Type2 const> const& p) {
template <typename T, typename... Args> template <typename T, typename... Args>
RefPtr<T> make_ref(Args&&... args) { RefPtr<T> make_ref(Args&&... args) {
return RefPtr<T>(new T(forward<Args>(args)...)); return RefPtr<T>(new T(std::forward<Args>(args)...));
} }
template <typename T> template <typename T>

22
source/core/StarRpcPromise.hpp
View File

@ -70,17 +70,17 @@ private:
template <typename Result, typename Error> template <typename Result, typename Error>
void RpcPromiseKeeper<Result, Error>::fulfill(Result result) { void RpcPromiseKeeper<Result, Error>::fulfill(Result result) {
m_fulfill(move(result)); m_fulfill(std::move(result));
} }
template <typename Result, typename Error> template <typename Result, typename Error>
void RpcPromiseKeeper<Result, Error>::fail(Error error) { void RpcPromiseKeeper<Result, Error>::fail(Error error) {
m_fail(move(error)); m_fail(std::move(error));
} }
template <typename Result, typename Error> template <typename Result, typename Error>
pair<RpcPromise<Result, Error>, RpcPromiseKeeper<Result, Error>> RpcPromise<Result, Error>::createPair() { pair<RpcPromise<Result, Error>, RpcPromiseKeeper<Result, Error>> RpcPromise<Result, Error>::createPair() {
auto valuePtr = make_shared<Value>(); auto valuePtr = std::make_shared<Value>();
RpcPromise promise; RpcPromise promise;
promise.m_getValue = [valuePtr]() { promise.m_getValue = [valuePtr]() {
@ -91,21 +91,21 @@ pair<RpcPromise<Result, Error>, RpcPromiseKeeper<Result, Error>> RpcPromise<Resu
keeper.m_fulfill = [valuePtr](Result result) { keeper.m_fulfill = [valuePtr](Result result) {
if (valuePtr->result || valuePtr->error) if (valuePtr->result || valuePtr->error)
throw RpcPromiseException("fulfill called on already finished RpcPromise"); throw RpcPromiseException("fulfill called on already finished RpcPromise");
valuePtr->result = move(result); valuePtr->result = std::move(result);
}; };
keeper.m_fail = [valuePtr](Error error) { keeper.m_fail = [valuePtr](Error error) {
if (valuePtr->result || valuePtr->error) if (valuePtr->result || valuePtr->error)
throw RpcPromiseException("fail called on already finished RpcPromise"); throw RpcPromiseException("fail called on already finished RpcPromise");
valuePtr->error = move(error); valuePtr->error = std::move(error);
}; };
return {move(promise), move(keeper)}; return {std::move(promise), std::move(keeper)};
} }
template <typename Result, typename Error> template <typename Result, typename Error>
RpcPromise<Result, Error> RpcPromise<Result, Error>::createFulfilled(Result result) { RpcPromise<Result, Error> RpcPromise<Result, Error>::createFulfilled(Result result) {
auto valuePtr = make_shared<Value>(); auto valuePtr = std::make_shared<Value>();
valuePtr->result = move(result); valuePtr->result = std::move(result);
RpcPromise<Result, Error> promise; RpcPromise<Result, Error> promise;
promise.m_getValue = [valuePtr]() { promise.m_getValue = [valuePtr]() {
@ -116,8 +116,8 @@ RpcPromise<Result, Error> RpcPromise<Result, Error>::createFulfilled(Result resu
template <typename Result, typename Error> template <typename Result, typename Error>
RpcPromise<Result, Error> RpcPromise<Result, Error>::createFailed(Error error) { RpcPromise<Result, Error> RpcPromise<Result, Error>::createFailed(Error error) {
auto valuePtr = make_shared<Value>(); auto valuePtr = std::make_shared<Value>();
valuePtr->error = move(error); valuePtr->error = std::move(error);
RpcPromise<Result, Error> promise; RpcPromise<Result, Error> promise;
promise.m_getValue = [valuePtr]() { promise.m_getValue = [valuePtr]() {
@ -157,7 +157,7 @@ template <typename Function>
decltype(auto) RpcPromise<Result, Error>::wrap(Function function) { decltype(auto) RpcPromise<Result, Error>::wrap(Function function) {
typedef RpcPromise<typename std::decay<decltype(function(std::declval<Result>()))>::type, Error> WrappedPromise; typedef RpcPromise<typename std::decay<decltype(function(std::declval<Result>()))>::type, Error> WrappedPromise;
WrappedPromise wrappedPromise; WrappedPromise wrappedPromise;
wrappedPromise.m_getValue = [wrapper = move(function), valuePtr = make_shared<typename WrappedPromise::Value>(), otherGetValue = m_getValue]() { wrappedPromise.m_getValue = [wrapper = std::move(function), valuePtr = std::make_shared<typename WrappedPromise::Value>(), otherGetValue = m_getValue]() {
if (!valuePtr->result && !valuePtr->error) { if (!valuePtr->result && !valuePtr->error) {
auto otherValue = otherGetValue(); auto otherValue = otherGetValue();
if (otherValue->result) if (otherValue->result)

14
source/core/StarRpcThreadPromise.hpp
View File

@ -66,12 +66,12 @@ private:
template <typename Result, typename Error> template <typename Result, typename Error>
void RpcThreadPromiseKeeper<Result, Error>::fulfill(Result result) { void RpcThreadPromiseKeeper<Result, Error>::fulfill(Result result) {
m_fulfill(move(result)); m_fulfill(std::move(result));
} }
template <typename Result, typename Error> template <typename Result, typename Error>
void RpcThreadPromiseKeeper<Result, Error>::fail(Error error) { void RpcThreadPromiseKeeper<Result, Error>::fail(Error error) {
m_fail(move(error)); m_fail(std::move(error));
} }
template <typename Result, typename Error> template <typename Result, typename Error>
@ -88,22 +88,22 @@ pair<RpcThreadPromise<Result, Error>, RpcThreadPromiseKeeper<Result, Error>> Rpc
MutexLocker lock(valuePtr->mutex); MutexLocker lock(valuePtr->mutex);
if (valuePtr->result || valuePtr->error) if (valuePtr->result || valuePtr->error)
throw RpcThreadPromiseException("fulfill called on already finished RpcThreadPromise"); throw RpcThreadPromiseException("fulfill called on already finished RpcThreadPromise");
valuePtr->result = move(result); valuePtr->result = std::move(result);
}; };
keeper.m_fail = [valuePtr](Error error) { keeper.m_fail = [valuePtr](Error error) {
MutexLocker lock(valuePtr->mutex); MutexLocker lock(valuePtr->mutex);
if (valuePtr->result || valuePtr->error) if (valuePtr->result || valuePtr->error)
throw RpcThreadPromiseException("fail called on already finished RpcThreadPromise"); throw RpcThreadPromiseException("fail called on already finished RpcThreadPromise");
valuePtr->error = move(error); valuePtr->error = std::move(error);
}; };
return {move(promise), move(keeper)}; return {std::move(promise), std::move(keeper)};
} }
template <typename Result, typename Error> template <typename Result, typename Error>
RpcThreadPromise<Result, Error> RpcThreadPromise<Result, Error>::createFulfilled(Result result) { RpcThreadPromise<Result, Error> RpcThreadPromise<Result, Error>::createFulfilled(Result result) {
auto valuePtr = make_shared<Value>(); auto valuePtr = make_shared<Value>();
valuePtr->result = move(result); valuePtr->result = std::move(result);
RpcThreadPromise<Result, Error> promise; RpcThreadPromise<Result, Error> promise;
promise.m_getValue = [valuePtr]() { promise.m_getValue = [valuePtr]() {
@ -115,7 +115,7 @@ RpcThreadPromise<Result, Error> RpcThreadPromise<Result, Error>::createFulfilled
template <typename Result, typename Error> template <typename Result, typename Error>
RpcThreadPromise<Result, Error> RpcThreadPromise<Result, Error>::createFailed(Error error) { RpcThreadPromise<Result, Error> RpcThreadPromise<Result, Error>::createFailed(Error error) {
auto valuePtr = make_shared<Value>(); auto valuePtr = make_shared<Value>();
valuePtr->error = move(error); valuePtr->error = std::move(error);
RpcThreadPromise<Result, Error> promise; RpcThreadPromise<Result, Error> promise;
promise.m_getValue = [valuePtr]() { promise.m_getValue = [valuePtr]() {

14
source/core/StarSectorArray2D.hpp
View File

@ -213,7 +213,7 @@ auto SectorArray2D<ElementT, SectorSize>::sector(Sector const& id) const -> Arra
template <typename ElementT, size_t SectorSize> template <typename ElementT, size_t SectorSize>
void SectorArray2D<ElementT, SectorSize>::loadSector(Sector const& id, ArrayPtr array) { void SectorArray2D<ElementT, SectorSize>::loadSector(Sector const& id, ArrayPtr array) {
auto& data = m_sectors(id[0], id[1]); auto& data = m_sectors(id[0], id[1]);
data = move(array); data = std::move(array);
if (data) if (data)
m_loadedSectors.add(id); m_loadedSectors.add(id);
else else
@ -224,7 +224,7 @@ template <typename ElementT, size_t SectorSize>
typename SectorArray2D<ElementT, SectorSize>::ArrayPtr SectorArray2D<ElementT, SectorSize>::copySector( typename SectorArray2D<ElementT, SectorSize>::ArrayPtr SectorArray2D<ElementT, SectorSize>::copySector(
Sector const& id) { Sector const& id) {
if (auto const& array = m_sectors(id)) if (auto const& array = m_sectors(id))
return make_unique<Array>(*array); return std::make_unique<Array>(*array);
else else
return {}; return {};
} }
@ -235,7 +235,7 @@ typename SectorArray2D<ElementT, SectorSize>::ArrayPtr SectorArray2D<ElementT, S
ArrayPtr ret; ArrayPtr ret;
m_loadedSectors.remove(id); m_loadedSectors.remove(id);
std::swap(m_sectors(id[0], id[1]), ret); std::swap(m_sectors(id[0], id[1]), ret);
return move(ret); return ret;
} }
template <typename ElementT, size_t SectorSize> template <typename ElementT, size_t SectorSize>
@ -268,14 +268,14 @@ template <typename ElementT, size_t SectorSize>
template <typename Function> template <typename Function>
bool SectorArray2D<ElementT, SectorSize>::eval( bool SectorArray2D<ElementT, SectorSize>::eval(
size_t minX, size_t minY, size_t width, size_t height, Function&& function, bool evalEmpty) const { size_t minX, size_t minY, size_t width, size_t height, Function&& function, bool evalEmpty) const {
return const_cast<SectorArray2D*>(this)->evalPriv(minX, minY, width, height, forward<Function>(function), evalEmpty); return const_cast<SectorArray2D*>(this)->evalPriv(minX, minY, width, height, std::forward<Function>(function), evalEmpty);
} }
template <typename ElementT, size_t SectorSize> template <typename ElementT, size_t SectorSize>
template <typename Function> template <typename Function>
bool SectorArray2D<ElementT, SectorSize>::eval( bool SectorArray2D<ElementT, SectorSize>::eval(
size_t minX, size_t minY, size_t width, size_t height, Function&& function, bool evalEmpty) { size_t minX, size_t minY, size_t width, size_t height, Function&& function, bool evalEmpty) {
return evalPriv(minX, minY, width, height, forward<Function>(function), evalEmpty); return evalPriv(minX, minY, width, height, std::forward<Function>(function), evalEmpty);
} }
template <typename ElementT, size_t SectorSize> template <typename ElementT, size_t SectorSize>
@ -283,14 +283,14 @@ template <typename Function>
bool SectorArray2D<ElementT, SectorSize>::evalColumns( bool SectorArray2D<ElementT, SectorSize>::evalColumns(
size_t minX, size_t minY, size_t width, size_t height, Function&& function, bool evalEmpty) const { size_t minX, size_t minY, size_t width, size_t height, Function&& function, bool evalEmpty) const {
return const_cast<SectorArray2D*>(this)->evalColumnsPriv( return const_cast<SectorArray2D*>(this)->evalColumnsPriv(
minX, minY, width, height, forward<Function>(function), evalEmpty); minX, minY, width, height, std::forward<Function>(function), evalEmpty);
} }
template <typename ElementT, size_t SectorSize> template <typename ElementT, size_t SectorSize>
template <typename Function> template <typename Function>
bool SectorArray2D<ElementT, SectorSize>::evalColumns( bool SectorArray2D<ElementT, SectorSize>::evalColumns(
size_t minX, size_t minY, size_t width, size_t height, Function&& function, bool evalEmpty) { size_t minX, size_t minY, size_t width, size_t height, Function&& function, bool evalEmpty) {
return evalColumnsPriv(minX, minY, width, height, forward<Function>(function), evalEmpty); return evalColumnsPriv(minX, minY, width, height, std::forward<Function>(function), evalEmpty);
} }
template <typename ElementT, size_t SectorSize> template <typename ElementT, size_t SectorSize>

14
source/core/StarSet.hpp
View File

@ -129,7 +129,7 @@ bool SetMixin<BaseSet>::add(value_type const& v) {
template <typename BaseSet> template <typename BaseSet>
bool SetMixin<BaseSet>::replace(value_type v) { bool SetMixin<BaseSet>::replace(value_type v) {
bool replaced = remove(v); bool replaced = remove(v);
Base::insert(move(v)); Base::insert(std::move(v));
return replaced; return replaced;
} }
@ -170,7 +170,7 @@ auto SetMixin<BaseSet>::takeFirst() -> value_type {
if (Base::empty()) if (Base::empty())
throw SetException("takeFirst called on empty set"); throw SetException("takeFirst called on empty set");
auto i = Base::begin(); auto i = Base::begin();
value_type v = move(*i); value_type v = std::move(*i);
Base::erase(i); Base::erase(i);
return v; return v;
} }
@ -180,9 +180,9 @@ auto SetMixin<BaseSet>::maybeTakeFirst() -> Maybe<value_type> {
if (Base::empty()) if (Base::empty())
return {}; return {};
auto i = Base::begin(); auto i = Base::begin();
value_type v = move(*i); value_type v = std::move(*i);
Base::erase(i); Base::erase(i);
return move(v); return std::move(v);
} }
template <typename BaseSet> template <typename BaseSet>
@ -204,7 +204,7 @@ auto SetMixin<BaseSet>::takeLast() -> value_type {
if (Base::empty()) if (Base::empty())
throw SetException("takeLast called on empty set"); throw SetException("takeLast called on empty set");
auto i = prev(Base::end()); auto i = prev(Base::end());
value_type v = move(*i); value_type v = std::move(*i);
Base::erase(i); Base::erase(i);
return v; return v;
} }
@ -214,9 +214,9 @@ auto SetMixin<BaseSet>::maybeTakeLast() -> Maybe<value_type> {
if (Base::empty()) if (Base::empty())
return {}; return {};
auto i = prev(Base::end()); auto i = prev(Base::end());
value_type v = move(*i); value_type v = std::move(*i);
Base::erase(i); Base::erase(i);
return move(v); return std::move(v);
} }
template <typename BaseSet> template <typename BaseSet>

2
source/core/StarShellParser.cpp
View File

@ -21,7 +21,7 @@ StringList ShellParser::tokenizeToStringList(String const& command) {
StringList res; StringList res;
for (auto token : tokenize(command)) { for (auto token : tokenize(command)) {
if (token.type == TokenType::Word) { if (token.type == TokenType::Word) {
res.append(move(token.token)); res.append(std::move(token.token));
} }
} }

24
source/core/StarSmallVector.hpp
View File

@ -122,7 +122,7 @@ template <typename Element, size_t MaxStackSize>
SmallVector<Element, MaxStackSize>::SmallVector(SmallVector&& other) SmallVector<Element, MaxStackSize>::SmallVector(SmallVector&& other)
: SmallVector() { : SmallVector() {
for (auto& e : other) for (auto& e : other)
emplace_back(move(e)); emplace_back(std::move(e));
} }
template <typename Element, size_t MaxStackSize> template <typename Element, size_t MaxStackSize>
@ -169,7 +169,7 @@ template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::operator=(SmallVector&& other) -> SmallVector& { auto SmallVector<Element, MaxStackSize>::operator=(SmallVector&& other) -> SmallVector& {
resize(other.size()); resize(other.size());
for (size_t i = 0; i < size(); ++i) for (size_t i = 0; i < size(); ++i)
operator[](i) = move(other[i]); operator[](i) = std::move(other[i]);
return *this; return *this;
} }
@ -178,7 +178,7 @@ template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::operator=(std::initializer_list<Element> list) -> SmallVector& { auto SmallVector<Element, MaxStackSize>::operator=(std::initializer_list<Element> list) -> SmallVector& {
resize(list.size()); resize(list.size());
for (size_t i = 0; i < size(); ++i) for (size_t i = 0; i < size(); ++i)
operator[](i) = move(list[i]); operator[](i) = std::move(list[i]);
return *this; return *this;
} }
@ -217,7 +217,7 @@ void SmallVector<Element, MaxStackSize>::reserve(size_t newCapacity) {
// We assume that move constructors can never throw. // We assume that move constructors can never throw.
for (size_t i = 0; i < size; ++i) { for (size_t i = 0; i < size; ++i) {
new (&newMem[i]) Element(move(oldMem[i])); new (&newMem[i]) Element(std::move(oldMem[i]));
} }
m_begin = newMem; m_begin = newMem;
@ -313,7 +313,7 @@ Element* SmallVector<Element, MaxStackSize>::ptr() {
template <typename Element, size_t MaxStackSize> template <typename Element, size_t MaxStackSize>
void SmallVector<Element, MaxStackSize>::push_back(Element e) { void SmallVector<Element, MaxStackSize>::push_back(Element e) {
emplace_back(move(e)); emplace_back(std::move(e));
} }
template <typename Element, size_t MaxStackSize> template <typename Element, size_t MaxStackSize>
@ -326,7 +326,7 @@ void SmallVector<Element, MaxStackSize>::pop_back() {
template <typename Element, size_t MaxStackSize> template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::insert(iterator pos, Element e) -> iterator { auto SmallVector<Element, MaxStackSize>::insert(iterator pos, Element e) -> iterator {
emplace(pos, move(e)); emplace(pos, std::move(e));
return pos; return pos;
} }
@ -341,7 +341,7 @@ auto SmallVector<Element, MaxStackSize>::insert(iterator pos, Iterator begin, It
resize(size() + toAdd); resize(size() + toAdd);
for (size_t i = toShift; i != 0; --i) for (size_t i = toShift; i != 0; --i)
operator[](endIndex + i - 1) = move(operator[](startIndex + i - 1)); operator[](endIndex + i - 1) = std::move(operator[](startIndex + i - 1));
for (size_t i = 0; i != toAdd; ++i) for (size_t i = 0; i != toAdd; ++i)
operator[](startIndex + i) = *begin++; operator[](startIndex + i) = *begin++;
@ -360,8 +360,8 @@ void SmallVector<Element, MaxStackSize>::emplace(iterator pos, Args&&... args) {
size_t index = pos - m_begin; size_t index = pos - m_begin;
emplace_back(Element()); emplace_back(Element());
for (size_t i = size() - 1; i != index; --i) for (size_t i = size() - 1; i != index; --i)
operator[](i) = move(operator[](i - 1)); operator[](i) = std::move(operator[](i - 1));
operator[](index) = Element(forward<Args>(args)...); operator[](index) = Element(std::forward<Args>(args)...);
} }
template <typename Element, size_t MaxStackSize> template <typename Element, size_t MaxStackSize>
@ -369,7 +369,7 @@ template <typename... Args>
void SmallVector<Element, MaxStackSize>::emplace_back(Args&&... args) { void SmallVector<Element, MaxStackSize>::emplace_back(Args&&... args) {
if (m_end == m_capacity) if (m_end == m_capacity)
reserve(size() + 1); reserve(size() + 1);
new (m_end) Element(forward<Args>(args)...); new (m_end) Element(std::forward<Args>(args)...);
++m_end; ++m_end;
} }
@ -383,7 +383,7 @@ template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::erase(iterator pos) -> iterator { auto SmallVector<Element, MaxStackSize>::erase(iterator pos) -> iterator {
size_t index = pos - ptr(); size_t index = pos - ptr();
for (size_t i = index; i < size() - 1; ++i) for (size_t i = index; i < size() - 1; ++i)
operator[](i) = move(operator[](i + 1)); operator[](i) = std::move(operator[](i + 1));
pop_back(); pop_back();
return pos; return pos;
} }
@ -394,7 +394,7 @@ auto SmallVector<Element, MaxStackSize>::erase(iterator begin, iterator end) ->
size_t endIndex = end - ptr(); size_t endIndex = end - ptr();
size_t toRemove = endIndex - startIndex; size_t toRemove = endIndex - startIndex;
for (size_t i = endIndex; i < size(); ++i) for (size_t i = endIndex; i < size(); ++i)
operator[](startIndex + (i - endIndex)) = move(operator[](i)); operator[](startIndex + (i - endIndex)) = std::move(operator[](i));
resize(size() - toRemove); resize(size() - toRemove);
return begin; return begin;
} }

2
source/core/StarSocket.cpp
View File

@ -96,7 +96,7 @@ Maybe<SocketPollResult> Socket::poll(SocketPollQuery const& query, unsigned time
pr.exception = pfd.revents & POLLHUP || pfd.revents & POLLNVAL || pfd.revents & POLLERR; pr.exception = pfd.revents & POLLHUP || pfd.revents & POLLNVAL || pfd.revents & POLLERR;
if (pfd.revents & POLLHUP) if (pfd.revents & POLLHUP)
p.first.first->doShutdown(); p.first.first->doShutdown();
result.add(p.first.first, move(pr)); result.add(p.first.first, std::move(pr));
} }
} }
#endif #endif

8
source/core/StarSpatialHash2D.hpp
View File

@ -239,19 +239,19 @@ void SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::set(Key con
template <typename KeyT, typename ScalarT, typename ValueT, typename IntT, size_t AllocatorBlockSize> template <typename KeyT, typename ScalarT, typename ValueT, typename IntT, size_t AllocatorBlockSize>
void SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::set(Key const& key, Coord const& pos, Value value) { void SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::set(Key const& key, Coord const& pos, Value value) {
set(key, {Rect(pos, pos)}, move(value)); set(key, {Rect(pos, pos)}, std::move(value));
} }
template <typename KeyT, typename ScalarT, typename ValueT, typename IntT, size_t AllocatorBlockSize> template <typename KeyT, typename ScalarT, typename ValueT, typename IntT, size_t AllocatorBlockSize>
void SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::set(Key const& key, Rect const& rect, Value value) { void SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::set(Key const& key, Rect const& rect, Value value) {
set(key, {rect}, move(value)); set(key, {rect}, std::move(value));
} }
template <typename KeyT, typename ScalarT, typename ValueT, typename IntT, size_t AllocatorBlockSize> template <typename KeyT, typename ScalarT, typename ValueT, typename IntT, size_t AllocatorBlockSize>
template <typename RectCollection> template <typename RectCollection>
void SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::set(Key const& key, RectCollection const& rects, Value value) { void SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::set(Key const& key, RectCollection const& rects, Value value) {
Entry& entry = m_entryMap[key]; Entry& entry = m_entryMap[key];
entry.value = move(value); entry.value = std::move(value);
updateSpatial(&entry, rects); updateSpatial(&entry, rects);
} }
@ -262,7 +262,7 @@ auto SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::remove(Key
return {}; return {};
removeSpatial(&iter->second); removeSpatial(&iter->second);
Maybe<Value> val = move(iter->second.value); Maybe<Value> val = std::move(iter->second.value);
m_entryMap.erase(iter); m_entryMap.erase(iter);
return val; return val;
} }

22
source/core/StarStaticVector.hpp
View File

@ -116,7 +116,7 @@ template <typename Element, size_t MaxSize>
StaticVector<Element, MaxSize>::StaticVector(StaticVector&& other) StaticVector<Element, MaxSize>::StaticVector(StaticVector&& other)
: StaticVector() { : StaticVector() {
for (auto& e : other) for (auto& e : other)
emplace_back(move(e)); emplace_back(std::move(e));
} }
template <typename Element, size_t MaxSize> template <typename Element, size_t MaxSize>
@ -163,7 +163,7 @@ template <typename Element, size_t MaxSize>
auto StaticVector<Element, MaxSize>::operator=(StaticVector&& other) -> StaticVector& { auto StaticVector<Element, MaxSize>::operator=(StaticVector&& other) -> StaticVector& {
resize(other.size()); resize(other.size());
for (size_t i = 0; i < m_size; ++i) for (size_t i = 0; i < m_size; ++i)
operator[](i) = move(other[i]); operator[](i) = std::move(other[i]);
return *this; return *this;
} }
@ -172,7 +172,7 @@ template <typename Element, size_t MaxSize>
auto StaticVector<Element, MaxSize>::operator=(std::initializer_list<Element> list) -> StaticVector& { auto StaticVector<Element, MaxSize>::operator=(std::initializer_list<Element> list) -> StaticVector& {
resize(list.size()); resize(list.size());
for (size_t i = 0; i < m_size; ++i) for (size_t i = 0; i < m_size; ++i)
operator[](i) = move(list[i]); operator[](i) = std::move(list[i]);
return *this; return *this;
} }
@ -275,7 +275,7 @@ Element* StaticVector<Element, MaxSize>::ptr() {
template <typename Element, size_t MaxSize> template <typename Element, size_t MaxSize>
void StaticVector<Element, MaxSize>::push_back(Element e) { void StaticVector<Element, MaxSize>::push_back(Element e) {
emplace_back(move(e)); emplace_back(std::move(e));
} }
template <typename Element, size_t MaxSize> template <typename Element, size_t MaxSize>
@ -288,7 +288,7 @@ void StaticVector<Element, MaxSize>::pop_back() {
template <typename Element, size_t MaxSize> template <typename Element, size_t MaxSize>
auto StaticVector<Element, MaxSize>::insert(iterator pos, Element e) -> iterator { auto StaticVector<Element, MaxSize>::insert(iterator pos, Element e) -> iterator {
emplace(pos, move(e)); emplace(pos, std::move(e));
return pos; return pos;
} }
@ -303,7 +303,7 @@ auto StaticVector<Element, MaxSize>::insert(iterator pos, Iterator begin, Iterat
resize(m_size + toAdd); resize(m_size + toAdd);
for (size_t i = toShift; i != 0; --i) for (size_t i = toShift; i != 0; --i)
operator[](endIndex + i - 1) = move(operator[](startIndex + i - 1)); operator[](endIndex + i - 1) = std::move(operator[](startIndex + i - 1));
for (size_t i = 0; i != toAdd; ++i) for (size_t i = 0; i != toAdd; ++i)
operator[](startIndex + i) = *begin++; operator[](startIndex + i) = *begin++;
@ -322,8 +322,8 @@ void StaticVector<Element, MaxSize>::emplace(iterator pos, Args&&... args) {
size_t index = pos - ptr(); size_t index = pos - ptr();
resize(m_size + 1); resize(m_size + 1);
for (size_t i = m_size - 1; i != index; --i) for (size_t i = m_size - 1; i != index; --i)
operator[](i) = move(operator[](i - 1)); operator[](i) = std::move(operator[](i - 1));
operator[](index) = Element(forward<Args>(args)...); operator[](index) = Element(std::forward<Args>(args)...);
} }
template <typename Element, size_t MaxSize> template <typename Element, size_t MaxSize>
@ -333,7 +333,7 @@ void StaticVector<Element, MaxSize>::emplace_back(Args&&... args) {
throw StaticVectorSizeException::format("StaticVector::emplace_back would extend StaticVector beyond size {}", MaxSize); throw StaticVectorSizeException::format("StaticVector::emplace_back would extend StaticVector beyond size {}", MaxSize);
m_size += 1; m_size += 1;
new (ptr() + m_size - 1) Element(forward<Args>(args)...); new (ptr() + m_size - 1) Element(std::forward<Args>(args)...);
} }
template <typename Element, size_t MaxSize> template <typename Element, size_t MaxSize>
@ -346,7 +346,7 @@ template <typename Element, size_t MaxSize>
auto StaticVector<Element, MaxSize>::erase(iterator pos) -> iterator { auto StaticVector<Element, MaxSize>::erase(iterator pos) -> iterator {
size_t index = pos - ptr(); size_t index = pos - ptr();
for (size_t i = index; i < m_size - 1; ++i) for (size_t i = index; i < m_size - 1; ++i)
operator[](i) = move(operator[](i + 1)); operator[](i) = std::move(operator[](i + 1));
resize(m_size - 1); resize(m_size - 1);
return pos; return pos;
} }
@ -357,7 +357,7 @@ auto StaticVector<Element, MaxSize>::erase(iterator begin, iterator end) -> iter
size_t endIndex = end - ptr(); size_t endIndex = end - ptr();
size_t toRemove = endIndex - startIndex; size_t toRemove = endIndex - startIndex;
for (size_t i = endIndex; i < m_size; ++i) for (size_t i = endIndex; i < m_size; ++i)
operator[](startIndex + (i - endIndex)) = move(operator[](i)); operator[](startIndex + (i - endIndex)) = std::move(operator[](i));
resize(m_size - toRemove); resize(m_size - toRemove);
return begin; return begin;
} }

18
source/core/StarString.cpp
View File

@ -343,7 +343,7 @@ StringList String::splitAny(String const& chars, size_t maxSplit) const {
} }
} }
if (!next.empty()) if (!next.empty())
ret.append(move(next)); ret.append(std::move(next));
return ret; return ret;
} }
@ -661,43 +661,43 @@ void String::append(Char c) {
void String::prepend(String const& s) { void String::prepend(String const& s) {
auto ns = s; auto ns = s;
ns.append(*this); ns.append(*this);
*this = move(ns); *this = std::move(ns);
} }
void String::prepend(std::string const& s) { void String::prepend(std::string const& s) {
auto ns = String(s); auto ns = String(s);
ns.append(*this); ns.append(*this);
*this = move(ns); *this = std::move(ns);
} }
void String::prepend(Char const* s) { void String::prepend(Char const* s) {
auto ns = String(s); auto ns = String(s);
ns.append(*this); ns.append(*this);
*this = move(ns); *this = std::move(ns);
} }
void String::prepend(Char const* s, size_t n) { void String::prepend(Char const* s, size_t n) {
auto ns = String(s, n); auto ns = String(s, n);
ns.append(*this); ns.append(*this);
*this = move(ns); *this = std::move(ns);
} }
void String::prepend(char const* s) { void String::prepend(char const* s) {
auto ns = String(s); auto ns = String(s);
ns.append(*this); ns.append(*this);
*this = move(ns); *this = std::move(ns);
} }
void String::prepend(char const* s, size_t n) { void String::prepend(char const* s, size_t n) {
auto ns = String(s, n); auto ns = String(s, n);
ns.append(*this); ns.append(*this);
*this = move(ns); *this = std::move(ns);
} }
void String::prepend(Char c) { void String::prepend(Char c) {
auto ns = String(c, 1); auto ns = String(c, 1);
ns.append(*this); ns.append(*this);
*this = move(ns); *this = std::move(ns);
} }
void String::push_back(Char c) { void String::push_back(Char c) {
@ -809,7 +809,7 @@ String& String::operator=(String const& s) {
} }
String& String::operator=(String&& s) { String& String::operator=(String&& s) {
m_string = move(s.m_string); m_string = std::move(s.m_string);
return *this; return *this;
} }

2
source/core/StarString.hpp
View File

@ -473,7 +473,7 @@ Maybe<String> String::maybeLookupTagsView(Lookup&& lookup) const {
template <typename Lookup> template <typename Lookup>
String String::lookupTagsView(Lookup&& lookup) const { String String::lookupTagsView(Lookup&& lookup) const {
auto result = maybeLookupTagsView(lookup); auto result = maybeLookupTagsView(lookup);
return result ? move(result.take()) : String(); return result ? std::move(result.take()) : String();
} }
template <typename MapType> template <typename MapType>

4
source/core/StarStringView.cpp
View File

@ -17,13 +17,13 @@ String& String::operator+=(std::string_view s) {
StringView::StringView() {} StringView::StringView() {}
StringView::StringView(StringView const& s) : m_view(s.m_view) {} StringView::StringView(StringView const& s) : m_view(s.m_view) {}
StringView::StringView(StringView&& s) noexcept : m_view(move(s.m_view)) {}; StringView::StringView(StringView&& s) noexcept : m_view(std::move(s.m_view)) {};
StringView::StringView(String const& s) : m_view(s.utf8()) {}; StringView::StringView(String const& s) : m_view(s.utf8()) {};
StringView::StringView(char const* s) : m_view(s) {}; StringView::StringView(char const* s) : m_view(s) {};
StringView::StringView(char const* s, size_t n) : m_view(s, n) {}; StringView::StringView(char const* s, size_t n) : m_view(s, n) {};
StringView::StringView(std::string_view const& s) : m_view(s) {}; StringView::StringView(std::string_view const& s) : m_view(s) {};
StringView::StringView(std::string_view&& s) noexcept : m_view(move(s)) {}; StringView::StringView(std::string_view&& s) noexcept : m_view(std::move(s)) {};
StringView::StringView(std::string const& s) : m_view(s) {} StringView::StringView(std::string const& s) : m_view(s) {}
StringView::StringView(Char const* s) : m_view((char const*)s, sizeof(*s)) {} StringView::StringView(Char const* s) : m_view((char const*)s, sizeof(*s)) {}

4
source/core/StarThread.hpp
View File

@ -352,7 +352,7 @@ bool MLocker<MutexType>::tryLock() {
template <typename Function, typename... Args> template <typename Function, typename... Args>
ThreadFunction<decltype(std::declval<Function>()(std::declval<Args>()...))> Thread::invoke(String const& name, Function&& f, Args&&... args) { ThreadFunction<decltype(std::declval<Function>()(std::declval<Args>()...))> Thread::invoke(String const& name, Function&& f, Args&&... args) {
return {bind(forward<Function>(f), forward<Args>(args)...), name}; return {bind(std::forward<Function>(f), std::forward<Args>(args)...), name};
} }
template <typename Return> template <typename Return>
@ -364,7 +364,7 @@ ThreadFunction<Return>::ThreadFunction(ThreadFunction&&) = default;
template <typename Return> template <typename Return>
ThreadFunction<Return>::ThreadFunction(function<Return()> function, String const& name) { ThreadFunction<Return>::ThreadFunction(function<Return()> function, String const& name) {
m_return = make_shared<Maybe<Return>>(); m_return = make_shared<Maybe<Return>>();
m_function = ThreadFunction<void>([function = move(function), retValue = m_return]() { m_function = ThreadFunction<void>([function = std::move(function), retValue = m_return]() {
*retValue = function(); *retValue = function();
}, name); }, name);
} }

6
source/core/StarThread_unix.cpp
View File

@ -101,10 +101,10 @@ struct ThreadImpl {
struct ThreadFunctionImpl : ThreadImpl { struct ThreadFunctionImpl : ThreadImpl {
ThreadFunctionImpl(std::function<void()> function, String name) ThreadFunctionImpl(std::function<void()> function, String name)
: ThreadImpl(wrapFunction(move(function)), move(name)) {} : ThreadImpl(wrapFunction(std::move(function)), std::move(name)) {}
std::function<void()> wrapFunction(std::function<void()> function) { std::function<void()> wrapFunction(std::function<void()> function) {
return [function = move(function), this]() { return [function = std::move(function), this]() {
try { try {
function(); function();
} catch (...) { } catch (...) {
@ -283,7 +283,7 @@ ThreadFunction<void>::ThreadFunction() {}
ThreadFunction<void>::ThreadFunction(ThreadFunction&&) = default; ThreadFunction<void>::ThreadFunction(ThreadFunction&&) = default;
ThreadFunction<void>::ThreadFunction(function<void()> function, String const& name) { ThreadFunction<void>::ThreadFunction(function<void()> function, String const& name) {
m_impl.reset(new ThreadFunctionImpl(move(function), name)); m_impl.reset(new ThreadFunctionImpl(std::move(function), name));
m_impl->start(); m_impl->start();
} }

6
source/core/StarThread_windows.cpp
View File

@ -106,10 +106,10 @@ private:
struct ThreadFunctionImpl : ThreadImpl { struct ThreadFunctionImpl : ThreadImpl {
ThreadFunctionImpl(std::function<void()> function, String name) ThreadFunctionImpl(std::function<void()> function, String name)
: ThreadImpl(wrapFunction(move(function)), move(name)) {} : ThreadImpl(wrapFunction(std::move(function)), std::move(name)) {}
std::function<void()> wrapFunction(std::function<void()> function) { std::function<void()> wrapFunction(std::function<void()> function) {
return [function = move(function), this]() { return [function = std::move(function), this]() {
try { try {
function(); function();
} catch (...) { } catch (...) {
@ -437,7 +437,7 @@ ThreadFunction<void>::ThreadFunction() {}
ThreadFunction<void>::ThreadFunction(ThreadFunction&&) = default; ThreadFunction<void>::ThreadFunction(ThreadFunction&&) = default;
ThreadFunction<void>::ThreadFunction(function<void()> function, String const& name) { ThreadFunction<void>::ThreadFunction(function<void()> function, String const& name) {
m_impl.reset(new ThreadFunctionImpl(move(function), name)); m_impl.reset(new ThreadFunctionImpl(std::move(function), name));
m_impl->start(); m_impl->start();
} }

2
source/core/StarTtlCache.hpp
View File

@ -134,7 +134,7 @@ template <typename LruCacheType>
auto TtlCacheBase<LruCacheType>::values() const -> List<Value> { auto TtlCacheBase<LruCacheType>::values() const -> List<Value> {
List<Value> values; List<Value> values;
for (auto& p : m_cache.values()) for (auto& p : m_cache.values())
values.append(move(p.second)); values.append(std::move(p.second));
return values; return values;
} }

56
source/core/StarVariant.hpp
View File

@ -75,7 +75,7 @@ public:
typename std::enable_if< std::is_constructible<T, Args...>::value, int >::type = 0 typename std::enable_if< std::is_constructible<T, Args...>::value, int >::type = 0
> >
Variant(std::in_place_type_t<T>, Args&&... args) { Variant(std::in_place_type_t<T>, Args&&... args) {
new (&m_buffer) T(forward<Args>(args)...); new (&m_buffer) T(std::forward<Args>(args)...);
m_typeIndex = TypeIndex<T>::value; m_typeIndex = TypeIndex<T>::value;
} }
@ -83,7 +83,7 @@ public:
typename std::enable_if< std::is_constructible<T, std::initializer_list<U>&, Args...>::value, int >::type = 0 typename std::enable_if< std::is_constructible<T, std::initializer_list<U>&, Args...>::value, int >::type = 0
> >
Variant(std::in_place_type_t<T>, std::initializer_list<U> il, Args&&... args) { Variant(std::in_place_type_t<T>, std::initializer_list<U> il, Args&&... args) {
new (&m_buffer) T(il, forward<Args>(args)...); new (&m_buffer) T(il, std::forward<Args>(args)...);
m_typeIndex = TypeIndex<T>::value; m_typeIndex = TypeIndex<T>::value;
} }
@ -373,12 +373,12 @@ Variant<FirstType, RestTypes...>::Variant(T const& x) {
template <typename FirstType, typename... RestTypes> template <typename FirstType, typename... RestTypes>
template <typename T, typename> template <typename T, typename>
Variant<FirstType, RestTypes...>::Variant(T&& x) { Variant<FirstType, RestTypes...>::Variant(T&& x) {
assign(forward<T>(x)); assign(std::forward<T>(x));
} }
template <typename FirstType, typename... RestTypes> template <typename FirstType, typename... RestTypes>
Variant<FirstType, RestTypes...>::Variant(Variant const& x) { Variant<FirstType, RestTypes...>::Variant(Variant const& x) {
x.call([this](auto const& t) { x.call([&](auto const& t) {
assign(t); assign(t);
}); });
} }
@ -386,8 +386,8 @@ Variant<FirstType, RestTypes...>::Variant(Variant const& x) {
template <typename FirstType, typename... RestTypes> template <typename FirstType, typename... RestTypes>
Variant<FirstType, RestTypes...>::Variant(Variant&& x) Variant<FirstType, RestTypes...>::Variant(Variant&& x)
noexcept(detail::IsNothrowMoveConstructible<FirstType, RestTypes...>::value) { noexcept(detail::IsNothrowMoveConstructible<FirstType, RestTypes...>::value) {
x.call([this](auto& t) { x.call([&](auto& t) {
assign(move(t)); assign(std::move(t));
}); });
} }
@ -401,7 +401,7 @@ Variant<FirstType, RestTypes...>& Variant<FirstType, RestTypes...>::operator=(Va
if (&x == this) if (&x == this)
return *this; return *this;
x.call([this](auto const& t) { x.call([&](auto const& t) {
assign(t); assign(t);
}); });
@ -414,8 +414,8 @@ Variant<FirstType, RestTypes...>& Variant<FirstType, RestTypes...>::operator=(Va
if (&x == this) if (&x == this)
return *this; return *this;
x.call([this](auto& t) { x.call([&](auto& t) {
assign(move(t)); assign(std::move(t));
}); });
return *this; return *this;
@ -431,7 +431,7 @@ Variant<FirstType, RestTypes...>& Variant<FirstType, RestTypes...>::operator=(T
template <typename FirstType, typename... RestTypes> template <typename FirstType, typename... RestTypes>
template <typename T, typename> template <typename T, typename>
Variant<FirstType, RestTypes...>& Variant<FirstType, RestTypes...>::operator=(T&& x) { Variant<FirstType, RestTypes...>& Variant<FirstType, RestTypes...>::operator=(T&& x) {
assign(forward<T>(x)); assign(std::forward<T>(x));
return *this; return *this;
} }
@ -484,13 +484,13 @@ bool Variant<FirstType, RestTypes...>::is() const {
template <typename FirstType, typename... RestTypes> template <typename FirstType, typename... RestTypes>
template <typename Function> template <typename Function>
decltype(auto) Variant<FirstType, RestTypes...>::call(Function&& function) { decltype(auto) Variant<FirstType, RestTypes...>::call(Function&& function) {
return doCall<Function, FirstType, RestTypes...>(forward<Function>(function)); return doCall<Function, FirstType, RestTypes...>(std::forward<Function>(function));
} }
template <typename FirstType, typename... RestTypes> template <typename FirstType, typename... RestTypes>
template <typename Function> template <typename Function>
decltype(auto) Variant<FirstType, RestTypes...>::call(Function&& function) const { decltype(auto) Variant<FirstType, RestTypes...>::call(Function&& function) const {
return doCall<Function, FirstType, RestTypes...>(forward<Function>(function)); return doCall<Function, FirstType, RestTypes...>(std::forward<Function>(function));
} }
template <typename FirstType, typename... RestTypes> template <typename FirstType, typename... RestTypes>
@ -588,10 +588,10 @@ template <typename T>
void Variant<FirstType, RestTypes...>::assign(T&& x) { void Variant<FirstType, RestTypes...>::assign(T&& x) {
typedef typename std::decay<T>::type AssignType; typedef typename std::decay<T>::type AssignType;
if (auto p = ptr<AssignType>()) { if (auto p = ptr<AssignType>()) {
*p = forward<T>(x); *p = std::forward<T>(x);
} else { } else {
destruct(); destruct();
new (&m_buffer) AssignType(forward<T>(x)); new (&m_buffer) AssignType(std::forward<T>(x));
m_typeIndex = TypeIndex<AssignType>::value; m_typeIndex = TypeIndex<AssignType>::value;
} }
} }
@ -611,7 +611,7 @@ decltype(auto) Variant<FirstType, RestTypes...>::doCall(Function&& function) {
if (T1* p = ptr<T1>()) if (T1* p = ptr<T1>())
return function(*p); return function(*p);
else else
return doCall<Function, T2, TL...>(forward<Function>(function)); return doCall<Function, T2, TL...>(std::forward<Function>(function));
} }
template <typename FirstType, typename... RestTypes> template <typename FirstType, typename... RestTypes>
@ -629,7 +629,7 @@ decltype(auto) Variant<FirstType, RestTypes...>::doCall(Function&& function) con
if (T1 const* p = ptr<T1>()) if (T1 const* p = ptr<T1>())
return function(*p); return function(*p);
else else
return doCall<Function, T2, TL...>(forward<Function>(function)); return doCall<Function, T2, TL...>(std::forward<Function>(function));
} }
template <typename FirstType, typename... RestTypes> template <typename FirstType, typename... RestTypes>
@ -665,7 +665,7 @@ MVariant<Types...>::MVariant(MVariant const& x)
template <typename... Types> template <typename... Types>
MVariant<Types...>::MVariant(MVariant&& x) { MVariant<Types...>::MVariant(MVariant&& x) {
m_variant = move(x.m_variant); m_variant = std::move(x.m_variant);
x.m_variant = MVariantEmpty(); x.m_variant = MVariantEmpty();
} }
@ -676,7 +676,7 @@ MVariant<Types...>::MVariant(Variant<Types...> const& x) {
template <typename... Types> template <typename... Types>
MVariant<Types...>::MVariant(Variant<Types...>&& x) { MVariant<Types...>::MVariant(Variant<Types...>&& x) {
operator=(move(x)); operator=(std::move(x));
} }
template <typename... Types> template <typename... Types>
@ -687,7 +687,7 @@ MVariant<Types...>::MVariant(T const& x)
template <typename... Types> template <typename... Types>
template <typename T, typename> template <typename T, typename>
MVariant<Types...>::MVariant(T&& x) MVariant<Types...>::MVariant(T&& x)
: m_variant(forward<T>(x)) {} : m_variant(std::forward<T>(x)) {}
template <typename... Types> template <typename... Types>
MVariant<Types...>::~MVariant() {} MVariant<Types...>::~MVariant() {}
@ -707,7 +707,7 @@ MVariant<Types...>& MVariant<Types...>::operator=(MVariant const& x) {
template <typename... Types> template <typename... Types>
MVariant<Types...>& MVariant<Types...>::operator=(MVariant&& x) { MVariant<Types...>& MVariant<Types...>::operator=(MVariant&& x) {
try { try {
m_variant = move(x.m_variant); m_variant = std::move(x.m_variant);
} catch (...) { } catch (...) {
if (m_variant.invalid()) if (m_variant.invalid())
m_variant = MVariantEmpty(); m_variant = MVariantEmpty();
@ -733,7 +733,7 @@ template <typename... Types>
template <typename T, typename> template <typename T, typename>
MVariant<Types...>& MVariant<Types...>::operator=(T&& x) { MVariant<Types...>& MVariant<Types...>::operator=(T&& x) {
try { try {
m_variant = forward<T>(x); m_variant = std::forward<T>(x);
} catch (...) { } catch (...) {
if (m_variant.invalid()) if (m_variant.invalid())
m_variant = MVariantEmpty(); m_variant = MVariantEmpty();
@ -753,7 +753,7 @@ MVariant<Types...>& MVariant<Types...>::operator=(Variant<Types...> const& x) {
template <typename... Types> template <typename... Types>
MVariant<Types...>& MVariant<Types...>::operator=(Variant<Types...>&& x) { MVariant<Types...>& MVariant<Types...>::operator=(Variant<Types...>&& x) {
x.call([this](auto& t) { x.call([this](auto& t) {
*this = move(t); *this = std::move(t);
}); });
return *this; return *this;
} }
@ -830,7 +830,7 @@ bool MVariant<Types...>::is() const {
template <typename... Types> template <typename... Types>
template <typename T, typename> template <typename T, typename>
T MVariant<Types...>::take() { T MVariant<Types...>::take() {
T t = move(m_variant.template get<T>()); T t = std::move(m_variant.template get<T>());
m_variant = MVariantEmpty(); m_variant = MVariantEmpty();
return t; return t;
} }
@ -854,7 +854,7 @@ Variant<Types...> MVariant<Types...>::takeValue() {
Variant<Types...> r; Variant<Types...> r;
call([&r](auto& v) { call([&r](auto& v) {
r = move(v); r = std::move(v);
}); });
m_variant = MVariantEmpty(); m_variant = MVariantEmpty();
return r; return r;
@ -878,13 +878,13 @@ MVariant<Types...>::operator bool() const {
template <typename... Types> template <typename... Types>
template <typename Function> template <typename Function>
void MVariant<Types...>::call(Function&& function) { void MVariant<Types...>::call(Function&& function) {
m_variant.call(RefCaller<Function>(forward<Function>(function))); m_variant.call(RefCaller<Function>(std::forward<Function>(function)));
} }
template <typename... Types> template <typename... Types>
template <typename Function> template <typename Function>
void MVariant<Types...>::call(Function&& function) const { void MVariant<Types...>::call(Function&& function) const {
m_variant.call(ConstRefCaller<Function>(forward<Function>(function))); m_variant.call(ConstRefCaller<Function>(std::forward<Function>(function)));
} }
template <typename... Types> template <typename... Types>
@ -910,7 +910,7 @@ bool MVariant<Types...>::MVariantEmpty::operator<(MVariantEmpty const&) const {
template <typename... Types> template <typename... Types>
template <typename Function> template <typename Function>
MVariant<Types...>::RefCaller<Function>::RefCaller(Function&& function) MVariant<Types...>::RefCaller<Function>::RefCaller(Function&& function)
: function(forward<Function>(function)) {} : function(std::forward<Function>(function)) {}
template <typename... Types> template <typename... Types>
template <typename Function> template <typename Function>
@ -926,7 +926,7 @@ void MVariant<Types...>::RefCaller<Function>::operator()(T& t) {
template <typename... Types> template <typename... Types>
template <typename Function> template <typename Function>
MVariant<Types...>::ConstRefCaller<Function>::ConstRefCaller(Function&& function) MVariant<Types...>::ConstRefCaller<Function>::ConstRefCaller(Function&& function)
: function(forward<Function>(function)) {} : function(std::forward<Function>(function)) {}
template <typename... Types> template <typename... Types>
template <typename Function> template <typename Function>

2
source/core/StarWeightedPool.hpp
View File

@ -69,7 +69,7 @@ void WeightedPool<Item>::add(double weight, Item item) {
if (weight <= 0.0) if (weight <= 0.0)
return; return;
m_items.append({weight, move(item)}); m_items.append({weight, std::move(item)});
m_totalWeight += weight; m_totalWeight += weight;
} }

Some files were not shown because too many files have changed in this diff Show More