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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
// slang-artifact.cpp
#include "slang-artifact-util.h"
#include "slang-artifact-impl.h"
#include "slang-artifact-representation-impl.h"
#include "slang-artifact-desc-util.h"
#include "../core/slang-file-system.h"
#include "../core/slang-io.h"
namespace Slang {
/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!! ArtifactUtilImpl !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
/* static */ArtifactUtilImpl ArtifactUtilImpl::g_singleton;
SlangResult ArtifactUtilImpl::queryInterface(SlangUUID const& uuid, void** outObject)
{
if (auto intf = getInterface(uuid))
{
*outObject = intf;
return SLANG_OK;
}
return SLANG_E_NO_INTERFACE;
}
void* ArtifactUtilImpl::getInterface(const Guid& guid)
{
if (guid == ISlangUnknown::getTypeGuid() || guid == IArtifactUtil::getTypeGuid())
{
return static_cast<IArtifactUtil*>(this);
}
return nullptr;
}
SlangResult ArtifactUtilImpl::createArtifact(const ArtifactDesc& desc, const char* inName, IArtifact** outArtifact)
{
String name;
if (inName)
{
name = inName;
}
ComPtr<IArtifact> artifact(new Artifact(desc, name));
*outArtifact = artifact.detach();
return SLANG_OK;
}
SlangResult ArtifactUtilImpl::createArtifactList(IArtifact* parent, IArtifactList** outArtifactList)
{
ComPtr<IArtifactList> artifactList(new ArtifactList(parent));
*outArtifactList = artifactList.detach();
return SLANG_OK;
}
ArtifactKind ArtifactUtilImpl::getKindParent(ArtifactKind kind) { return getParent(kind); }
UnownedStringSlice ArtifactUtilImpl::getKindName(ArtifactKind kind) { return getName(kind); }
bool ArtifactUtilImpl::isKindDerivedFrom(ArtifactKind kind, ArtifactKind base) { return isDerivedFrom(kind, base); }
ArtifactPayload ArtifactUtilImpl::getPayloadParent(ArtifactPayload payload) { return getParent(payload); }
UnownedStringSlice ArtifactUtilImpl::getPayloadName(ArtifactPayload payload) { return getName(payload); }
bool ArtifactUtilImpl::isPayloadDerivedFrom(ArtifactPayload payload, ArtifactPayload base) { return isDerivedFrom(payload, base); }
ArtifactStyle ArtifactUtilImpl::getStyleParent(ArtifactStyle style) { return getParent(style); }
UnownedStringSlice ArtifactUtilImpl::getStyleName(ArtifactStyle style) { return getName(style); }
bool ArtifactUtilImpl::isStyleDerivedFrom(ArtifactStyle style, ArtifactStyle base) { return isDerivedFrom(style, base); }
SlangResult ArtifactUtilImpl::createLockFile(const char* inNameBase, ISlangMutableFileSystem* fileSystem, IFileArtifactRepresentation** outLockFile)
{
if (fileSystem)
{
if (fileSystem != OSFileSystem::getMutableSingleton())
{
// We can only create lock files, on the global OS file system
return SLANG_E_NOT_AVAILABLE;
}
fileSystem = nullptr;
}
const UnownedStringSlice nameBase = (inNameBase && inNameBase[0] != 0) ? UnownedStringSlice(inNameBase) : UnownedStringSlice("unknown");
String lockPath;
SLANG_RETURN_ON_FAIL(File::generateTemporary(nameBase, lockPath));
ComPtr<IFileArtifactRepresentation> lockFile(new FileArtifactRepresentation(IFileArtifactRepresentation::Kind::Lock, lockPath, nullptr, fileSystem));
*outLockFile = lockFile.detach();
return SLANG_OK;
}
SlangResult ArtifactUtilImpl::calcArtifactPath(const ArtifactDesc& desc, const char* inBasePath, ISlangBlob** outPath)
{
UnownedStringSlice basePath(inBasePath);
StringBuilder path;
SLANG_RETURN_ON_FAIL(ArtifactDescUtil::calcPathForDesc(desc, basePath, path));
*outPath = StringBlob::create(path).detach();
return SLANG_OK;
}
SlangResult ArtifactUtilImpl::requireFileDefaultImpl(IArtifact* artifact, ArtifactKeep keep, IFileArtifactRepresentation** outFile)
{
// See if we already have it
if (auto fileRep = findRepresentation<IFileArtifactRepresentation>(artifact))
{
fileRep->addRef();
*outFile = fileRep;
return SLANG_OK;
}
// If we are going to access as a file we need to be able to write it, and to do that we need a blob
ComPtr<ISlangBlob> blob;
SLANG_RETURN_ON_FAIL(artifact->loadBlob(keep, blob.writeRef()));
// Okay we need to store as a temporary. Get a lock file.
ComPtr<IFileArtifactRepresentation> lockFile;
SLANG_RETURN_ON_FAIL(createLockFile(artifact->getName(), nullptr, lockFile.writeRef()));
// Now we need the appropriate name for this item
ComPtr<ISlangBlob> pathBlob;
SLANG_RETURN_ON_FAIL(calcArtifactPath(artifact->getDesc(), lockFile->getPath(), pathBlob.writeRef()));
const auto path = StringUtil::getString(pathBlob);
// Write the contents
SLANG_RETURN_ON_FAIL(File::writeAllBytes(path, blob->getBufferPointer(), blob->getBufferSize()));
ComPtr<IFileArtifactRepresentation> fileRep;
// TODO(JS): This path comparison is perhaps not perfect, in that it assumes the path is not changed
// in any way. For example an impl of calcArtifactPath that changed slashes or used a canonical path
// might mean the lock file and the rep have the same path.
// As it stands calcArtifactPath impl doesn't do that, but that is perhaps somewhatfragile
// If the paths are identical, we can just use the lock file for the rep
if (UnownedStringSlice(lockFile->getPath()) == path.getUnownedSlice())
{
fileRep.swap(lockFile);
}
else
{
// Create a new rep that references the lock file
fileRep = new FileArtifactRepresentation(IFileArtifactRepresentation::Kind::Owned, path, lockFile, nullptr);
}
// Create the rep
if (canKeep(keep))
{
artifact->addRepresentation(fileRep);
}
// Return the file
*outFile = fileRep.detach();
return SLANG_OK;
}
ArtifactDesc ArtifactUtilImpl::makeDescFromCompileTarget(SlangCompileTarget target)
{
return ArtifactDescUtil::makeDescFromCompileTarget(target);
}
SlangResult ArtifactUtilImpl::getChildrenDefaultImpl(IArtifact* artifact, IArtifactList** outList)
{
auto desc = artifact->getDesc();
// If it's a container type for now, just create empty list of children
if (isDerivedFrom(desc.kind, ArtifactKind::Container))
{
*outList = ComPtr<IArtifactList>(new ArtifactList(artifact)).detach();
return SLANG_OK;
}
return SLANG_E_NOT_AVAILABLE;
}
} // namespace Slang
|
