base.h

#pragma once
 
#include <cgv/type/info/type_name.h>
#include <cgv/reflect/reflection_handler.h>
#include <cgv/data/ref_ptr.h>
#include <iostream>
 
#include <cgv/type/lib_begin.h>
 
namespace cgv {
        namespace type {
                namespace info {
 
struct CGV_API type_interface;
 
typedef cgv::data::ref_ptr<const type_interface,true> const_type_ptr;
 
                }
        }
}
#include <cgv/config/lib_end.h>
 
#include "lib_begin.h"
 
namespace cgv {
        namespace base {
 
class CGV_API base;
class CGV_API named;
class CGV_API node;
class CGV_API group;
 
typedef data::ref_ptr<base,true> base_ptr;
 
struct cast_helper_base
{
        template <class T>
        static data::ref_ptr<T,true> cast_of_base(base* b);
};
 
template <class T> 
struct cast_helper : public cast_helper_base
{ 
        inline static data::ref_ptr<T,true> cast(base* b) 
        { 
                return cast_of_base<T>(b); 
        }
};
 
class CGV_API base : public data::ref_counted, public cgv::reflect::self_reflection_tag
{
protected:
        friend class data::ref_ptr_impl<base,true>;
        virtual ~base();
        friend struct cast_helper_base;
        template <class T>
        inline static data::ref_ptr<T,true> cast_dynamic(base* b) 
        {
                return data::ref_ptr<T,true>(dynamic_cast<T*>(b)); 
        }
public:
        virtual std::string get_type_name() const;
        virtual std::string get_default_options() const;
        virtual void on_register();
        virtual void unregister();
        virtual void stream_stats(std::ostream&);
        virtual data::ref_ptr<named,true> get_named();
        virtual data::ref_ptr<node,true> get_node();
        virtual data::ref_ptr<group,true> get_group();
        template <class T>
        data::ref_ptr<T,true> cast() {
                return cast_helper<T>::cast(this);
        }
        template <class T>
        T* get_interface() {
                return dynamic_cast<T*>(this);
        }
        template <class T>
        const T* get_const_interface() const {
                return dynamic_cast<const T*>(this);
        }
        virtual void update();
        virtual void* get_user_data() const;
 
 
        virtual bool self_reflect(cgv::reflect::reflection_handler&);
 
        virtual std::string get_property_declarations();
 
        virtual bool set_void(const std::string& property, const std::string& value_type, const void* value_ptr);
        virtual void on_set(void* member_ptr);
 
        virtual bool get_void(const std::string& property, const std::string& value_type, void* value_ptr);
 
        virtual bool call_void(const std::string& method, 
                                                   const std::vector<std::string>& param_value_types,
                                                   const std::vector<const void*>& param_value_ptrs,
                                                   const std::string& result_type = "",
                                                   void* result_value_ptr = 0);
 
        void set(const std::string& property, const char* value) { const std::string& s(value); set_void(property, cgv::type::info::type_name<std::string>::get_name(), &s); }
 
        template <typename T>
        void set(const std::string& property, const T& value) { set_void(property, cgv::type::info::type_name<T>::get_name(), &value); }
 
        template <typename T>
        T get(const std::string& property) { T value; get_void(property, cgv::type::info::type_name<T>::get_name(), &value); return value; }
 
        void multi_set(const std::string& property_assignments, bool report_error = true);
 
        bool is_property(const std::string& property_name, std::string* type_name = 0);
 
        void* find_member_ptr(const std::string& property_name, std::string* type_name = 0);
};
 
 
template <typename T>
inline data::ref_ptr<T,true> cast_helper_base::cast_of_base(base* b)
{
        return base::cast_dynamic<T>(b);
}
 
#if _MSC_VER > 1400
CGV_TEMPLATE template class CGV_API cgv::data::ref_ptr<cgv::base::base>;
CGV_TEMPLATE template class CGV_API std::vector<cgv::data::ref_ptr<cgv::base::base> >;
#endif
 
        }
}
 
 
#include <cgv/config/lib_end.h>