ycpp_deque.hpp

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

    const_reference at( size_type index ) const
    {
        const_pointer p = (const_pointer)chkarr_at(&m_chks, index);
        if( !p )
            throw std::out_of_range( "young::deque::at out of range!" );
        return *p;
    }

    void swap( self& rhs )
    {
        if( &rhs != this )
            std::swap( m_chks, rhs.m_chks );
    }

    void clear()
    {
        chkarr_erase_range( &m_chks, 0, SIZE_MAX );
    }

    void pop_back()
    {
        if( !empty() )
        {
            if( m_chks.m_finish.current != m_chks.m_finish.first )
            {
                m_chks.m_finish.current = (T*)(m_chks.m_finish.current) - 1;
                ylib_destroy( (T*)(m_chks.m_finish.current) );
            }
            else
                chkarr_pop_back( &m_chks );
        }
    }

    void pop_front()
    {
        if( !empty() )
        {
            if( m_chks.m_start.current != (T*)(m_chks.m_start.last) - 1 )
            {
                ylib_destroy( (T*)(m_chks.m_start.current) );
                m_chks.m_start.current = (T*)(m_chks.m_start.current) + 1;
            }
            else
                chkarr_pop_front( &m_chks );
        }
    }

    void push_back( const T& value )
    {
        if( m_chks.m_chunk_array
            && m_chks.m_finish.current != (T*)(m_chks.m_finish.last) - 1 )
        {
            ylib_construct( (T*)(m_chks.m_finish.current), value );
            m_chks.m_finish.current = (T*)(m_chks.m_finish.current) + 1;
        }
        else if( !chkarr_push_back(&m_chks, &value) )
            throw std::bad_alloc();
    }

    void push_front( const T& value )
    {
        if( m_chks.m_start.current != m_chks.m_start.first )
        {
            m_chks.m_start.current = (T*)(m_chks.m_start.current) - 1;
            ylib_construct( (T*)(m_chks.m_start.current), value );
        }
        else if( !chkarr_push_front(&m_chks, &value) )
            throw std::bad_alloc();
    }

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

    iterator erase( iterator pos )
        {  return chkarr_erase_pos( &m_chks, pos - begin() );  }
    iterator erase( iterator first, iterator last )
        {  return chkarr_erase_range( &m_chks, first - begin(), last - begin() );  }

    iterator insert( iterator pos, const T& value = T() )
    {
        size_t index = pos - begin();
        if( !chkarr_insert_value(&m_chks, index, &value, 1) )
            throw std::bad_alloc();
        return begin() + index;
    }

    void insert( iterator pos, int count, const T& value )
        {  insert( pos, static_cast<size_type>( count ), value );  }
    void insert( iterator pos, long count, const T& value )
        {  insert( pos, static_cast<size_type>( count ), value );  }
    void insert( iterator pos, size_type count, const T& value )
    {
        if( !chkarr_insert_value(&m_chks, pos - begin(), &value, count) )
            throw std::bad_alloc();
    }

    void insert( iterator pos, T* first, T* last )
        {  insert( pos, (const T*)first, (const T*)last );  }
    void insert( iterator pos, const T* first, const T* last )
    {
        if( !chkarr_insert_array(&m_chks, pos - begin(), first, last - first) )
            throw std::bad_alloc();
    }

    template< typename InputIterator >
    void insert( iterator pos, InputIterator first, InputIterator last )
    {
        size_t index = pos - begin();
        if( !chkarr_insert_array(&m_chks, index, NULL, std::distance(first, last)) )
            throw std::bad_alloc();
        std::copy( first, last, begin() + index );
    }

    void assign( int new_size, const T& value = T() )
        {  assign( static_cast<size_type>( new_size ), value );  }
    void assign( long new_size, const T& value = T() )
        {  assign( static_cast<size_type>( new_size ), value );  }
    void assign( size_type new_size, const T& value = T() )
    {
        if( !chkarr_replace_fill(&m_chks, 0, SIZE_MAX, &value, new_size) )
            throw std::bad_alloc();
    }

    void assign( T* first, T* last )
        {  assign( (const T*)first, (const T*)last );  }
    void assign( const T* first, const T* last )
    {
        if( !chkarr_replace_array( &m_chks, 0, SIZE_MAX, first, last - first) )
            throw std::bad_alloc();
    }

    template< typename InputIterator >
    void assign( InputIterator first, InputIterator last )
    {
        if( !chkarr_replace_array( &m_chks, 0, SIZE_MAX, NULL,
                                   std::distance(first, last)) )
            throw std::bad_alloc();
        std::copy( first, last, begin() );
    }

private:
    mutable youngc::chkarray m_chks;

    void init( true_type )
    {
        chkarr_init( &m_chks, sizeof(T), 0, NULL, NULL, NULL, NULL, NULL, NULL,
                     alloc_adapter<Allocator>, dealloc_adapter<Allocator> );
    }

    void init( false_type )
    {
        typedef  typename move_traits<T>::move_ability  mv;
        init_obj( mv() );
    }

    void init_obj( true_type )
    {
        youngc::ylib_fp_oper_t init = init_adapter<T>;
        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>;

        chkarr_init( &m_chks, sizeof(T), 0,
                     property_traits<T>::trivial_constructor ? NULL : init,
                     property_traits<T>::trivial_copy ? NULL : cp,
                     property_traits<T>::trivial_assign ? NULL : ass,
                     T::init_move, T::assign_move,
                     property_traits<T>::trivial_destructor ? NULL : dsty,
                     alloc_adapter<Allocator>, dealloc_adapter<Allocator> );
    }

    void init_obj( false_type )
    {
        youngc::ylib_fp_oper_t init = init_adapter<T>;
        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>;

        chkarr_init( &m_chks, sizeof(T), 0,
                     property_traits<T>::trivial_constructor ? NULL : init,
                     property_traits<T>::trivial_copy ? NULL : cp,
                     property_traits<T>::trivial_assign ? NULL : ass,
                     NULL, NULL,
                     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( !chkarr_resize(&m_chks, n, &value) )
        {
            chkarr_destroy( &m_chks );
            throw std::bad_alloc();
        }
    }
};

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

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

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

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

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

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

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

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

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