MergedPreferences.h

Go to the documentation of this file.

#ifndef WS_MERGED_PREFERENCES_H_INCLUDED
#define WS_MERGED_PREFERENCES_H_INCLUDED
/*
 * Copyright 2011-2016 Universiteit Antwerpen
 *
 * Licensed under the EUPL, Version 1.1 or  as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl5
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing
 * permissions and limitations under the Licence.
 */
#include "util/misc/Subject.h"
#include "workspace/IWorkspace.h"
#include "workspace/IProject.h"

#include <type_traits>
#include <boost/property_tree/ptree.hpp>

namespace SimShell
{
namespace Ws
{

class MergedPreferences;

namespace Event {
        struct MergedPreferencesChanged {
                const std::shared_ptr<MergedPreferences> source;
        };
}

class MergedPreferences : public SimPT_Sim::Util::Subject<Event::MergedPreferencesChanged, std::weak_ptr<const void>>,
                    public std::enable_shared_from_this<MergedPreferences>
{
public:
        static std::shared_ptr<MergedPreferences> Create(const std::shared_ptr<Ws::IWorkspace>&,
                                                   const std::shared_ptr<Ws::IProject>&);

        virtual ~MergedPreferences();

        template <typename T>
        typename std::enable_if<std::is_same<T, std::string>::value, T>::type
        Get(const boost::property_tree::ptree::path_type&) const;

        template <typename T>
        typename std::enable_if<!std::is_same<T, std::string>::value, T>::type
        Get(const boost::property_tree::ptree::path_type&) const;

        template <typename T>
        typename std::enable_if<std::is_same<T, std::string>::value, T>::type
        Get(const boost::property_tree::ptree::path_type&, const T&) const;

        template <typename T>
        typename std::enable_if<!std::is_same<T, std::string>::value, T>::type
        Get(const boost::property_tree::ptree::path_type&, const T&) const;

        template <typename T>
        void Put(const boost::property_tree::ptree::path_type&, const T&);

        std::shared_ptr<MergedPreferences> GetChild(const boost::property_tree::ptree::path_type&) const;

        std::shared_ptr<MergedPreferences> GetGlobal() const;

        const std::string& GetPath() const;

        const boost::property_tree::ptree& GetProjectPreferencesTree();

private:
        MergedPreferences(const std::shared_ptr<Ws::IWorkspace>&,
                    const std::shared_ptr<Ws::IProject>&);

        MergedPreferences(const boost::property_tree::ptree::path_type&, const MergedPreferences&);

        void ListenPreferencesChanged(const Ws::Event::PreferencesChanged&);

        boost::property_tree::ptree::path_type        m_path;
        std::shared_ptr<Ws::IWorkspace>               m_workspace;
        std::shared_ptr<Ws::IProject>                 m_project;
};

template <typename T>
typename std::enable_if<std::is_same<T, std::string>::value, T>::type
MergedPreferences::Get(const boost::property_tree::ptree::path_type& p) const
{
        auto str = m_project->GetPreferences().get<std::string>(m_path / p); // may throw ptree_bad_path
        if (str == "$WORKSPACE$") {
                return m_workspace->GetPreferences().get<T>(m_path / p); // may throw either ptree_bad_path or ptree_bad_data but probably won't
        } else {
                return str;
        }
}

template <typename T>
typename std::enable_if<!std::is_same<T, std::string>::value, T>::type
MergedPreferences::Get(const boost::property_tree::ptree::path_type& p) const
{
        auto str = m_project->GetPreferences().get<std::string>(m_path / p); // may throw ptree_bad_path
        if (str == "$WORKSPACE$") {
                return m_workspace->GetPreferences().get<T>(m_path / p); // may throw either ptree_bad_path or ptree_bad_data but probably won't
        } else {
                return m_project->GetPreferences().get<T>(m_path / p); // may throw ptree_bad_data
        }
}

template <typename T>
typename std::enable_if<std::is_same<T, std::string>::value, T>::type
MergedPreferences::Get(const boost::property_tree::ptree::path_type& p, const T& v) const
{
        auto str_optional = m_project->GetPreferences().get_optional<std::string>(m_path / p); // won't throw
        if (str_optional) {
                auto& str = str_optional.get();
                if (str == "$WORKSPACE$") {
                        return m_workspace->GetPreferences().get<T>(m_path / p); // may throw either ptree_bad_path or ptree_bad_data but probably won't
                } else {
                        return str;
                }
        } else {
                return v;
        }
}

template <typename T>
typename std::enable_if<!std::is_same<T, std::string>::value, T>::type
MergedPreferences::Get(const boost::property_tree::ptree::path_type& p, const T& v) const
{
        auto str_optional = m_project->GetPreferences().get_optional<std::string>(m_path / p); // won't throw
        if (str_optional) {
                auto& str = str_optional.get();
                if (str == "$WORKSPACE$") {
                        return m_workspace->GetPreferences().get<T>(m_path / p); // may throw either ptree_bad_path or ptree_bad_data but probably won't
                } else {
                        return m_project->GetPreferences().get<T>(m_path / p); // may throw ptree_bad_data
                }
        } else {
                return v;
        }
}

template <typename T>
inline void MergedPreferences::Put(const boost::property_tree::ptree::path_type& p, const T& v)
{
        auto prefs = m_project->GetPreferences(); // copy
        prefs.put<T>(m_path / p, v);
        m_project->SetPreferences(prefs);
}

} // namespace
} // namespace

#endif // end_of_inclde_guard