group.h

#pragma once
 
#include "node.h"
#include <vector>
 
#include "lib_begin.h"
 
namespace cgv {
    namespace base {
 
class CGV_API group;
 
typedef data::ref_ptr<group, true> group_ptr;
typedef data::ref_ptr<const group, true> const_group_ptr;
 
class CGV_API group : public node
{
protected:
    friend class data::ref_ptr<group,true>;
    std::vector<base_ptr> children;
    void link(base_ptr b);
    void unlink(base_ptr b);
public:
    group(const std::string& name = "");
    unsigned int get_nr_children() const;
    base_ptr get_child(unsigned int i) const;
    template<typename T>
    data::ref_ptr<T> create_and_append_child(const std::string& name = "", unsigned int* index = nullptr) {
        static_assert(std::is_base_of<node, T>::value, "T must inherit from node");
        data::ref_ptr<T> ptr(new T());
        ptr->set_name(name);
        unsigned int i = append_child(ptr);
        if(index)
            *index = i;
        return ptr;
    }
    virtual unsigned int append_child(base_ptr child);
    virtual unsigned int remove_child(base_ptr child);
    virtual void remove_all_children();
    virtual void insert_child(unsigned int i, base_ptr child);
    group_ptr get_group();
    const_group_ptr get_group_const();
    std::string get_type_name() const;
};
 
template <> struct cast_helper<group>
{
    inline static group_ptr cast(base* b) { return b->get_group(); }
};
template <> struct cast_const_helper<group>
{
    inline static const_group_ptr cast_const(const base* b) { return b->get_group_const(); }
};
 
 
#if _MSC_VER >= 1400
CGV_TEMPLATE template class CGV_API data::ref_ptr<group>;
CGV_TEMPLATE template class CGV_API std::vector<base_ptr>;
#endif
 
    }
}
 
#include <cgv/config/lib_end.h>