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;
 
typedef data::ref_ptr<const base, true> const_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); 
    }
};
 
struct cast_const_helper_base
{
    template <class T>
    static data::ref_ptr<const T, true> cast_const_of_base(const base* b);
};
 
template <class T>
struct cast_const_helper : public cast_const_helper_base
{
    inline static data::ref_ptr<const T, true> cast_const(const base* b)
    {
        return cast_const_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;
    std::string get_name_or_type_name() const;
    virtual void on_register();
    virtual void unregister();
    virtual bool on_exit_request();
    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();
    virtual data::ref_ptr<const named, true> get_named_const() const;
    virtual data::ref_ptr<const node, true> get_node_const() const;
    virtual data::ref_ptr<const group, true> get_group_const() const;
    template <class T>
    data::ref_ptr<T, true> cast() {
        return cast_helper<T>::cast(this);
    }
    template <class T>
    data::ref_ptr<const T, true> cast_const() {
        return cast_const_helper<T>::cast_const(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);
}
 
template <typename T>
inline data::ref_ptr<const T, true> cast_const_helper_base::cast_const_of_base(const 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>