LocalStorage.cpp

Go to the documentation of this file.

/*
    This source file is part of Rigs of Rods
    Copyright 2005-2012 Pierre-Michel Ricordel
    Copyright 2007-2012 Thomas Fischer
    Copyright 2013-2020 Petr Ohlidal
 
    For more information, see http://www.rigsofrods.org/
 
    Rigs of Rods is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License version 3, as
    published by the Free Software Foundation.
 
    Rigs of Rods 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 General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with Rigs of Rods. If not, see <http://www.gnu.org/licenses/>.
*/
 
#include "LocalStorage.h"
 
#include "Actor.h"
#include "Application.h"
#include "ContentManager.h"
#include "PlatformUtils.h"
 
using namespace RoR;
 
 
/* class that implements the localStorage interface for the scripts */
LocalStorage::LocalStorage(std::string fileName_in, const std::string& sectionName_in, const std::string &resource_group = RGN_CACHE)
{
    // inversed logic, better use a whitelist instead of a blacklist, so you are on the safe side ;) - tdev
    std::string allowedChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-";
    for (std::string::iterator it = fileName_in.begin() ; it < fileName_in.end() ; ++it){
        if ( allowedChars.find(*it) == std::string::npos )
            *it = '_';
    }
 
    sectionName = sectionName_in.substr(0, sectionName_in.find(".", 0));
    
    m_filename = fileName_in + ".asdata";
    m_resource_group = resource_group;
    this->separators = "=";
    loadDict();
    
    saved = true;
}
LocalStorage::LocalStorage(std::string fileName_in, const std::string& sectionName_in, const std::string &resource_group = RGN_CACHE) {…}
 
LocalStorage::~LocalStorage()
{
    // save everything
    saveDict();
}
LocalStorage::~LocalStorage() {…}
 
void LocalStorage::copyFrom(LocalStoragePtr other)
{
    m_filename = other->getFilename();
    sectionName = other->getSection();
    SettingsBySection::iterator secIt;
    SettingsBySection osettings = other->getSettings();
    for (secIt = osettings.begin(); secIt!=osettings.end(); secIt++)
    {
        SettingsMultiMap::iterator setIt;
        for (setIt = secIt->second->begin(); setIt!=secIt->second->end(); setIt++)
        {
            setSetting(setIt->first, setIt->second, secIt->first);
        }
    }
}
void LocalStorage::copyFrom(LocalStoragePtr other) {…}
 
void LocalStorage::changeSection(const std::string &section)
{
    sectionName = section.substr(0, section.find(".", 0));
}
void LocalStorage::changeSection(const std::string &section) {…}
 
// getters and setters
std::string LocalStorage::get(std::string key)
{
    std::string sec;
    parseKey(key, sec);
    return getString(key, sec);
}
std::string LocalStorage::get(std::string key) {…}
 
void LocalStorage::set(std::string key, const std::string &value)
{
    std::string sec;
    parseKey(key, sec);
    setSetting(key, value, sec);
    saved = false;
}
void LocalStorage::set(std::string key, const std::string &value) {…}
 
int LocalStorage::getInt(std::string key)
{
    std::string sec;
    parseKey(key, sec);
    return getSettingInt(key, sec);
}
int LocalStorage::getInt(std::string key) {…}
 
void LocalStorage::set(std::string key, const int value)
{
    std::string sec;
    parseKey(key, sec);
    setSetting(key, value, sec);
    saved = false;
}
void LocalStorage::set(std::string key, const int value) {…}
 
float LocalStorage::getFloat(std::string key)
{
    std::string sec;
    parseKey(key, sec);
    return getSettingReal(key, sec);
}
float LocalStorage::getFloat(std::string key) {…}
 
void LocalStorage::set(std::string key, const float value)
{
    std::string sec;
    parseKey(key, sec);
    setSetting(key, value, sec);
    saved = false;
}
void LocalStorage::set(std::string key, const float value) {…}
 
bool LocalStorage::getBool(std::string key)
{
    std::string sec;
    parseKey(key, sec);
    return getSettingBool(key, sec);
}
bool LocalStorage::getBool(std::string key) {…}
 
void LocalStorage::set(std::string key, const bool value)
{
    std::string sec;
    parseKey(key, sec);
    setSetting(key, value, sec);
    saved = false;
}
void LocalStorage::set(std::string key, const bool value) {…}
 
Ogre::Vector3 LocalStorage::getVector3(std::string key)
{
    std::string sec;
    parseKey(key, sec);
    return getSettingVector3(key, sec);
}
Ogre::Vector3 LocalStorage::getVector3(std::string key) {…}
 
void LocalStorage::set(std::string key, const Ogre::Vector3 &value)
{
    std::string sec;
    parseKey(key, sec);
    setSetting(key, value, sec);
    saved = false;
}
void LocalStorage::set(std::string key, const Ogre::Vector3 &value) {…}
 
Ogre::Quaternion LocalStorage::getQuaternion(std::string key)
{
    std::string sec;
    parseKey(key, sec);
    return getSettingQuaternion(key, sec);
}
Ogre::Quaternion LocalStorage::getQuaternion(std::string key) {…}
 
void LocalStorage::set(std::string key, const Ogre::Quaternion &value)
{
    std::string sec;
    parseKey(key, sec);
    setSetting(key, value, sec);
    saved = false;
}
void LocalStorage::set(std::string key, const Ogre::Quaternion &value) {…}
 
Ogre::Radian LocalStorage::getRadian(std::string key)
{
    std::string sec;
    parseKey(key, sec);
    return getSettingRadian(key, sec);
}
Ogre::Radian LocalStorage::getRadian(std::string key) {…}
 
void LocalStorage::set(std::string key, const Ogre::Radian &value)
{
    std::string sec;
    parseKey(key, sec);
    setSetting(key, value, sec);
    saved = false;
}
void LocalStorage::set(std::string key, const Ogre::Radian &value) {…}
 
Ogre::Degree LocalStorage::getDegree(std::string key)
{
    std::string sec;
    parseKey(key, sec);
    return Ogre::Degree(getSettingRadian(key, sec));
}
Ogre::Degree LocalStorage::getDegree(std::string key) {…}
 
void LocalStorage::set(std::string key, const Ogre::Degree &value)
{
    std::string sec;
    parseKey(key, sec);
    setSetting(key, Ogre::Radian(value), sec);
    saved = false;
}
void LocalStorage::set(std::string key, const Ogre::Degree &value) {…}
 
void LocalStorage::saveDict()
{
    if (this->saved)
    {
        return;
    }
 
    try
    {
        this->saveImprovedCfg(m_filename, RGN_CACHE);
        this->saved = true;
    }
    catch (std::exception& e)
    {
        RoR::LogFormat("[RoR|Scripting|LocalStorage]"
                       "Error saving file '%s' (resource group '%s'), message: '%s'",
                        m_filename.c_str(), RGN_CACHE, e.what());
    }
}
void LocalStorage::saveDict() {…}
 
bool LocalStorage::loadDict()
{
    try
    {
        this->loadImprovedCfg(m_filename, RGN_CACHE);
    }
    catch (std::exception& e)
    {
        RoR::LogFormat("[RoR|Scripting|LocalStorage]"
                       "Error reading file '%s' (resource group '%s'), message: '%s'",
                        m_filename.c_str(), RGN_CACHE, e.what());
        return false;
    }
    saved = true;
    return true;
}
bool LocalStorage::loadDict() {…}
 
void LocalStorage::eraseKey(std::string key)
{
    std::string sec;
    parseKey(key, sec);
    if (mSettingsPtr.find(sec) != mSettingsPtr.end() && mSettingsPtr[sec]->find(key) != mSettingsPtr[sec]->end())
        if (mSettingsPtr[sec]->erase(key) > 0)
            saved = false;
}
void LocalStorage::eraseKey(std::string key) {…}
 
void LocalStorage::deleteAll()
{
    // SLOG("This feature is not available yet");
}
void LocalStorage::deleteAll() {…}
 
void LocalStorage::parseKey(std::string& key, std::string &section)
{
    size_t dot = key.find(".", 0);
    if ( dot != std::string::npos )
    {
        section = key.substr(0, dot);
 
        if ( !section.length() )
            section = sectionName;
 
        key.erase(0, dot+1);
    }
    else
        section = sectionName;
}
void LocalStorage::parseKey(std::string& key, std::string &section) {…}
 
bool LocalStorage::exists(std::string key)
{
    std::string sec;
    parseKey(key, sec);
    return hasSetting(key, sec);
}
bool LocalStorage::exists(std::string key) {…}