xpath_allocator Struct Reference

Public Member Functions
	xpath_allocator (xpath_memory_block *root, bool *error=0)
void *	allocate (size_t size)
void *	reallocate (void *ptr, size_t old_size, size_t new_size)
void	revert (const xpath_allocator &state)
void	release ()

Public Attributes
xpath_memory_block *	_root
size_t	_root_size
bool *	_error

Detailed Description

Definition at line 7768 of file pugixml.cc.

Constructor & Destructor Documentation

xpath_allocator()

xpath_allocator::xpath_allocator ( xpath_memory_block * root, bool * error = 0 )

inline

Definition at line 7774 of file pugixml.cc.

                                                                : _root(root), _root_size(0), _error(error)
        {
        }

Referenced by revert().

Member Function Documentation

allocate()

void * xpath_allocator::allocate ( size_t size )

inline

Definition at line 7778 of file pugixml.cc.

        {
            // round size up to block alignment boundary
            size = (size + xpath_memory_block_alignment - 1) & ~(xpath_memory_block_alignment - 1);
 
            if (_root_size + size <= _root->capacity)
            {
                void* buf = &_root->data[0] + _root_size;
                _root_size += size;
                return buf;
            }
            else
            {
                // make sure we have at least 1/4th of the page free after allocation to satisfy subsequent allocation requests
                size_t block_capacity_base = sizeof(_root->data);
                size_t block_capacity_req = size + block_capacity_base / 4;
                size_t block_capacity = (block_capacity_base > block_capacity_req) ? block_capacity_base : block_capacity_req;
 
                size_t block_size = block_capacity + offsetof(xpath_memory_block, data);
 
                xpath_memory_block* block = static_cast<xpath_memory_block*>(xml_memory::allocate(block_size));
                if (!block)
                {
                    if (_error) *_error = true;
                    return 0;
                }
 
                block->next = _root;
                block->capacity = block_capacity;
 
                _root = block;
                _root_size = size;
 
                return block->data;
            }
        }

Referenced by convert_number_to_string(), xpath_ast_node::eval_string_concat(), xpath_node_set_raw::remove_duplicates(), and translate_table_generate().

reallocate()

void * xpath_allocator::reallocate ( void * ptr, size_t old_size, size_t new_size )

inline

Definition at line 7815 of file pugixml.cc.

        {
            // round size up to block alignment boundary
            old_size = (old_size + xpath_memory_block_alignment - 1) & ~(xpath_memory_block_alignment - 1);
            new_size = (new_size + xpath_memory_block_alignment - 1) & ~(xpath_memory_block_alignment - 1);
 
            // we can only reallocate the last object
            assert(ptr == 0 || static_cast<char*>(ptr) + old_size == &_root->data[0] + _root_size);
 
            // try to reallocate the object inplace
            if (ptr && _root_size - old_size + new_size <= _root->capacity)
            {
                _root_size = _root_size - old_size + new_size;
                return ptr;
            }
 
            // allocate a new block
            void* result = allocate(new_size);
            if (!result) return 0;
 
            // we have a new block
            if (ptr)
            {
                // copy old data (we only support growing)
                assert(new_size >= old_size);
                memcpy(result, ptr, old_size);
 
                // free the previous page if it had no other objects
                assert(_root->data == result);
                assert(_root->next);
 
                if (_root->next->data == ptr)
                {
                    // deallocate the whole page, unless it was the first one
                    xpath_memory_block* next = _root->next->next;
 
                    if (next)
                    {
                        xml_memory::deallocate(_root->next);
                        _root->next = next;
                    }
                }
            }
 
            return result;
        }

Referenced by xpath_node_set_raw::append(), xpath_string::append(), and xpath_node_set_raw::push_back_grow().

release()

void xpath_allocator::release ( )

inline

Definition at line 7881 of file pugixml.cc.

        {
            xpath_memory_block* cur = _root;
            assert(cur);
 
            while (cur->next)
            {
                xpath_memory_block* next = cur->next;
 
                xml_memory::deallocate(cur);
 
                cur = next;
            }
        }

Referenced by xpath_query_impl::destroy().

revert()

void xpath_allocator::revert ( const xpath_allocator & state )

inline

Definition at line 7862 of file pugixml.cc.

        {
            // free all new pages
            xpath_memory_block* cur = _root;
 
            while (cur != state._root)
            {
                xpath_memory_block* next = cur->next;
 
                xml_memory::deallocate(cur);
 
                cur = next;
            }
 
            // restore state
            _root = state._root;
            _root_size = state._root_size;
        }

Member Data Documentation

_error

bool* xpath_allocator::_error

Definition at line 7772 of file pugixml.cc.

Referenced by allocate(), and xpath_allocator().

_root

xpath_memory_block* xpath_allocator::_root

Definition at line 7770 of file pugixml.cc.

Referenced by allocate(), reallocate(), release(), revert(), and xpath_allocator().

_root_size

size_t xpath_allocator::_root_size

Definition at line 7771 of file pugixml.cc.

Referenced by allocate(), reallocate(), revert(), and xpath_allocator().

---

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

• pugixml.cc