началось все с этого

Автор:
Дата: 20.02.09

... после бдений и обработки напильником получилось нижеописанное. почему-то стойкое ощущение того, что изобрел велосипед...

//////////////////////////////////////////////////////////////////////////////////////////
template <typename Item>
class compound_list
{
    typedef Item                                    item;
    //typedef std::list<item*>                        item_list;
    // кому что нравится, но вариант с std::list будет жрать прорву памяти
    // при сомнительной выгоде вставки/удаления
    typedef std::vector<item*>                        item_list;
    typedef typename item_list::iterator            item_it;

    item_list                m_listItems;
public:
    inline                    compound_list(void)        { }
    inline                    ~compound_list(void)    { DeleteAllItems(); }
public:
    inline void                AddItem(item* pItem)
    { m_listItems.push_back(pItem); }
    inline void                AddSubItem(item* pParentItem, item* pItem)
    { pParentItem->AddItem(pItem); }

    inline void                DeleteAllItems(void)
    {
        int                        iSize                    = m_listItems.size();
        if(iSize)
        {
            item_it                    pCursor                    = m_listItems.begin();
            do { delete *pCursor; ++pCursor; } while(--iSize);
        }
    }
};
//////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////
struct item                { virtual ~item(void) { } };
template <typename Ctrl>
struct item_impl : public item, public Ctrl        { };

template <typename Ctrl>
item*                    CreateItem(void)        { return new item_impl<Ctrl>; }
//////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////
class hierarchy_item
{
    typedef compound_list<hierarchy_item>            item_list;

    item_list                m_listItems;
public:
    virtual                    ~hierarchy_item(void)    { }
    inline void                AddItem(hierarchy_item* pItem)
    { m_listItems.AddItem(pItem); }
};
template <typename Ctrl>
struct hierarhy_item_impl : public hierarchy_item, public Ctrl            { };

template <typename Ctrl>
hierarchy_item*            CreateHierarchyItem(void)
{ return new hierarhy_item_impl<Ctrl>; }
//////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////
class static_ctrl        { };
class edit_ctrl            { };
//////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////
void                    TestCompoundList(void)
{
    {
    // плоский однородный список
    typedef compound_list<static_ctrl>                compound_list;
    compound_list            listHomogeneous;
    listHomogeneous.AddItem(new static_ctrl());
    listHomogeneous.AddItem(new static_ctrl());
    listHomogeneous.AddItem(new static_ctrl());
    listHomogeneous.AddItem(new static_ctrl());
    }
    {
    // плоский разнородный список
    typedef compound_list<item>                        compound_list;
    compound_list            listHeterogeneous;
    listHeterogeneous.AddItem(CreateItem<static_ctrl>());
    listHeterogeneous.AddItem(CreateItem<edit_ctrl>());
    listHeterogeneous.AddItem(CreateItem<static_ctrl>());
    listHeterogeneous.AddItem(CreateItem<edit_ctrl>());
    }

    {
    // иерархический разнородный список
    typedef compound_list<hierarchy_item>            compound_list;
    hierarchy_item*            pItem                    = NULL;
    hierarchy_item*            pSubItem                = NULL;
    compound_list            listHeterogeneous;

    pItem                    = CreateHierarchyItem<static_ctrl>();
    listHeterogeneous.AddItem(pItem);
    pSubItem                = CreateHierarchyItem<edit_ctrl>();
    listHeterogeneous.AddSubItem(pItem, pSubItem);
    listHeterogeneous.AddSubItem(pSubItem, CreateHierarchyItem<static_ctrl>());

    pItem                    = CreateHierarchyItem<edit_ctrl>();
    listHeterogeneous.AddItem(pItem);
    listHeterogeneous.AddSubItem(pItem, CreateHierarchyItem<static_ctrl>());
    }
}
//////////////////////////////////////////////////////////////////////////////////////////

Здравствуйте, Аноним, Вы писали:

А>началось все с этого

Автор:
Дата: 20.02.09

... после бдений и обработки напильником получилось нижеописанное. почему-то стойкое ощущение того, что изобрел велосипед...
А>

А>//////////////////////////////////////////////////////////////////////////////////////////
...
А>//////////////////////////////////////////////////////////////////////////////////////////
А>

Почти велосипед

Здравствуйте, kubic2009, Вы писали:

K>Почти велосипед
а можно, если это возможно, ссылку на оригинальное изобретение...

Здравствуйте, <Аноним>, Вы писали:

K>>Почти велосипед
А>а можно, если это возможно, ссылку на оригинальное изобретение...

boost.variant + std::vector, не устроит?

    typedef boost::variant< boost::shared_ptr<ControlA>, boost::shared_ptr<ControlB> > Type;
    std::vector< Type > contrl_vec;
    contrl_vec.push_back( boost::shared_ptr< ControlA >( new ControlA() ) );
    contrl_vec.push_back( boost::shared_ptr< ControlB >( new ControlB() ) );

Здравствуйте, serg baburin, Вы писали:

SB>boost.variant + std::vector, не устроит?

SB>

SB>    typedef boost::variant< boost::shared_ptr<ControlA>, boost::shared_ptr<ControlB> > Type;
SB>    std::vector< Type > contrl_vec;
SB>    contrl_vec.push_back( boost::shared_ptr< ControlA >( new ControlA() ) );
SB>    contrl_vec.push_back( boost::shared_ptr< ControlB >( new ControlB() ) );
SB>

в целом, думаю устроит. спасибо!