namespace esd::module {
using tizen_base::_;
-using tizen_base::dbtype_cast;
namespace {
return false;
for (const auto& i : r) {
- auto [table_name] = i.Get<_>();
- if (dbtype_cast<std::string>(table_name) == "cion")
+ std::string table_name = i.Get(0);
+ if (table_name == "cion")
return true;
}
return false;
for (const auto& i : r) {
- auto [uuid_rec] = i.Get<_>();
- uuid = dbtype_cast<std::string>(uuid_rec);
+ uuid = static_cast<std::string>(i.Get(0));
return true;
}
return;
for (const auto& i : r) {
- auto [display_name_rec] = i.Get<_>();
- display_name = dbtype_cast<std::string>(display_name_rec);
+ display_name = static_cast<std::string>(i.Get(0));
ret = 0;
break;
}
return;
for (const auto& i : r2) {
- auto [display_name_rec] = i.Get<_>();
- std::string display_name = dbtype_cast<std::string>(display_name_rec);
+ std::string display_name = i.Get(0);
if (enabled)
AddEnabledApp(service_name, appid, display_name);
else
return;
for (const auto& i : r) {
- auto [enabled_rec] = i.Get<_>();
- enabled = (bool)dbtype_cast<int>(enabled_rec);
+ enabled = static_cast<bool>(static_cast<int>(i.Get(0)));
ret = 0;
break;
}
for (const auto& i : r) {
auto [service_name, appid, display_name] = i.Get<_, _, _>();
info_list.push_back(
- CionServiceInfo(dbtype_cast<std::string>(service_name),
- dbtype_cast<std::string>(appid),
- dbtype_cast<std::string>(display_name)));
+ CionServiceInfo(static_cast<std::string>(service_name),
+ static_cast<std::string>(appid),
+ static_cast<std::string>(display_name)));
}
return info_list;
namespace tizen_base {
-using DbType = std::variant<int, double, std::string,
- std::vector<unsigned char>>;
-using _ = DbType;
-
-template<typename T>
-T dbtype_cast(DbType v) {
- return std::get<T>(v);
-}
-
template<std::size_t N>
struct num {
static const constexpr auto value = N;
for_(func, std::make_index_sequence<N>());
}
+using DbType = std::variant<int, double, std::string,
+ std::vector<unsigned char>>;
+
+class AutoDbType {
+ public:
+ AutoDbType() = default;
+ AutoDbType(DbType db_type) : db_type_(db_type) {}
+
+ operator int () {
+ return std::get<int>(db_type_);
+ }
+
+ operator std::string () {
+ return std::get<std::string>(db_type_);
+ }
+
+ operator double () {
+ return std::get<double>(db_type_);
+ }
+
+ operator std::vector<unsigned char> () {
+ return std::get<std::vector<unsigned char>>(db_type_);
+ }
+
+ private:
+ DbType db_type_;
+};
+
+using _ = AutoDbType;
+
class Database {
public:
class TransactionGuard {
public:
Record(const sqlite3_stmt* stmt) : stmt_(stmt) {}
- DbType Get(int pos) const {
+ AutoDbType Get(int pos) const {
sqlite3_stmt* stmt = const_cast<sqlite3_stmt*>(stmt_);
int type = sqlite3_column_type(stmt, pos);
if (type == SQLITE_NULL)
throw std::runtime_error("invalid column type");
}
- return dbt;
+ return AutoDbType(dbt);
}
template <typename ...Types>