14 struct BackendOptions;
26 static const bool value = std::is_same<T, int>::value ||
27 std::is_same<T, float>::value ||
28 std::is_same<T, bool>::value ||
29 std::is_same<T, std::string>::value ||
30 std::is_same<T, const char*>::value;
40 explicit Var(
int i) : m_Vals(i), m_Type(VarTypes::Integer) {};
41 explicit Var(
float f) : m_Vals(f), m_Type(VarTypes::Float) {};
42 explicit Var(
bool b) : m_Vals(b), m_Type(VarTypes::
Boolean) {};
43 explicit Var(
const char* s) : m_Vals(s), m_Type(VarTypes::String) {};
44 explicit Var(std::string s) : m_Vals(s), m_Type(VarTypes::String) {};
47 template<
typename DisallowedType>
50 static_assert(CheckAllowed<DisallowedType>::value,
"Type is not allowed for Var<DisallowedType>.");
51 assert(
false &&
"Unreachable code");
56 : m_Type(other.m_Type)
60 case VarTypes::String:
62 new (&m_Vals.s) std::string(other.m_Vals.s);
67 DoOp(other, [](
auto& a,
auto& b)
80 if (m_Type == VarTypes::String)
85 m_Type = other.m_Type;
88 case VarTypes::String:
91 new (&m_Vals.s) std::string(other.m_Vals.s);
96 DoOp(other, [](
auto& a,
auto& b)
109 bool IsInt()
const {
return m_Type == VarTypes::Integer; }
110 bool IsFloat()
const {
return m_Type == VarTypes::Float; }
111 bool IsString()
const {
return m_Type == VarTypes::String; }
114 bool AsBool()
const { assert(IsBool());
return m_Vals.b; }
115 int AsInt()
const { assert(IsInt());
return m_Vals.i; }
116 float AsFloat()
const { assert(IsFloat());
return m_Vals.f; }
117 std::string
AsString()
const { assert(IsString());
return m_Vals.s; }
122 DoOp(*
this, [
this](
auto& a,
auto&)
128 template<
typename Func>
129 void DoOp(
const Var& other, Func func)
133 func(m_Vals.b, other.m_Vals.b);
135 else if (other.
IsInt())
137 func(m_Vals.i, other.m_Vals.i);
141 func(m_Vals.f, other.m_Vals.f);
145 func(m_Vals.s, other.m_Vals.s);
149 template<
typename Destructable>
150 void Destruct(Destructable& d)
152 if (std::is_destructible<Destructable>::value)
179 explicit Vals(
int i) : i(i) {};
180 explicit Vals(
float f) : f(f) {};
181 explicit Vals(
bool b) : b(b) {};
182 explicit Vals(
const char* s) : s(std::string(s)) {}
183 explicit Vals(std::string s) : s(s) {}
194 : m_Name(name), m_Value(value)
197 : m_Name(name), m_Value(value)
200 : m_Name(name), m_Value(value)
203 : m_Name(name), m_Value(value)
206 : m_Name(name), m_Value(value)
209 template<
typename DisallowedType>
213 static_assert(CheckAllowed<DisallowedType>::value,
"Type is not allowed for BackendOption.");
214 assert(
false &&
"Unreachable code");
223 std::string
GetName()
const {
return m_Name; }
232 : m_TargetBackend(backend)
236 : m_TargetBackend(backend)
247 m_Options.push_back(option);
252 m_Options.push_back(option);
264 std::vector<BackendOption> m_Options;
268 template <
typename F>
271 for (
auto optionsGroup : options)
273 if (optionsGroup.GetBackendId() == backend)
275 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.
void ParseOptions(const std::vector< BackendOptions > &options, BackendId backend, F f)
std::vector< BackendOptions > ModelOptions
std::vector< BackendOptions > NetworkOptions
Copyright (c) 2020 ARM Limited.
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
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)
BackendOption(std::string name, const char *value)
BackendOption(std::string, DisallowedType)
const BackendId & GetBackendId() const noexcept
BackendOption(std::string name, std::string value)