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

Fixed a huge amount of Clang warnings

Browse Source 
On Linux and macOS, using Clang to compile OpenStarbound produces about 400 MB worth of warnings during the build, making the compiler output unreadable and slowing the build down considerably.

99% of the warnings were unqualified uses of std::move and std::forward, which are now all properly qualified.

Fixed a few other minor warnings about non-virtual destructors and some uses of std::move preventing copy elision on temporary objects.

Most remaining warnings are now unused parameters.
This commit is contained in:
Kai Blaschke 2024-02-19 16:55:19 +01:00
parent 30e1871d3f
commit 431a9c00a5
No known key found for this signature in database
GPG Key ID: B014B6811527389F
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")
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_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -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 -Wall -Wextra -Wuninitialized -Wno-parentheses-equality -Wno-deprecated-declarations")
IF (STAR_SYSTEM_MACOS)
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_LIBRARY "libc++")
ELSEIF ()
SET (CMAKE_C_FLAGS "${CMAKE_C_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 ()
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::applicationInit(ApplicationControllerPtr appController) {
m_appController = move(appController);
m_appController = std::move(appController);
}
void Application::renderInit(RendererPtr renderer) {
m_renderer = move(renderer);
m_renderer = std::move(renderer);
}
void Application::windowChanged(WindowMode, Vec2U) {}

14
source/application/StarMainApplication_sdl.cpp
View File

@ -206,7 +206,7 @@ ControllerButton controllerButtonFromSdlControllerButton(uint8_t button) {
class SdlPlatform {
public:
SdlPlatform(ApplicationUPtr application, StringList cmdLineArgs) {
m_application = move(application);
m_application = std::move(application);
// extract application path from command line args
String applicationPath = cmdLineArgs.first();
@ -215,7 +215,7 @@ public:
StringList platformArguments;
eraseWhere(cmdLineArgs, [&platformArguments](String& argument) {
if (argument.beginsWith("+platform")) {
platformArguments.append(move(argument));
platformArguments.append(std::move(argument));
return true;
}
return false;
@ -461,7 +461,7 @@ private:
Maybe<String> string;
if (SDL_HasClipboardText()) {
if (auto text = SDL_GetClipboardText()) {
if (*text != NULL)
if (*text != '\0')
string.emplace(text);
SDL_free(text);
}
@ -482,7 +482,7 @@ private:
}
void setApplicationTitle(String title) override {
parent->m_windowTitle = move(title);
parent->m_windowTitle = std::move(title);
if (parent->m_sdlWindow)
SDL_SetWindowTitle(parent->m_sdlWindow, parent->m_windowTitle.utf8Ptr());
}
@ -817,10 +817,10 @@ private:
else
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!)
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();
@ -907,7 +907,7 @@ private:
int runMainApplication(ApplicationUPtr application, StringList cmdLineArgs) {
try {
{
SdlPlatform platform(move(application), move(cmdLineArgs));
SdlPlatform platform(std::move(application), std::move(cmdLineArgs));
platform.run();
}
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_callbackJoinRequested(this, &PcP2PNetworkingService::steamOnJoinRequested),
m_callbackSessionRequest(this, &PcP2PNetworkingService::steamOnSessionRequest),
m_state(move(state)) {
m_state(std::move(state)) {
#else
: m_state(move(state)) {
: m_state(std::move(state)) {
#endif
#ifdef STAR_ENABLE_DISCORD_INTEGRATION
@ -224,7 +224,7 @@ Either<String, P2PSocketUPtr> PcP2PNetworkingService::connectToPeer(P2PNetworkin
if (type == "discord") {
auto remoteUserId = lexicalCast<discord::UserId>(peerId.extract("_"));
auto lobbyId = lexicalCast<discord::LobbyId>(peerId.extract("_"));
String lobbySecret = move(peerId);
String lobbySecret = std::move(peerId);
return makeRight(discordConnectRemote(remoteUserId, lobbyId, lobbySecret));
}
}
@ -242,7 +242,7 @@ void PcP2PNetworkingService::addPendingJoin(String connectionString) {
if (connectionString.extract(":") != "connect")
throw ApplicationException::format("malformed connection string '{}'", connectionString);
String target = move(connectionString);
String target = std::move(connectionString);
String targetType = target.extract("_");
if (targetType == "address")
@ -357,7 +357,7 @@ void PcP2PNetworkingService::steamReceiveAll() {
SteamNetworking()->ReadP2PPacket(data.ptr(), messageSize, &messageSize, &messageRemoteUser);
if (auto openSocket = m_steamOpenSockets.value(messageRemoteUser.ConvertToUint64())) {
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) {
@ -507,7 +507,7 @@ void PcP2PNetworkingService::discordOnLobbyMemberConnect(discord::LobbyId lobbyI
socket->mode = DiscordSocketMode::Connected;
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);
}
}

2
source/application/StarPlatformServices_pc.cpp
View File

@ -118,7 +118,7 @@ PcPlatformServicesUPtr PcPlatformServices::create(String const& path, StringList
for (auto& argument : platformArguments) {
if (argument.beginsWith("+platform:connect:")) {
Logger::info("PC platform services joining from command line argument '{}'", argument);
p2pNetworkingService->addPendingJoin(move(argument));
p2pNetworkingService->addPendingJoin(std::move(argument));
} else {
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 };
}
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());
a = { minPosition, { 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 };
}
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());
a = { screenCoords.min(), { 0, 0 }, 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 };
}
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 };
b = { posB, uvB, 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)
: 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)
: 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 };
}
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 };
b = { posB, uvB, color, param1 };
c = { posC, uvC, color, 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) {
return RenderQuad(move(texture), screenCoords, color, param1);
return RenderQuad(std::move(texture), screenCoords, color, 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) {
m_immediatePrimitives.append(move(primitive));
m_immediatePrimitives.append(std::move(primitive));
}
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);
}
vertexBuffers.emplace_back(move(vb));
vertexBuffers.emplace_back(std::move(vb));
currentTextures.clear();
currentTextureSizes.clear();
@ -701,7 +701,7 @@ void OpenGl20Renderer::GlRenderBuffer::set(List<RenderPrimitive>& primitives) {
if (auto gt = as<GlGroupedTexture>(texture.get()))
gt->incrementBufferUseCount();
usedTextures.add(move(texture));
usedTextures.add(std::move(texture));
return {float(textureIndex), Vec2F(glTexture->glTextureCoordinateOffset())};
};
@ -723,14 +723,14 @@ void OpenGl20Renderer::GlRenderBuffer::set(List<RenderPrimitive>& primitives) {
Texture* lastTexture = nullptr;
for (auto& primitive : primitives) {
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->b, textureIndex, textureOffset);
appendBufferVertex(tri->c, textureIndex, textureOffset);
} 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->b, textureIndex, textureOffset);
@ -742,7 +742,7 @@ void OpenGl20Renderer::GlRenderBuffer::set(List<RenderPrimitive>& primitives) {
} else if (auto poly = primitive.ptr<RenderPoly>()) {
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) {
appendBufferVertex(poly->vertexes[0], textureIndex, textureOffset);

6
source/application/StarTextureAtlas.hpp
View File

@ -33,6 +33,8 @@ public:
TextureAtlasSet(unsigned cellSize, unsigned atlasNumCells);
virtual ~TextureAtlasSet() = default;
// The constant square size of all atlas textures
Vec2U atlasTextureSize() const;
@ -88,6 +90,8 @@ private:
};
struct TextureEntry : Texture {
virtual ~TextureEntry() = default;
Vec2U imageSize() const override;
AtlasTextureHandle const& atlasTexture() const override;
@ -168,7 +172,7 @@ auto TextureAtlasSet<AtlasTextureHandle>::addTexture(Image const& image, bool bo
return nullptr;
auto textureEntry = make_shared<TextureEntry>();
textureEntry->textureImage = move(finalImage);
textureEntry->textureImage = std::move(finalImage);
textureEntry->atlasPlacement = *placement;
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->stateProperties = stateConfig.getObject("properties", {});
newState->stateFrameProperties = stateConfig.getObject("frameProperties", {});
newStateType.states[stateName] = move(newState);
newStateType.states[stateName] = std::move(newState);
}
newStateType.states.sortByKey();
@ -38,7 +38,7 @@ AnimatedPartSet::AnimatedPartSet(Json config) {
if (newStateType.defaultState.empty() && !newStateType.states.empty())
newStateType.defaultState = newStateType.states.firstKey();
m_stateTypes[stateTypeName] = move(newStateType);
m_stateTypes[stateTypeName] = std::move(newStateType);
}
// Sort state types by decreasing priority.
@ -61,13 +61,13 @@ AnimatedPartSet::AnimatedPartSet(Json config) {
auto const& stateConfig = partStatePair.second;
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.activePartDirty = true;
m_parts[partName] = move(newPart);
m_parts[partName] = std::move(newPart);
}
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) {
const char* const AssetsPatchSuffix = ".patch";
m_settings = move(settings);
m_settings = std::move(settings);
m_stopThreads = false;
m_assetSources = move(assetSources);
m_assetSources = std::move(assetSources);
for (auto& sourcePath : m_assetSources) {
Logger::info("Loading assets from: '{}'", sourcePath);
AssetSourcePtr source;
if (File::isDirectory(sourcePath))
source = make_shared<DirectoryAssetSource>(sourcePath, m_settings.pathIgnore);
source = std::make_shared<DirectoryAssetSource>(sourcePath, m_settings.pathIgnore);
else
source = make_shared<PackedAssetSource>(sourcePath);
source = std::make_shared<PackedAssetSource>(sourcePath);
m_assetSourcePaths.add(sourcePath, source);
@ -225,7 +225,7 @@ Json Assets::json(String const& path) const {
auto components = AssetPath::split(path);
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 {
@ -255,7 +255,7 @@ void Assets::queueImages(StringList const& paths) const {
auto components = AssetPath::split(path);
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);
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 {
@ -288,7 +288,7 @@ void Assets::queueAudios(StringList const& paths) const {
const auto components = AssetPath::split(path);
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);
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;
else
return {};
@ -306,14 +306,14 @@ FontConstPtr Assets::font(String const& path) const {
auto components = AssetPath::split(path);
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 {
auto components = AssetPath::split(path);
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 {
@ -386,7 +386,7 @@ bool Assets::BytesData::shouldPersist() const {
FramesSpecification Assets::parseFramesSpecification(Json const& frameConfig, String path) {
FramesSpecification framesSpecification;
framesSpecification.framesFile = move(path);
framesSpecification.framesFile = std::move(path);
if (frameConfig.contains("frameList")) {
for (auto const& pair : frameConfig.get("frameList").toObject()) {
@ -469,7 +469,7 @@ FramesSpecification Assets::parseFramesSpecification(Json const& frameConfig, St
if (!framesSpecification.frames.contains(value))
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) {
auto components = AssetPath::split(ref);
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)
return {};
references[ref] = refImage->image;
@ -881,7 +881,7 @@ shared_ptr<Assets::AssetData> Assets::loadImage(AssetPath const& path) const {
else
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;
});

4
source/base/StarDirectoryAssetSource.cpp
View File

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

6
source/client/StarClientApplication.cpp
View File

@ -607,7 +607,7 @@ void ClientApplication::changeState(MainAppState newState) {
setError(strf("Cannot join peer: {}", result.left()));
return;
} else {
packetSocket = P2PPacketSocket::open(move(result.right()));
packetSocket = P2PPacketSocket::open(std::move(result.right()));
}
} else {
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();
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)) {
setError(*errorMessage);
return;
@ -951,7 +951,7 @@ void ClientApplication::updateRunning(float dt) {
if (m_universeServer) {
if (auto p2pNetworkingService = appController()->p2pNetworkingService()) {
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());

6
source/core/StarAStar.hpp
View File

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

68
source/core/StarAlgorithm.hpp
View File

@ -14,7 +14,7 @@ template <typename ToType>
struct construct {
template <typename... FromTypes>
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 {
template <typename... T>
void operator()(T&&... args) {
func(forward<T>(args)...);
func(std::forward<T>(args)...);
}
Func func;
@ -37,7 +37,7 @@ struct SwallowReturn {
template <typename Func>
SwallowReturn<Func> swallow(Func f) {
return SwallowReturn<Func>{move(f)};
return SwallowReturn<Func>{std::move(f)};
}
struct Empty {
@ -58,18 +58,18 @@ struct FunctionComposer {
template <typename... T>
decltype(auto) operator()(T&&... args) {
return f1(f2(forward<T>(args)...));
return f1(f2(std::forward<T>(args)...));
}
};
template <typename FirstFunction, typename 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>
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>
@ -260,7 +260,7 @@ void sortByComputedValue(Container& container, Getter&& valueGetter, bool stable
template <typename Container, typename Getter>
void stableSortByComputedValue(Container& container, Getter&& valueGetter) {
return sortByComputedValue(container, forward<Getter>(valueGetter), true);
return sortByComputedValue(container, std::forward<Getter>(valueGetter), true);
}
template <typename Container>
@ -293,7 +293,7 @@ template <typename OutContainer, typename InContainer, typename Function>
void transformInto(OutContainer& outContainer, InContainer&& inContainer, Function&& function) {
for (auto&& elem : inContainer) {
if (std::is_rvalue_reference<InContainer&&>::value)
outContainer.insert(outContainer.end(), function(move(elem)));
outContainer.insert(outContainer.end(), function(std::move(elem)));
else
outContainer.insert(outContainer.end(), function(elem));
}
@ -302,7 +302,7 @@ void transformInto(OutContainer& outContainer, InContainer&& inContainer, Functi
template <typename OutContainer, typename InContainer, typename Function>
OutContainer transform(InContainer&& container, Function&& function) {
OutContainer res;
transformInto(res, forward<InContainer>(container), forward<Function>(function));
transformInto(res, std::forward<InContainer>(container), std::forward<Function>(function));
return res;
}
@ -326,7 +326,7 @@ OutputContainer zipWith(Function&& function, Container1 const& cont1, Container2
// default constructed state.
template <typename T>
T take(T& t) {
T t2 = move(t);
T t2 = std::move(t);
t = T();
return t2;
}
@ -356,7 +356,7 @@ public:
template <typename T>
OutputProxy& operator=(T&& value) {
m_function(forward<T>(value));
m_function(std::forward<T>(value));
return *this;
}
@ -365,7 +365,7 @@ public:
};
explicit FunctionOutputIterator(UnaryFunction f = UnaryFunction())
: m_function(move(f)) {}
: m_function(std::move(f)) {}
OutputProxy operator*() {
return OutputProxy(m_function);
@ -385,7 +385,7 @@ private:
template <typename UnaryFunction>
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
@ -401,7 +401,7 @@ public:
typedef typename std::result_of<NullaryFunction()>::type FunctionReturnType;
explicit FunctionInputIterator(NullaryFunction f = {})
: m_function(move(f)) {}
: m_function(std::move(f)) {}
FunctionReturnType operator*() {
return m_function();
@ -421,7 +421,7 @@ private:
template <typename NullaryFunction>
FunctionInputIterator<NullaryFunction> makeFunctionInputIterator(NullaryFunction f) {
return FunctionInputIterator<NullaryFunction>(move(f));
return FunctionInputIterator<NullaryFunction>(std::move(f));
}
template <typename Iterable>
@ -449,14 +449,14 @@ ReverseWrapper<Iterable> reverseIterate(Iterable& list) {
template <typename Functor>
class FinallyGuard {
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();
}
FinallyGuard& operator=(FinallyGuard&& o) {
functor = move(o.functor);
functor = std::move(o.functor);
dismiss = o.dismiss;
o.cancel();
return *this;
@ -478,7 +478,7 @@ private:
template <typename Functor>
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
@ -498,12 +498,12 @@ struct GenIndexSequence<Min, Min, S...> {
template <typename Function, typename Tuple, size_t... Indexes>
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>
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());
}
@ -512,12 +512,12 @@ decltype(auto) tupleUnpackFunction(Function&& function, Tuple&& args) {
template <typename Function, typename Tuple, size_t... Indexes>
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>
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());
}
@ -530,35 +530,35 @@ void tupleCallFunctionCaller(Function&&, Tuple&&) {}
template <typename Tuple, typename Function, typename First, typename... Rest>
void tupleCallFunctionCaller(Tuple&& t, Function&& function) {
tupleCallFunctionCaller<Tuple, Function, Rest...>(forward<Tuple>(t), forward<Function>(function));
function(get<sizeof...(Rest)>(forward<Tuple>(t)));
tupleCallFunctionCaller<Tuple, Function, Rest...>(std::forward<Tuple>(t), std::forward<Function>(function));
function(get<sizeof...(Rest)>(std::forward<Tuple>(t)));
}
template <typename Tuple, typename Function, typename... T>
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>
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
template <typename Tuple, size_t... Indexes>
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>
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>
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
@ -568,14 +568,14 @@ void unpackVariadicImpl(Container&) {}
template <typename Container, typename TFirst, typename... TRest>
void unpackVariadicImpl(Container& container, TFirst&& tfirst, TRest&&... trest) {
container.insert(container.end(), forward<TFirst>(tfirst));
unpackVariadicImpl(container, forward<TRest>(trest)...);
container.insert(container.end(), std::forward<TFirst>(tfirst));
unpackVariadicImpl(container, std::forward<TRest>(trest)...);
}
template <typename Container, typename... T>
Container unpackVariadic(T&&... t) {
Container c;
unpackVariadicImpl(c, forward<T>(t)...);
unpackVariadicImpl(c, std::forward<T>(t)...);
return c;
}
@ -587,7 +587,7 @@ void callFunctionVariadic(Function&&) {}
template <typename Function, typename Arg1, typename... ArgRest>
void callFunctionVariadic(Function&& function, Arg1&& arg1, ArgRest&&... argRest) {
function(arg1);
callFunctionVariadic(forward<Function>(function), forward<ArgRest>(argRest)...);
callFunctionVariadic(std::forward<Function>(function), std::forward<ArgRest>(argRest)...);
}
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) {
*this = move(AssetPath::split(path));
*this = AssetPath::split(path);
}
AssetPath::AssetPath(String const& path) {
*this = move(AssetPath::split(path));
*this = AssetPath::split(path);
}
AssetPath::AssetPath(String&& basePath, Maybe<String>&& subPath, DirectivesGroup&& directives) {
this->basePath = move(basePath);
this->subPath = move(subPath);
this->directives = move(directives);
this->basePath = std::move(basePath);
this->subPath = std::move(subPath);
this->directives = std::move(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;
ds.read(string);
path = move(string);
path = std::move(string);
return ds;
}

10
source/core/StarAtomicSharedPtr.hpp
View File

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

12
source/core/StarAudio.cpp
View File

@ -129,7 +129,7 @@ namespace {
for (size_t i = 0; i < pcmData->size() / 2; ++i)
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) {
m_channels = channels;
m_sampleRate = sampleRate;
m_audioData = move(data);
m_audioData = std::move(data);
m_memoryFile.reset(m_audioData->ptr(), m_audioData->size());
}
@ -335,7 +335,7 @@ Audio::Audio(IODevicePtr device) {
if (isUncompressed(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 {
m_compressed = make_shared<CompressedAudioImpl>(device);
if (!m_compressed->open())
@ -348,7 +348,7 @@ Audio::Audio(Audio const& audio) {
}
Audio::Audio(Audio&& audio) {
operator=(move(audio));
operator=(std::move(audio));
}
Audio& Audio::operator=(Audio const& audio) {
@ -365,8 +365,8 @@ Audio& Audio::operator=(Audio const& audio) {
}
Audio& Audio::operator=(Audio&& audio) {
m_compressed = move(audio.m_compressed);
m_uncompressed = move(audio.m_uncompressed);
m_compressed = std::move(audio.m_compressed);
m_uncompressed = std::move(audio.m_uncompressed);
return *this;
}

80
source/core/StarBTree.hpp
View File

@ -284,18 +284,18 @@ template <typename Base>
template <typename Visitor>
void BTreeMixin<Base>::forEach(Key const& lower, Key const& upper, Visitor&& visitor) {
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
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 Visitor>
void BTreeMixin<Base>::forAll(Visitor&& visitor) {
if (Base::rootIsLeaf())
forAll(Base::loadLeaf(Base::rootPointer()), forward<Visitor>(visitor));
forAll(Base::loadLeaf(Base::rootPointer()), std::forward<Visitor>(visitor));
else
forAll(Base::loadIndex(Base::rootPointer()), forward<Visitor>(visitor));
forAll(Base::loadIndex(Base::rootPointer()), std::forward<Visitor>(visitor));
}
template <typename Base>
@ -303,9 +303,9 @@ template <typename Visitor, typename ErrorHandler>
void BTreeMixin<Base>::recoverAll(Visitor&& visitor, ErrorHandler&& error) {
try {
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
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) {
error("Error loading root index or leaf node", e);
}
@ -317,17 +317,17 @@ void BTreeMixin<Base>::forAllNodes(Visitor&& visitor) {
if (Base::rootIsLeaf())
visitor(Base::loadLeaf(Base::rootPointer()));
else
forAllNodes(Base::loadIndex(Base::rootPointer()), forward<Visitor>(visitor));
forAllNodes(Base::loadIndex(Base::rootPointer()), std::forward<Visitor>(visitor));
}
template <typename Base>
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>
bool BTreeMixin<Base>::remove(Key k) {
return modify(DataElement{move(k), Data()}, RemoveAction);
return modify(DataElement{std::move(k), Data()}, RemoveAction);
}
template <typename Base>
@ -422,7 +422,7 @@ bool BTreeMixin<Base>::LeafCounter::operator()(Leaf const&) {
template <typename Base>
BTreeMixin<Base>::ModifyInfo::ModifyInfo(ModifyAction a, DataElement e)
: targetElement(move(e)), action(a) {
: targetElement(std::move(e)), action(a) {
found = false;
state = Done;
}
@ -466,9 +466,9 @@ auto BTreeMixin<Base>::forEach(Index const& index, Key const& lower, Key const&
Key lastKey;
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
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))
return lastKey;
@ -483,9 +483,9 @@ auto BTreeMixin<Base>::forEach(Index const& index, Key const& lower, Key const&
continue;
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
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))
break;
@ -530,9 +530,9 @@ auto BTreeMixin<Base>::forAll(Index const& index, Visitor&& o) -> Key {
continue;
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
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;
@ -550,7 +550,7 @@ auto BTreeMixin<Base>::forAll(Leaf const& leaf, Visitor&& o) -> Key {
}
if (auto nextLeafPointer = Base::nextLeaf(leaf))
return forAll(Base::loadLeaf(*nextLeafPointer), forward<Visitor>(o));
return forAll(Base::loadLeaf(*nextLeafPointer), std::forward<Visitor>(o));
else
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) {
if (Base::indexLevel(index) == 0) {
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) {
error("Error loading leaf node", e);
}
} else {
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) {
error("Error loading index node", e);
}
@ -608,7 +608,7 @@ void BTreeMixin<Base>::modify(Leaf& leafNode, ModifyInfo& info) {
return;
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);
if (splitResult) {
@ -677,26 +677,26 @@ void BTreeMixin<Base>::modify(Index& indexNode, ModifyInfo& info) {
} else if (Base::leafElementCount(rightLeaf) == 0) {
// Leaves merged.
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
// leaf.
if (left != 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);
selfUpdated = true;
} else {
// 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
// left index node.
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;
}
@ -725,25 +725,25 @@ void BTreeMixin<Base>::modify(Index& indexNode, ModifyInfo& info) {
} else if (Base::indexPointerCount(rightIndex) == 0) {
// Indexes merged.
Base::deleteIndex(move(rightIndex));
Base::deleteIndex(std::move(rightIndex));
// Replace two sibling pointer elements with one pointing to merged
// index.
if (left != 0)
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);
selfUpdated = true;
} else {
// 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 node.
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);
selfUpdated = true;
@ -752,19 +752,19 @@ void BTreeMixin<Base>::modify(Index& indexNode, ModifyInfo& info) {
}
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);
selfUpdated = true;
}
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);
selfUpdated = true;
}
if (info.state == LeafNeedsUpdate) {
Pointer lowerLeafPointer = Base::storeLeaf(move(lowerLeaf));
Pointer lowerLeafPointer = Base::storeLeaf(std::move(lowerLeaf));
if (lowerLeafPointer != Base::indexPointer(indexNode, i)) {
Base::indexUpdatePointer(indexNode, i, lowerLeafPointer);
selfUpdated = true;
@ -772,7 +772,7 @@ void BTreeMixin<Base>::modify(Index& indexNode, ModifyInfo& info) {
}
if (info.state == IndexNeedsUpdate) {
Pointer lowerIndexPointer = Base::storeIndex(move(lowerIndex));
Pointer lowerIndexPointer = Base::storeIndex(std::move(lowerIndex));
if (lowerIndexPointer != Base::indexPointer(indexNode, i)) {
Base::indexUpdatePointer(indexNode, i, lowerIndexPointer);
selfUpdated = true;
@ -796,7 +796,7 @@ void BTreeMixin<Base>::modify(Index& indexNode, ModifyInfo& info) {
template <typename Base>
bool BTreeMixin<Base>::modify(DataElement e, ModifyAction action) {
ModifyInfo info(action, move(e));
ModifyInfo info(action, std::move(e));
Leaf lowerLeaf;
Index lowerIndex;
@ -816,7 +816,7 @@ bool BTreeMixin<Base>::modify(DataElement e, ModifyAction action) {
// removes until setNewRoot)
Pointer pointer = Base::indexPointer(lowerIndex, 0);
size_t level = Base::indexLevel(lowerIndex);
Base::deleteIndex(move(lowerIndex));
Base::deleteIndex(std::move(lowerIndex));
Base::setNewRoot(pointer, level == 0);
} else {
// Else just update.
@ -833,24 +833,24 @@ bool BTreeMixin<Base>::modify(DataElement e, ModifyAction action) {
Index newRoot;
if (info.state == IndexSplit) {
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);
} else {
newRoot = Base::createIndex(Base::storeLeaf(move(lowerLeaf)));
newRoot = Base::createIndex(Base::storeLeaf(std::move(lowerLeaf)));
Base::setIndexLevel(newRoot, 0);
}
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) {
Pointer newRootPointer = Base::storeIndex(move(lowerIndex));
Pointer newRootPointer = Base::storeIndex(std::move(lowerIndex));
if (newRootPointer != Base::rootPointer())
Base::setNewRoot(newRootPointer, false);
}
if (info.state == LeafNeedsUpdate) {
Pointer newRootPointer = Base::storeLeaf(move(lowerLeaf));
Pointer newRootPointer = Base::storeLeaf(std::move(lowerLeaf));
if (newRootPointer != Base::rootPointer())
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) {
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 {
if (!visitor(Base::loadLeaf(Base::indexPointer(index, i))))
return;

12
source/core/StarBTreeDatabase.cpp
View File

@ -58,7 +58,7 @@ String BTreeDatabase::contentIdentifier() const {
void BTreeDatabase::setContentIdentifier(String contentIdentifier) {
WriteLocker writeLocker(m_lock);
checkIfOpen("setContentIdentifier", false);
m_contentIdentifier = move(contentIdentifier);
m_contentIdentifier = std::move(contentIdentifier);
}
uint32_t BTreeDatabase::indexCacheSize() const {
@ -91,7 +91,7 @@ IODevicePtr BTreeDatabase::ioDevice() const {
void BTreeDatabase::setIODevice(IODevicePtr device) {
WriteLocker writeLocker(m_lock);
checkIfOpen("setIODevice", false);
m_device = move(device);
m_device = std::move(device);
}
bool BTreeDatabase::isOpen() const {
@ -188,12 +188,12 @@ void BTreeDatabase::forEach(ByteArray const& lower, ByteArray const& upper, func
ReadLocker readLocker(m_lock);
checkKeySize(lower);
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) {
ReadLocker readLocker(m_lock);
m_impl.forAll(move(v));
m_impl.forAll(std::move(v));
}
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) {
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) {
@ -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) {
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) {

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) {
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... Args>
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>

10
source/core/StarBuffer.cpp
View File

@ -17,7 +17,7 @@ Buffer::Buffer(size_t initialSize)
Buffer::Buffer(ByteArray b)
: Buffer() {
reset(move(b));
reset(std::move(b));
}
Buffer::Buffer(Buffer const& buffer)
@ -27,7 +27,7 @@ Buffer::Buffer(Buffer const& buffer)
Buffer::Buffer(Buffer&& buffer)
: Buffer() {
operator=(move(buffer));
operator=(std::move(buffer));
}
StreamOffset Buffer::pos() {
@ -106,7 +106,7 @@ ByteArray const& Buffer::data() const {
}
ByteArray Buffer::takeData() {
ByteArray ret = move(m_bytes);
ByteArray ret = std::move(m_bytes);
reset(0);
return ret;
}
@ -143,7 +143,7 @@ void Buffer::reset(size_t newSize) {
void Buffer::reset(ByteArray b) {
m_pos = 0;
m_bytes = move(b);
m_bytes = std::move(b);
}
Buffer& Buffer::operator=(Buffer const& buffer) {
@ -156,7 +156,7 @@ Buffer& Buffer::operator=(Buffer const& buffer) {
Buffer& Buffer::operator=(Buffer&& buffer) {
IODevice::operator=(buffer);
m_pos = buffer.m_pos;
m_bytes = move(buffer.m_bytes);
m_bytes = std::move(buffer.m_bytes);
buffer.m_pos = 0;
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() {
operator=(move(b));
operator=(std::move(b));
}
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);
}
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)
: IODevice(IOMode::Closed), m_file(0), m_compression(MediumCompression) {
setFilename(move(filename));
setFilename(std::move(filename));
}
CompressedFile::~CompressedFile() {
@ -172,7 +172,7 @@ size_t CompressedFile::write(const char* data, size_t len) {
void CompressedFile::setFilename(String filename) {
if (isOpen())
throw IOException("Cannot call setFilename while CompressedFile is open");
m_filename = move(filename);
m_filename = std::move(filename);
}
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) {
std::string string;
operator>>(string);
s = move(string);
s = std::move(string);
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::mapped_type 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 {
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) {
if (!m_reader)
@ -18,7 +18,7 @@ void DataStreamFunctions::writeData(char const* data, size_t len) {
}
DataStreamIODevice::DataStreamIODevice(IODevicePtr device)
: m_device(move(device)) {}
: m_device(std::move(device)) {}
IODevicePtr const& DataStreamIODevice::device() const {
return m_device;
@ -119,7 +119,7 @@ void DataStreamBuffer::reset(size_t newSize) {
}
void DataStreamBuffer::reset(ByteArray b) {
m_buffer->reset(move(b));
m_buffer->reset(std::move(b));
}
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>
void DataStreamBuffer::deserialize(T& t, ByteArray data) {
DataStreamBuffer ds(move(data));
DataStreamBuffer ds(std::move(data));
ds.read(t);
}
template <typename T>
void DataStreamBuffer::deserializeContainer(T& t, ByteArray data) {
DataStreamBuffer ds(move(data));
DataStreamBuffer ds(std::move(data));
ds.readContainer(t);
}
template <typename T, typename ReadFunction>
void DataStreamBuffer::deserializeContainer(T& t, ByteArray data, ReadFunction readFunction) {
DataStreamBuffer ds(move(data));
DataStreamBuffer ds(std::move(data));
ds.readContainer(t, readFunction);
}
template <typename T>
void DataStreamBuffer::deserializeMapContainer(T& t, ByteArray data) {
DataStreamBuffer ds(move(data));
DataStreamBuffer ds(std::move(data));
ds.readMapContainer(t);
}
template <typename T, typename ReadFunction>
void DataStreamBuffer::deserializeMapContainer(T& t, ByteArray data, ReadFunction readFunction) {
DataStreamBuffer ds(move(data));
DataStreamBuffer ds(std::move(data));
ds.readMapContainer(t, readFunction);
}
template <typename T>
T DataStreamBuffer::deserialize(ByteArray data) {
T t;
deserialize(t, move(data));
deserialize(t, std::move(data));
return t;
}
template <typename T>
T DataStreamBuffer::deserializeContainer(ByteArray data) {
T t;
deserializeContainer(t, move(data));
deserializeContainer(t, std::move(data));
return t;
}
template <typename T, typename ReadFunction>
T DataStreamBuffer::deserializeContainer(ByteArray data, ReadFunction readFunction) {
T t;
deserializeContainer(t, move(data), readFunction);
deserializeContainer(t, std::move(data), readFunction);
return t;
}
template <typename T>
T DataStreamBuffer::deserializeMapContainer(ByteArray data) {
T t;
deserializeMapContainer(t, move(data));
deserializeMapContainer(t, std::move(data));
return t;
}
template <typename T, typename ReadFunction>
T DataStreamBuffer::deserializeMapContainer(ByteArray data, ReadFunction readFunction) {
T t;
deserializeMapContainer(t, move(data), readFunction);
deserializeMapContainer(t, std::move(data), readFunction);
return t;
}

2
source/core/StarDataStreamExtra.hpp
View File

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

30
source/core/StarDirectives.cpp
View File

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

24
source/core/StarEither.hpp
View File

@ -85,12 +85,12 @@ private:
template <typename Value>
EitherLeftValue<Value> makeLeft(Value value) {
return {move(value)};
return {std::move(value)};
}
template <typename Value>
EitherRightValue<Value> makeRight(Value value) {
return {move(value)};
return {std::move(value)};
}
template <typename Left, typename Right>
@ -98,21 +98,21 @@ Either<Left, Right>::Either() {}
template <typename Left, typename Right>
Either<Left, Right>::Either(EitherLeftValue<Left> left)
: m_value(move(left)) {}
: m_value(std::move(left)) {}
template <typename Left, typename Right>
Either<Left, Right>::Either(EitherRightValue<Right> right)
: m_value(move(right)) {}
: m_value(std::move(right)) {}
template <typename Left, typename Right>
template <typename T>
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 T>
Either<Left, Right>::Either(EitherRightValue<T> right)
: Either(RightType{move(right.value)}) {}
: Either(RightType{std::move(right.value)}) {}
template <typename Left, typename Right>
Either<Left, Right>::Either(Either const& rhs)
@ -120,7 +120,7 @@ Either<Left, Right>::Either(Either const& rhs)
template <typename Left, typename Right>
Either<Left, Right>::Either(Either&& rhs)
: m_value(move(rhs.m_value)) {}
: m_value(std::move(rhs.m_value)) {}
template <typename Left, typename Right>
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>
Either<Left, Right>& Either<Left, Right>::operator=(Either&& rhs) {
m_value = move(rhs.m_value);
m_value = std::move(rhs.m_value);
return *this;
}
template <typename Left, typename Right>
template <typename T>
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;
}
template <typename Left, typename Right>
template <typename T>
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;
}
@ -160,12 +160,12 @@ bool Either<Left, Right>::isRight() const {
template <typename Left, typename Right>
void Either<Left, Right>::setLeft(Left left) {
m_value = LeftType{move(left)};
m_value = LeftType{std::move(left)};
}
template <typename Left, typename Right>
void Either<Left, Right>::setRight(Right right) {
m_value = RightType{move(right)};
m_value = RightType{std::move(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 { \
public: \
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...)); \
} \
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) {} \
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: \
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) \
: BaseName(type, move(message), cause) {} \
: BaseName(type, std::move(message), cause) {} \
}
STAR_EXCEPTION(OutOfRangeException, StarException);

12
source/core/StarException_unix.cpp
View File

@ -18,7 +18,7 @@ inline StackCapture captureStack() {
}
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);
for (size_t i = 0; i < stack.second; ++i) {
os << symbols[i];
@ -39,13 +39,13 @@ StarException::StarException() noexcept
StarException::~StarException() 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::string(), cause) {}
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() {
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(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) {
self(os, fullStacktrace);
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()));
}
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) {

12
source/core/StarException_windows.cpp
View File

@ -117,7 +117,7 @@ inline StackCapture captureStack() {
}
OutputProxy outputStack(StackCapture stack) {
return OutputProxy([stack = move(stack)](std::ostream & os) {
return OutputProxy([stack = std::move(stack)](std::ostream & os) {
HANDLE process = GetCurrentProcess();
g_dbgHelpLock.lock();
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(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::string(), cause) {}
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() {
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(type, move(message)) {
: StarException(type, std::move(message)) {
auto printException = [](std::ostream& os,
bool fullStacktrace,
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()));
}
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) {

4
source/core/StarFile.cpp
View File

@ -124,7 +124,7 @@ File::File()
}
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() {
close();
@ -190,7 +190,7 @@ String File::fileName() const {
void File::setFilename(String filename) {
if (isOpen())
throw IOException("Cannot call setFilename while File is open");
m_filename = move(filename);
m_filename = std::move(filename);
}
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>
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>
FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::FlatHashMap(FlatHashMap&& other, allocator_type const& alloc)
: FlatHashMap(alloc) {
operator=(move(other));
operator=(std::move(other));
}
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>
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;
}
@ -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 T, typename>
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};
}
@ -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 T, typename>
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>
@ -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... Args>
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... Args>
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>
@ -480,7 +480,7 @@ auto FlatHashMap<Key, Mapped, Hash, Equals, Allocator>::operator[](key_type&& ke
auto i = m_table.find(key);
if (i != m_table.end())
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>

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>
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>
FlatHashSet<Key, Hash, Equals, Allocator>::FlatHashSet(FlatHashSet&& other, allocator_type const& alloc)
: FlatHashSet(alloc) {
operator=(move(other));
operator=(std::move(other));
}
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>
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;
}
@ -376,7 +376,7 @@ auto FlatHashSet<Key, Hash, Equals, Allocator>::insert(value_type const& value)
template <typename Key, typename Hash, typename Equals, typename Allocator>
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};
}
@ -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>
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>

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) {
this->hash = rhs.hash;
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>
@ -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& {
if (auto o = rhs.valuePtr()) {
if (auto s = valuePtr())
*s = move(*o);
*s = std::move(*o);
else
new (&this->value) Value(move(*o));
new (&this->value) Value(std::move(*o));
} else {
if (auto s = valuePtr())
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>
void FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::Bucket::setFilled(size_t hash, Value value) {
if (auto s = valuePtr())
*s = move(value);
*s = std::move(value);
else
new (&this->value) Value(move(value));
new (&this->value) Value(std::move(value));
this->hash = hash | FilledHashBit;
}
@ -370,7 +370,7 @@ auto FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::insert(Value va
currentBucket = hashBucket(currentBucket + 1);
} else {
target.setFilled(hash, move(value));
target.setFilled(hash, std::move(value));
++m_filledCount;
if (insertedBucket == NPos)
insertedBucket = currentBucket;
@ -392,7 +392,7 @@ auto FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::erase(const_ite
if (auto nextPtr = nextBucket->valuePtr()) {
if (bucketError(nextBucketIndex, nextBucket->hash) > 0) {
currentBucket->hash = nextBucket->hash;
*currentBucket->valuePtr() = move(*nextPtr);
*currentBucket->valuePtr() = std::move(*nextPtr);
currentBucketIndex = nextBucketIndex;
currentBucket = nextBucket;
} else {
@ -548,7 +548,7 @@ void FlatHashTable<Value, Key, GetKey, Hash, Equals, Allocator>::checkCapacity(s
for (auto& entry : oldBuckets) {
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 {
HostAddress ha;
ha.set(address);
return makeRight(move(ha));
return makeRight(std::move(ha));
} catch (NetworkException const& e) {
return makeLeft(String(e.what()));
}
@ -35,7 +35,7 @@ HostAddress::HostAddress(String const& address) {
if (a.isLeft())
throw NetworkException(a.left().takeUtf8());
else
*this = move(a.right());
*this = std::move(a.right());
}
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) {
auto hostAddress = HostAddress::lookup(address);
if (hostAddress.isLeft())
return makeLeft(move(hostAddress.left()));
return makeLeft(std::move(hostAddress.left()));
else
return makeRight(HostAddressWithPort(move(hostAddress.right()), port));
return makeRight(HostAddressWithPort(std::move(hostAddress.right()), port));
}
Either<String, HostAddressWithPort> HostAddressWithPort::lookupWithPort(String const& address) {
@ -228,9 +228,9 @@ Either<String, HostAddressWithPort> HostAddressWithPort::lookupWithPort(String c
auto hostAddress = HostAddress::lookup(host);
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) {}
@ -247,14 +247,14 @@ HostAddressWithPort::HostAddressWithPort(String const& address, uint16_t port) {
auto a = lookup(address, port);
if (a.isLeft())
throw NetworkException(a.left().takeUtf8());
*this = move(a.right());
*this = std::move(a.right());
}
HostAddressWithPort::HostAddressWithPort(String const& address) {
auto a = lookupWithPort(address);
if (a.isLeft())
throw NetworkException(a.left().takeUtf8());
*this = move(a.right());
*this = std::move(a.right());
}
HostAddress HostAddressWithPort::address() const {

2
source/core/StarIdMap.hpp
View File

@ -101,7 +101,7 @@ auto IdMapWrapper<BaseMap>::nextId() -> IdType {
template <typename BaseMap>
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));
}

2
source/core/StarImage.cpp
View File

@ -217,7 +217,7 @@ Image::Image(Image const& image) : Image() {
}
Image::Image(Image&& image) : Image() {
operator=(move(image));
operator=(std::move(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))
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.
return move(operation);
return std::move(operation);
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)
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;
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)
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;
Pos min = posGetter(*i);

4
source/core/StarIterator.hpp
View File

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

10
source/core/StarJsonBuilder.cpp
View File

@ -15,12 +15,12 @@ void JsonBuilderStream::endObject() {
JsonObject object;
while (true) {
if (isSentry()) {
set(Json(move(object)));
set(Json(std::move(object)));
return;
} else {
Json v = pop();
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));
}
}
@ -35,7 +35,7 @@ void JsonBuilderStream::endArray() {
while (true) {
if (isSentry()) {
array.reverse();
set(Json(move(array)));
set(Json(std::move(array)));
return;
} else {
array.append(pop());
@ -81,7 +81,7 @@ Json JsonBuilderStream::takeTop() {
}
void JsonBuilderStream::push(Json v) {
m_stack.append(move(v));
m_stack.append(std::move(v));
}
Json JsonBuilderStream::pop() {
@ -89,7 +89,7 @@ Json JsonBuilderStream::pop() {
}
void JsonBuilderStream::set(Json v) {
m_stack.last() = move(v);
m_stack.last() = std::move(v);
}
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> result;
for (auto const& entry : v.iterateArray())
result.append(move(entry.toString()));
result.append(entry.toString());
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>
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>
@ -281,12 +281,12 @@ Json jsonFromMapKV(MapType const& map, KeyConverter&& keyConvert, ValueConverter
template <typename MapType, typename KeyConverter>
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>
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>

2
source/core/StarJsonParser.hpp
View File

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

2
source/core/StarJsonRpc.cpp
View File

@ -13,7 +13,7 @@ JsonRpc::JsonRpc() {
void JsonRpc::registerHandler(String const& handler, JsonRpcRemoteFunction func) {
if (m_handlers.contains(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) {

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)
return {};
return move(result);
return std::move(result);
}
template <typename Type>

54
source/core/StarList.hpp
View File

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

6
source/core/StarListener.cpp
View File

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

10
source/core/StarLockFile_unix.cpp
View File

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

12
source/core/StarLockFile_windows.cpp
View File

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

6
source/core/StarLogging.cpp
View File

@ -212,9 +212,9 @@ void SpatialLogger::clear() {
decltype(s_logText) logText;
{
MutexLocker locker(s_mutex);
lines = move(s_lines);
points = move(s_points);
logText = move(s_logText);
lines = std::move(s_lines);
points = std::move(s_points);
logText = std::move(s_logText);
} // 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) {
auto i = m_map.find(key);
if (i == m_map.end()) {
m_map.add(key, move(value));
m_map.add(key, std::move(value));
} else {
i->second = move(value);
i->second = std::move(value);
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 {
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) {
@ -92,7 +92,7 @@ void LuaContext::load(ByteArray const& contents, String const& name) {
}
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 {
@ -162,11 +162,11 @@ Maybe<Json> LuaConverter<Json>::to(LuaEngine&, LuaValue const& 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) {
auto j = engine.luaTo<Json>(move(v));
auto j = engine.luaTo<Json>(std::move(v));
if (j.type() == Json::Type::Object) {
return j.toObject();
} 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) {
return engine.luaFrom<Json>(Json(move(v)));
return engine.luaFrom<Json>(Json(std::move(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) {
return j.toArray();
} 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);
bool cont = false;
try {
cont = iterator(move(key), move(value));
cont = iterator(std::move(key), std::move(value));
} catch (...) {
lua_pop(m_state, 2);
throw;
@ -881,7 +881,7 @@ void LuaEngine::setContextRequire(int handleIndex, LuaContext::RequireFunction r
pushHandle(m_state, handleIndex);
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_setmetatable(m_state, -2);
@ -1076,7 +1076,7 @@ LuaFunction LuaEngine::createWrappedFunction(LuaDetail::LuaWrappedFunction funct
lua_checkstack(m_state, 2);
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_setmetatable(m_state, -2);
@ -1400,7 +1400,7 @@ Maybe<Json> LuaDetail::tableToJsonContainer(LuaTable const& table) {
if (auto i = asInteger(key)) {
intEntries[*i] = jsonValue.take();
} else {
auto stringKey = table.engine().luaMaybeTo<String>(move(key));
auto stringKey = table.engine().luaMaybeTo<String>(std::move(key));
if (!stringKey) {
failedConversion = true;
return false;
@ -1420,12 +1420,12 @@ Maybe<Json> LuaDetail::tableToJsonContainer(LuaTable const& table) {
if (interpretAsList) {
JsonArray list;
for (auto& p : intEntries)
list.set(p.first - 1, move(p.second));
return Json(move(list));
list.set(p.first - 1, std::move(p.second));
return Json(std::move(list));
} else {
for (auto& p : intEntries)
stringEntries[toString(p.first)] = move(p.second);
return Json(move(stringEntries));
stringEntries[toString(p.first)] = std::move(p.second);
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) {
return engine.luaTo<String>(move(v)).takeUtf8();
return engine.luaTo<String>(std::move(v)).takeUtf8();
}
};
@ -887,12 +887,12 @@ struct LuaConverter<Directives> {
template <>
struct LuaConverter<LuaString> {
static LuaValue from(LuaEngine&, LuaString v) {
return LuaValue(move(v));
return LuaValue(std::move(v));
}
static Maybe<LuaString> to(LuaEngine& engine, LuaValue v) {
if (v.is<LuaString>())
return LuaString(move(v.get<LuaString>()));
return LuaString(std::move(v.get<LuaString>()));
if (v.is<LuaInt>())
return engine.createString(toString(v.get<LuaInt>()));
if (v.is<LuaFloat>())
@ -909,7 +909,7 @@ struct LuaValueConverter {
static Maybe<T> to(LuaEngine&, LuaValue v) {
if (auto p = v.ptr<T>()) {
return move(*p);
return std::move(*p);
}
return {};
}
@ -967,7 +967,7 @@ struct LuaConverter<Maybe<T>> {
static Maybe<Maybe<T>> to(LuaEngine& engine, LuaValue&& v) {
if (v != LuaNil) {
if (auto conv = engine.luaMaybeTo<T>(move(v)))
if (auto conv = engine.luaMaybeTo<T>(std::move(v)))
return conv;
else
return {};
@ -991,8 +991,8 @@ struct LuaMapConverter {
T result;
bool failed = false;
table->iterate([&result, &failed, &engine](LuaValue key, LuaValue value) {
auto contKey = engine.luaMaybeTo<typename T::key_type>(move(key));
auto contValue = engine.luaMaybeTo<typename T::mapped_type>(move(value));
auto contKey = engine.luaMaybeTo<typename T::key_type>(std::move(key));
auto contValue = engine.luaMaybeTo<typename T::mapped_type>(std::move(value));
if (!contKey || !contValue) {
failed = true;
return false;
@ -1026,7 +1026,7 @@ struct LuaContainerConverter {
failed = true;
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) {
failed = true;
return false;
@ -1086,7 +1086,7 @@ struct LuaConverter<JsonArray> {
namespace LuaDetail {
inline LuaHandle::LuaHandle(LuaEnginePtr engine, int handleIndex)
: engine(move(engine)), handleIndex(handleIndex) {}
: engine(std::move(engine)), handleIndex(handleIndex) {}
inline LuaHandle::~LuaHandle() {
if (engine)
@ -1213,7 +1213,7 @@ namespace LuaDetail {
struct ArgGet {
static T get(LuaEngine& engine, size_t argc, LuaValue* argv, size_t index) {
if (index < argc)
return engine.luaTo<T>(move(argv[index]));
return engine.luaTo<T>(std::move(argv[index]));
return engine.luaTo<T>(LuaNil);
}
};
@ -1226,7 +1226,7 @@ namespace LuaDetail {
LuaVariadic<T> subargs(argc - index);
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;
}
};
@ -1235,14 +1235,14 @@ namespace LuaDetail {
struct FunctionWrapper {
template <typename Function, size_t... Indexes>
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)...));
};
}
template <typename Function>
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...> {
template <typename Function, size_t... Indexes>
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)...);
return LuaFunctionReturn();
};
@ -1258,7 +1258,7 @@ namespace LuaDetail {
template <typename Function>
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...> {
template <typename Function, size_t... Indexes>
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)...));
};
}
template <typename Function>
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...> {
template <typename Function, size_t... Indexes>
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)...);
return LuaFunctionReturn();
};
@ -1289,31 +1289,31 @@ namespace LuaDetail {
template <typename Function>
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>
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>
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>
LuaWrappedFunction wrapFunction(Function&& func) {
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>
struct MethodWrapper {
template <typename Function, size_t... Indexes>
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)
throw LuaException("No object argument passed to wrapped method");
return toWrappedReturn(engine,
@ -1323,7 +1323,7 @@ namespace LuaDetail {
template <typename Function>
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...> {
template <typename Function, size_t... Indexes>
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)
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)...);
@ -1341,7 +1341,7 @@ namespace LuaDetail {
template <typename Function>
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...> {
template <typename Function, size_t... Indexes>
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)
throw LuaException("No object argument passed to wrapped method");
return toWrappedReturn(
@ -1360,7 +1360,7 @@ namespace LuaDetail {
template <typename Function>
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...> {
template <typename Function, size_t... Indexes>
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)
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)...);
@ -1378,24 +1378,24 @@ namespace LuaDetail {
template <typename Function>
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>
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>
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>
LuaWrappedFunction wrapMethod(Function&& func) {
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>
@ -1405,8 +1405,8 @@ namespace LuaDetail {
struct TableIteratorWrapper<bool, LuaEngine&, Key, Value> {
template <typename Function>
static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) {
return [&engine, func = move(func)](LuaValue key, LuaValue value) -> bool {
return func(engine, engine.luaTo<Key>(move(key)), engine.luaTo<Value>(move(value)));
return [&engine, func = std::move(func)](LuaValue key, LuaValue value) -> bool {
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> {
template <typename Function>
static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) {
return [&engine, func = move(func)](LuaValue key, LuaValue value) -> bool {
func(engine, engine.luaTo<Key>(move(key)), engine.luaTo<Value>(move(value)));
return [&engine, func = std::move(func)](LuaValue key, LuaValue value) -> bool {
func(engine, engine.luaTo<Key>(std::move(key)), engine.luaTo<Value>(std::move(value)));
return true;
};
}
@ -1426,8 +1426,8 @@ namespace LuaDetail {
struct TableIteratorWrapper<bool, Key, Value> {
template <typename Function>
static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) {
return [&engine, func = move(func)](LuaValue key, LuaValue value) -> bool {
return func(engine.luaTo<Key>(move(key)), engine.luaTo<Value>(move(value)));
return [&engine, func = std::move(func)](LuaValue key, LuaValue value) -> bool {
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> {
template <typename Function>
static function<bool(LuaValue, LuaValue)> wrap(LuaEngine& engine, Function&& func) {
return [&engine, func = move(func)](LuaValue key, LuaValue value) -> bool {
func(engine.luaTo<Key>(move(key)), engine.luaTo<Value>(move(value)));
return [&engine, func = std::move(func)](LuaValue key, LuaValue value) -> bool {
func(engine.luaTo<Key>(std::move(key)), engine.luaTo<Value>(std::move(value)));
return true;
};
}
@ -1445,19 +1445,19 @@ namespace LuaDetail {
template <typename Return, typename... Args, typename Function>
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>
function<bool(LuaValue, LuaValue)> wrapTableIteratorArgs(
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>
function<bool(LuaValue, LuaValue)> wrapTableIterator(LuaEngine& engine, Function&& func) {
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.
@ -1520,7 +1520,7 @@ LuaVariadic<typename std::decay<Container>::type::value_type> luaUnpack(Containe
LuaVariadic<typename std::decay<Container>::type::value_type> ret;
if (std::is_rvalue_reference<Container&&>::value) {
for (auto& e : c)
ret.append(move(e));
ret.append(std::move(e));
} else {
for (auto const& e : c)
ret.append(e);
@ -1535,7 +1535,7 @@ LuaTupleReturn<Types...>::LuaTupleReturn(Types const&... args)
template <typename... Types>
template <typename... UTypes>
LuaTupleReturn<Types...>::LuaTupleReturn(UTypes&&... args)
: Base(move(args)...) {}
: Base(std::move(args)...) {}
template <typename... Types>
template <typename... UTypes>
@ -1548,7 +1548,7 @@ LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn const& rhs)
template <typename... Types>
LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn&& rhs)
: Base(move(rhs)) {}
: Base(std::move(rhs)) {}
template <typename... Types>
template <typename... UTypes>
@ -1558,7 +1558,7 @@ LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn<UTypes...> const& rhs)
template <typename... Types>
template <typename... UTypes>
LuaTupleReturn<Types...>::LuaTupleReturn(LuaTupleReturn<UTypes...>&& rhs)
: Base(move(rhs)) {}
: Base(std::move(rhs)) {}
template <typename... Types>
LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn const& rhs) {
@ -1568,7 +1568,7 @@ LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn con
template <typename... Types>
LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn&& rhs) {
Base::operator=(move(rhs));
Base::operator=(std::move(rhs));
return *this;
}
@ -1582,7 +1582,7 @@ LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn<UTy
template <typename... Types>
template <typename... UTypes>
LuaTupleReturn<Types...>& LuaTupleReturn<Types...>::operator=(LuaTupleReturn<UTypes...>&& rhs) {
Base::operator=((tuple<UTypes...> && )move(rhs));
Base::operator=((tuple<UTypes...> && )std::move(rhs));
return *this;
}
@ -1593,10 +1593,10 @@ LuaTupleReturn<Types&...> luaTie(Types&... args) {
template <typename... Types>
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 {
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>
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>
@ -1698,17 +1698,17 @@ T LuaTable::get(char const* key) const {
template <typename T, typename K>
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>
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>
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>
@ -1718,12 +1718,12 @@ void LuaTable::remove(K key) const {
template <typename Function>
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>
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>
@ -1779,27 +1779,27 @@ T& LuaUserData::get() const {
template <typename Function>
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);
}
template <typename Return, typename... Args, typename Function>
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);
}
template <typename T>
template <typename Function>
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);
}
template <typename T>
template <typename Return, typename... Args, typename Function>
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)
throw LuaException::format("Lua method '{}' was registered twice", name);
}
@ -1811,12 +1811,12 @@ StringMap<LuaDetail::LuaWrappedFunction> const& LuaMethods<T>::methods() const {
template <typename T>
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>
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>
@ -1834,7 +1834,7 @@ Ret LuaContext::invokePath(String const& key, Args const&... args) const {
template <typename T>
LuaValue LuaContext::luaFrom(T&& t) {
return engine().luaFrom(forward<T>(t));
return engine().luaFrom(std::forward<T>(t));
}
template <typename T>
@ -1844,7 +1844,7 @@ LuaValue LuaContext::luaFrom(T const& t) {
template <typename T>
Maybe<T> LuaContext::luaMaybeTo(LuaValue&& v) {
return engine().luaFrom(move(v));
return engine().luaFrom(std::move(v));
}
template <typename T>
@ -1854,7 +1854,7 @@ Maybe<T> LuaContext::luaMaybeTo(LuaValue const& v) {
template <typename T>
T LuaContext::luaTo(LuaValue&& v) {
return engine().luaTo<T>(move(v));
return engine().luaTo<T>(std::move(v));
}
template <typename T>
@ -1874,17 +1874,17 @@ LuaTable LuaContext::createArrayTable(Container const& array) {
template <typename Function>
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>
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>
LuaUserData LuaContext::createUserData(T t) {
return engine().createUserData(move(t));
return engine().createUserData(std::move(t));
}
template <typename T>
@ -1894,7 +1894,7 @@ LuaMethods<T> LuaUserDataMethods<T>::make() {
template <typename T>
LuaValue LuaUserDataConverter<T>::from(LuaEngine& engine, T t) {
return engine.createUserData(move(t));
return engine.createUserData(std::move(t));
}
template <typename T>
@ -1908,7 +1908,7 @@ Maybe<T> LuaUserDataConverter<T>::to(LuaEngine&, LuaValue const& v) {
template <typename 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>
@ -1918,7 +1918,7 @@ LuaValue LuaEngine::luaFrom(T const& t) {
template <typename T>
Maybe<T> LuaEngine::luaMaybeTo(LuaValue&& v) {
return LuaConverter<T>::to(*this, move(v));
return LuaConverter<T>::to(*this, std::move(v));
}
template <typename T>
@ -1928,7 +1928,7 @@ Maybe<T> LuaEngine::luaMaybeTo(LuaValue const& v) {
template <typename T>
T LuaEngine::luaTo(LuaValue&& v) {
if (auto res = luaMaybeTo<T>(move(v)))
if (auto res = luaMaybeTo<T>(std::move(v)))
return res.take();
throw LuaConversionException::format("Error converting LuaValue to type '{}'", typeid(T).name());
}
@ -1961,12 +1961,12 @@ LuaTable LuaEngine::createArrayTable(Container const& array) {
template <typename Function>
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>
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>
@ -2026,7 +2026,7 @@ Maybe<LuaDetail::LuaFunctionReturn> LuaEngine::resumeThread(int handleIndex, Arg
LuaVariadic<LuaValue> ret(returnValues);
for (int i = returnValues - 1; i >= 0; --i)
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);
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_setmetatable(m_state, -2);
@ -2083,7 +2083,7 @@ template <typename T, typename K>
T LuaEngine::getGlobal(K key) {
lua_checkstack(m_state, 1);
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);
LuaValue v = popLuaValue(m_state);
@ -2109,8 +2109,8 @@ void LuaEngine::setGlobal(K key, T value) {
lua_checkstack(m_state, 1);
lua_rawgeti(m_state, LUA_REGISTRYINDEX, m_scriptDefaultEnvRegistryId);
pushLuaValue(m_state, luaFrom(move(key)));
pushLuaValue(m_state, luaFrom(move(value)));
pushLuaValue(m_state, luaFrom(std::move(key)));
pushLuaValue(m_state, luaFrom(std::move(value)));
lua_rawset(m_state, -3);
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>> {
static LuaValue from(LuaEngine& engine, pair<T1, T2>&& v) {
auto t = engine.createTable();
t.set(1, move(v.first));
t.set(2, move(v.second));
t.set(1, std::move(v.first));
t.set(2, std::move(v.second));
return t;
}
@ -46,7 +46,7 @@ struct LuaConverter<pair<T1, T2>> {
}
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 p2 = engine.luaMaybeTo<T2>(table->get(2));
if (p1 && p2)
@ -173,7 +173,7 @@ struct LuaConverter<Variant<FirstType, RestTypes...>> {
}
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) {
@ -194,7 +194,7 @@ struct LuaConverter<Variant<FirstType, RestTypes...>> {
}
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>
@ -202,12 +202,12 @@ struct LuaConverter<Variant<FirstType, RestTypes...>> {
if (auto t1 = engine.luaMaybeTo<CheckType1>(v))
return t1;
else
return checkTypeTo<CheckType2, CheckTypeRest...>(engine, move(v));
return checkTypeTo<CheckType2, CheckTypeRest...>(engine, std::move(v));
}
template <typename Type>
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) {
LuaValue value;
variant.call([&value, &engine](auto& a) {
value = luaFrom(engine, move(a));
value = luaFrom(engine, std::move(a));
});
return value;
}
@ -253,7 +253,7 @@ struct LuaConverter<MVariant<Types...>> {
static Maybe<MVariant<Types...>> to(LuaEngine& engine, LuaValue&& v) {
if (v == LuaNil)
return MVariant<Types...>();
return checkTypeTo<Types...>(engine, move(v));
return checkTypeTo<Types...>(engine, std::move(v));
}
template <typename CheckType1, typename CheckType2, typename... CheckTypeRest>
@ -261,12 +261,12 @@ struct LuaConverter<MVariant<Types...>> {
if (auto t1 = engine.luaMaybeTo<CheckType1>(v))
return t1;
else
return checkTypeTo<CheckType2, CheckTypeRest...>(engine, move(v));
return checkTypeTo<CheckType2, CheckTypeRest...>(engine, std::move(v));
}
template <typename CheckType>
static Maybe<MVariant<Types...>> checkTypeTo(LuaEngine& engine, LuaValue&& v) {
return engine.luaMaybeTo<CheckType>(move(v));
return engine.luaMaybeTo<CheckType>(std::move(v));
}
};

10
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()) {
mapped_type v = std::move(i->second);
Base::erase(i);
return move(v);
return std::move(v);
}
return {};
@ -260,12 +260,12 @@ auto MapMixin<BaseMap>::hasValue(mapped_type const& v) const -> bool {
template <typename BaseMap>
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>
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)
throw MapException(strf("Entry with key '{}' already present.", outputAny(k)));
else
@ -276,10 +276,10 @@ template <typename BaseMap>
auto MapMixin<BaseMap>::set(key_type k, mapped_type v) -> mapped_type& {
auto i = Base::find(k);
if (i != Base::end()) {
i->second = move(v);
i->second = std::move(v);
return i->second;
} 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>
Maybe<T>::Maybe(T&& t)
: Maybe() {
new (&m_data) T(forward<T>(t));
new (&m_data) T(std::forward<T>(t));
m_initialized = true;
}
@ -135,7 +135,7 @@ template <typename T>
Maybe<T>::Maybe(Maybe&& rhs)
: Maybe() {
if (rhs.m_initialized) {
new (&m_data) T(move(rhs.m_data));
new (&m_data) T(std::move(rhs.m_data));
m_initialized = true;
rhs.reset();
}
@ -308,7 +308,7 @@ T Maybe<T>::take() {
if (!m_initialized)
throw InvalidMaybeAccessException();
T val(move(m_data));
T val(std::move(m_data));
reset();
@ -318,7 +318,7 @@ T Maybe<T>::take() {
template <typename T>
bool Maybe<T>::put(T& t) {
if (m_initialized) {
t = move(m_data);
t = std::move(m_data);
reset();
@ -335,7 +335,7 @@ void Maybe<T>::set(T const& t) {
template <typename T>
void Maybe<T>::set(T&& t) {
emplace(forward<T>(t));
emplace(std::forward<T>(t));
}
template <typename T>
@ -343,7 +343,7 @@ template <typename... Args>
void Maybe<T>::emplace(Args&&... t) {
reset();
new (&m_data) T(forward<Args>(t)...);
new (&m_data) T(std::forward<Args>(t)...);
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));
}
m_data[storageIndex(index)] = move(element);
m_data[storageIndex(index)] = std::move(element);
}
template <typename Element, size_t Rank>
Element MultiArray<Element, Rank>::get(IndexArray const& index, Element def) {
for (size_t i = Rank; i != 0; --i) {
if (index[i - 1] >= m_shape[i - 1])
return move(def);
return std::move(def);
}
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);
resize(newShape);
m_data[storageIndex(index)] = move(element);
m_data[storageIndex(index)] = std::move(element);
}
template <typename Element, size_t Rank>
@ -369,26 +369,26 @@ template <typename Element, size_t Rank>
template <typename OpType>
void MultiArray<Element, Rank>::forEach(IndexArray const& min, SizeArray const& size, OpType&& op) {
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 OpType>
void MultiArray<Element, Rank>::forEach(IndexArray const& min, SizeArray const& size, OpType&& op) const {
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 OpType>
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 OpType>
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>
@ -461,7 +461,7 @@ void MultiArray<Element, Rank>::subForEach(IndexArray const& min, SizeArray cons
if (dim == Rank - 1)
op(index, m_data[offset + i]);
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)
op(index, m_data[offset + i]);
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>
void NetElementBasicField<T>::push(T value) {
m_value = move(value);
m_value = std::move(value);
updated();
m_latestUpdateVersion = m_netVersion ? m_netVersion->current() : 0;
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
// any other incoming values.
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 {
m_value = move(t);
m_value = std::move(t);
m_pendingInterpolatedValues->clear();
updated();
}
} else {
m_value = move(t);
m_value = std::move(t);
updated();
}
}
@ -314,7 +314,7 @@ NetElementData<T>::NetElementData()
template <typename T>
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>
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;
for (auto& change : Star::take(m_pendingChangeData))
applyChange(move(change.second));
applyChange(std::move(change.second));
addChangeData(ClearChange());
for (auto const& p : *this)
@ -140,7 +140,7 @@ template <typename BaseMap>
void NetElementMapWrapper<BaseMap>::disableNetInterpolation() {
m_interpolationEnabled = false;
for (auto& change : Star::take(m_pendingChangeData))
applyChange(move(change.second));
applyChange(std::move(change.second));
}
template <typename BaseMap>
@ -175,7 +175,7 @@ void NetElementMapWrapper<BaseMap>::netLoad(DataStream& ds) {
for (uint64_t i = 0; i < count; ++i) {
auto change = readChange(ds);
addChangeData(change);
applyChange(move(change));
applyChange(std::move(change));
}
m_updated = true;
@ -219,9 +219,9 @@ void NetElementMapWrapper<BaseMap>::readNetDelta(DataStream& ds, float interpola
addChangeData(change);
if (m_interpolationEnabled && interpolationTime > 0.0f)
addPendingChangeData(move(change), interpolationTime);
addPendingChangeData(std::move(change), interpolationTime);
else
applyChange(move(change));
applyChange(std::move(change));
} else {
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 res = BaseMap::insert(v);
if (res.second) {
addChangeData(SetChange{move(v.first), move(v.second)});
addChangeData(SetChange{std::move(v.first), std::move(v.second)});
m_updated = true;
}
return res;
@ -260,12 +260,12 @@ auto NetElementMapWrapper<BaseMap>::insert(value_type v) -> pair<const_iterator,
template <typename BaseMap>
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>
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));
}
@ -274,13 +274,13 @@ void NetElementMapWrapper<BaseMap>::set(key_type k, mapped_type v) {
auto i = BaseMap::find(k);
if (i != BaseMap::end()) {
if (!(i->second == v)) {
addChangeData(SetChange{move(k), v});
i->second = move(v);
addChangeData(SetChange{std::move(k), v});
i->second = std::move(v);
m_updated = true;
}
} else {
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;
}
}
@ -289,11 +289,11 @@ template <typename BaseMap>
void NetElementMapWrapper<BaseMap>::push(key_type k, mapped_type v) {
auto i = BaseMap::find(k);
if (i != BaseMap::end()) {
addChangeData(SetChange(move(k), v));
i->second = move(v);
addChangeData(SetChange(std::move(k), v));
i->second = std::move(v);
} else {
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;
}
@ -322,7 +322,7 @@ auto NetElementMapWrapper<BaseMap>::take(key_type const& k) -> mapped_type {
auto i = BaseMap::find(k);
if (i == BaseMap::end())
throw MapException::format("Key '{}' not found in Map::take()", outputAny(k));
auto m = move(i->second);
auto m = std::move(i->second);
erase(i);
return m;
}
@ -332,9 +332,9 @@ auto NetElementMapWrapper<BaseMap>::maybeTake(key_type const& k) -> Maybe<mapped
auto i = BaseMap::find(k);
if (i == BaseMap::end())
return {};
auto m = move(i->second);
auto m = std::move(i->second);
erase(i);
return Maybe<mapped_type>(move(m));
return Maybe<mapped_type>(std::move(m));
}
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>
@ -420,7 +420,7 @@ void NetElementMapWrapper<BaseMap>::addChangeData(ElementChange change) {
uint64_t currentVersion = m_netVersion ? m_netVersion->current() : 0;
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);
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) {
if (!m_pendingChangeData.empty() && interpolationTime < m_pendingChangeData.last().first) {
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>
void NetElementMapWrapper<BaseMap>::applyChange(ElementChange change) {
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>())
BaseMap::remove(move(remove->key));
BaseMap::remove(std::move(remove->key));
else
BaseMap::clear();
m_updated = true;

10
source/core/StarNetElementDynamicGroup.hpp
View File

@ -91,7 +91,7 @@ auto NetElementDynamicGroup<Element>::addNetElement(ElementPtr element) -> Eleme
readyElement(element);
DataStreamBuffer storeBuffer;
element->netStore(storeBuffer);
auto id = m_idMap.add(move(element));
auto id = m_idMap.add(std::move(element));
addChangeData(ElementAddition(id, storeBuffer.takeData()));
@ -192,7 +192,7 @@ void NetElementDynamicGroup<Element>::netLoad(DataStream& ds) {
element->netLoad(storeBuffer);
readyElement(element);
m_idMap.add(id, move(element));
m_idMap.add(id, std::move(element));
addChangeData(ElementAddition(id, storeBuffer.takeData()));
}
}
@ -256,10 +256,10 @@ void NetElementDynamicGroup<Element>::readNetDelta(DataStream& ds, float interpo
m_idMap.clear();
} else if (auto addition = changeUpdate.template ptr<ElementAddition>()) {
ElementPtr element = make_shared<Element>();
DataStreamBuffer storeBuffer(move(get<1>(*addition)));
DataStreamBuffer storeBuffer(std::move(get<1>(*addition)));
element->netLoad(storeBuffer);
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>()) {
m_idMap.remove(*removal);
}
@ -296,7 +296,7 @@ void NetElementDynamicGroup<Element>::addChangeData(ElementChange change) {
uint64_t currentVersion = m_netVersion ? m_netVersion->current() : 0;
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);
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>
void NetElementFloating<T>::setInterpolator(function<T(T, T, T)> interpolator) {
m_interpolator = move(interpolator);
m_interpolator = std::move(interpolator);
}
template <typename T>

8
source/core/StarNetElementSignal.hpp
View File

@ -71,7 +71,7 @@ template <typename Signal>
void NetElementSignal<Signal>::disableNetInterpolation() {
m_netInterpolationEnabled = false;
for (auto& p : take(m_pendingSignals))
send(move(p.second));
send(std::move(p.second));
}
template <typename Signal>
@ -112,11 +112,11 @@ void NetElementSignal<Signal>::readNetDelta(DataStream& ds, float interpolationT
if (m_netInterpolationEnabled && interpolationTime > 0.0f) {
if (!m_pendingSignals.empty() && m_pendingSignals.last().first > interpolationTime) {
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 {
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 NetElementCallbackGroup::setNeedsLoadCallback(function<void(bool)> needsLoadCallback) {
m_netElementsNeedLoad = move(needsLoadCallback);
m_netElementsNeedLoad = std::move(needsLoadCallback);
}
void NetElementCallbackGroup::setNeedsStoreCallback(function<void()> needsStoreCallback) {
m_netElementsNeedStore = move(needsStoreCallback);
m_netElementsNeedStore = std::move(needsStoreCallback);
}
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);
} else {
DataStreamBuffer ds(move(data));
DataStreamBuffer ds(std::move(data));
if (ds.read<bool>())
BaseNetElement::netLoad(ds);

2
source/core/StarObserverStream.hpp
View File

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

18
source/core/StarOptionParser.cpp
View File

@ -4,29 +4,29 @@
namespace Star {
void OptionParser::setCommandName(String commandName) {
m_commandName = move(commandName);
m_commandName = std::move(commandName);
}
void OptionParser::setSummary(String summary) {
m_summary = move(summary);
m_summary = std::move(summary);
}
void OptionParser::setAdditionalHelp(String help) {
m_additionalHelp = move(help);
m_additionalHelp = std::move(help);
}
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);
}
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);
}
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 {
@ -51,7 +51,7 @@ pair<OptionParser::Options, StringList> OptionParser::parseOptions(StringList co
}
if (option->is<Switch>()) {
result.switches.add(move(flag));
result.switches.add(std::move(flag));
} else {
auto const& parameter = option->get<Parameter>();
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));
continue;
}
result.parameters[move(flag)].append(move(val));
result.parameters[std::move(flag)].append(std::move(val));
}
} else {
@ -96,7 +96,7 @@ pair<OptionParser::Options, StringList> OptionParser::parseOptions(StringList co
errors.append(strf(
"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 {

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>
OrderedMapWrapper<Map, Key, Value, Allocator, MapArgs...>::OrderedMapWrapper(initializer_list<value_type> 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>
@ -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 i = m_map.find(k);
if (i == m_map.end())
return move(d);
return std::move(d);
else
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>
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>
@ -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>
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>
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)
throw MapException(strf("Entry with key '{}' already present.", outputAny(k)));
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 i = find(k);
if (i != end()) {
i->second = move(v);
i->second = std::move(v);
return i->second;
} 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 i = m_map.find(v.first);
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));
return orderIt;
} else {
i->second->second = move(v.second);
i->second->second = std::move(v.second);
m_order.splice(pos, m_order, 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> {
List<value_type> values;
for (auto p : *this)
values.append(move(p));
values.append(std::move(p));
return values;
}

2
source/core/StarOutputProxy.hpp
View File

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

8
source/core/StarParametricFunction.hpp
View File

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

10
source/core/StarPerlin.hpp
View File

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

10
source/core/StarPoly.hpp
View File

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

2
source/core/StarPythonic.hpp
View File

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

22
source/core/StarRpcPromise.hpp
View File

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

14
source/core/StarRpcThreadPromise.hpp
View File

@ -66,12 +66,12 @@ private:
template <typename Result, typename Error>
void RpcThreadPromiseKeeper<Result, Error>::fulfill(Result result) {
m_fulfill(move(result));
m_fulfill(std::move(result));
}
template <typename Result, typename Error>
void RpcThreadPromiseKeeper<Result, Error>::fail(Error error) {
m_fail(move(error));
m_fail(std::move(error));
}
template <typename Result, typename Error>
@ -88,22 +88,22 @@ pair<RpcThreadPromise<Result, Error>, RpcThreadPromiseKeeper<Result, Error>> Rpc
MutexLocker lock(valuePtr->mutex);
if (valuePtr->result || valuePtr->error)
throw RpcThreadPromiseException("fulfill called on already finished RpcThreadPromise");
valuePtr->result = move(result);
valuePtr->result = std::move(result);
};
keeper.m_fail = [valuePtr](Error error) {
MutexLocker lock(valuePtr->mutex);
if (valuePtr->result || valuePtr->error)
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>
RpcThreadPromise<Result, Error> RpcThreadPromise<Result, Error>::createFulfilled(Result result) {
auto valuePtr = make_shared<Value>();
valuePtr->result = move(result);
valuePtr->result = std::move(result);
RpcThreadPromise<Result, Error> promise;
promise.m_getValue = [valuePtr]() {
@ -115,7 +115,7 @@ RpcThreadPromise<Result, Error> RpcThreadPromise<Result, Error>::createFulfilled
template <typename Result, typename Error>
RpcThreadPromise<Result, Error> RpcThreadPromise<Result, Error>::createFailed(Error error) {
auto valuePtr = make_shared<Value>();
valuePtr->error = move(error);
valuePtr->error = std::move(error);
RpcThreadPromise<Result, Error> promise;
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>
void SectorArray2D<ElementT, SectorSize>::loadSector(Sector const& id, ArrayPtr array) {
auto& data = m_sectors(id[0], id[1]);
data = move(array);
data = std::move(array);
if (data)
m_loadedSectors.add(id);
else
@ -224,7 +224,7 @@ template <typename ElementT, size_t SectorSize>
typename SectorArray2D<ElementT, SectorSize>::ArrayPtr SectorArray2D<ElementT, SectorSize>::copySector(
Sector const& id) {
if (auto const& array = m_sectors(id))
return make_unique<Array>(*array);
return std::make_unique<Array>(*array);
else
return {};
}
@ -235,7 +235,7 @@ typename SectorArray2D<ElementT, SectorSize>::ArrayPtr SectorArray2D<ElementT, S
ArrayPtr ret;
m_loadedSectors.remove(id);
std::swap(m_sectors(id[0], id[1]), ret);
return move(ret);
return std::move(ret);
}
template <typename ElementT, size_t SectorSize>
@ -268,14 +268,14 @@ template <typename ElementT, size_t SectorSize>
template <typename Function>
bool SectorArray2D<ElementT, SectorSize>::eval(
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 Function>
bool SectorArray2D<ElementT, SectorSize>::eval(
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>
@ -283,14 +283,14 @@ template <typename Function>
bool SectorArray2D<ElementT, SectorSize>::evalColumns(
size_t minX, size_t minY, size_t width, size_t height, Function&& function, bool evalEmpty) const {
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 Function>
bool SectorArray2D<ElementT, SectorSize>::evalColumns(
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>

14
source/core/StarSet.hpp
View File

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

2
source/core/StarShellParser.cpp
View File

@ -21,7 +21,7 @@ StringList ShellParser::tokenizeToStringList(String const& command) {
StringList res;
for (auto token : tokenize(command)) {
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() {
for (auto& e : other)
emplace_back(move(e));
emplace_back(std::move(e));
}
template <typename Element, size_t MaxStackSize>
@ -169,7 +169,7 @@ template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::operator=(SmallVector&& other) -> SmallVector& {
resize(other.size());
for (size_t i = 0; i < size(); ++i)
operator[](i) = move(other[i]);
operator[](i) = std::move(other[i]);
return *this;
}
@ -178,7 +178,7 @@ template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::operator=(std::initializer_list<Element> list) -> SmallVector& {
resize(list.size());
for (size_t i = 0; i < size(); ++i)
operator[](i) = move(list[i]);
operator[](i) = std::move(list[i]);
return *this;
}
@ -217,7 +217,7 @@ void SmallVector<Element, MaxStackSize>::reserve(size_t newCapacity) {
// We assume that move constructors can never throw.
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;
@ -313,7 +313,7 @@ Element* SmallVector<Element, MaxStackSize>::ptr() {
template <typename Element, size_t MaxStackSize>
void SmallVector<Element, MaxStackSize>::push_back(Element e) {
emplace_back(move(e));
emplace_back(std::move(e));
}
template <typename Element, size_t MaxStackSize>
@ -326,7 +326,7 @@ void SmallVector<Element, MaxStackSize>::pop_back() {
template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::insert(iterator pos, Element e) -> iterator {
emplace(pos, move(e));
emplace(pos, std::move(e));
return pos;
}
@ -341,7 +341,7 @@ auto SmallVector<Element, MaxStackSize>::insert(iterator pos, Iterator begin, It
resize(size() + toAdd);
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)
operator[](startIndex + i) = *begin++;
@ -360,8 +360,8 @@ void SmallVector<Element, MaxStackSize>::emplace(iterator pos, Args&&... args) {
size_t index = pos - m_begin;
emplace_back(Element());
for (size_t i = size() - 1; i != index; --i)
operator[](i) = move(operator[](i - 1));
operator[](index) = Element(forward<Args>(args)...);
operator[](i) = std::move(operator[](i - 1));
operator[](index) = Element(std::forward<Args>(args)...);
}
template <typename Element, size_t MaxStackSize>
@ -369,7 +369,7 @@ template <typename... Args>
void SmallVector<Element, MaxStackSize>::emplace_back(Args&&... args) {
if (m_end == m_capacity)
reserve(size() + 1);
new (m_end) Element(forward<Args>(args)...);
new (m_end) Element(std::forward<Args>(args)...);
++m_end;
}
@ -383,7 +383,7 @@ template <typename Element, size_t MaxStackSize>
auto SmallVector<Element, MaxStackSize>::erase(iterator pos) -> iterator {
size_t index = pos - ptr();
for (size_t i = index; i < size() - 1; ++i)
operator[](i) = move(operator[](i + 1));
operator[](i) = std::move(operator[](i + 1));
pop_back();
return pos;
}
@ -394,7 +394,7 @@ auto SmallVector<Element, MaxStackSize>::erase(iterator begin, iterator end) ->
size_t endIndex = end - ptr();
size_t toRemove = endIndex - startIndex;
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);
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;
if (pfd.revents & POLLHUP)
p.first.first->doShutdown();
result.add(p.first.first, move(pr));
result.add(p.first.first, std::move(pr));
}
}
#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>
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>
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 RectCollection>
void SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::set(Key const& key, RectCollection const& rects, Value value) {
Entry& entry = m_entryMap[key];
entry.value = move(value);
entry.value = std::move(value);
updateSpatial(&entry, rects);
}
@ -262,7 +262,7 @@ auto SpatialHash2D<KeyT, ScalarT, ValueT, IntT, AllocatorBlockSize>::remove(Key
return {};
removeSpatial(&iter->second);
Maybe<Value> val = move(iter->second.value);
Maybe<Value> val = std::move(iter->second.value);
m_entryMap.erase(iter);
return val;
}

22
source/core/StarStaticVector.hpp
View File

@ -115,7 +115,7 @@ template <typename Element, size_t MaxSize>
StaticVector<Element, MaxSize>::StaticVector(StaticVector&& other)
: StaticVector() {
for (auto& e : other)
emplace_back(move(e));
emplace_back(std::move(e));
}
template <typename Element, size_t MaxSize>
@ -162,7 +162,7 @@ template <typename Element, size_t MaxSize>
auto StaticVector<Element, MaxSize>::operator=(StaticVector&& other) -> StaticVector& {
resize(other.size());
for (size_t i = 0; i < m_size; ++i)
operator[](i) = move(other[i]);
operator[](i) = std::move(other[i]);
return *this;
}
@ -171,7 +171,7 @@ template <typename Element, size_t MaxSize>
auto StaticVector<Element, MaxSize>::operator=(std::initializer_list<Element> list) -> StaticVector& {
resize(list.size());
for (size_t i = 0; i < m_size; ++i)
operator[](i) = move(list[i]);
operator[](i) = std::move(list[i]);
return *this;
}
@ -274,7 +274,7 @@ Element* StaticVector<Element, MaxSize>::ptr() {
template <typename Element, size_t MaxSize>
void StaticVector<Element, MaxSize>::push_back(Element e) {
emplace_back(move(e));
emplace_back(std::move(e));
}
template <typename Element, size_t MaxSize>
@ -287,7 +287,7 @@ void StaticVector<Element, MaxSize>::pop_back() {
template <typename Element, size_t MaxSize>
auto StaticVector<Element, MaxSize>::insert(iterator pos, Element e) -> iterator {
emplace(pos, move(e));
emplace(pos, std::move(e));
return pos;
}
@ -302,7 +302,7 @@ auto StaticVector<Element, MaxSize>::insert(iterator pos, Iterator begin, Iterat
resize(m_size + toAdd);
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)
operator[](startIndex + i) = *begin++;
@ -321,8 +321,8 @@ void StaticVector<Element, MaxSize>::emplace(iterator pos, Args&&... args) {
size_t index = pos - ptr();
resize(m_size + 1);
for (size_t i = m_size - 1; i != index; --i)
operator[](i) = move(operator[](i - 1));
operator[](index) = Element(forward<Args>(args)...);
operator[](i) = std::move(operator[](i - 1));
operator[](index) = Element(std::forward<Args>(args)...);
}
template <typename Element, size_t MaxSize>
@ -332,7 +332,7 @@ void StaticVector<Element, MaxSize>::emplace_back(Args&&... args) {
throw StaticVectorSizeException::format("StaticVector::emplace_back would extend StaticVector beyond size {}", MaxSize);
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>
@ -345,7 +345,7 @@ template <typename Element, size_t MaxSize>
auto StaticVector<Element, MaxSize>::erase(iterator pos) -> iterator {
size_t index = pos - ptr();
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);
return pos;
}
@ -356,7 +356,7 @@ auto StaticVector<Element, MaxSize>::erase(iterator begin, iterator end) -> iter
size_t endIndex = end - ptr();
size_t toRemove = endIndex - startIndex;
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);
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())
ret.append(move(next));
ret.append(std::move(next));
return ret;
}
@ -661,43 +661,43 @@ void String::append(Char c) {
void String::prepend(String const& s) {
auto ns = s;
ns.append(*this);
*this = move(ns);
*this = std::move(ns);
}
void String::prepend(std::string const& s) {
auto ns = String(s);
ns.append(*this);
*this = move(ns);
*this = std::move(ns);
}
void String::prepend(Char const* s) {
auto ns = String(s);
ns.append(*this);
*this = move(ns);
*this = std::move(ns);
}
void String::prepend(Char const* s, size_t n) {
auto ns = String(s, n);
ns.append(*this);
*this = move(ns);
*this = std::move(ns);
}
void String::prepend(char const* s) {
auto ns = String(s);
ns.append(*this);
*this = move(ns);
*this = std::move(ns);
}
void String::prepend(char const* s, size_t n) {
auto ns = String(s, n);
ns.append(*this);
*this = move(ns);
*this = std::move(ns);
}
void String::prepend(Char c) {
auto ns = String(c, 1);
ns.append(*this);
*this = move(ns);
*this = std::move(ns);
}
void String::push_back(Char c) {
@ -809,7 +809,7 @@ String& String::operator=(String const& s) {
}
String& String::operator=(String&& s) {
m_string = move(s.m_string);
m_string = std::move(s.m_string);
return *this;
}

2
source/core/StarString.hpp
View File

@ -473,7 +473,7 @@ Maybe<String> String::maybeLookupTagsView(Lookup&& lookup) const {
template <typename Lookup>
String String::lookupTagsView(Lookup&& lookup) const {
auto result = maybeLookupTagsView(lookup);
return result ? move(result.take()) : String();
return result ? std::move(result.take()) : String();
}
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 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(char const* s) : m_view(s) {};
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&& 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(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>
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>
@ -364,7 +364,7 @@ ThreadFunction<Return>::ThreadFunction(ThreadFunction&&) = default;
template <typename Return>
ThreadFunction<Return>::ThreadFunction(function<Return()> function, String const& name) {
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();
}, name);
}

6
source/core/StarThread_unix.cpp
View File

@ -101,10 +101,10 @@ struct ThreadImpl {
struct ThreadFunctionImpl : ThreadImpl {
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) {
return [function = move(function), this]() {
return [function = std::move(function), this]() {
try {
function();
} catch (...) {
@ -283,7 +283,7 @@ ThreadFunction<void>::ThreadFunction() {}
ThreadFunction<void>::ThreadFunction(ThreadFunction&&) = default;
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();
}

6
source/core/StarThread_windows.cpp
View File

@ -106,10 +106,10 @@ private:
struct ThreadFunctionImpl : ThreadImpl {
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) {
return [function = move(function), this]() {
return [function = std::move(function), this]() {
try {
function();
} catch (...) {
@ -437,7 +437,7 @@ ThreadFunction<void>::ThreadFunction() {}
ThreadFunction<void>::ThreadFunction(ThreadFunction&&) = default;
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();
}

2
source/core/StarTtlCache.hpp
View File

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

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