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

Merge pull request #19 from kblaschke/fix-compiler-warnings

Browse Source 
Fixed a huge amount of Clang warnings
This commit is contained in:
Kae 2024-02-20 09:47:10 +11:00 committed by GitHub
commit 1c89042016
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
274 changed files with 1456 additions and 1445 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 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 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));
}
};

12
source/core/StarMap.hpp
View File

@ -172,7 +172,7 @@ auto MapMixin<BaseMap>::maybeTake(key_type const& k) -> Maybe<mapped_type> {
if (i != Base::end()) {
mapped_type v = std::move(i->second);
Base::erase(i);
return move(v);
return v;
}
return {};
@ -198,7 +198,7 @@ template <typename BaseMap>
auto MapMixin<BaseMap>::value(key_type const& k, mapped_type d) const -> mapped_type {
const_iterator i = Base::find(k);
if (i == Base::end())
return std::move(d);
return d;
else
return i->second;
}
@ -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 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 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