14 struct BackendOptions;
27 static const bool value = std::is_same<T, int>::value ||
28 std::is_same<T, unsigned int>::value ||
29 std::is_same<T, float>::value ||
30 std::is_same<T, bool>::value ||
31 std::is_same<T, std::string>::value ||
32 std::is_same<T, const char*>::value;
42 explicit Var(
int i) : m_Vals(i), m_Type(VarTypes::Integer) {};
43 explicit Var(
unsigned int u) : m_Vals(u), m_Type(VarTypes::UnsignedInteger) {};
44 explicit Var(
float f) : m_Vals(f), m_Type(VarTypes::Float) {};
45 explicit Var(
bool b) : m_Vals(b), m_Type(VarTypes::
Boolean) {};
46 explicit Var(
const char* s) : m_Vals(s), m_Type(VarTypes::String) {};
47 explicit Var(std::string s) : m_Vals(s), m_Type(VarTypes::String) {};
50 template<
typename DisallowedType>
53 static_assert(CheckAllowed<DisallowedType>::value,
"Type is not allowed for Var<DisallowedType>.");
54 assert(
false &&
"Unreachable code");
59 : m_Type(other.m_Type)
63 case VarTypes::String:
65 new (&m_Vals.s) std::string(other.m_Vals.s);
70 DoOp(other, [](
auto& a,
auto& b)
83 if (m_Type == VarTypes::String)
88 m_Type = other.m_Type;
91 case VarTypes::String:
94 new (&m_Vals.s) std::string(other.m_Vals.s);
99 DoOp(other, [](
auto& a,
auto& b)
112 bool IsInt()
const {
return m_Type == VarTypes::Integer; }
114 bool IsFloat()
const {
return m_Type == VarTypes::Float; }
115 bool IsString()
const {
return m_Type == VarTypes::String; }
118 bool AsBool()
const { assert(IsBool());
return m_Vals.b; }
119 int AsInt()
const { assert(IsInt());
return m_Vals.i; }
120 unsigned int AsUnsignedInt()
const { assert(IsUnsignedInt());
return m_Vals.u; }
121 float AsFloat()
const { assert(IsFloat());
return m_Vals.f; }
122 std::string
AsString()
const { assert(IsString());
return m_Vals.s; }
127 DoOp(*
this, [
this](
auto& a,
auto&)
133 template<
typename Func>
134 void DoOp(
const Var& other, Func func)
138 func(m_Vals.b, other.m_Vals.b);
140 else if (other.
IsInt())
142 func(m_Vals.i, other.m_Vals.i);
146 func(m_Vals.u, other.m_Vals.u);
150 func(m_Vals.f, other.m_Vals.f);
154 func(m_Vals.s, other.m_Vals.s);
158 template<
typename Destructable>
159 void Destruct(Destructable& d)
161 if (std::is_destructible<Destructable>::value)
190 explicit Vals(
int i) : i(i) {};
191 explicit Vals(
unsigned int u) : u(u) {};
192 explicit Vals(
float f) : f(f) {};
193 explicit Vals(
bool b) : b(b) {};
194 explicit Vals(
const char* s) : s(std::string(s)) {}
195 explicit Vals(std::string s) : s(s) {}
206 : m_Name(name), m_Value(value)
209 : m_Name(name), m_Value(value)
212 : m_Name(name), m_Value(value)
215 : m_Name(name), m_Value(value)
218 : m_Name(name), m_Value(value)
221 : m_Name(name), m_Value(value)
224 template<
typename DisallowedType>
228 static_assert(CheckAllowed<DisallowedType>::value,
"Type is not allowed for BackendOption.");
229 assert(
false &&
"Unreachable code");
238 std::string
GetName()
const {
return m_Name; }
247 : m_TargetBackend(backend)
251 : m_TargetBackend(backend)
262 m_Options.push_back(option);
267 m_Options.push_back(option);
279 std::vector<BackendOption> m_Options;
283 template <
typename F>
286 for (
auto optionsGroup : options)
288 if (optionsGroup.GetBackendId() == backend)
290 for (
size_t i=0; i < optionsGroup.GetOptionCount(); i++)
const BackendOption & GetOption(size_t idx) const
BackendOptions(BackendId backend, std::initializer_list< BackendOption > options)
Very basic type safe variant.
BackendOption(std::string name, bool value)
Var(const Var &other)
Copy Construct.
BackendOption(std::string name, unsigned int value)
void ParseOptions(const std::vector< BackendOptions > &options, BackendId backend, F f)
std::vector< BackendOptions > ModelOptions
std::vector< BackendOptions > NetworkOptions
Copyright (c) 2021 ARM Limited and Contributors.
BackendOptions(BackendId backend)
size_t GetOptionCount() const noexcept
void AddOption(BackendOption &&option)
Var & operator=(const Var &other)
Copy operator.
BackendOption(std::string name, int value)
std::string AsString() const
Var(DisallowedType)
Disallow implicit conversions from types not explicitly allowed below.
BackendOptions & operator=(const BackendOptions &other)=default
unsigned int AsUnsignedInt() const
Struct for the users to pass backend specific options.
void AddOption(const BackendOption &option)
bool AsBool() const
Value getters.
std::string GetName() const
bool IsBool() const
Type getters.
BackendOption(std::string name, float value)
bool IsUnsignedInt() const
BackendOption(std::string name, const char *value)
BackendOption(std::string, DisallowedType)
const BackendId & GetBackendId() const noexcept
BackendOption(std::string name, std::string value)