1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
// Copyright (C) 2020 Alexis Jeandet.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
#pragma once
#include <utils/algorithm.h>
#include <utils/fileutils.h>
#include <utils/optional.h>
#include <QDir>
#include <QVariant>
namespace MesonProjectManager {
namespace Internal {
inline QStringList cleanPath(QStringList &&paths)
{
return Utils::transform(paths, QDir::cleanPath);
}
struct Target
{
enum class Type {
executable,
run,
custom,
sharedLibrary,
sharedModule,
staticLibrary,
jar,
unknown
};
struct SourceGroup
{
const QString language;
const QStringList compiler;
const QStringList parameters;
const QStringList sources;
const QStringList generatedSources;
SourceGroup(QString &&language,
QStringList &&compiler,
QStringList &¶meters,
QStringList &&sources,
QStringList &&generatedSources)
: language{std::move(language)}
, compiler{std::move(compiler)}
, parameters{std::move(parameters)}
, sources{cleanPath(std::move(sources))}
, generatedSources{cleanPath(std::move(generatedSources))}
{}
};
using SourceGroupList = std::vector<SourceGroup>;
const Type type;
const QString name;
const QString id;
const QString definedIn;
const QStringList fileName;
const QStringList extraFiles;
const Utils::optional<QString> subproject;
const SourceGroupList sources;
static inline QString fullName(const Utils::FilePath &srcDir, const Target &target)
{
using namespace Utils;
if (FileUtils::isAbsolutePath(target.fileName.first())) {
const auto fname = target.fileName.first().split('/').last();
QString definedIn = FilePath::fromString(target.definedIn).absolutePath().toString();
return definedIn.remove(srcDir.toString()) + '/' + fname;
} else {
return target.fileName.first();
}
}
static Type toType(const QString &typeStr)
{
if (typeStr == "executable")
return Type::executable;
if (typeStr == "static library")
return Type::staticLibrary;
if (typeStr == "shared library")
return Type::sharedLibrary;
if (typeStr == "shared module")
return Type::sharedModule;
if (typeStr == "custom")
return Type::custom;
if (typeStr == "run")
return Type::run;
if (typeStr == "jar")
return Type::jar;
return Type::unknown;
}
Target(const QString &type,
QString &&name,
QString &&id,
QString &&definedIn,
QStringList &&fileName,
QStringList &&extraFiles,
QString &&subproject,
SourceGroupList &&sources)
: type{toType(type)}
, name{std::move(name)}
, id{std::move(id)}
, definedIn{QDir::cleanPath(definedIn)}
, fileName{cleanPath(std::move(fileName))}
, extraFiles{cleanPath(std::move(extraFiles))}
, subproject{subproject.isNull() ? Utils::nullopt
: Utils::optional<QString>{std::move(subproject)}}
, sources{std::move(sources)}
{}
};
using TargetsList = std::vector<Target>;
template<class function>
void for_each_source_group(const TargetsList &targets, const function &f)
{
for (const Target &target : targets) {
for (const Target::SourceGroup &group : target.sources) {
f(target, group);
}
}
}
} // namespace Internal
} // namespace MesonProjectManager
|
