deque2.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:      deque2.h
 *
 * Requires:  
 * - Mbo.h
 */
/* ------------------------------------------------------------------------ */

#ifndef _DEQUE2_H_
#define _DEQUE2_H_

#include "Mbo.h"

#include <algorithm>
#include <deque>

namespace std
{

template <class _Ty, class _Alloc = allocator<_Ty> >
class deque2 : public deque<_Ty, _Alloc>
{
public:
    typedef deque2<_Ty, _Alloc>   _Myt;    
    typedef deque<_Ty, _Alloc>    _Mybase; 
    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>(static_cast<size_type>(-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;
    }

    void sort()
    {
        if (size()>1)
        {
            std::sort(begin(), end());
        }
    }

    static _Myt __cdecl dyn_create( 
            _IN size_type   _Count, 
            ...
        )
    {
        _Myt       _Deque;
        va_list    _Args;

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

template < class _Ty_a, class _Alloc_a
         , class _Ty_b, class _Alloc_b
         >
deque2<_Ty_a, _Alloc_a> & operator += (
        _IN deque2<_Ty_a, _Alloc_a> & container,
        _IN const deque<_Ty_b, _Alloc_b> & values
    )
{
    // NO clear
    for (deque2<_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
         >
deque2<_Ty_a, _Alloc_a> & operator << (
        _IN deque2<_Ty_a, _Alloc_a> & container,
        _IN const deque<_Ty_b, _Alloc_b> & values
    )
{
    container.clear();
    container += values;
    return container;
};

}; // namespace std

#endif //_DEQUE2_H_

---