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 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 
{
        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>