configurable.h

Go to the documentation of this file.

/*
**  configurable.h
**
**  This is part of Shiokaze, a research-oriented fluid solver for computer graphics.
**  Created by Ryoichi Ando <rand@nii.ac.jp> on Sep 8, 2017.
**
**  Permission is hereby granted, free of charge, to any person obtaining a copy of
**  this software and associated documentation files (the "Software"), to deal in
**  the Software without restriction, including without limitation the rights to use,
**  copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
**  Software, and to permit persons to whom the Software is furnished to do so,
**  subject to the following conditions:
**
**  The above copyright notice and this permission notice shall be included in all copies
**  or substantial portions of the Software.
**
**  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
**  INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
**  PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
**  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
**  CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
**  OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
//
#ifndef SHKZ_CONFIGURABLE_H
#define SHKZ_CONFIGURABLE_H
//
#include <shiokaze/core/configuration.h>
#include <string>
#include <vector>
#include <map>
#include <cassert>
#include <algorithm>
//
SHKZ_BEGIN_NAMESPACE
//
class configurable {
public:
    using environment_map = std::map<std::string,const void *>;
    virtual void load ( configuration &config ) {}
    virtual void configure ( configuration &config ) {}
    virtual void initialize( const environment_map &environment ) {}
    static configuration& set_global_configuration( const configuration& config );
    static configuration& get_global_configuration();
    template <class T > static const T& get_env( const environment_map &environment, std::string key ) {
        return *reinterpret_cast<const T *>(environment.at(key));
    }
    virtual void setup_now( configuration& config=get_global_configuration() ) {
        assert(not_recursive());
        load(config);
        configure(config);
        initialize(environment_map());
    }
    virtual bool not_recursive() { return true; } // for safety check
protected:
    bool check_set( const environment_map &environment, std::vector<std::string> names ) {
        bool result (true);
        for( const auto &key : names ) {
            result = result && environment.find(key) != environment.end();
        }
        return result;
    }
};
//
class recursive_configurable : public configurable {
public:
    recursive_configurable() = default;
    virtual void recursive_load ( configuration &config ) {
        load(config);
        for( auto it=m_children.rbegin(); it!=m_children.rend(); ++it ) (*it)->load(config);
        for( auto it=m_recursive_children.rbegin(); it!=m_recursive_children.rend(); ++it ) (*it)->recursive_load(config);
        post_load();
        m_load_done = true;
    }
    virtual void recursive_configure ( configuration &config ) {
        assert(m_load_done);
        configure(config);
        for( auto it=m_children.rbegin(); it!=m_children.rend(); ++it ) (*it)->configure(config);
        for( auto it=m_recursive_children.rbegin(); it!=m_recursive_children.rend(); ++it ) (*it)->recursive_configure(config);
        post_configure();
        m_configure_done = true;
    }
    virtual void recursive_initialize( const configurable::environment_map &environment=configurable::environment_map() ) {
        assert(m_configure_done);
        configurable::environment_map merged_environment(m_environment);
        merged_environment.insert(environment.begin(),environment.end());
        initialize(merged_environment);
        for( auto it=m_children.rbegin(); it!=m_children.rend(); ++it ) (*it)->initialize(merged_environment);
        for( auto it=m_recursive_children.rbegin(); it!=m_recursive_children.rend(); ++it ) (*it)->recursive_initialize(merged_environment);
        post_initialize();
        m_initialize_done = true;
    }
    virtual bool is_ready() const {
        return m_initialize_done;
    }
    virtual void add_child( configurable *child ) {
        assert(child->not_recursive());
        m_children.push_back(child);
    }
    virtual void add_child( recursive_configurable *child ) {
        m_recursive_children.push_back(child);
    }
    virtual void remove_child( configurable *child ) {
        assert(child->not_recursive());
        m_children.erase(find(m_children.begin(),m_children.end(),child));
    }
    virtual void remove_child( recursive_configurable *child ) {
        m_recursive_children.erase(find(m_recursive_children.begin(),m_recursive_children.end(),child));
    }
    virtual void setup_now( configuration& config=get_global_configuration() ) override {
        recursive_load(config);
        recursive_configure(config);
        recursive_initialize();
    }
    virtual bool not_recursive() override { return false; } // for safety check
    void set_environment( std::string name, const void *value ) {
        m_environment[name] = value;
    }
    //
protected:
    //
    class environment_setter {
    public:
        environment_setter ( recursive_configurable *instance ) {
            instance->m_environment.clear();
        }
        environment_setter ( recursive_configurable *instance, std::string name, const void *value ) {
            instance->m_environment[name] = value;
        }
        environment_setter ( recursive_configurable *instance, const configurable::environment_map &env ) {
            instance->m_environment = env;
        }
    };
    //
private:
    //
    using configurable::load;
    using configurable::configure;
    //
    virtual void initialize( const environment_map &environment ) override { configurable::initialize(environment); }
    virtual void post_load () {}
    virtual void post_configure () {}
    virtual void post_initialize () {}
    //
    std::vector<configurable *> m_children;
    std::vector<recursive_configurable *> m_recursive_children;
    configurable::environment_map m_environment;
    //
    bool m_load_done{false}, m_configure_done{false}, m_initialize_done{false};
    //
    recursive_configurable( const recursive_configurable & ) = delete;
    recursive_configurable& operator=( const recursive_configurable & ) = delete;
};
//
SHKZ_END_NAMESPACE
//
#endif