/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

/*

 * 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.

 */

/*

 * $Id: RefStackOf.hpp 568078 2007-08-21 11:43:25Z amassari $

 */

#if !defined(REFSTACKOF_HPP)

#define REFSTACKOF_HPP

#include <xercesc/util/RefVectorOf.hpp>

#include <xercesc/util/EmptyStackException.hpp>

XERCES_CPP_NAMESPACE_BEGIN

//

//  Forward declare the enumerator so he can be our friend. Can you say

//  friend? Sure...

//

template <class TElem> class RefStackEnumerator;

template <class TElem> class RefStackOf : public XMemory

{

public :

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

    //  Constructors and Destructor

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

    RefStackOf(const unsigned int initElems,

               const bool adoptElems = true,

               MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);

    ~RefStackOf();

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

    //  Element management methods

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

    const TElem* elementAt(const unsigned int index) const;

    void push(TElem* const toPush);

    const TElem* peek() const;

    TElem* pop();

    void removeAllElements();

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

    //  Getter methods

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

    bool empty();

    unsigned int curCapacity();

    unsigned int size();

private :

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

    //  Declare our friends

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

    friend class RefStackEnumerator<TElem>;

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

    //  Unimplemented constructors and operators

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

    RefStackOf(const RefStackOf<TElem>&);

    RefStackOf<TElem>& operator=(const RefStackOf<TElem>&);

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

    //  Data Members

    //

    //  fVector

    //      The vector that is used as the backing data structure for the

    //      stack.

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

    RefVectorOf<TElem>  fVector;

};

//

//  An enumerator for a value stack. It derives from the basic enumerator

//  class, so that value stacks can be generically enumerated.

//

template <class TElem> class RefStackEnumerator : public XMLEnumerator<TElem>, public XMemory

{

public :

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

    //  Constructors and Destructor

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

    RefStackEnumerator

    (

                RefStackOf<TElem>* const    toEnum

        , const bool                        adopt = false

    );

    virtual ~RefStackEnumerator();

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

    //  Enum interface

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

    bool hasMoreElements() const;

    TElem& nextElement();

    void Reset();

private :

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

    //  Unimplemented constructors and operators

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

    RefStackEnumerator(const RefStackEnumerator<TElem>&);

    RefStackEnumerator<TElem>& operator=(const RefStackEnumerator<TElem>&);

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

    //  Data Members

    //

    //  fAdopted

    //      Indicates whether we have adopted the passed stack. If so then

    //      we delete the stack when we are destroyed.

    //

    //  fCurIndex

    //      This is the current index into the vector inside the stack being

    //      enumerated.

    //

    //  fToEnum

    //      The stack that is being enumerated. This is just kept for

    //      adoption purposes, since we really are enumerating the vector

    //      inside of it.

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

    bool                fAdopted;

    unsigned int        fCurIndex;

    RefVectorOf<TElem>* fVector;

    RefStackOf<TElem>*  fToEnum;

};

XERCES_CPP_NAMESPACE_END

#if !defined(XERCES_TMPLSINC)

#include <xercesc/util/RefStackOf.c>

#endif

#endif