stdext::allocators::cache_chunklist< _Sz, _Nelts > Class Template Reference

Classes
class	_Data_array
class	_Data_block
struct	_Data_node

Public Member Functions
	cache_chunklist ()
	~cache_chunklist () _NOEXCEPT
void *	allocate (size_t _Count)
void	deallocate (void *_Ptr, size_t)
bool	equals (const cache_chunklist< _Sz, _Nelts > &) const

Private Attributes
_Data_block *	_List
_Data_block *	_Cached_block

Constructor & Destructor Documentation

template<size_t _Sz, size_t _Nelts = 20>

stdext::allocators::cache_chunklist< _Sz, _Nelts >::cache_chunklist ( )

inline

        : _List(0), _Cached_block(0)
        {   // construct with empty list
        }

template<size_t _Sz, size_t _Nelts = 20>

stdext::allocators::cache_chunklist< _Sz, _Nelts >::~cache_chunklist ( )

inline

        {   // discard any cached block
        delete _Cached_block;
        }

Member Function Documentation

template<size_t _Sz, size_t _Nelts = 20>

void* stdext::allocators::cache_chunklist< _Sz, _Nelts >::allocate ( size_t  _Count )

inline

        {   // suballocate
        if (_List == 0)
            {   // no list, allocate new item
            _List = new _Data_block(_Count);
            _List->_Next = _List->_Prev = _List;
            }
        else if (_List->_Free_count == 0)
            {   // list empty, return cached or allocate
            _Data_block *_Block;
            if (_Cached_block != 0)
                {   // return cached
                _Block = _Cached_block;
                _Cached_block = 0;
                }
            else
                _Block = new _Data_block(_Count);

            _Block->_Next = _List->_Next;
            _Block->_Prev = _List;
            _Block->_Next->_Prev = _Block;
            _Block->_Prev->_Next = _Block;
            _List = _Block;
            }

        void *_Res = _List->allocate();
        if (_List->_Free_count == 0 && _List->_Next != _List)
            {   // unlink head block with no available nodes
            _List->_Next->_Prev = _List->_Prev;
            _List->_Prev->_Next = _List->_Next;
            _List = _List->_Next;
            }
        return (_Res);
        }

template<size_t _Sz, size_t _Nelts = 20>

void stdext::allocators::cache_chunklist< _Sz, _Nelts >::deallocate ( void *  _Ptr, size_t    )

inline

        {   // deallocate node
        _Data_block *_Block = _Data_block::deallocate(_Ptr);
        if (_Block == _List->_Prev)
            ;
        else if (_Block->_Free_count == 1)
            {   // insert master block before tail block
            _Data_block *tail = _List->_Prev;
            tail->_Prev->_Next = _Block;
            _Block->_Prev = tail->_Prev;
            tail->_Prev = _Block;
            _Block->_Next = tail;
            if (_List->_Free_count == 0)
                _List = _List->_Next;
            }
        else if (_Block->_Free_count == _Nelts)
            {   // unlink and deallocate master block
            _Block->_Next->_Prev = _Block->_Prev;
            _Block->_Prev->_Next = _Block->_Next;
            if (_List == _Block)
                _List = _List->_Next;
            if (_Cached_block == 0)
                _Cached_block = _Block;
            }
        }

template<size_t _Sz, size_t _Nelts = 20>

bool stdext::allocators::cache_chunklist< _Sz, _Nelts >::equals ( const cache_chunklist< _Sz, _Nelts > &  ) const

inline

        {   // report that caches can share data
        return (true);
        }

Member Data Documentation

template<size_t _Sz, size_t _Nelts = 20>

_Data_block* stdext::allocators::cache_chunklist< _Sz, _Nelts >::_Cached_block

private

template<size_t _Sz, size_t _Nelts = 20>

_Data_block* stdext::allocators::cache_chunklist< _Sz, _Nelts >::_List

private

---

The documentation for this class was generated from the following file:

• VS2013/inc/allocators