reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-11-24 20:19:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

clang-tidy: Pass by value

Browse Source
This commit is contained in:
Regina Pfeifer 2019-01-21 17:15:21 +01:00 committed by Brad King
parent bcc9ea2b3d
commit 5a0784ddea
74 changed files with 265 additions and 257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.clang-tidy
View File

@ -11,7 +11,6 @@ misc-*,\
-misc-static-assert,\
modernize-*,\
-modernize-deprecated-headers,\
-modernize-pass-by-value,\
-modernize-raw-string-literal,\
-modernize-return-braced-init-list,\
-modernize-use-auto,\

50
Source/CPack/cmCPackDebGenerator.cxx
View File

@ -23,17 +23,15 @@ namespace {
class DebGenerator
{
public:
DebGenerator(cmCPackLog* logger, std::string const& outputName,
std::string const& workDir, std::string const& topLevelDir,
std::string const& temporaryDir,
DebGenerator(cmCPackLog* logger, std::string outputName, std::string workDir,
std::string topLevelDir, std::string temporaryDir,
const char* debianCompressionType,
const char* debianArchiveType,
std::map<std::string, std::string> const& controlValues,
bool genShLibs, std::string const& shLibsFilename,
bool genPostInst, std::string const& postInst, bool genPostRm,
std::string const& postRm, const char* controlExtra,
bool permissionStrctPolicy,
std::vector<std::string> const& packageFiles);
std::map<std::string, std::string> controlValues,
bool genShLibs, std::string shLibsFilename, bool genPostInst,
std::string postInst, bool genPostRm, std::string postRm,
const char* controlExtra, bool permissionStrctPolicy,
std::vector<std::string> packageFiles);
bool generate() const;
@ -66,31 +64,29 @@ private:
};
DebGenerator::DebGenerator(
cmCPackLog* logger, std::string const& outputName,
std::string const& workDir, std::string const& topLevelDir,
std::string const& temporaryDir, const char* debianCompressionType,
const char* debianArchiveType,
std::map<std::string, std::string> const& controlValues, bool genShLibs,
std::string const& shLibsFilename, bool genPostInst,
std::string const& postInst, bool genPostRm, std::string const& postRm,
const char* controlExtra, bool permissionStrictPolicy,
std::vector<std::string> const& packageFiles)
cmCPackLog* logger, std::string outputName, std::string workDir,
std::string topLevelDir, std::string temporaryDir,
const char* debianCompressionType, const char* debianArchiveType,
std::map<std::string, std::string> controlValues, bool genShLibs,
std::string shLibsFilename, bool genPostInst, std::string postInst,
bool genPostRm, std::string postRm, const char* controlExtra,
bool permissionStrictPolicy, std::vector<std::string> packageFiles)
: Logger(logger)
, OutputName(outputName)
, WorkDir(workDir)
, TopLevelDir(topLevelDir)
, TemporaryDir(temporaryDir)
, OutputName(std::move(outputName))
, WorkDir(std::move(workDir))
, TopLevelDir(std::move(topLevelDir))
, TemporaryDir(std::move(temporaryDir))
, DebianArchiveType(debianArchiveType ? debianArchiveType : "gnutar")
, ControlValues(controlValues)
, ControlValues(std::move(controlValues))
, GenShLibs(genShLibs)
, ShLibsFilename(shLibsFilename)
, ShLibsFilename(std::move(shLibsFilename))
, GenPostInst(genPostInst)
, PostInst(postInst)
, PostInst(std::move(postInst))
, GenPostRm(genPostRm)
, PostRm(postRm)
, PostRm(std::move(postRm))
, ControlExtra(controlExtra)
, PermissionStrictPolicy(permissionStrictPolicy)
, PackageFiles(packageFiles)
, PackageFiles(std::move(packageFiles))
{
if (!debianCompressionType) {
debianCompressionType = "gzip";

9
Source/CPack/cmCPackFreeBSDGenerator.cxx
View File

@ -17,6 +17,7 @@
#include <pkg.h>
#include <algorithm>
#include <utility>
cmCPackFreeBSDGenerator::cmCPackFreeBSDGenerator()
: cmCPackArchiveGenerator(cmArchiveWrite::CompressXZ, "paxr")
@ -97,8 +98,8 @@ class ManifestKey
public:
std::string key;
ManifestKey(const std::string& k)
: key(k)
ManifestKey(std::string k)
: key(std::move(k))
{
}
@ -115,9 +116,9 @@ class ManifestKeyValue : public ManifestKey
public:
std::string value;
ManifestKeyValue(const std::string& k, const std::string& v)
ManifestKeyValue(const std::string& k, std::string v)
: ManifestKey(k)
, value(v)
, value(std::move(v))
{
}

5
Source/CursesDialog/cmCursesMainForm.cxx
View File

@ -20,15 +20,16 @@
#include <algorithm>
#include <stdio.h>
#include <string.h>
#include <utility>
inline int ctrl(int z)
{
return (z & 037);
}
cmCursesMainForm::cmCursesMainForm(std::vector<std::string> const& args,
cmCursesMainForm::cmCursesMainForm(std::vector<std::string> args,
int initWidth)
: Args(args)
: Args(std::move(args))
, InitialWidth(initWidth)
{
this->NumberOfPages = 0;

2
Source/CursesDialog/cmCursesMainForm.h
View File

@ -26,7 +26,7 @@ class cmCursesMainForm : public cmCursesForm
CM_DISABLE_COPY(cmCursesMainForm)
public:
cmCursesMainForm(std::vector<std::string> const& args, int initwidth);
cmCursesMainForm(std::vector<std::string> args, int initwidth);
~cmCursesMainForm() override;
/**

5
Source/QtDialog/QCMakeWidgets.cxx
View File

@ -7,10 +7,11 @@
#include <QFileInfo>
#include <QResizeEvent>
#include <QToolButton>
#include <utility>
QCMakeFileEditor::QCMakeFileEditor(QWidget* p, const QString& var)
QCMakeFileEditor::QCMakeFileEditor(QWidget* p, QString var)
: QLineEdit(p)
, Variable(var)
, Variable(std::move(var))
{
this->ToolButton = new QToolButton(this);
this->ToolButton->setText("...");

2
Source/QtDialog/QCMakeWidgets.h
View File

@ -18,7 +18,7 @@ class QCMakeFileEditor : public QLineEdit
{
Q_OBJECT
public:
QCMakeFileEditor(QWidget* p, const QString& var);
QCMakeFileEditor(QWidget* p, QString var);
protected slots:
virtual void chooseFile() = 0;
signals:

4
Source/cmAlgorithms.h
View File

@ -61,8 +61,8 @@ struct cmStrCmp
: m_test(test)
{
}
cmStrCmp(const std::string& test)
: m_test(test)
cmStrCmp(std::string test)
: m_test(std::move(test))
{
}

6
Source/cmComputeLinkInformation.h
View File

@ -9,6 +9,7 @@
#include <iosfwd>
#include <set>
#include <string>
#include <utility>
#include <vector>
class cmGeneratorTarget;
@ -31,9 +32,8 @@ public:
struct Item
{
Item() {}
Item(std::string const& v, bool p,
cmGeneratorTarget const* target = nullptr)
: Value(v)
Item(std::string v, bool p, cmGeneratorTarget const* target = nullptr)
: Value(std::move(v))
, IsPath(p)
, Target(target)
{

9
Source/cmConditionEvaluator.cxx
View File

@ -8,6 +8,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <utility>
#include "cmAlgorithms.h"
#include "cmMakefile.h"
@ -53,11 +54,11 @@ static std::string const keyVERSION_LESS = "VERSION_LESS";
static std::string const keyVERSION_LESS_EQUAL = "VERSION_LESS_EQUAL";
cmConditionEvaluator::cmConditionEvaluator(cmMakefile& makefile,
const cmListFileContext& context,
const cmListFileBacktrace& bt)
cmListFileContext context,
cmListFileBacktrace bt)
: Makefile(makefile)
, ExecutionContext(context)
, Backtrace(bt)
, ExecutionContext(std::move(context))
, Backtrace(std::move(bt))
, Policy12Status(makefile.GetPolicyStatus(cmPolicies::CMP0012))
, Policy54Status(makefile.GetPolicyStatus(cmPolicies::CMP0054))
, Policy57Status(makefile.GetPolicyStatus(cmPolicies::CMP0057))

4
Source/cmConditionEvaluator.h
View File

@ -21,8 +21,8 @@ class cmConditionEvaluator
public:
typedef std::list<cmExpandedCommandArgument> cmArgumentList;
cmConditionEvaluator(cmMakefile& makefile, cmListFileContext const& context,
cmListFileBacktrace const& bt);
cmConditionEvaluator(cmMakefile& makefile, cmListFileContext context,
cmListFileBacktrace bt);
// this is a shared function for both If and Else to determine if the
// arguments were valid, and if so, was the response true. If there is

18
Source/cmCustomCommand.cxx
View File

@ -4,17 +4,19 @@
#include "cmMakefile.h"
#include <utility>
cmCustomCommand::cmCustomCommand(cmMakefile const* mf,
const std::vector<std::string>& outputs,
const std::vector<std::string>& byproducts,
const std::vector<std::string>& depends,
const cmCustomCommandLines& commandLines,
std::vector<std::string> outputs,
std::vector<std::string> byproducts,
std::vector<std::string> depends,
cmCustomCommandLines commandLines,
const char* comment,
const char* workingDirectory)
: Outputs(outputs)
, Byproducts(byproducts)
, Depends(depends)
, CommandLines(commandLines)
: Outputs(std::move(outputs))
, Byproducts(std::move(byproducts))
, Depends(std::move(depends))
, CommandLines(std::move(commandLines))
, Comment(comment ? comment : "")
, WorkingDirectory(workingDirectory ? workingDirectory : "")
, HaveComment(comment != nullptr)

11
Source/cmCustomCommand.h
View File

@ -23,12 +23,11 @@ class cmCustomCommand
{
public:
/** Main constructor specifies all information for the command. */
cmCustomCommand(cmMakefile const* mf,
const std::vector<std::string>& outputs,
const std::vector<std::string>& byproducts,
const std::vector<std::string>& depends,
const cmCustomCommandLines& commandLines,
const char* comment, const char* workingDirectory);
cmCustomCommand(cmMakefile const* mf, std::vector<std::string> outputs,
std::vector<std::string> byproducts,
std::vector<std::string> depends,
cmCustomCommandLines commandLines, const char* comment,
const char* workingDirectory);
/** Get the output file produced by the command. */
const std::vector<std::string>& GetOutputs() const;

4
Source/cmCustomCommandGenerator.cxx
View File

@ -16,10 +16,10 @@
#include <utility>
cmCustomCommandGenerator::cmCustomCommandGenerator(cmCustomCommand const& cc,
const std::string& config,
std::string config,
cmLocalGenerator* lg)
: CC(cc)
, Config(config)
, Config(std::move(config))
, LG(lg)
, OldStyle(cc.GetEscapeOldStyle())
, MakeVars(cc.GetEscapeAllowMakeVars())

4
Source/cmCustomCommandGenerator.h
View File

@ -29,8 +29,8 @@ class cmCustomCommandGenerator
const char* GetArgv0Location(unsigned int c) const;
public:
cmCustomCommandGenerator(cmCustomCommand const& cc,
const std::string& config, cmLocalGenerator* lg);
cmCustomCommandGenerator(cmCustomCommand const& cc, std::string config,
cmLocalGenerator* lg);
~cmCustomCommandGenerator();
cmCustomCommand const& GetCC() const { return this->CC; }
unsigned int GetNumberOfCommands() const;

4
Source/cmDepends.cxx
View File

@ -13,9 +13,9 @@
#include <string.h>
#include <utility>
cmDepends::cmDepends(cmLocalGenerator* lg, const std::string& targetDir)
cmDepends::cmDepends(cmLocalGenerator* lg, std::string targetDir)
: LocalGenerator(lg)
, TargetDirectory(targetDir)
, TargetDirectory(std::move(targetDir))
, Dependee(new char[MaxPath])
, Depender(new char[MaxPath])
{

2
Source/cmDepends.h
View File

@ -29,7 +29,7 @@ class cmDepends
public:
/** Instances need to know the build directory name and the relative
path from the build directory to the target file. */
cmDepends(cmLocalGenerator* lg = nullptr, const std::string& targetDir = "");
cmDepends(cmLocalGenerator* lg = nullptr, std::string targetDir = "");
/** Set the local generator for the directory in which we are
scanning dependencies. This is not a full local generator; it

6
Source/cmExpandedCommandArgument.cxx
View File

@ -2,13 +2,15 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmExpandedCommandArgument.h"
#include <utility>
cmExpandedCommandArgument::cmExpandedCommandArgument()
{
}
cmExpandedCommandArgument::cmExpandedCommandArgument(std::string const& value,
cmExpandedCommandArgument::cmExpandedCommandArgument(std::string value,
bool quoted)
: Value(value)
: Value(std::move(value))
, Quoted(quoted)
{
}

2
Source/cmExpandedCommandArgument.h
View File

@ -18,7 +18,7 @@ class cmExpandedCommandArgument
{
public:
cmExpandedCommandArgument();
cmExpandedCommandArgument(std::string const& value, bool quoted);
cmExpandedCommandArgument(std::string value, bool quoted);
std::string const& GetValue() const;

5
Source/cmExportSet.h
View File

@ -6,6 +6,7 @@
#include "cmConfigure.h" // IWYU pragma: keep
#include <string>
#include <utility>
#include <vector>
class cmInstallExportGenerator;
@ -17,8 +18,8 @@ class cmExportSet
{
public:
/// Construct an empty export set named \a name
cmExportSet(const std::string& name)
: Name(name)
cmExportSet(std::string name)
: Name(std::move(name))
{
}
/// Destructor

9
Source/cmExternalMakefileProjectGenerator.cxx
View File

@ -2,6 +2,8 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmExternalMakefileProjectGenerator.h"
#include <utility>
class cmMakefile;
void cmExternalMakefileProjectGenerator::EnableLanguage(
@ -32,10 +34,9 @@ bool cmExternalMakefileProjectGenerator::Open(
}
cmExternalMakefileProjectGeneratorFactory::
cmExternalMakefileProjectGeneratorFactory(const std::string& n,
const std::string& doc)
: Name(n)
, Documentation(doc)
cmExternalMakefileProjectGeneratorFactory(std::string n, std::string doc)
: Name(std::move(n))
, Documentation(std::move(doc))
{
}

3
Source/cmExternalMakefileProjectGenerator.h
View File

@ -70,8 +70,7 @@ protected:
class cmExternalMakefileProjectGeneratorFactory
{
public:
cmExternalMakefileProjectGeneratorFactory(const std::string& n,
const std::string& doc);
cmExternalMakefileProjectGeneratorFactory(std::string n, std::string doc);
virtual ~cmExternalMakefileProjectGeneratorFactory();
std::string GetName() const;

6
Source/cmFileAPICodemodel.cxx
View File

@ -166,13 +166,13 @@ class BacktraceData
}
public:
BacktraceData(std::string const& topSource);
BacktraceData(std::string topSource);
bool Add(cmListFileBacktrace const& bt, Json::ArrayIndex& index);
Json::Value Dump();
};
BacktraceData::BacktraceData(std::string const& topSource)
: TopSource(topSource)
BacktraceData::BacktraceData(std::string topSource)
: TopSource(std::move(topSource))
{
}

12
Source/cmFindPackageCommand.cxx
View File

@ -1760,8 +1760,8 @@ bool cmFileListGeneratorBase::Consider(std::string const& fullPath,
class cmFileListGeneratorFixed : public cmFileListGeneratorBase
{
public:
cmFileListGeneratorFixed(std::string const& str)
: String(str)
cmFileListGeneratorFixed(std::string str)
: String(std::move(str))
{
}
cmFileListGeneratorFixed(cmFileListGeneratorFixed const& r)
@ -1940,8 +1940,8 @@ private:
class cmFileListGeneratorCaseInsensitive : public cmFileListGeneratorBase
{
public:
cmFileListGeneratorCaseInsensitive(std::string const& str)
: String(str)
cmFileListGeneratorCaseInsensitive(std::string str)
: String(std::move(str))
{
}
cmFileListGeneratorCaseInsensitive(
@ -1982,8 +1982,8 @@ private:
class cmFileListGeneratorGlob : public cmFileListGeneratorBase
{
public:
cmFileListGeneratorGlob(std::string const& str)
: Pattern(str)
cmFileListGeneratorGlob(std::string str)
: Pattern(std::move(str))
{
}
cmFileListGeneratorGlob(cmFileListGeneratorGlob const& r)

10
Source/cmFortranParser.h
View File

@ -8,6 +8,7 @@
# include <set>
# include <string>
# include <utility>
# include <vector>
#endif
@ -114,10 +115,10 @@ int cmFortran_yyparse(yyscan_t);
// Define parser object internal structure.
struct cmFortranFile
{
cmFortranFile(FILE* file, YY_BUFFER_STATE buffer, const std::string& dir)
cmFortranFile(FILE* file, YY_BUFFER_STATE buffer, std::string dir)
: File(file)
, Buffer(buffer)
, Directory(dir)
, Directory(std::move(dir))
, LastCharWasNewline(false)
{
}
@ -129,9 +130,8 @@ struct cmFortranFile
struct cmFortranParser_s
{
cmFortranParser_s(std::vector<std::string> const& includes,
std::set<std::string> const& defines,
cmFortranSourceInfo& info);
cmFortranParser_s(std::vector<std::string> includes,
std::set<std::string> defines, cmFortranSourceInfo& info);
~cmFortranParser_s();
bool FindIncludeFile(const char* dir, const char* includeName,

9
Source/cmFortranParserImpl.cxx
View File

@ -8,6 +8,7 @@
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
bool cmFortranParser_s::FindIncludeFile(const char* dir,
@ -42,11 +43,11 @@ bool cmFortranParser_s::FindIncludeFile(const char* dir,
return false;
}
cmFortranParser_s::cmFortranParser_s(std::vector<std::string> const& includes,
std::set<std::string> const& defines,
cmFortranParser_s::cmFortranParser_s(std::vector<std::string> includes,
std::set<std::string> defines,
cmFortranSourceInfo& info)
: IncludePath(includes)
, PPDefinitions(defines)
: IncludePath(std::move(includes))
, PPDefinitions(std::move(defines))
, Info(info)
{
this->InInterface = false;

11
Source/cmGeneratorExpression.cxx
View File

@ -15,9 +15,8 @@
#include "cmGeneratorExpressionParser.h"
#include "cmSystemTools.h"
cmGeneratorExpression::cmGeneratorExpression(
const cmListFileBacktrace& backtrace)
: Backtrace(backtrace)
cmGeneratorExpression::cmGeneratorExpression(cmListFileBacktrace backtrace)
: Backtrace(std::move(backtrace))
{
}
@ -96,9 +95,9 @@ const std::string& cmCompiledGeneratorExpression::EvaluateWithContext(
}
cmCompiledGeneratorExpression::cmCompiledGeneratorExpression(
cmListFileBacktrace const& backtrace, const std::string& input)
: Backtrace(backtrace)
, Input(input)
cmListFileBacktrace backtrace, std::string input)
: Backtrace(std::move(backtrace))
, Input(std::move(input))
, HadContextSensitiveCondition(false)
, HadHeadSensitiveCondition(false)
, EvaluateForBuildsystem(false)

16
Source/cmGeneratorExpression.h
View File

@ -11,6 +11,7 @@
#include <memory> // IWYU pragma: keep
#include <set>
#include <string>
#include <utility>
#include <vector>
class cmCompiledGeneratorExpression;
@ -35,8 +36,7 @@ class cmGeneratorExpression
public:
/** Construct. */
cmGeneratorExpression(
cmListFileBacktrace const& backtrace = cmListFileBacktrace());
cmGeneratorExpression(cmListFileBacktrace backtrace = cmListFileBacktrace());
~cmGeneratorExpression();
std::unique_ptr<cmCompiledGeneratorExpression> Parse(
@ -140,8 +140,8 @@ private:
cmGeneratorExpressionContext& context,
cmGeneratorExpressionDAGChecker* dagChecker) const;
cmCompiledGeneratorExpression(cmListFileBacktrace const& backtrace,
const std::string& input);
cmCompiledGeneratorExpression(cmListFileBacktrace backtrace,
std::string input);
friend class cmGeneratorExpression;
@ -169,13 +169,13 @@ class cmGeneratorExpressionInterpreter
public:
cmGeneratorExpressionInterpreter(cmLocalGenerator* localGenerator,
std::string const& config,
std::string config,
cmGeneratorTarget const* headTarget,
std::string const& lang = std::string())
std::string lang = std::string())
: LocalGenerator(localGenerator)
, Config(config)
, Config(std::move(config))
, HeadTarget(headTarget)
, Language(lang)
, Language(std::move(lang))
{
}

14
Source/cmGeneratorExpressionContext.cxx
View File

@ -2,15 +2,17 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmGeneratorExpressionContext.h"
#include <utility>
cmGeneratorExpressionContext::cmGeneratorExpressionContext(
cmLocalGenerator* lg, std::string const& config, bool quiet,
cmLocalGenerator* lg, std::string config, bool quiet,
cmGeneratorTarget const* headTarget, const cmGeneratorTarget* currentTarget,
bool evaluateForBuildsystem, cmListFileBacktrace const& backtrace,
std::string const& language)
: Backtrace(backtrace)
bool evaluateForBuildsystem, cmListFileBacktrace backtrace,
std::string language)
: Backtrace(std::move(backtrace))
, LG(lg)
, Config(config)
, Language(language)
, Config(std::move(config))
, Language(std::move(language))
, HeadTarget(headTarget)
, CurrentTarget(currentTarget)
, Quiet(quiet)

6
Source/cmGeneratorExpressionContext.h
View File

@ -14,12 +14,12 @@ class cmLocalGenerator;
struct cmGeneratorExpressionContext
{
cmGeneratorExpressionContext(cmLocalGenerator* lg, std::string const& config,
cmGeneratorExpressionContext(cmLocalGenerator* lg, std::string config,
bool quiet, const cmGeneratorTarget* headTarget,
cmGeneratorTarget const* currentTarget,
bool evaluateForBuildsystem,
cmListFileBacktrace const& backtrace,
std::string const& language);
cmListFileBacktrace backtrace,
std::string language);
cmListFileBacktrace Backtrace;
std::set<cmGeneratorTarget*> DependTargets;

12
Source/cmGeneratorExpressionDAGChecker.cxx
View File

@ -15,26 +15,26 @@
#include <utility>
cmGeneratorExpressionDAGChecker::cmGeneratorExpressionDAGChecker(
const cmListFileBacktrace& backtrace, cmGeneratorTarget const* target,
const std::string& property, const GeneratorExpressionContent* content,
cmListFileBacktrace backtrace, cmGeneratorTarget const* target,
std::string property, const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* parent)
: Parent(parent)
, Target(target)
, Property(property)
, Property(std::move(property))
, Content(content)
, Backtrace(backtrace)
, Backtrace(std::move(backtrace))
, TransitivePropertiesOnly(false)
{
Initialize();
}
cmGeneratorExpressionDAGChecker::cmGeneratorExpressionDAGChecker(
cmGeneratorTarget const* target, const std::string& property,
cmGeneratorTarget const* target, std::string property,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* parent)
: Parent(parent)
, Target(target)
, Property(property)
, Property(std::move(property))
, Content(content)
, Backtrace()
, TransitivePropertiesOnly(false)

6
Source/cmGeneratorExpressionDAGChecker.h
View File

@ -42,13 +42,13 @@ class cmGeneratorTarget;
struct cmGeneratorExpressionDAGChecker
{
cmGeneratorExpressionDAGChecker(const cmListFileBacktrace& backtrace,
cmGeneratorExpressionDAGChecker(cmListFileBacktrace backtrace,
cmGeneratorTarget const* target,
const std::string& property,
std::string property,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* parent);
cmGeneratorExpressionDAGChecker(cmGeneratorTarget const* target,
const std::string& property,
std::string property,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker* parent);

4
Source/cmGeneratorExpressionEvaluationFile.cxx
View File

@ -18,11 +18,11 @@
#include "cmSystemTools.h"
cmGeneratorExpressionEvaluationFile::cmGeneratorExpressionEvaluationFile(
const std::string& input,
std::string input,
std::unique_ptr<cmCompiledGeneratorExpression> outputFileExpr,
std::unique_ptr<cmCompiledGeneratorExpression> condition,
bool inputIsContent, cmPolicies::PolicyStatus policyStatusCMP0070)
: Input(input)
: Input(std::move(input))
, OutputFileExpr(std::move(outputFileExpr))
, Condition(std::move(condition))
, InputIsContent(inputIsContent)

2
Source/cmGeneratorExpressionEvaluationFile.h
View File

@ -20,7 +20,7 @@ class cmGeneratorExpressionEvaluationFile
{
public:
cmGeneratorExpressionEvaluationFile(
const std::string& input,
std::string input,
std::unique_ptr<cmCompiledGeneratorExpression> outputFileExpr,
std::unique_ptr<cmCompiledGeneratorExpression> condition,
bool inputIsContent, cmPolicies::PolicyStatus policyStatusCMP0070);

4
Source/cmGeneratorExpressionParser.cxx
View File

@ -9,8 +9,8 @@
#include <utility>
cmGeneratorExpressionParser::cmGeneratorExpressionParser(
const std::vector<cmGeneratorExpressionToken>& tokens)
: Tokens(tokens)
std::vector<cmGeneratorExpressionToken> tokens)
: Tokens(std::move(tokens))
, NestingLevel(0)
{
}

3
Source/cmGeneratorExpressionParser.h
View File

@ -13,8 +13,7 @@ struct cmGeneratorExpressionEvaluator;
struct cmGeneratorExpressionParser
{
cmGeneratorExpressionParser(
const std::vector<cmGeneratorExpressionToken>& tokens);
cmGeneratorExpressionParser(std::vector<cmGeneratorExpressionToken> tokens);
void Parse(std::vector<cmGeneratorExpressionEvaluator*>& result);

5
Source/cmGeneratorTarget.cxx
View File

@ -14,6 +14,7 @@
#include <stdlib.h>
#include <string.h>
#include <unordered_set>
#include <utility>
#include "cmAlgorithms.h"
#include "cmComputeLinkInformation.h"
@ -1805,10 +1806,10 @@ class cmTargetCollectLinkLanguages
{
public:
cmTargetCollectLinkLanguages(cmGeneratorTarget const* target,
const std::string& config,
std::string config,
std::unordered_set<std::string>& languages,
cmGeneratorTarget const* head)
: Config(config)
: Config(std::move(config))
, Languages(languages)
, HeadTarget(head)
, Target(target)

8
Source/cmGlobVerificationManager.h
View File

@ -55,13 +55,13 @@ private:
const bool FollowSymlinks;
const std::string Relative;
const std::string Expression;
CacheEntryKey(const bool rec, const bool l, const bool s,
const std::string& rel, const std::string& e)
CacheEntryKey(const bool rec, const bool l, const bool s, std::string rel,
std::string e)
: Recurse(rec)
, ListDirectories(l)
, FollowSymlinks(s)
, Relative(rel)
, Expression(e)
, Relative(std::move(rel))
, Expression(std::move(e))
{
}
bool operator<(const CacheEntryKey& r) const;

5
Source/cmGraphAdjacencyList.h
View File

@ -7,6 +7,7 @@
#include "cmListFileCache.h"
#include <utility>
#include <vector>
/**
@ -17,10 +18,10 @@
class cmGraphEdge
{
public:
cmGraphEdge(int n, bool s, cmListFileBacktrace const& bt)
cmGraphEdge(int n, bool s, cmListFileBacktrace bt)
: Dest(n)
, Strong(s)
, Backtrace(bt)
, Backtrace(std::move(bt))
{
}
operator int() const { return this->Dest; }

4
Source/cmInstallCommandArguments.cxx
View File

@ -16,7 +16,7 @@ const char* cmInstallCommandArguments::PermissionsTable[] = {
const std::string cmInstallCommandArguments::EmptyString;
cmInstallCommandArguments::cmInstallCommandArguments(
const std::string& defaultComponent)
std::string defaultComponent)
: Destination(&Parser, "DESTINATION", &ArgumentGroup)
, Component(&Parser, "COMPONENT", &ArgumentGroup)
, NamelinkComponent(&Parser, "NAMELINK_COMPONENT", &ArgumentGroup)
@ -29,7 +29,7 @@ cmInstallCommandArguments::cmInstallCommandArguments(
, NamelinkSkip(&Parser, "NAMELINK_SKIP", &ArgumentGroup)
, Type(&Parser, "TYPE", &ArgumentGroup)
, GenericArguments(nullptr)
, DefaultComponentName(defaultComponent)
, DefaultComponentName(std::move(defaultComponent))
{
}

2
Source/cmInstallCommandArguments.h
View File

@ -13,7 +13,7 @@
class cmInstallCommandArguments
{
public:
cmInstallCommandArguments(const std::string& defaultComponent);
cmInstallCommandArguments(std::string defaultComponent);
void SetGenericArguments(cmInstallCommandArguments* args)
{
this->GenericArguments = args;

8
Source/cmInstallTargetGenerator.cxx
View File

@ -22,18 +22,18 @@
#include "cmake.h"
cmInstallTargetGenerator::cmInstallTargetGenerator(
const std::string& targetName, const char* dest, bool implib,
std::string targetName, const char* dest, bool implib,
const char* file_permissions, std::vector<std::string> const& configurations,
const char* component, MessageLevel message, bool exclude_from_all,
bool optional, cmListFileBacktrace const& backtrace)
bool optional, cmListFileBacktrace backtrace)
: cmInstallGenerator(dest, configurations, component, message,
exclude_from_all)
, TargetName(targetName)
, TargetName(std::move(targetName))
, Target(nullptr)
, FilePermissions(file_permissions)
, ImportLibrary(implib)
, Optional(optional)
, Backtrace(backtrace)
, Backtrace(std::move(backtrace))
{
this->ActionsPerConfig = true;
this->NamelinkMode = NamelinkModeNone;

4
Source/cmInstallTargetGenerator.h
View File

@ -23,11 +23,11 @@ class cmInstallTargetGenerator : public cmInstallGenerator
{
public:
cmInstallTargetGenerator(
std::string const& targetName, const char* dest, bool implib,
std::string targetName, const char* dest, bool implib,
const char* file_permissions,
std::vector<std::string> const& configurations, const char* component,
MessageLevel message, bool exclude_from_all, bool optional,
cmListFileBacktrace const& backtrace = cmListFileBacktrace());
cmListFileBacktrace backtrace = cmListFileBacktrace());
~cmInstallTargetGenerator() override;
/** Select the policy for installing shared library linkable name

11
Source/cmLinkItem.cxx
View File

@ -10,16 +10,15 @@ cmLinkItem::cmLinkItem()
{
}
cmLinkItem::cmLinkItem(std::string const& n, cmListFileBacktrace const& bt)
: String(n)
, Backtrace(bt)
cmLinkItem::cmLinkItem(std::string n, cmListFileBacktrace bt)
: String(std::move(n))
, Backtrace(std::move(bt))
{
}
cmLinkItem::cmLinkItem(cmGeneratorTarget const* t,
cmListFileBacktrace const& bt)
cmLinkItem::cmLinkItem(cmGeneratorTarget const* t, cmListFileBacktrace bt)
: Target(t)
, Backtrace(bt)
, Backtrace(std::move(bt))
{
}

4
Source/cmLinkItem.h
View File

@ -24,8 +24,8 @@ class cmLinkItem
public:
cmLinkItem();
cmLinkItem(std::string const& s, cmListFileBacktrace const& bt);
cmLinkItem(cmGeneratorTarget const* t, cmListFileBacktrace const& bt);
cmLinkItem(std::string s, cmListFileBacktrace bt);
cmLinkItem(cmGeneratorTarget const* t, cmListFileBacktrace bt);
std::string const& AsStr() const;
cmGeneratorTarget const* Target = nullptr;
cmListFileBacktrace Backtrace;

11
Source/cmListCommand.cxx
View File

@ -659,15 +659,14 @@ bool cmListCommand::HandleTransformCommand(
// Transform: lambda function implementing the action
struct ActionDescriptor
{
ActionDescriptor(const std::string& name)
: Name(name)
ActionDescriptor(std::string name)
: Name(std::move(name))
{
}
ActionDescriptor(const std::string& name, int arity,
const transform_type& transform)
: Name(name)
ActionDescriptor(std::string name, int arity, transform_type transform)
: Name(std::move(name))
, Arity(arity)
, Transform(transform)
, Transform(std::move(transform))
{
}

7
Source/cmListFileCache.cxx
View File

@ -24,7 +24,7 @@ cmCommandContext::cmCommandName& cmCommandContext::cmCommandName::operator=(
struct cmListFileParser
{
cmListFileParser(cmListFile* lf, cmListFileBacktrace const& lfbt,
cmListFileParser(cmListFile* lf, cmListFileBacktrace lfbt,
cmMessenger* messenger, const char* filename);
~cmListFileParser();
void IssueFileOpenError(std::string const& text) const;
@ -47,12 +47,11 @@ struct cmListFileParser
} Separation;
};
cmListFileParser::cmListFileParser(cmListFile* lf,
cmListFileBacktrace const& lfbt,
cmListFileParser::cmListFileParser(cmListFile* lf, cmListFileBacktrace lfbt,
cmMessenger* messenger,
const char* filename)
: ListFile(lf)
, Backtrace(lfbt)
, Backtrace(std::move(lfbt))
, Messenger(messenger)
, FileName(filename)
, Lexer(cmListFileLexer_New())

4
Source/cmListFileCache.h
View File

@ -51,8 +51,8 @@ struct cmListFileArgument
Bracket
};
cmListFileArgument() {}
cmListFileArgument(const std::string& v, Delimiter d, long line)
: Value(v)
cmListFileArgument(std::string v, Delimiter d, long line)
: Value(std::move(v))
, Delim(d)
, Line(line)
{

5
Source/cmLocalCommonGenerator.cxx
View File

@ -12,10 +12,9 @@
class cmGlobalGenerator;
cmLocalCommonGenerator::cmLocalCommonGenerator(cmGlobalGenerator* gg,
cmMakefile* mf,
std::string const& wd)
cmMakefile* mf, std::string wd)
: cmLocalGenerator(gg, mf)
, WorkingDirectory(wd)
, WorkingDirectory(std::move(wd))
{
// Store the configuration name that will be generated.
if (const char* config = this->Makefile->GetDefinition("CMAKE_BUILD_TYPE")) {

2
Source/cmLocalCommonGenerator.h
View File

@ -22,7 +22,7 @@ class cmLocalCommonGenerator : public cmLocalGenerator
{
public:
cmLocalCommonGenerator(cmGlobalGenerator* gg, cmMakefile* mf,
std::string const& wd);
std::string wd);
~cmLocalCommonGenerator() override;
std::string const& GetConfigName() { return this->ConfigName; }

6
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -1733,9 +1733,9 @@ class NotInProjectDir
{
public:
// Constructor with the source and binary directory's path
NotInProjectDir(const std::string& sourceDir, const std::string& binaryDir)
: SourceDir(sourceDir)
, BinaryDir(binaryDir)
NotInProjectDir(std::string sourceDir, std::string binaryDir)
: SourceDir(std::move(sourceDir))
, BinaryDir(std::move(binaryDir))
{
}

5
Source/cmLocalUnixMakefileGenerator3.h
View File

@ -12,6 +12,7 @@
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>
class cmCustomCommand;
@ -267,9 +268,9 @@ private:
cmGeneratorTarget* Target = nullptr;
std::string Language;
LocalObjectEntry() {}
LocalObjectEntry(cmGeneratorTarget* t, const std::string& lang)
LocalObjectEntry(cmGeneratorTarget* t, std::string lang)
: Target(t)
, Language(lang)
, Language(std::move(lang))
{
}
};

5
Source/cmOSXBundleGenerator.cxx
View File

@ -10,15 +10,16 @@
#include "cmTarget.h"
#include <cassert>
#include <utility>
class cmSourceFile;
cmOSXBundleGenerator::cmOSXBundleGenerator(cmGeneratorTarget* target,
const std::string& configName)
std::string configName)
: GT(target)
, Makefile(target->Target->GetMakefile())
, LocalGenerator(target->GetLocalGenerator())
, ConfigName(configName)
, ConfigName(std::move(configName))
, MacContentFolders(nullptr)
{
if (this->MustSkip()) {

3
Source/cmOSXBundleGenerator.h
View File

@ -17,8 +17,7 @@ class cmSourceFile;
class cmOSXBundleGenerator
{
public:
cmOSXBundleGenerator(cmGeneratorTarget* target,
const std::string& configName);
cmOSXBundleGenerator(cmGeneratorTarget* target, std::string configName);
// create an app bundle at a given root, and return
// the directory within the bundle that contains the executable

6
Source/cmPathLabel.cxx
View File

@ -2,8 +2,10 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmPathLabel.h"
cmPathLabel::cmPathLabel(const std::string& label)
: Label(label)
#include <utility>
cmPathLabel::cmPathLabel(std::string label)
: Label(std::move(label))
, Hash(0)
{
// Use a Jenkins one-at-a-time hash with under/over-flow protection

2
Source/cmPathLabel.h
View File

@ -17,7 +17,7 @@
class cmPathLabel
{
public:
cmPathLabel(const std::string& label);
cmPathLabel(std::string label);
// The comparison operators are only for quick sorting and searching and
// in no way imply any lexicographical order of the label

4
Source/cmPipeConnection.cxx
View File

@ -6,10 +6,10 @@
#include "cmServer.h"
cmPipeConnection::cmPipeConnection(const std::string& name,
cmPipeConnection::cmPipeConnection(std::string name,
cmConnectionBufferStrategy* bufferStrategy)
: cmEventBasedConnection(bufferStrategy)
, PipeName(name)
, PipeName(std::move(name))
{
}

2
Source/cmPipeConnection.h
View File

@ -13,7 +13,7 @@
class cmPipeConnection : public cmEventBasedConnection
{
public:
cmPipeConnection(const std::string& name,
cmPipeConnection(std::string name,
cmConnectionBufferStrategy* bufferStrategy = nullptr);
bool OnServeStart(std::string* pString) override;

12
Source/cmQtAutoGeneratorMocUic.h
View File

@ -49,8 +49,8 @@ public:
{
}
KeyExpT(std::string const& key, std::string const& exp)
: Key(key)
KeyExpT(std::string key, std::string const& exp)
: Key(std::move(key))
, Exp(exp)
{
}
@ -240,10 +240,10 @@ public:
class JobMocT : public JobT
{
public:
JobMocT(std::string&& sourceFile, std::string const& includerFile,
JobMocT(std::string&& sourceFile, std::string includerFile,
std::string&& includeString)
: SourceFile(std::move(sourceFile))
, IncluderFile(includerFile)
, IncluderFile(std::move(includerFile))
, IncludeString(std::move(includeString))
{
}
@ -269,10 +269,10 @@ public:
class JobUicT : public JobT
{
public:
JobUicT(std::string&& sourceFile, std::string const& includerFile,
JobUicT(std::string&& sourceFile, std::string includerFile,
std::string&& includeString)
: SourceFile(std::move(sourceFile))
, IncluderFile(includerFile)
, IncluderFile(std::move(includerFile))
, IncludeString(std::move(includeString))
{
}

4
Source/cmRST.cxx
View File

@ -13,9 +13,9 @@
#include <stddef.h>
#include <utility>
cmRST::cmRST(std::ostream& os, std::string const& docroot)
cmRST::cmRST(std::ostream& os, std::string docroot)
: OS(os)
, DocRoot(docroot)
, DocRoot(std::move(docroot))
, IncludeDepth(0)
, OutputLinePending(false)
, LastLineEndedInColonColon(false)

2
Source/cmRST.h
View File

@ -25,7 +25,7 @@
class cmRST
{
public:
cmRST(std::ostream& os, std::string const& docroot);
cmRST(std::ostream& os, std::string docroot);
bool ProcessFile(std::string const& fname, bool isModule = false);
private:

14
Source/cmRulePlaceholderExpander.cxx
View File

@ -10,13 +10,13 @@
#include "cmSystemTools.h"
cmRulePlaceholderExpander::cmRulePlaceholderExpander(
std::map<std::string, std::string> const& compilers,
std::map<std::string, std::string> const& variableMappings,
std::string const& compilerSysroot, std::string const& linkerSysroot)
: Compilers(compilers)
, VariableMappings(variableMappings)
, CompilerSysroot(compilerSysroot)
, LinkerSysroot(linkerSysroot)
std::map<std::string, std::string> compilers,
std::map<std::string, std::string> variableMappings,
std::string compilerSysroot, std::string linkerSysroot)
: Compilers(std::move(compilers))
, VariableMappings(std::move(variableMappings))
, CompilerSysroot(std::move(compilerSysroot))
, LinkerSysroot(std::move(linkerSysroot))
{
}

6
Source/cmRulePlaceholderExpander.h
View File

@ -15,9 +15,9 @@ class cmRulePlaceholderExpander
{
public:
cmRulePlaceholderExpander(
std::map<std::string, std::string> const& compilers,
std::map<std::string, std::string> const& variableMappings,
std::string const& compilerSysroot, std::string const& linkerSysroot);
std::map<std::string, std::string> compilers,
std::map<std::string, std::string> variableMappings,
std::string compilerSysroot, std::string linkerSysroot);
void SetTargetImpLib(std::string const& targetImpLib)
{

11
Source/cmScriptGenerator.cxx
View File

@ -4,11 +4,12 @@
#include "cmSystemTools.h"
cmScriptGenerator::cmScriptGenerator(
const std::string& config_var,
std::vector<std::string> const& configurations)
: RuntimeConfigVariable(config_var)
, Configurations(configurations)
#include <utility>
cmScriptGenerator::cmScriptGenerator(std::string config_var,
std::vector<std::string> configurations)
: RuntimeConfigVariable(std::move(config_var))
, Configurations(std::move(configurations))
, ConfigurationName("")
, ConfigurationTypes(nullptr)
, ActionsPerConfig(false)

4
Source/cmScriptGenerator.h
View File

@ -47,8 +47,8 @@ class cmScriptGenerator
CM_DISABLE_COPY(cmScriptGenerator)
public:
cmScriptGenerator(const std::string& config_var,
std::vector<std::string> const& configurations);
cmScriptGenerator(std::string config_var,
std::vector<std::string> configurations);
virtual ~cmScriptGenerator();
void Generate(std::ostream& os, const std::string& config,

28
Source/cmServerProtocol.cxx
View File

@ -20,6 +20,7 @@
#include <functional>
#include <memory>
#include <string>
#include <utility>
#include <vector>
// Get rid of some windows macros:
@ -39,11 +40,10 @@ std::vector<std::string> toStringList(const Json::Value& in)
} // namespace
cmServerRequest::cmServerRequest(cmServer* server, cmConnection* connection,
const std::string& t, const std::string& c,
const Json::Value& d)
: Type(t)
, Cookie(c)
, Data(d)
std::string t, std::string c, Json::Value d)
: Type(std::move(t))
, Cookie(std::move(c))
, Data(std::move(d))
, Connection(connection)
, m_Server(server)
{
@ -707,15 +707,15 @@ cmServerResponse cmServerProtocol1::ProcessCTests(
}
cmServerProtocol1::GeneratorInformation::GeneratorInformation(
const std::string& generatorName, const std::string& extraGeneratorName,
const std::string& toolset, const std::string& platform,
const std::string& sourceDirectory, const std::string& buildDirectory)
: GeneratorName(generatorName)
, ExtraGeneratorName(extraGeneratorName)
, Toolset(toolset)
, Platform(platform)
, SourceDirectory(sourceDirectory)
, BuildDirectory(buildDirectory)
std::string generatorName, std::string extraGeneratorName,
std::string toolset, std::string platform, std::string sourceDirectory,
std::string buildDirectory)
: GeneratorName(std::move(generatorName))
, ExtraGeneratorName(std::move(extraGeneratorName))
, Toolset(std::move(toolset))
, Platform(std::move(platform))
, SourceDirectory(std::move(sourceDirectory))
, BuildDirectory(std::move(buildDirectory))
{
}

15
Source/cmServerProtocol.h
View File

@ -56,9 +56,8 @@ public:
cmConnection* Connection;
private:
cmServerRequest(cmServer* server, cmConnection* connection,
const std::string& t, const std::string& c,
const Json::Value& d);
cmServerRequest(cmServer* server, cmConnection* connection, std::string t,
std::string c, Json::Value d);
void ReportProgress(int min, int current, int max,
const std::string& message) const;
@ -140,12 +139,10 @@ private:
{
public:
GeneratorInformation() = default;
GeneratorInformation(const std::string& generatorName,
const std::string& extraGeneratorName,
const std::string& toolset,
const std::string& platform,
const std::string& sourceDirectory,
const std::string& buildDirectory);
GeneratorInformation(std::string generatorName,
std::string extraGeneratorName, std::string toolset,
std::string platform, std::string sourceDirectory,
std::string buildDirectory);
void SetupGenerator(cmake* cm, std::string* errorMessage);

6
Source/cmSourceGroup.cxx
View File

@ -2,15 +2,17 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmSourceGroup.h"
#include <utility>
class cmSourceGroupInternals
{
public:
std::vector<cmSourceGroup> GroupChildren;
};
cmSourceGroup::cmSourceGroup(const std::string& name, const char* regex,
cmSourceGroup::cmSourceGroup(std::string name, const char* regex,
const char* parentName)
: Name(name)
: Name(std::move(name))
{
this->Internal = new cmSourceGroupInternals;
this->SetGroupRegex(regex);

2
Source/cmSourceGroup.h
View File

@ -26,7 +26,7 @@ class cmSourceGroupInternals;
class cmSourceGroup
{
public:
cmSourceGroup(const std::string& name, const char* regex,
cmSourceGroup(std::string name, const char* regex,
const char* parentName = nullptr);
cmSourceGroup(cmSourceGroup const& r);
~cmSourceGroup();

5
Source/cmStringReplaceHelper.cxx
View File

@ -5,13 +5,14 @@
#include "cmMakefile.h"
#include <sstream>
#include <utility>
cmStringReplaceHelper::cmStringReplaceHelper(const std::string& regex,
const std::string& replace_expr,
std::string replace_expr,
cmMakefile* makefile)
: RegExString(regex)
, RegularExpression(regex)
, ReplaceExpression(replace_expr)
, ReplaceExpression(std::move(replace_expr))
, Makefile(makefile)
{
this->ParseReplaceExpression();

8
Source/cmStringReplaceHelper.h
View File

@ -6,6 +6,7 @@
#include "cmsys/RegularExpression.hxx"
#include <string>
#include <utility>
#include <vector>
class cmMakefile;
@ -13,8 +14,7 @@ class cmMakefile;
class cmStringReplaceHelper
{
public:
cmStringReplaceHelper(const std::string& regex,
const std::string& replace_expr,
cmStringReplaceHelper(const std::string& regex, std::string replace_expr,
cmMakefile* makefile = nullptr);
bool IsRegularExpressionValid() const
@ -39,9 +39,9 @@ private:
, Value(s)
{
}
RegexReplacement(const std::string& s)
RegexReplacement(std::string s)
: Number(-1)
, Value(s)
, Value(std::move(s))
{
}
RegexReplacement(int n)

5
Source/cmUnexpectedCommand.h
View File

@ -6,6 +6,7 @@
#include "cmConfigure.h" // IWYU pragma: keep
#include <string>
#include <utility>
#include <vector>
#include "cmCommand.h"
@ -15,8 +16,8 @@ class cmExecutionStatus;
class cmUnexpectedCommand : public cmCommand
{
public:
cmUnexpectedCommand(std::string const& name, const char* error)
: Name(name)
cmUnexpectedCommand(std::string name, const char* error)
: Name(std::move(name))
, Error(error)
{
}

5
Source/cmXCodeScheme.cxx
View File

@ -5,16 +5,17 @@
#include <iomanip>
#include <iostream>
#include <sstream>
#include <utility>
#include "cmGeneratedFileStream.h"
#include "cmGeneratorTarget.h"
#include "cmXMLSafe.h"
cmXCodeScheme::cmXCodeScheme(cmXCodeObject* xcObj, const TestObjects& tests,
cmXCodeScheme::cmXCodeScheme(cmXCodeObject* xcObj, TestObjects tests,
const std::vector<std::string>& configList,
unsigned int xcVersion)
: Target(xcObj)
, Tests(tests)
, Tests(std::move(tests))
, TargetName(xcObj->GetTarget()->GetName())
, ConfigList(configList)
, XcodeVersion(xcVersion)

2
Source/cmXCodeScheme.h
View File

@ -20,7 +20,7 @@ class cmXCodeScheme
public:
typedef std::vector<const cmXCodeObject*> TestObjects;
cmXCodeScheme(cmXCodeObject* xcObj, const TestObjects& tests,
cmXCodeScheme(cmXCodeObject* xcObj, TestObjects tests,
const std::vector<std::string>& configList,
unsigned int xcVersion);