Skip to content
Permalink
Browse files

Add ModMetadata API (#5131)

* mod can create a ModMetadata object where store its values and retrieve it.
* Modmetadata object can only be fetched at mod loading
* Save when modified using same time as map interval or at server stop
* add helper function to get mod storage path
* ModMetadata has exactly same calls than all every other Metadata
  • Loading branch information...
nerzhul committed Feb 7, 2017
1 parent 0680c47 commit ef6feca501fcf0d5a1fd2021f1d4df96a4533f65
@@ -2629,6 +2629,11 @@ These functions return the leftover itemstack.
* `HTTPApiTable.fetch_async_get(handle)`: returns HTTPRequestResult
* Return response data for given asynchronous HTTP request

### Storage API:
* `minetest.get_mod_storage()`:
* returns reference to mod private `StorageRef`
* must be called during mod load time

### Misc.
* `minetest.get_connected_players()`: returns list of `ObjectRefs`
* `minetest.player_exists(name)`: boolean, whether player exists (regardless of online status)
@@ -2791,7 +2796,7 @@ Class reference
---------------

### `MetaDataRef`
See `NodeMetaRef` and `ItemStackMetaRef`.
See `StorageRef`, `NodeMetaRef` and `ItemStackMetaRef`.

#### Methods
* `set_string(name, value)`
@@ -2845,6 +2850,9 @@ Can be gotten via `minetest.get_node_timer(pos)`.
* `is_started()`: returns boolean state of timer
* returns `true` if timer is started, otherwise `false`

### `StorageRef`
This is basically a reference to a C++ `ModMetadata`

### `ObjectRef`
Moving things in the game are generally these.

@@ -76,13 +76,27 @@ const std::string &Metadata::getString(const std::string &name,
return resolveString(it->second, recursion);
}

void Metadata::setString(const std::string &name, const std::string &var)
/**
* Sets var to name key in the metadata storage
*
* @param name
* @param var
* @return true if key-value pair is created or changed
*/
bool Metadata::setString(const std::string &name, const std::string &var)
{
if (var.empty()) {
m_stringvars.erase(name);
} else {
m_stringvars[name] = var;
return true;
}

StringMap::iterator it = m_stringvars.find(name);
if (it != m_stringvars.end() && it->second == var) {
return false;
}

m_stringvars[name] = var;
return true;
}

const std::string &Metadata::resolveString(const std::string &str,
@@ -46,7 +46,7 @@ class Metadata
size_t size() const;
bool contains(const std::string &name) const;
const std::string &getString(const std::string &name, u16 recursion = 0) const;
void setString(const std::string &name, const std::string &var);
virtual bool setString(const std::string &name, const std::string &var);
const StringMap &getStrings() const
{
return m_stringvars;
@@ -21,13 +21,10 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include <fstream>
#include "mods.h"
#include "filesys.h"
#include "util/strfnd.h"
#include "log.h"
#include "subgame.h"
#include "settings.h"
#include "util/strfnd.h"
#include "convert_json.h"
#include "exceptions.h"

static bool parseDependsLine(std::istream &is,
std::string &dep, std::set<char> &symbols)
@@ -356,3 +353,80 @@ Json::Value getModstoreUrl(std::string url)
}

#endif

ModMetadata::ModMetadata(const std::string &mod_name):
m_mod_name(mod_name),
m_modified(false)
{
m_stringvars.clear();
}

void ModMetadata::clear()
{
Metadata::clear();
m_modified = true;
}

bool ModMetadata::save(const std::string &root_path)
{
Json::Value json;
for (StringMap::const_iterator it = m_stringvars.begin();
it != m_stringvars.end(); ++it) {
json[it->first] = it->second;
}

if (!fs::PathExists(root_path)) {
if (!fs::CreateAllDirs(root_path)) {
errorstream << "ModMetadata[" << m_mod_name << "]: Unable to save. '"
<< root_path << "' tree cannot be created." << std::endl;
return false;
}
} else if (!fs::IsDir(root_path)) {
errorstream << "ModMetadata[" << m_mod_name << "]: Unable to save. '"
<< root_path << "' is not a directory." << std::endl;
return false;
}

bool w_ok = fs::safeWriteToFile(root_path + DIR_DELIM + m_mod_name,
Json::FastWriter().write(json));

if (w_ok) {
m_modified = false;
} else {
errorstream << "ModMetadata[" << m_mod_name << "]: failed write file." << std::endl;
}
return w_ok;
}

bool ModMetadata::load(const std::string &root_path)
{
m_stringvars.clear();

std::ifstream is((root_path + DIR_DELIM + m_mod_name).c_str(), std::ios_base::binary);
if (!is.good()) {
return false;
}

Json::Reader reader;
Json::Value root;
if (!reader.parse(is, root)) {
errorstream << "ModMetadata[" << m_mod_name << "]: failed read data "
"(Json decoding failure)." << std::endl;
return false;
}

const Json::Value::Members attr_list = root.getMemberNames();
for (Json::Value::Members::const_iterator it = attr_list.begin();
it != attr_list.end(); ++it) {
Json::Value attr_value = root[*it];
m_stringvars[*it] = attr_value.asString();
}

return true;
}

bool ModMetadata::setString(const std::string &name, const std::string &var)
{
m_modified = Metadata::setString(name, var);
return m_modified;
}
@@ -28,6 +28,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include <map>
#include <json/json.h>
#include "config.h"
#include "metadata.h"

#define MODNAME_ALLOWED_CHARS "abcdefghijklmnopqrstuvwxyz0123456789_"

@@ -205,4 +206,24 @@ struct ModStoreModDetails {
bool valid;
};

class ModMetadata: public Metadata
{
public:
ModMetadata(const std::string &mod_name);
~ModMetadata() {}

virtual void clear();

bool save(const std::string &root_path);
bool load(const std::string &root_path);

bool isModified() const { return m_modified; }
const std::string &getModName() const { return m_mod_name; }

virtual bool setString(const std::string &name, const std::string &var);
private:
std::string m_mod_name;
bool m_modified;
};

#endif
@@ -174,7 +174,7 @@ void RemotePlayer::deSerialize(std::istream &is, const std::string &playername,

const Json::Value::Members attr_list = attr_root.getMemberNames();
for (Json::Value::Members::const_iterator it = attr_list.begin();
it != attr_list.end(); ++it) {
it != attr_list.end(); ++it) {
Json::Value attr_value = attr_root[*it];
sao->setExtendedAttribute(*it, attr_value.asString());
}
@@ -15,6 +15,7 @@ set(common_SCRIPT_LUA_API_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/l_particles.cpp
${CMAKE_CURRENT_SOURCE_DIR}/l_rollback.cpp
${CMAKE_CURRENT_SOURCE_DIR}/l_server.cpp
${CMAKE_CURRENT_SOURCE_DIR}/l_storage.cpp
${CMAKE_CURRENT_SOURCE_DIR}/l_util.cpp
${CMAKE_CURRENT_SOURCE_DIR}/l_vmanip.cpp
${CMAKE_CURRENT_SOURCE_DIR}/l_settings.cpp
@@ -0,0 +1,143 @@
/*
Minetest
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
Copyright (C) 2017 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
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.
*/

#include "lua_api/l_storage.h"
#include "l_internal.h"
#include "mods.h"
#include "server.h"

int ModApiStorage::l_get_mod_storage(lua_State *L)
{
lua_rawgeti(L, LUA_REGISTRYINDEX, CUSTOM_RIDX_CURRENT_MOD_NAME);
if (!lua_isstring(L, -1)) {
return 0;
}

std::string mod_name = lua_tostring(L, -1);

ModMetadata *store = new ModMetadata(mod_name);
// For server side
if (Server *server = getServer(L)) {
store->load(server->getModStoragePath());
server->registerModStorage(store);
} else {
assert(false); // this should not happen
}

StorageRef::create(L, store);
int object = lua_gettop(L);

lua_pushvalue(L, object);
return 1;
}

void ModApiStorage::Initialize(lua_State *L, int top)
{
API_FCT(get_mod_storage);
}

StorageRef::StorageRef(ModMetadata *object):
m_object(object)
{
}

void StorageRef::create(lua_State *L, ModMetadata *object)
{
StorageRef *o = new StorageRef(object);
*(void **)(lua_newuserdata(L, sizeof(void *))) = o;
luaL_getmetatable(L, className);
lua_setmetatable(L, -2);
}

int StorageRef::gc_object(lua_State *L)
{
StorageRef *o = *(StorageRef **)(lua_touserdata(L, 1));
// Server side
if (Server *server = getServer(L))
server->unregisterModStorage(getobject(o)->getModName());
delete o;
return 0;
}

void StorageRef::Register(lua_State *L)
{
lua_newtable(L);
int methodtable = lua_gettop(L);
luaL_newmetatable(L, className);
int metatable = lua_gettop(L);

lua_pushliteral(L, "__metatable");
lua_pushvalue(L, methodtable);
lua_settable(L, metatable); // hide metatable from Lua getmetatable()

lua_pushliteral(L, "metadata_class");
lua_pushlstring(L, className, strlen(className));
lua_settable(L, metatable);

lua_pushliteral(L, "__index");
lua_pushvalue(L, methodtable);
lua_settable(L, metatable);

lua_pushliteral(L, "__gc");
lua_pushcfunction(L, gc_object);
lua_settable(L, metatable);

lua_pop(L, 1); // drop metatable

luaL_openlib(L, 0, methods, 0); // fill methodtable
lua_pop(L, 1); // drop methodtable
}

StorageRef* StorageRef::checkobject(lua_State *L, int narg)
{
luaL_checktype(L, narg, LUA_TUSERDATA);
void *ud = luaL_checkudata(L, narg, className);
if (!ud) luaL_typerror(L, narg, className);
return *(StorageRef**)ud; // unbox pointer
}

ModMetadata* StorageRef::getobject(StorageRef *ref)
{
ModMetadata *co = ref->m_object;
return co;
}

Metadata* StorageRef::getmeta(bool auto_create)
{
return m_object;
}

void StorageRef::clearMeta()
{
m_object->clear();
}

const char StorageRef::className[] = "StorageRef";
const luaL_reg StorageRef::methods[] = {
luamethod(MetaDataRef, get_string),
luamethod(MetaDataRef, set_string),
luamethod(MetaDataRef, get_int),
luamethod(MetaDataRef, set_int),
luamethod(MetaDataRef, get_float),
luamethod(MetaDataRef, set_float),
luamethod(MetaDataRef, to_table),
luamethod(MetaDataRef, from_table),
{0,0}
};

0 comments on commit ef6feca

Please sign in to comment.
You can’t perform that action at this time.