2013-09-10 15:49:43 +02:00
|
|
|
/*
|
|
|
|
Minetest
|
|
|
|
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU Lesser General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU Lesser General Public License along
|
|
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
2012-10-22 23:18:44 +02:00
|
|
|
/*
|
2014-11-16 21:31:57 +01:00
|
|
|
Dummy database class
|
2012-10-22 23:18:44 +02:00
|
|
|
*/
|
|
|
|
|
2013-09-10 15:49:43 +02:00
|
|
|
#include "database-dummy.h"
|
2020-09-20 21:51:12 +02:00
|
|
|
#include "remoteplayer.h"
|
2013-09-10 15:49:43 +02:00
|
|
|
|
2012-10-22 23:18:44 +02:00
|
|
|
|
2024-02-17 15:35:33 +01:00
|
|
|
bool Database_Dummy::saveBlock(const v3s16 &pos, std::string_view data)
|
2012-10-22 23:18:44 +02:00
|
|
|
{
|
2014-11-16 21:31:57 +01:00
|
|
|
m_database[getBlockAsInteger(pos)] = data;
|
2014-07-07 07:20:25 +02:00
|
|
|
return true;
|
2012-10-22 23:18:44 +02:00
|
|
|
}
|
|
|
|
|
2016-05-14 12:23:15 +02:00
|
|
|
void Database_Dummy::loadBlock(const v3s16 &pos, std::string *block)
|
2012-10-22 23:18:44 +02:00
|
|
|
{
|
2014-11-16 21:31:57 +01:00
|
|
|
s64 i = getBlockAsInteger(pos);
|
2017-08-17 23:02:50 +02:00
|
|
|
auto it = m_database.find(i);
|
2016-05-14 12:23:15 +02:00
|
|
|
if (it == m_database.end()) {
|
2022-09-06 12:21:09 +02:00
|
|
|
block->clear();
|
2016-05-14 12:23:15 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
*block = it->second;
|
2012-10-22 23:18:44 +02:00
|
|
|
}
|
|
|
|
|
2014-11-16 21:31:57 +01:00
|
|
|
bool Database_Dummy::deleteBlock(const v3s16 &pos)
|
2015-01-15 22:20:05 +01:00
|
|
|
{
|
2014-11-16 21:31:57 +01:00
|
|
|
m_database.erase(getBlockAsInteger(pos));
|
2015-01-16 11:59:59 +01:00
|
|
|
return true;
|
2015-01-15 22:20:05 +01:00
|
|
|
}
|
|
|
|
|
2015-02-17 14:30:32 +01:00
|
|
|
void Database_Dummy::listAllLoadableBlocks(std::vector<v3s16> &dst)
|
2012-10-22 23:18:44 +02:00
|
|
|
{
|
2015-12-26 17:01:41 +01:00
|
|
|
dst.reserve(m_database.size());
|
2014-11-16 21:31:57 +01:00
|
|
|
for (std::map<s64, std::string>::const_iterator x = m_database.begin();
|
|
|
|
x != m_database.end(); ++x) {
|
|
|
|
dst.push_back(getIntegerAsBlock(x->first));
|
2012-10-22 23:18:44 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-20 21:51:12 +02:00
|
|
|
void Database_Dummy::savePlayer(RemotePlayer *player)
|
|
|
|
{
|
|
|
|
m_player_database.insert(player->getName());
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Database_Dummy::loadPlayer(RemotePlayer *player, PlayerSAO *sao)
|
|
|
|
{
|
|
|
|
return m_player_database.find(player->getName()) != m_player_database.end();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Database_Dummy::removePlayer(const std::string &name)
|
|
|
|
{
|
|
|
|
m_player_database.erase(name);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Database_Dummy::listPlayers(std::vector<std::string> &res)
|
|
|
|
{
|
|
|
|
for (const auto &player : m_player_database) {
|
|
|
|
res.emplace_back(player);
|
|
|
|
}
|
|
|
|
}
|
2022-01-07 19:28:49 +01:00
|
|
|
|
2022-11-23 23:46:20 +01:00
|
|
|
void Database_Dummy::getModEntries(const std::string &modname, StringMap *storage)
|
2022-01-07 19:28:49 +01:00
|
|
|
{
|
2022-11-23 23:25:34 +01:00
|
|
|
const auto mod_pair = m_mod_storage_database.find(modname);
|
|
|
|
if (mod_pair != m_mod_storage_database.cend()) {
|
2022-01-07 19:28:49 +01:00
|
|
|
for (const auto &pair : mod_pair->second) {
|
|
|
|
(*storage)[pair.first] = pair.second;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-23 23:46:20 +01:00
|
|
|
void Database_Dummy::getModKeys(const std::string &modname, std::vector<std::string> *storage)
|
2022-11-15 16:45:12 +01:00
|
|
|
{
|
2022-11-23 23:25:34 +01:00
|
|
|
const auto mod_pair = m_mod_storage_database.find(modname);
|
|
|
|
if (mod_pair != m_mod_storage_database.cend()) {
|
2022-11-15 16:45:12 +01:00
|
|
|
storage->reserve(storage->size() + mod_pair->second.size());
|
|
|
|
for (const auto &pair : mod_pair->second)
|
|
|
|
storage->push_back(pair.first);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-09-26 23:03:43 +02:00
|
|
|
bool Database_Dummy::getModEntry(const std::string &modname,
|
|
|
|
const std::string &key, std::string *value)
|
|
|
|
{
|
2022-11-23 23:25:34 +01:00
|
|
|
auto mod_pair = m_mod_storage_database.find(modname);
|
|
|
|
if (mod_pair == m_mod_storage_database.end())
|
2022-09-26 23:03:43 +02:00
|
|
|
return false;
|
|
|
|
const StringMap &meta = mod_pair->second;
|
|
|
|
|
|
|
|
auto pair = meta.find(key);
|
|
|
|
if (pair != meta.end()) {
|
|
|
|
*value = pair->second;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Database_Dummy::hasModEntry(const std::string &modname, const std::string &key)
|
|
|
|
{
|
2022-11-23 23:25:34 +01:00
|
|
|
auto mod_pair = m_mod_storage_database.find(modname);
|
|
|
|
if (mod_pair == m_mod_storage_database.end())
|
2022-09-26 23:03:43 +02:00
|
|
|
return false;
|
|
|
|
const StringMap &meta = mod_pair->second;
|
|
|
|
|
|
|
|
return meta.find(key) != meta.cend();
|
|
|
|
}
|
|
|
|
|
2022-01-07 19:28:49 +01:00
|
|
|
bool Database_Dummy::setModEntry(const std::string &modname,
|
2024-02-17 15:35:33 +01:00
|
|
|
const std::string &key, std::string_view value)
|
2022-01-07 19:28:49 +01:00
|
|
|
{
|
2022-11-23 23:25:34 +01:00
|
|
|
auto mod_pair = m_mod_storage_database.find(modname);
|
|
|
|
if (mod_pair == m_mod_storage_database.end()) {
|
2024-02-17 15:35:33 +01:00
|
|
|
auto &map = m_mod_storage_database[modname];
|
|
|
|
map[key] = value;
|
2022-01-07 19:28:49 +01:00
|
|
|
} else {
|
|
|
|
mod_pair->second[key] = value;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Database_Dummy::removeModEntry(const std::string &modname, const std::string &key)
|
|
|
|
{
|
2022-11-23 23:25:34 +01:00
|
|
|
auto mod_pair = m_mod_storage_database.find(modname);
|
|
|
|
if (mod_pair != m_mod_storage_database.end())
|
2022-01-07 19:28:49 +01:00
|
|
|
return mod_pair->second.erase(key) > 0;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2022-09-26 23:03:43 +02:00
|
|
|
bool Database_Dummy::removeModEntries(const std::string &modname)
|
|
|
|
{
|
2022-11-23 23:25:34 +01:00
|
|
|
auto mod_pair = m_mod_storage_database.find(modname);
|
|
|
|
if (mod_pair != m_mod_storage_database.end() && !mod_pair->second.empty()) {
|
2022-09-26 23:03:43 +02:00
|
|
|
mod_pair->second.clear();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2022-01-07 19:28:49 +01:00
|
|
|
void Database_Dummy::listMods(std::vector<std::string> *res)
|
|
|
|
{
|
2022-11-23 23:25:34 +01:00
|
|
|
for (const auto &pair : m_mod_storage_database) {
|
2022-01-07 19:28:49 +01:00
|
|
|
res->push_back(pair.first);
|
|
|
|
}
|
|
|
|
}
|