ycpp_list.hpp

一个类STL的多平台可移植的算法容器库,主要用于嵌入式系统编程时的内存管理等方面

    void swap( self& rhs )      {  dblnklst_swap( &m_dli, &(rhs.m_dli) );  }

    void pop_back()     {  dblnklst_pop_back(&m_dli);  }
    void pop_front()    {  dblnklst_pop_front(&m_dli);  }

    void push_back( const T& value )
    {
        if( !dblnklst_push_back(&m_dli, &value) )
            throw std::bad_alloc();
    }

    void push_front( const T& value )
    {
        if( !dblnklst_push_front(&m_dli, &value) )
            throw std::bad_alloc();
    }

    void clear()
    {
        dblnklst_erase_range( &m_dli, dblnklst_begin(&m_dli),
                              dblnklst_end(&m_dli) );
    }

    reference operator[]( size_type index )
        {  return *((pointer)dblnklst_index(&m_dli, index));  }
    const_reference operator[]( size_type index ) const
        {  return *((const_pointer)dblnklst_index(&m_dli, index));  }

    reference at( size_type index )
    {
        pointer p = (pointer)dblnklst_at( &m_dli, index );
        if( !p )
            throw std::out_of_range( "young::list::at out of range!" );
        return *p;
    }
    const_reference at( size_type index ) const
    {
        const_pointer p = (const_pointer)dblnklst_at( &m_dli, index );
        if( !p )
            throw std::out_of_range( "young::list::at out of range!" );
        return *p;
    }

    void splice( iterator pos, self& src )
        {  dblnklst_splice_dblnklst( &m_dli, pos.itr, &(src.m_dli) );  }
    void splice( iterator pos, self& src, iterator new_node )
        {  dblnklst_splice_node( &m_dli, pos, &(src.m_dli), new_node.itr );  }
    void splice( iterator pos, self& src, iterator first, iterator last )
        {  dblnklst_splice_range( &m_dli, pos.itr,
                                  &(src.m_dli), first.itr, last.itr );  }

    iterator erase( iterator position )
        {  return dblnklst_erase_pos( &m_dli, position.itr );  }
    iterator erase( iterator first, iterator last )
        {  return dblnklst_erase_range( &m_dli, first.itr, last.itr );  }

    iterator insert( iterator position, const T& value = value_type() )
    {
        youngc::dblnklst_iterator itr = dblnklst_insert_node( &m_dli,
                                                        position.itr, &value );
        if( !itr )
            throw std::bad_alloc();
        return itr;
    }

    void insert( iterator position, int count, const T& value )
        {  insert( position, static_cast<size_type>(count), value );  }
    void insert( iterator position, long count, const T& value )
        {  insert( position, static_cast<size_type>(count), value );  }
    void insert( iterator position, size_type count, const T& value )
    {
        if( !dblnklst_insert_value( &m_dli, position.itr, &value, count ) )
            throw std::bad_alloc();
    }

    template< typename InputIterator >
    void insert( iterator pos, InputIterator first, InputIterator last )
    {
        for( ; first != last; ++first )
        {
            if( !dblnklst_insert_node( &m_dli, pos.itr, &(*first) ) )
                throw std::bad_alloc();
        }
    }

    void resize( size_type new_size, const T& value = value_type() )
    {
        if( dblnklst_resize(&m_dli, new_size, &value) != new_size )
            throw std::bad_alloc();
    }

    void assign( int new_size, const T& value = value_type() )
        {  assign( static_cast<size_type>(new_size), value );  }
    void assign( long new_size, const T& value = value_type() )
        {  assign( static_cast<size_type>(new_size), value );  }
    void assign( size_type new_size, const T& value = value_type() )
    {
        if( dblnklst_replace_fill( &m_dli, dblnklst_begin(&m_dli),
                                   dblnklst_end(&m_dli), &value, new_size )
            != new_size )
            throw std::bad_alloc();
    }

    template< typename InputIterator >
    void assign( InputIterator first, InputIterator last )
    {
        iterator b = begin(), e = end();
        for( ; first != last && b != e; ++b,++first )
            *b = *first;
        if( first == last && b != e )
            dblnklst_erase_range( &m_dli, b.itr, e.itr );
        else if( first != last && b == e )
            insert( e, first, last );
    }

    void remove( const T& value )
        {  dblnklst_remove( &m_dli, &value, eq_adapter<T> );  }
    void unique()
        {  dblnklst_unique( &m_dli, eq_adapter<T> );  }
    void merge( self& src )
        {  dblnklst_merge( &m_dli, &(src.m_dli), cmp_adapter<T> );  }
    void sort()
        {  dblnklst_sort( &m_dli, sizeof(int) * 8, cmp_adapter<T> );  }

    template< typename Predicate >
    void remove_if( Predicate )
        {  dblnklst_remove( &m_dli, NULL, pred_adapter<T, Predicate> );  }

    template< typename Equal >
    void unique( Equal )
        {  dblnklst_unique( &m_dli, eq_adapter<T, Equal> );  }

    template< typename Compare >
    void merge( self& src, Compare )
        {  dblnklst_merge( &m_dli, &(src.m_dli), cmp_adapter<T, Compare> );  }

    template< typename Compare >
    void sort( Compare )
        {  dblnklst_sort( &m_dli, sizeof(int) * 8, cmp_adapter<T, Compare> );  }

private:
    mutable youngc::dblnklst m_dli;

    void init()
    {
        youngc::ylib_fp_copy_t cp = init_copy_adapter<T>;
        youngc::ylib_fp_copy_t ass = assign_copy_adapter<T>;
        youngc::ylib_fp_oper_t dsty = destroy_adapter<T>;

        dblnklst_init( &m_dli, sizeof(T),
                       property_traits<T>::trivial_copy ? NULL : cp,
                       property_traits<T>::trivial_assign ? NULL : ass,
                       property_traits<T>::trivial_destructor ? NULL : dsty,
                       alloc_adapter<Allocator>,
                       dealloc_adapter<Allocator> );
    }

    void init_fill( size_type n, const T& value )
    {
        typedef  typename property_traits<T>::is_POD  POD;
        init( POD() );
        if( dblnklst_insert_value(&m_dli, dblnklst_end(&m_dli), &value, n) != n )
        {
            dblnklst_destroy( &m_dli );
            throw std::bad_alloc();
        }
    }
};

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

template< typename T, typename Allocator >
inline void swap( list<T, Allocator>& lhs, list<T, Allocator>& rhs )
{
    lhs.swap( rhs );
}

template< typename T, typename Allocator >
inline bool operator==( const list<T, Allocator>& lhs,
                        const list<T, Allocator>& rhs )
{
    return std::matching( lhs.begin(), lhs.end(), rhs.begin(), rhs.end() );
}

template< typename T, typename Allocator >
inline bool operator!=( const list<T, Allocator>& lhs,
                        const list<T, Allocator>& rhs )
{
    return !( lhs == rhs );
}

template< typename T, typename Allocator >
inline bool operator<( const list<T, Allocator>& lhs,
                       const list<T, Allocator>& rhs )
{
    return std::lexicographical_compare( lhs.begin(), lhs.end(),
                                         rhs.begin(), rhs.end() );
}

template< typename T, typename Allocator >
inline bool operator>( const list<T, Allocator>& lhs,
                       const list<T, Allocator>& rhs )
{
    return rhs < lhs;
}

template< typename T, typename Allocator >
inline bool operator<=( const list<T, Allocator>& lhs,
                        const list<T, Allocator>& rhs )
{
    return !( rhs < lhs );
}

template< typename T, typename Allocator >
inline bool operator>=( const list<T, Allocator>& lhs,
                        const list<T, Allocator>& rhs )
{
    return !( lhs < rhs );
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
}  //end namespace
#endif
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------