list2.h

Go to the documentation of this file.

/*****************************************************************************
* Copyright (c) 2001 - 2008 Marcus Boerger.  All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
* ========================================================================= */

/* ------------------------------------------------------------------------ */
/* Name:      list2.h
 *
 * Requires:  
 * - Mbo.h
 */
/* ------------------------------------------------------------------------ */

#ifndef _LIST2_H_
#define _LIST2_H_

#include "Mbo.h"

#include <list>
#include <stdexcept>

namespace std
{

template <class _Ty, class _Alloc = allocator<_Ty> >
class list2 : public list<_Ty, _Alloc>
{
typedef list2<_Ty, _Alloc>   _Myt;     
typedef list<_Ty, _Alloc>    _Mybase;  
public:

    virtual void limit(
            _IN size_type   _Limit
        )
    {
        if (size() > _Limit)
        {
            resize(_Limit);
        }
    }

    pair<size_type, bool> position(
            _IN  const _Ty  &_Val
        ) const
    {
        size_type _Index = 0;
        for (const_iterator iter = begin(); iter != end(); ++iter, ++_Index)
        {
            if (*iter == _Val)
            {
                return pair<size_type, bool>(_Index, true);
            }
        }
        return pair<size_type, bool>(-1, false);
    }

    bool contains(
            _IN  const _Ty  &_Val
        ) const
    {
        return std::find(begin(), end(), _Val) != end();
    }

    bool contains_no(
            _IN  const _Ty  &_Val
        ) const
    {
        return std::find(begin(), end(), _Val) == end();
    }

    virtual bool add_if_new(
            _IN  const _Ty  &_Val
        )
    {
        if (!contains(_Val))
        {
            push_back(_Val);
            return true;
        }
        return false;
    }

    operator bool()
    {
        return size() > 0;
    }

    reference at(
            _IN size_type _Off
        )
    {   // subscript mutable sequence with checking
        if (size() <= _Off)
        {
            _Xran();
        }
        iterator it = begin();
        while(_Off--) ++it;
        return *it;
    }

    const_reference at(
            _IN size_type _Off
        ) const
    {   // subscript non mutable sequence with checking
        if (size() <= _Off)
        {
            _Xran();
        }
        const_iterator it = begin();
        while(_Off--) ++it;
        return *it;
    }

    reference operator[] (
            _IN size_type _Off
        )
    {   // subscript mutable sequence
        return at(_Off);
    }

    const_reference operator[] (
            _IN size_type _Off
        ) const
    {   // subscript nonmutable sequence
        return at(_Off);
    }

    static list2<_Ty, _Alloc> __cdecl dyn_create( 
            _IN size_type   _Count, 
            ...
        )
    {
        _Myt       _List;
        va_list    _Args;

        va_start(_Args, _Count);
        while(_Count--)
        {
            _List.push_back(va_arg(_Args, const _Ty));
        }
        va_end(_Args);
        return _List;
    }

protected:

    void _Xran() const
    {   // report an out_of_range error
        _THROW(out_of_range, "invalid list2<T> subscript");
    }

};

template < class _Ty_a, class _Alloc_a
         , class _Ty_b, class _Alloc_b
         >
list2<_Ty_a, _Alloc_a> & operator += (
        _IN list2<_Ty_a, _Alloc_a> & container,
        _IN const list<_Ty_b, _Alloc_b> & values
    )
{
    // NO clear
    for (list2<_Ty_b, _Alloc_b>::const_iterator it = values.begin(); it != values.end(); ++it)
    {
        container.push_back((_Ty_a)*it);
    }
    return container;
};

template < class _Ty_a, class _Alloc_a
         , class _Ty_b, class _Alloc_b
         >
list2<_Ty_a, _Alloc_a> & operator << (
        _IN list2<_Ty_a, _Alloc_a> & container,
        _IN const list<_Ty_b, _Alloc_b> & values
    )
{
    container.clear();
    container += values;
    return container;
};

}; // namespace std

#endif // _LIST2_H_

---