plugin.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 Cryptonomex, Inc., and contributors.
 *
 * The MIT License
 *
 * 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.
 */
#pragma once
 
#include <scorum/app/application.hpp>
 
#include <scorum/chain/evaluators/evaluator.hpp>
#include <scorum/chain/database/database.hpp>
 
#include <boost/program_options.hpp>
 
#include <fc/io/json.hpp>
#include <fc/static_variant.hpp>
#include <fc/unique_ptr.hpp>
#include <fc/vector.hpp>
 
#include <memory>
 
namespace scorum {
namespace app {
 
using fc::static_variant;
using fc::unique_ptr;
 
class abstract_plugin
{
public:
    virtual ~abstract_plugin()
    {
    }
    virtual std::string plugin_name() const = 0;
 
    virtual void plugin_initialize(const boost::program_options::variables_map& options) = 0;
 
    virtual void plugin_startup() = 0;
 
    virtual void plugin_shutdown() = 0;
 
    virtual void plugin_set_program_options(boost::program_options::options_description& command_line_options,
                                            boost::program_options::options_description& config_file_options)
        = 0;
};
 
class plugin : public abstract_plugin
{
public:
    plugin(application* app);
    virtual ~plugin() override;
 
    virtual std::string plugin_name() const override;
    virtual void plugin_initialize(const boost::program_options::variables_map& options) override;
    virtual void plugin_startup() override;
    virtual void plugin_shutdown() override;
    virtual void plugin_set_program_options(boost::program_options::options_description& command_line_options,
                                            boost::program_options::options_description& config_file_options) override;
 
    chain::database& database()
    {
        return *app().chain_database();
    }
    application& app() const
    {
        assert(_app);
        return *_app;
    }
 
protected:
    void print_greeting();
 
    graphene::net::node& p2p_node()
    {
        return *app().p2p_node();
    }
 
private:
    application* _app = nullptr;
};
 
template <typename T> T dejsonify(const std::string& s)
{
    return fc::json::from_string(s).as<T>();
}
 
#define DEFAULT_VALUE_VECTOR(value) default_value({ fc::json::to_string(value) }, fc::json::to_string(value))
#define LOAD_VALUE_SET(options, name, container, type)                                                                 \
    if (options.count(name))                                                                                           \
    {                                                                                                                  \
        const std::vector<std::string>& ops = options[name].as<std::vector<std::string>>();                            \
        std::transform(ops.begin(), ops.end(), std::inserter(container, container.end()),                              \
                       &scorum::app::dejsonify<type>);                                                                 \
    }
}
} // scorum::app
 
#define SCORUM_DEFINE_PLUGIN(plugin_name, plugin_class)                                                                \
    namespace scorum {                                                                                                 \
    namespace plugin {                                                                                                 \
    std::shared_ptr<scorum::app::abstract_plugin> create_##plugin_name##_plugin(app::application* app)                 \
    {                                                                                                                  \
        return std::make_shared<plugin_class>(app);                                                                    \
    }                                                                                                                  \
    }                                                                                                                  \
    }
 
#define DEFINE_PLUGIN_EVALUATOR(PLUGIN, OPERATION, X)                                                                  \
    class X##_evaluator : public scorum::chain::evaluator_impl<scorum::chain::database, X##_evaluator, OPERATION>      \
    {                                                                                                                  \
    public:                                                                                                            \
        typedef X##_operation operation_type;                                                                          \
                                                                                                                       \
        X##_evaluator(database& db, PLUGIN* plugin)                                                                    \
            : scorum::chain::evaluator_impl<scorum::chain::database, X##_evaluator, OPERATION>(db)                     \
            , _plugin(plugin)                                                                                          \
        {                                                                                                              \
        }                                                                                                              \
                                                                                                                       \
        void do_apply(const X##_operation& o);                                                                         \
                                                                                                                       \
        PLUGIN* _plugin;                                                                                               \
    };