/data/gitorious.org/libyui/libyui-master/src/YChildrenManager.h

/**************************************************************************
Copyright (C) 2000 - 2010 Novell, Inc.
All Rights Reserved.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

**************************************************************************/


/*---------------------------------------------------------------------\
|                                                                      |
|                      __   __    ____ _____ ____                      |
|                      \ \ / /_ _/ ___|_   _|___ \                     |
|                       \ V / _` \___ \ | |   __) |                    |
|                        | | (_| |___) || |  / __/                     |
|                        |_|\__,_|____/ |_| |_____|                    |
|                                                                      |
|                               core system                            |
|                                                        (C) SuSE GmbH |
\----------------------------------------------------------------------/

  File:         YChildrenManager.h

  Author:       Stefan Hundhammer <sh@suse.de>

/-*/

#ifndef YChildrenManager_h
#define YChildrenManager_h

#include <list>
#include <algorithm>
#include <YUIException.h>


template<class T> class YChildrenManager
{
public:

    YChildrenManager( T * containerParent )
        : _container( containerParent )
        {}

    virtual ~YChildrenManager() {}

    
    typedef std::list<T *> ChildrenList;
    
    bool hasChildren() const { return ! empty(); }

    bool empty() const { return _children.empty(); }

    int count() const { return _children.size(); }

    typename ChildrenList::const_iterator begin() const
        { return _children.begin(); }

    typename ChildrenList::const_iterator end() const
        { return _children.end(); }

    typename ChildrenList::const_reverse_iterator rbegin() const
        { return _children.rbegin(); }
    
    typename ChildrenList::const_reverse_iterator rend() const
        { return _children.rend(); }

    T * firstChild()
        { return _children.empty() ? (T *) 0 : _children.front(); }

    T * lastChild()
        { return _children.empty() ? (T *) 0 : _children.back(); }

    virtual void add( T * child )
        { _children.push_back( child ); }

    virtual void remove( T * child )
        { _children.remove( child ); }

    virtual void clear()
        { _children.clear(); }

    bool contains( T * child ) const
    {
        return ( find( _children.begin(), _children.end(), child )
                 != _children.end() );
    }

    T * container() const { return _container; }

protected:

    T *                 _container;
    ChildrenList        _children;
};


template<class T> class YSingleChildManager: public YChildrenManager<T>
{
public:
    
    YSingleChildManager( T * containerParent )
        : YChildrenManager<T>( containerParent )
        {}

    virtual void add( T * child )
    {
        if ( this->empty() )
            this->_children.push_back( child );
        else
            YUI_THROW( YUITooManyChildrenException<T>( this->container() ) );
    }

    void replace( T * newChild )
    {
        this->_children.clear();
        this->_children.push_back( newChild );
    }
};


template<class T> class YChildrenRejector: public YChildrenManager<T>
{
public:
    YChildrenRejector( T * containerParent )
        : YChildrenManager<T>( containerParent )
        {}

    virtual void add( T * child )
        { YUI_THROW( YUITooManyChildrenException<T>( this->container() ) ); }
};


#endif // YChildrenManager_h