register.h

#pragma once
 
#include <cgv/base/base.h>
#include <cgv/base/named.h>
#include <cgv/utils/token.h>
#include <cgv/type/info/type_name.h>
#include <string>
#include <iostream>
#include <map>
 
#include "lib_begin.h"
 
#ifndef _WIN32
#include <unistd.h>
#include <dlfcn.h>
#endif
 
namespace cgv {
    namespace base {
 
 
 
extern void CGV_API enable_registration();
extern void CGV_API disable_registration();
extern bool CGV_API is_registration_enabled();
 
extern void CGV_API define_registration_order(const std::string& partial_order, bool before_contructor_execution = false, const std::string& when = "always");
 
struct CGV_API registration_order_definition
{
    registration_order_definition(const std::string& partial_order, bool before_contructor_execution = false, const std::string& when = "always");
};
 
extern void CGV_API enable_registration_debugging();
extern void CGV_API disable_registration_debugging();
extern bool CGV_API is_registration_debugging_enabled();
 
extern void CGV_API enable_permanent_registration();
extern void CGV_API disable_permanent_registration();
extern bool CGV_API is_permanent_registration_enabled();
extern void CGV_API unregister_all_objects();
extern bool CGV_API request_exit_from_all_objects();
extern unsigned CGV_API get_nr_permanently_registered_objects();
extern base_ptr CGV_API get_permanently_registered_object(unsigned i);
 
 
 
extern void CGV_API enable_registration_event_cleanup();
extern void CGV_API disable_registration_event_cleanup();
extern bool CGV_API is_registration_event_cleanup_enabled();
 
 
 
extern void CGV_API register_object(base_ptr object, const std::string& options = "");
extern void CGV_API unregister_object(base_ptr object, const std::string& options = "");
 
struct CGV_API object_constructor : public cgv::base::base
{
public:
    std::string get_type_name() const { return cgv::type::info::type_name<object_constructor>::get_name(); }
    virtual std::string get_constructed_type_name() const = 0;
    virtual base_ptr construct_object() const = 0;
};
 
// type specific specialization of helper class to perform delayed registration and creation of objects in case that the registration is disabled
template <class T>
class object_constructor_impl : public object_constructor
{
public:
    std::string get_type_name() const { return cgv::type::info::type_name<object_constructor_impl<T> >::get_name(); }
    std::string get_constructed_type_name() const { return cgv::type::info::type_name<T>::get_name(); }
    // creation function
    base_ptr construct_object() const { return base_ptr(new T()); }
};
 
// type specific specialization of helper class to perform delayed registration and creation of objects in case that the registration is disabled
template <class T, typename CA>
class object_constructor_impl_1 : public object_constructor
{
    // buffer constructor argument
    CA ca;
public:
    // construct from option
    object_constructor_impl_1(const CA& _ca) : ca(_ca) {}
    std::string get_type_name() const { return cgv::type::info::type_name<object_constructor_impl_1<T, CA> >::get_name(); }
    std::string get_constructed_type_name() const { return cgv::type::info::type_name<T>::get_name(); }
    // creation function
    base_ptr construct_object() const { return base_ptr(new T(ca)); }
};
 
// type specific specialization of helper class to perform delayed registration and creation of objects in case that the registration is disabled
template <class T, typename CA1, typename CA2>
class object_constructor_impl_2 : public object_constructor
{
    // buffer constructor arguments
    CA1 ca1;
    CA2 ca2;
public:
    // construct from option
    object_constructor_impl_2(const CA1& _ca1, const CA2& _ca2) : ca1(_ca1), ca2(_ca2) {}
    std::string get_type_name() const { return cgv::type::info::type_name<object_constructor_impl_2<T,CA1,CA2> >::get_name(); }
    std::string get_constructed_type_name() const { return cgv::type::info::type_name<T>::get_name(); }
    // creation function
    base_ptr construct_object() const { return base_ptr(new T(ca1,ca2)); }
};
 
template <class T>
struct object_registration
{
    explicit object_registration(const std::string& options) {
        if (is_registration_enabled())
            register_object(base_ptr(new T()),options);
        else
            register_object(base_ptr(new object_constructor_impl<T>()), options);
    }
};
 
template <class T, typename CA>
struct object_registration_1
{
    object_registration_1(const CA& arg, const std::string& options = "") {
        if (is_registration_enabled())
            register_object(base_ptr(new T(arg)),options);
        else
            register_object(base_ptr(new object_constructor_impl_1<T,CA>(arg)), options);
    }
};
 
template <class T, typename CA1, typename CA2>
struct object_registration_2
{
    object_registration_2(const CA1& a1, const CA2& a2, const std::string& options = "")
    {
        if (is_registration_enabled())
            register_object(base_ptr(new T(a1,a2)),options);
        else
            register_object(base_ptr(new object_constructor_impl_2<T,CA1,CA2>(a1,a2)),options);
    }
};
 
 
 
struct CGV_API server
{
};
 
 
struct CGV_API driver
{
};
 
 
struct CGV_API registration_listener
{
    virtual void register_object(base_ptr object, const std::string& options = "") = 0;
    virtual void unregister_object(base_ptr object, const std::string& options = "") = 0;
};
 
struct CGV_API factory : public base
{
protected:
    std::string created_type_name;
    bool is_singleton;
    base_ptr singleton;
    std::string object_options;
public:
    factory(const std::string& _created_type_name, bool _singleton = false, const std::string& _object_options = "");
    virtual std::string get_object_options() const;
    const std::string& get_created_type_name() const;
    std::string get_property_declarations();
    bool set_void(const std::string& property, const std::string& value_type, const void* value_ptr);
    bool get_void(const std::string& property, const std::string& value_type, void* value_ptr);
    bool is_singleton_factory() const;
    base_ptr get_singleton() const;
    void release_singleton();
    base_ptr create_object();
    virtual base_ptr create_object_impl() = 0;
};
 
template <class T>
struct factory_impl : public factory
{
    inline factory_impl(const std::string& _created_type_name, bool _is_singleton = false, const std::string& _object_options = "") :
                factory(_created_type_name, _is_singleton, _object_options) {}
    inline base_ptr create_object_impl() { return base_ptr(new T()); }
    std::string get_type_name() const { return std::string("factory_impl<")+get_created_type_name()+">"; }
};
 
template <class T, typename CA>
struct factory_impl_1 : public factory
{
    CA ca;
    inline factory_impl_1(CA _ca, const std::string& _created_type_name, bool is_singleton = false, const std::string& _object_options = "") :
        factory(_created_type_name, is_singleton, _object_options), ca(_ca) {}
    inline base_ptr create_object_impl() { return base_ptr(new T(ca)); }
    std::string get_type_name() const { return std::string("factory_impl_1<")+get_created_type_name()+">"; }
};
 
template <class T, typename CA1, typename CA2>
struct factory_impl_2 : public factory
{
    CA1 ca1;
    CA2 ca2;
    inline factory_impl_2(CA1 _ca1, CA2 _ca2, const std::string& _created_type_name, bool is_singleton = false, const std::string& _object_options = "") :
        factory(_created_type_name, is_singleton, _object_options), ca1(_ca1), ca2(_ca2) {}
    inline base_ptr create_object_impl() { return base_ptr(new T(ca2)); }
    std::string get_type_name() const { return std::string("factory_impl_2<")+get_created_type_name()+">"; }
};
 
extern std::string CGV_API guess_created_type_name(const char* item_text);
extern void CGV_API register_factory_object(base_ptr fo, const char* item_text, char shortcut);
 
template <class T>
struct factory_registration
{
 
    factory_registration(const std::string& _created_type_name, const std::string& _options = "", bool _is_singleton = false, const std::string& _object_options = "") {
        register_object(new factory_impl<T>(_created_type_name, _is_singleton, _object_options), _options);
    }
 
    factory_registration(const char* item_text, char shortcut, bool is_singleton = false) {
        register_factory_object(new factory_impl<T>(guess_created_type_name(item_text), is_singleton), item_text, shortcut);
    }
};
 
template <class T, typename CA>
struct factory_registration_1
{
 
    factory_registration_1(const std::string& _created_type_name, const CA& _ca, const std::string& _options = "", bool _is_singleton = false, const std::string& _object_options = "") {
        register_object(new factory_impl_1<T,CA>(_ca, _created_type_name, _is_singleton, _object_options), _options);
    }
 
    factory_registration_1(const char* item_text, char shortcut, const CA& _ca, bool is_singleton = false) {
        register_factory_object(new factory_impl_1<T,CA>(_ca, guess_created_type_name(item_text), is_singleton), item_text, shortcut);
    }
};
 
template <class T, typename CA1, typename CA2>
struct factory_registration_2
{
 
    factory_registration_2(const std::string& _created_type_name, const CA1& _ca1, const CA2& _ca2, const std::string& _options = "", bool _is_singleton = false, const std::string& _object_options = "") {
        register_object(new factory_impl_2<T,CA1,CA2>(_ca1, _ca2, _created_type_name, _is_singleton, _object_options), _options);
    }
};
 
 
 
 
class CGV_API test : public base
{
public:
    static int nr_failed;
protected:
    std::string test_name;
    bool (*test_func)();
public:
    test(const std::string& _test_name, bool (*_test_func)());
    std::string get_type_name() const;
    std::string get_test_name() const;
    bool exec_test() const;
};
 
#define TEST_ASSERT(V) \
    if (!(V)) { \
        std::cerr << "\n" << __FILE__ << "(" << __LINE__ << ") : error: test failure" << std::endl; \
        ++cgv::base::test::nr_failed; \
    }
 
#define TEST_ASSERT_EQ(V,Q) \
    if ((V) != (Q)) { \
        std::cerr << "\n" << __FILE__ << "(" << __LINE__ << ") : error: test failure " << (V) << "!=" << (Q) << std::endl; \
        ++cgv::base::test::nr_failed; \
    }
 
struct CGV_API test_registration
{
    test_registration(const std::string& _test_name, bool (*_test_func)());
};
 
 
 
 
struct CGV_API resource_file_info
{
    unsigned int file_offset;
    unsigned int file_length;
    const char* file_data;
    std::string source_file;
    resource_file_info(
        unsigned int _file_offset = 0,
        unsigned int _file_length = 0,
        const char* _file_data = 0,
        const std::string& _source_file = "");
};
 
extern CGV_API std::map<std::string, resource_file_info>& ref_resource_file_map();
 
extern CGV_API void register_resource_file(const std::string& file_path, unsigned int file_offset, unsigned int file_length, const char* file_data, const std::string& source_file = "");
 
struct CGV_API resource_file_registration
{
    resource_file_registration(const char* file_data);
};
 
extern CGV_API void register_resource_string(const std::string& string_name, const char* string_data);
 
struct CGV_API resource_string_registration
{
    resource_string_registration(const std::string& string_name, const char* string_data);
};
 
 
 
struct argument_handler
{
    virtual void handle_args(std::vector<std::string>& args) = 0;
};
 
enum CommandType
{
    CT_UNKNOWN,    // command is not known to framework
    CT_EMPTY,      // command specification was empty
    CT_COMMENT,    // a comment was given starting with '/'
    CT_SHOW,       // a show command was specified, currently only show all is supported
    CT_PERSISTENT, // the persistent command means that all successive value set commands in a config file should be updated during execution when the user changes one of them
    CT_INITIAL,    // reverts a persistent command
    CT_PLUGIN,     // loads a plugin
    CT_CONFIG,     // executes a config file
    CT_GUI,        // loads a gui description file
    CT_NAME,       // sets a value of a registered object of the given name
    CT_TYPE        // sets a value of a registered object of the given type
};
 
struct command_info
{
    CommandType command_type;
    std::vector<cgv::utils::token> parameters;
};
 
extern CommandType CGV_API analyze_command(const cgv::utils::token& cmd, bool eliminate_quotes = true, command_info* info_ptr = 0);
 
extern bool CGV_API process_command(const command_info& info);
 
 
 
extern bool CGV_API process_command(const std::string& cmd, bool eliminate_quotes = true);
 
extern void CGV_API show_all();
 
 
extern CGV_API void register_prog_name(const char* prog_name);
extern CGV_API std::string& ref_prog_name();
extern CGV_API std::string& ref_prog_path_prefix();
extern CGV_API void process_command_line_args(int argc, char** argv);
 
 
 
struct config_file_observer
{
    virtual void multi_observe(base_ptr bp, const std::string& property_assignments, size_t off) = 0;
};
 
 
struct config_file_driver
{
public:
    virtual config_file_observer* find_config_file_observer(const std::string& file_name, const std::string& content) = 0;
    virtual bool process_gui_file(const std::string& file_name) = 0;
};
 
extern CGV_API void register_config_file_driver(config_file_driver* cfd);
 
extern named_ptr CGV_API find_object_by_name(const std::string& name);
extern base_ptr CGV_API find_object_by_type(const std::string& type_name);
extern bool CGV_API process_config_file(const std::string& file_name);
extern bool CGV_API process_gui_file(const std::string& file_name);
 
 
extern CGV_API void* load_plugin(const std::string& file_name);
extern CGV_API std::string& ref_plugin_name();
extern CGV_API bool unload_plugin(void* handle);
 
 
    }
}
 
#include <cgv/config/lib_end.h>