yum-mirror/slang

Making it easier to work with shaders

git clone https://git.yummers.dev/yum-mirror/slang

Ellie Hermaszewskaformatf65d756bf

master
branchesmasterall refs →
4.5 KiB201 linesraw
1// slang-name-value.cpp
2
3#include "slang-name-value.h"
4
5#include "slang-char-util.h"
6#include "slang-string-util.h"
7
8namespace Slang
9{
10
11/* static */ ValueInt NameValueUtil::findValue(
12    const ConstArrayView<NameValue>& opts,
13    const UnownedStringSlice& slice,
14    ValueInt defaultValue)
15{
16    for (const auto& opt : opts)
17    {
18        if (UnownedStringSlice(opt.name) == slice)
19        {
20            return opt.value;
21        }
22    }
23    return defaultValue;
24}
25
26/* static */ ValueInt NameValueUtil::findValue(
27    const ConstArrayView<NamesValue>& opts,
28    const UnownedStringSlice& slice,
29    ValueInt defaultValue)
30{
31    for (const auto& opt : opts)
32    {
33        UnownedStringSlice names(opt.names);
34
35        if (StringUtil::indexOfInSplit(names, ',', slice) >= 0)
36        {
37            return opt.value;
38        }
39    }
40    return defaultValue;
41}
42
43/* static */ ValueInt NameValueUtil::findValue(
44    const ConstArrayView<NamesDescriptionValue>& opts,
45    const UnownedStringSlice& slice,
46    ValueInt defaultValue)
47{
48    for (const auto& opt : opts)
49    {
50        UnownedStringSlice names(opt.names);
51        if (StringUtil::indexOfInSplit(names, ',', slice) >= 0)
52        {
53            return opt.value;
54        }
55    }
56    return defaultValue;
57}
58
59/* static */ UnownedStringSlice NameValueUtil::findName(
60    const ConstArrayView<NameValue>& opts,
61    ValueInt value,
62    const UnownedStringSlice& defaultName)
63{
64    for (const auto& opt : opts)
65    {
66        if (opt.value == value)
67        {
68            return UnownedStringSlice(opt.name);
69        }
70    }
71    return defaultName;
72}
73
74/* static */ UnownedStringSlice NameValueUtil::findName(
75    const ConstArrayView<NamesValue>& opts,
76    ValueInt value,
77    const UnownedStringSlice& defaultName)
78{
79    for (const auto& opt : opts)
80    {
81        if (opt.value == value)
82        {
83            // Get the first name
84            return StringUtil::getAtInSplit(UnownedStringSlice(opt.names), ',', 0);
85        }
86    }
87
88    return defaultName;
89}
90
91/* static */ UnownedStringSlice NameValueUtil::findName(
92    const ConstArrayView<NamesDescriptionValue>& opts,
93    ValueInt value,
94    const UnownedStringSlice& defaultName)
95{
96    for (const auto& opt : opts)
97    {
98        if (opt.value == value)
99        {
100            // Get the first name
101            return StringUtil::getAtInSplit(UnownedStringSlice(opt.names), ',', 0);
102        }
103    }
104
105    return defaultName;
106}
107
108
109/* static */ UnownedStringSlice NameValueUtil::findDescription(
110    const ConstArrayView<NamesDescriptionValue>& opts,
111    ValueInt value,
112    const UnownedStringSlice& defaultDescription)
113{
114    for (const auto& opt : opts)
115    {
116        if (opt.value == value && opt.description)
117        {
118            return UnownedStringSlice(opt.description);
119        }
120    }
121
122    return defaultDescription;
123}
124
125/* static */ void NameValueUtil::appendNames(
126    NameKind kind,
127    const ConstArrayView<NameValue>& opts,
128    List<UnownedStringSlice>& out)
129{
130    SLANG_UNUSED(kind);
131    for (auto& opt : opts)
132    {
133        out.add(UnownedStringSlice(opt.name));
134    }
135}
136
137static void _appendNames(
138    NameValueUtil::NameKind kind,
139    const char* names,
140    List<UnownedStringSlice>& out)
141{
142    if (kind == NameValueUtil::NameKind::All)
143    {
144        StringUtil::appendSplit(UnownedStringSlice(names), ',', out);
145    }
146    else
147    {
148        out.add(StringUtil::getAtInSplit(UnownedStringSlice(names), ',', 0));
149    }
150}
151
152/* static */ void NameValueUtil::appendNames(
153    NameKind kind,
154    const ConstArrayView<NamesValue>& opts,
155    List<UnownedStringSlice>& out)
156{
157    for (auto& opt : opts)
158    {
159        _appendNames(kind, opt.names, out);
160    }
161}
162
163/* static */ void NameValueUtil::appendNames(
164    NameKind kind,
165    const ConstArrayView<NamesDescriptionValue>& opts,
166    List<UnownedStringSlice>& out)
167{
168    for (auto& opt : opts)
169    {
170        _appendNames(kind, opt.names, out);
171    }
172}
173
174/* static */ List<UnownedStringSlice> NameValueUtil::getNames(
175    NameKind kind,
176    const ConstArrayView<NameValue>& opts)
177{
178    List<UnownedStringSlice> names;
179    appendNames(kind, opts, names);
180    return names;
181}
182
183/* static */ List<UnownedStringSlice> NameValueUtil::getNames(
184    NameKind kind,
185    const ConstArrayView<NamesValue>& opts)
186{
187    List<UnownedStringSlice> names;
188    appendNames(kind, opts, names);
189    return names;
190}
191
192/* static */ List<UnownedStringSlice> NameValueUtil::getNames(
193    NameKind kind,
194    const ConstArrayView<NamesDescriptionValue>& opts)
195{
196    List<UnownedStringSlice> names;
197    appendNames(kind, opts, names);
198    return names;
199}
200
201} // namespace Slang