ycpp_slist.hpp

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

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

    void splice_after( iterator before_pos, self& src )
    {
        sglnklst_splice_after_sglnklst(&m_sli, before_pos.itr, &(src.m_sli));
    }
    void splice_after( iterator before_pos, self& src, iterator before_node )
    {
        sglnklst_splice_after_node( &m_sli, before_pos.itr,
                                    &(src.m_sli), before_node.itr );
    }
    void splice_after( iterator before_pos, self& src,
                       iterator before_first, iterator before_last )
    {
        sglnklst_splice_after_range( &m_sli, before_pos.itr, &(src.m_sli),
                                     before_first.itr, before_last.itr );
    }

    void splice( iterator pos, self& src )
    {
        splice_after( previous(pos), src );
    }
    void splice( iterator pos, self& src, iterator node )
    {
        splice_after( previous(pos), src, src.previous(node) );
    }
    void splice( iterator pos, self& src, iterator first, iterator last )
    {
        splice_after( previous(pos), src,
                      src.previous(first), src.previous(last) );
    }

    iterator erase_after( iterator before_pos )
        {  return sglnklst_erase_after_pos( &m_sli, before_pos.itr );  }
    void erase_after( iterator before_first, iterator last )
        {  sglnklst_erase_after_range( &m_sli, before_first.itr, last.itr );  }

    iterator erase( iterator position )
        {  return erase_after( previous(position) );  }
    void erase( iterator first, iterator last )
        {  erase_after( previous(first), last );  }

    void insert_after( iterator before_pos, int count, const T& value )
        {  insert_after( before_pos, static_cast<size_type>(count), value ); }
    void insert_after( iterator before_pos, long count, const T& value )
        {  insert_after( before_pos, static_cast<size_type>(count), value );  }
    void insert_after( iterator before_pos, size_type count, const T& value )
    {
        if( sglnklst_insert_after_value(&m_sli, before_pos.itr, &value, count)
            != count )
            throw std::bad_alloc();
    }

    iterator insert_after( iterator before_pos, const T& value = value_type() )
    {
        youngc::sglnklst_iterator itr = sglnklst_insert_after_node( &m_sli,
                                                    before_pos.itr, &value );
        if( !itr )
            throw std::bad_alloc();
        return itr;
    }

    template< typename InputIterator >
    void insert_after( iterator before_pos, InputIterator first,
                       InputIterator last )
    {
        for( ; first != last; ++first,++before_pos )
        {
            if( !sglnklst_insert_after_node( &m_sli, before_pos.itr, &(*first) ) )
                throw std::bad_alloc();
        }
    }

    void insert( iterator position, size_type count, const_reference value )
        {  insert_after( previous(position), count, value );  }
    void insert( iterator position, int count, const_reference value )
        {  insert( position, static_cast<size_type>(count), value );  }
    void insert( iterator position, long count, const_reference value )
        {  insert( position, static_cast<size_type>(count), value );  }
    iterator insert( iterator position, const_reference value = value_type() )
        {  return insert_after( previous(position), value );  }
    template< typename InputIterator >
    void insert( iterator position, InputIterator first, InputIterator last )
        {  insert_after( previous(position), first, last );  }

    void resize( size_type new_size, const T& value = value_type() )
    {
        if( sglnklst_resize(&m_sli, 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( sglnklst_replace_after_fill( &m_sli, sglnklst_header(&m_sli), NULL,
                                         &value, new_size ) != new_size )
            throw std::bad_alloc();
    }

    template< typename InputIterator >
    void assign( InputIterator first, InputIterator last )
    {
        iterator h = header(), next = begin();
        for( ; first != last && next.itr; ++h,++next,++first )
            *next = *first;
        if( first == last && next.itr )
            sglnklst_erase_after_range( &m_sli, h.itr, 0 );
        else if( first != last && !next.itr )
            insert_after( h, first, last );
    }

    void remove( const T& value )
        {  sglnklst_remove( &m_sli, &value, eq_adapter<T> );  }
    void unique()
        {  sglnklst_unique( &m_sli, eq_adapter<T> );  }
    void merge( self& src )
        {  sglnklst_merge( &m_sli, &(src.m_sli), cmp_adapter<T> );  }
    void sort()
        {  sglnklst_sort( &m_sli, sizeof(int) * 8, cmp_adapter<T> );  }

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

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

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

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

private:
    mutable youngc::sglnklst m_sli;

    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>;

        sglnklst_init( &m_sli, 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 )
    {
        init();
        if( sglnklst_insert_value(&m_sli, sglnklst_header(&m_sli), &value, n)
            != n )
        {
            sglnklst_destroy( &m_sli );
            throw std::bad_alloc();
        }
    }
};

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

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

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

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

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

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

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

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

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