DataManagerParameterFile.hxx

Go to the documentation of this file.

/*  This file is part of Charon.

    Charon 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 3 of the License, or
    (at your option) any later version.

    Charon 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 Charon.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef DATAMANAGERPARAMETERFILE_HXX
#define DATAMANAGERPARAMETERFILE_HXX

#include "Slots.hxx"
#include "FileTool.h"

namespace DataManagers {

    template <typename T>
    class charon_core_LOCAL DataManagerParameterFile :
            public Slot::DataManager<T> {
    private:
        ParameterFile _pf;
        const std::string _filename;
        std::string _paramName;
    public:

        DataManagerParameterFile(
            const Slot& slot, const std::string& config = "");
        virtual void setData(const T& data);
        virtual T getData();
        virtual std::string getConfig() const;
    };
}

template<typename T>
DataManagers::DataManagerParameterFile<T>::DataManagerParameterFile(
    const Slot& slot, const std::string& config) :
        _filename("lastRunParameterCache.wrp")
{
    if (!FileTool::exists(_filename)) {
        _pf.save(_filename);
    }
    if (config.size()) {
        _paramName = config;
    }
    else {
        _paramName = slot.getParent().getName() + "." + slot.getName();
    }
}

template<typename T>
void DataManagers::DataManagerParameterFile<T>::setData(const T& data) {
    _pf.load  (_filename);
    _pf.set<T>(_paramName, data);
    _pf.save  (_filename);
    _pf.clear ();
}

template<typename T>
T DataManagers::DataManagerParameterFile<T>::getData() {
    _pf.load(_filename);
    T val = _pf.get<T>(_paramName);
    _pf.clear();
    return val;
}

template<typename T>
std::string DataManagers::DataManagerParameterFile<T>::getConfig() const {
    return _paramName;
}

// \{
template<>
Slot::DataManager<int>* Slot::DataManagerFactory<int>::getManager(
        const Slot& slot, const std::string& config) {
    return new DataManagers::DataManagerParameterFile<int>(slot, config);
}

template<>
Slot::DataManager<float>* Slot::DataManagerFactory<float>::getManager(
        const Slot& slot, const std::string& config) {
    return new DataManagers::DataManagerParameterFile<float>(slot, config);
}

template<>
Slot::DataManager<double>* Slot::DataManagerFactory<double>::getManager(
        const Slot& slot, const std::string& config) {
    return new DataManagers::DataManagerParameterFile<double>(slot, config);
}

template<>
Slot::DataManager<std::string>* Slot::DataManagerFactory<std::string>::getManager(
        const Slot& slot, const std::string& config) {
    return new DataManagers::DataManagerParameterFile<std::string>(slot, config);
}
// \}

#endif // DATAMANAGERPARAMETERFILE_HXX