14 struct BackendOptions;
26 static const bool value = std::is_same<T, int>::value ||
27 std::is_same<T, unsigned int>::value ||
28 std::is_same<T, float>::value ||
29 std::is_same<T, bool>::value ||
30 std::is_same<T, std::string>::value ||
31 std::is_same<T, const char*>::value;
41 explicit Var(
int i) : m_Vals(i), m_Type(VarTypes::Integer) {};
42 explicit Var(
unsigned int u) : m_Vals(u), m_Type(VarTypes::UnsignedInteger) {};
43 explicit Var(
float f) : m_Vals(f), m_Type(VarTypes::Float) {};
44 explicit Var(
bool b) : m_Vals(b), m_Type(VarTypes::
Boolean) {};
45 explicit Var(
const char* s) : m_Vals(s), m_Type(VarTypes::String) {};
46 explicit Var(std::string s) : m_Vals(s), m_Type(VarTypes::String) {};
49 template<
typename DisallowedType>
52 static_assert(CheckAllowed<DisallowedType>::value,
"Type is not allowed for Var<DisallowedType>.");
53 assert(
false &&
"Unreachable code");
58 : m_Type(other.m_Type)
62 case VarTypes::String:
64 new (&m_Vals.s) std::string(other.m_Vals.s);
69 DoOp(other, [](
auto& a,
auto& b)
82 if (m_Type == VarTypes::String)
87 m_Type = other.m_Type;
90 case VarTypes::String:
93 new (&m_Vals.s) std::string(other.m_Vals.s);
98 DoOp(other, [](
auto& a,
auto& b)
111 bool IsInt()
const {
return m_Type == VarTypes::Integer; }
113 bool IsFloat()
const {
return m_Type == VarTypes::Float; }
114 bool IsString()
const {
return m_Type == VarTypes::String; }
117 bool AsBool()
const { assert(IsBool());
return m_Vals.b; }
118 int AsInt()
const { assert(IsInt());
return m_Vals.i; }
119 unsigned int AsUnsignedInt()
const { assert(IsUnsignedInt());
return m_Vals.u; }
120 float AsFloat()
const { assert(IsFloat());
return m_Vals.f; }
121 std::string
AsString()
const { assert(IsString());
return m_Vals.s; }
126 DoOp(*
this, [
this](
auto& a,
auto&)
132 template<
typename Func>
133 void DoOp(
const Var& other, Func func)
137 func(m_Vals.b, other.m_Vals.b);
139 else if (other.
IsInt())
141 func(m_Vals.i, other.m_Vals.i);
145 func(m_Vals.u, other.m_Vals.u);
149 func(m_Vals.f, other.m_Vals.f);
153 func(m_Vals.s, other.m_Vals.s);
157 template<
typename Destructable>
158 void Destruct(Destructable& d)
160 if (std::is_destructible<Destructable>::value)
189 explicit Vals(
int i) : i(i) {};
190 explicit Vals(
unsigned int u) : u(u) {};
191 explicit Vals(
float f) : f(f) {};
192 explicit Vals(
bool b) : b(b) {};
193 explicit Vals(
const char* s) : s(std::string(s)) {}
194 explicit Vals(std::string s) : s(s) {}
205 : m_Name(name), m_Value(value)
208 : m_Name(name), m_Value(value)
211 : m_Name(name), m_Value(value)
214 : m_Name(name), m_Value(value)
217 : m_Name(name), m_Value(value)
220 : m_Name(name), m_Value(value)
223 template<
typename DisallowedType>
227 static_assert(CheckAllowed<DisallowedType>::value,
"Type is not allowed for BackendOption.");
228 assert(
false &&
"Unreachable code");
237 std::string
GetName()
const {
return m_Name; }
246 : m_TargetBackend(backend)
250 : m_TargetBackend(backend)
261 m_Options.push_back(option);
266 m_Options.push_back(option);
278 std::vector<BackendOption> m_Options;
282 template <
typename F>
285 for (
auto optionsGroup : options)
287 if (optionsGroup.GetBackendId() == backend)
289 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)