CRNSavable.cpp

Go to the documentation of this file.

/* Copyright 2006-2016 INSA Lyon, CoReNum, ENS-Lyon
 * 
 * This file is part of libcrn.
 * 
 * libcrn 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.
 * 
 * libcrn 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 libcrn.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * file: CRNSavable.cpp
 * \author Yann LEYDIER
 */

#include <CRNi18n.h>
#include <CRNSavable.h>
#include <CRNException.h>
#include <CRNData/CRNMap.h>
#include <CRNXml/CRNXml.h>

using namespace crn;

const StringUTF8 USERDATA_NAME("userdata");

Savable::Savable(const String &s):
    name(s),
    user_data(nullptr),
    filelock(std::make_unique<std::mutex>()),
    filename("")
{ 
}

Savable::~Savable()
{ 
}

Savable::Savable(Savable&&) noexcept = default;
Savable& Savable::operator=(Savable&&c) = default;

/*****************************************************************************/
bool Savable::IsUserData(const String &key) const
{
    if (!user_data) 
        return false;
    if (user_data->Find(key) != user_data->end())
        return true;
    else
        return false;
}

/*****************************************************************************/
SObject Savable::GetUserData(const String &key)
{
    if (!user_data)
        return nullptr;
    if (IsUserData(key))
        return (*user_data)[key];
    else
        return nullptr;
}

/*****************************************************************************/
String Savable::GetUserDataKey(const SObject &value) const
{
    if (!user_data)
        return U"";
    for (Map::const_iterator it = user_data->begin(); it != user_data->end(); ++it)
    {
        if (it->second == value)
            return it->first;
    }
    return U"";
}

/*****************************************************************************/
const SObject Savable::GetUserData(const String &key) const
{
    if (!user_data)
        return nullptr;
    if (IsUserData(key))
        return (*user_data)[key];
    else
        return nullptr;
}

/*****************************************************************************/
void Savable::DeleteUserData(const String &key)
{
    if (!user_data)
        throw ExceptionNotFound(_("No user data to remove."));
    user_data->Remove(key); // may throw
}

void Savable::SetUserData(const String &key, SObject value)
{
    if (!user_data)
        user_data.reset(new Map());
    user_data->Set(key, value);
}

void Savable::ClearUserData()
{
    if (user_data)
        user_data->Clear();
}

/***************************************************************************/
/* Savable informal protocol                                               */
/***************************************************************************/
Savable::Savable(const String &s, const Path &fname):
    name(s),
    user_data(nullptr),
    filelock(std::make_unique<std::mutex>()),
    filename(fname)
{ 
}

void Savable::Load(const Path &fname)
{
    std::lock_guard<std::mutex> lock(*filelock);
    Path fn;
    if (fname.IsAbsolute())
        fn = fname;
    else
        fn = completeFilename(fname);
    load(fn);
    filename = fname;
}

void Savable::Save(const Path &fname)
{
    std::lock_guard<std::mutex> lock(*filelock);
    Path fn;
    if (fname.IsAbsolute())
        fn = fname;
    else
        fn = completeFilename(fname);
    save(fn);
    filename = fname;
}

void Savable::Save()
{
    if (filename.IsEmpty())
        return throw ExceptionUninitialized(_("Cannot save an object with no filename."));
    Save(filename);
}

Path Savable::completeFilename(const Path &fn) const
{
    return fn;
}

void Savable::load(const Path &fname)
{
    throw ExceptionProtocol(StringUTF8("load() not implemented in ") + typeid(*this).name());
}

void Savable::save(const Path &fname)
{
    throw ExceptionProtocol(StringUTF8("save() not implemented in ") + typeid(*this).name());
}

/*****************************************************************************/
void Savable::deserialize_internal_data(xml::Element &el)
{
    // read name if any
    const StringUTF8 nam = el.GetAttribute<StringUTF8>("name");

    xml::Element udel(el.GetFirstChildElement("Map"));
    while (udel)
    { // look for a map containing user data
        const StringUTF8 role = udel.GetAttribute<StringUTF8>("role");
        // check role
        if (role == USERDATA_NAME)
        { // found the user data
            if (!user_data)
            { // create the object if needed
                user_data.reset(new Map());
            }
            else
            { // clear the current user data if needed
                user_data->Clear();
            }
            // read the user data and quit the method
            user_data->Deserialize(udel);
            return;
        }
        udel = udel.GetNextSiblingElement("Map");
    }
}

/*****************************************************************************/
void Savable::serialize_internal_data(xml::Element &el) const
{
    el.SetAttribute("name", name.CStr());
    if (user_data)
    {
        xml::Element udel = user_data->Serialize(el);
        udel.SetAttribute("role", USERDATA_NAME);
    }
}