/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the  "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#if !defined(REUSABLEARENAALLOCATOR_INCLUDE_GUARD_1357924680)
#define REUSABLEARENAALLOCATOR_INCLUDE_GUARD_1357924680


#include <algorithm>


#include "ReusableArenaBlock.hpp"
#include "ArenaAllocator.hpp"


namespace XALAN_CPP_NAMESPACE {


template<class ObjectType>
class ReusableArenaAllocator : public ArenaAllocator<ObjectType,
                                                     ReusableArenaBlock<ObjectType> >
{
public:

    typedef ReusableArenaBlock<ObjectType>              ReusableArenaBlockType;

    typedef typename ReusableArenaBlockType::size_type  size_type;

    typedef ArenaAllocator<ObjectType,
                           ReusableArenaBlockType>      BaseClassType;

    typedef ReusableArenaAllocator<ObjectType>          ThisType;

    typedef XalanList<ReusableArenaBlockType*>          ArenaBlockListType;

    typedef typename ArenaBlockListType::iterator               iterator;
    typedef typename ArenaBlockListType::const_iterator         const_iterator;
    typedef typename ArenaBlockListType::reverse_iterator       reverse_iterator;
    typedef typename ArenaBlockListType::const_reverse_iterator const_reverse_iterator;


    /*
     * Construct an instance that will allocate blocks of the specified size.
     *
     * @param theBlockSize The block size.
     */
    ReusableArenaAllocator(
                MemoryManager&  theManager,
                size_type           theBlockSize, 
                bool                destroyBlocks = false) :
        BaseClassType(theManager, theBlockSize),
        m_destroyBlocks(destroyBlocks)
    {
    }

    virtual
    ~ReusableArenaAllocator()
    {
    }

    /*
     * Destroy the object, and free the block for re-use.
     *
     * @param theObject the address of the object.
     * @return true if the object was deleted, false if not.
     */
    bool
    destroyObject(ObjectType*   theObject)
    {
        bool bResult = false;

        assert ( theObject != 0 );

        if ( this->m_blocks.empty() )
            return bResult;

        iterator iTerator = this->m_blocks.begin();

        iterator iEnd = this->m_blocks.end();

        // first , run over unfull blocks ( that consentrated from the head )
        while( iTerator != iEnd 
                    && (*iTerator)->blockAvailable() )
        {
            if ((*iTerator)->ownsBlock(theObject) == true)
            {
                (*iTerator)->destroyObject(theObject);
                
                // move the block we have just deleted to the head of the list
                if (iTerator != this->m_blocks.begin())
                {
                    // move the block to the beginning
                    ReusableArenaBlockType* block = *iTerator;

                    assert(block != 0);
                    
                    this->m_blocks.erase(iTerator);

                    this->m_blocks.push_front(block);
                }

                if (m_destroyBlocks)
                {
                    destroyBlock();
                }

                bResult = true;

                break;
            }

            ++iTerator;
        }

        reverse_iterator rIterator = this->m_blocks.rbegin();

        reverse_iterator rEnd = this->m_blocks.rend();

        // if the block hasn't been found from the head , start with full blocks ( from the taile)
        while ( !bResult && rIterator != rEnd )
        {
            if ((*rIterator)->ownsBlock(theObject))
            {
                (*rIterator)->destroyObject(theObject);

                if (rIterator != this->m_blocks.rbegin())
                {
                    // move the block to the beginning
                    ReusableArenaBlockType* block = *iTerator;

                    assert(block != 0);
                    
                    this->m_blocks.erase(iTerator);

                    this->m_blocks.push_front(block);

                }

                if (m_destroyBlocks)
                {
                    destroyBlock();
                }

                bResult = true;

                break; 
            }

            if ( *rIterator == *iTerator)
            {
                break;
            }
            else
            {
                ++rIterator;
            }
        }

        return bResult;
    }

    /*
     * Allocate a block of the appropriate size for an
     * object.  Call commitAllocation() when after
     * the object is successfully constructed.  You _must_
     * commit an allocation before performing any other
     * operation on the allocator.
     * 
     *
     * @return A pointer to a block of memory
     */
    virtual ObjectType*
    allocateBlock()
    {
        if( this->m_blocks.empty() 
            || !this->m_blocks.front()->blockAvailable() )
        {
            this->m_blocks.push_front(
                ReusableArenaBlockType::create(
                    this->getMemoryManager(),
                    this->m_blockSize));
            
            assert( this->m_blocks.front() != 0 );
        }

        assert( this->m_blocks.front() != 0 );
        assert( this->m_blocks.front()->blockAvailable() );

        return this->m_blocks.front()->allocateBlock();
    }

    /*
     * Commits the allocation of the previous
     * allocateBlock() call.
     *
     * @param theObject A pointer to a block of memory
     */
    virtual void
    commitAllocation(ObjectType*    theObject)
    {
        // Note that this-> is required by template lookup rules.
        assert( this->m_blocks.empty() == false );
        assert( this->m_blocks.front() != 0 );
        assert( this->m_blocks.front()->ownsBlock(theObject) == true );

        this->m_blocks.front()->commitAllocation(theObject);

        if( !this->m_blocks.front()->blockAvailable() )
        {
            ReusableArenaBlockType* fullBlock = this->m_blocks.front();

            assert ( fullBlock != 0 );

            this->m_blocks.pop_front();

            this->m_blocks.push_back( fullBlock );
        }
    }


    virtual bool
    ownsObject(const ObjectType*    theObject) const
    {
        if ( this->m_blocks.empty() )
            return false;

        const_iterator iTerator = this->m_blocks.begin();

        const_iterator iEnd = this->m_blocks.end();

        while( iTerator != iEnd 
                    && (*iTerator)->blockAvailable() )
        {
            if ((*iTerator)->ownsBlock(theObject) )
            {
                return true;
            }

            ++iTerator;
        }

        const_reverse_iterator rIterator = this->m_blocks.rbegin();

        const_reverse_iterator rEnd = this->m_blocks.rend();

        while( rIterator != rEnd )
        {
            if ((*rIterator)->ownsBlock(theObject) )
            {
                return true;
            }

            if ( *iTerator == *rIterator )
            {
                break;
            }
            else
            {
                ++rIterator;
            }
        }

        return false;
    }

protected:

    /*
     * The method destroys an empty block from the head of the list.
     * For eliminating multiple create/destroy operation, the block
     * is destroyed only if the second one is not full.
     */
    void
    destroyBlock()
    {
        assert(m_destroyBlocks == true);

        if ( this->m_blocks.empty() == false)
        {
            const_iterator iTerator = this->m_blocks.begin();

            if ( (*iTerator)->isEmpty() )
            {
                ++iTerator;

                if (iTerator == this->m_blocks.end() ||
                    (*iTerator)->blockAvailable() )
                {
                    this->m_blocks.pop_front();
                }
            }
        }
    }

    // data members
    const bool  m_destroyBlocks;

private:

    // Not defined...
    ReusableArenaAllocator(const ReusableArenaAllocator<ObjectType>&);

    ReusableArenaAllocator<ObjectType>&
    operator=(const ReusableArenaAllocator<ObjectType>&);

    bool
    operator==(const ReusableArenaAllocator<ObjectType>&) const;
};


}


#endif  // !defined(REUSABLEARENAALLOCATOR_INCLUDE_GUARD_1357924680)