/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* 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: XMLStringTokenizer.hpp 568078 2007-08-21 11:43:25Z amassari $

 */

#if !defined(XMLSTRINGTOKENIZER_HPP)

#define XMLSTRINGTOKENIZER_HPP

#include <xercesc/util/RefArrayVectorOf.hpp>

#include <xercesc/util/XMLString.hpp>

XERCES_CPP_NAMESPACE_BEGIN

/**

  * The string tokenizer class breaks a string into tokens.

  *

  * The XMLStringTokenizer methods do not distinguish among identifiers,

  * numbers, and quoted strings, nor do they recognize and skip comments

  *

  * A XMLStringTokenizer object internally maintains a current position within

  * the string to be tokenized. Some operations advance this current position

  * past the characters processed.

  */

  class XMLUTIL_EXPORT XMLStringTokenizer :public XMemory

{

public:

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

    //  Public Constructors

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

    /** @name Constructors */

    //@{

    /**

      * Constructs a string tokenizer for the specified string. The tokenizer

      * uses the default delimiter set, which is "\t\n\r\f": the space

      * character, the tab character, the newline character, the

      * carriage-return character, and the form-feed character. Delimiter

      * characters themselves will not be treated as tokens.

      *

      * @param  srcStr  The string to be parsed.

      * @param  manager Pointer to the memory manager to be used to

      *                 allocate objects.

      *

      */

	XMLStringTokenizer(const XMLCh* const srcStr,

                       MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);

    /**

      * Constructs a string tokenizer for the specified string. The characters

      * in the delim argument are the delimiters for separating tokens.

      * Delimiter characters themselves will not be treated as tokens.

      *

      * @param  srcStr  The string to be parsed.

      * @param  delim   The set of delimiters.

      * @param  manager Pointer to the memory manager to be used to

      *                 allocate objects.

      */

    XMLStringTokenizer(const XMLCh* const srcStr

                       , const XMLCh* const delim

                       , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);

    //@}

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

    //  Public Destructor

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

	/** @name Destructor. */

    //@{

    ~XMLStringTokenizer();

    //@}

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

    // Management methods

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

    /** @name Management Function */

    //@{

     /**

       * Tests if there are more tokens available from this tokenizer's string.

       *

       * Returns true if and only if there is at least one token in the string

       * after the current position; false otherwise.

       */

	bool hasMoreTokens();

    /**

      * Calculates the number of times that this tokenizer's nextToken method

      * can be called to return a valid token. The current position is not

      * advanced.

      *

      * Returns the number of tokens remaining in the string using the current

      * delimiter set.

      */

    int countTokens();

    /**

      * Returns the next token from this string tokenizer.

      *

      * Function allocated, function managed (fafm). The calling function

      * does not need to worry about deleting the returned pointer.

	  */

	XMLCh* nextToken();

    //@}

private:

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

    //  Unimplemented constructors and operators

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

    XMLStringTokenizer(const XMLStringTokenizer&);

    XMLStringTokenizer& operator=(const XMLStringTokenizer&);

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

    //  CleanUp methods

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

	void cleanUp();

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

    //  Helper methods

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

    bool isDelimeter(const XMLCh ch);

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

    //  Private data members

    //

    //  fOffset

    //      The current position in the parsed string.

    //

    //  fStringLen

    //      The length of the string parsed (for convenience).

    //

    //  fString

    //      The string to be parsed

	//

    //  fDelimeters

    //      A set of delimeter characters

    //

    //  fTokens

    //      A vector of the token strings

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

    int                 fOffset;

    int                 fStringLen;

	XMLCh*              fString;

    const XMLCh*        fDelimeters;

	RefArrayVectorOf<XMLCh>* fTokens;

    MemoryManager*           fMemoryManager;

};

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

//  XMLStringTokenizer: Helper methods

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

inline bool XMLStringTokenizer::isDelimeter(const XMLCh ch) {

    return XMLString::indexOf(fDelimeters, ch) == -1 ? false : true;

}

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

//  XMLStringTokenizer: Management methods

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

inline int XMLStringTokenizer::countTokens() {

    if (fStringLen == 0)

		return 0;

    int  tokCount = 0;

    bool inToken = false;

    for (int i= fOffset; i< fStringLen; i++) {

        if (isDelimeter(fString[i])) {

            if (inToken) {

                inToken = false;

            }

            continue;

        }

		if (!inToken) {

            tokCount++;

            inToken = true;

        }

    } // end for

    return tokCount;

}

XERCES_CPP_NAMESPACE_END

#endif

/**

  * End of file XMLStringTokenizer.hpp

  */