/** Iterate through a string based on code points instead of UTF-16 code units.

    See Chapter 3 of The Unicode Standard 5.0 (Addison--Wesley, 2006) for

    definitions of the various terms used in this description.

    The given string is interpreted as a sequence of zero or more UTF-16 code

    units.  For each index into this sequence (from zero to the length of the

    sequence, inclusive), a code point represented starting at the given index

    is computed as follows:

    - If the index points to the end of the sequence, the computed code point

    is the special marker SAL_MAX_UINT32.

    - Otherwise, if the UTF-16 code unit addressed by the index constitutes a

    well-formed UTF-16 code unit sequence, the computed code point is the scalar

    value encoded by that UTF-16 code unit sequence.

    - Otherwise, if the index is at least two UTF-16 code units away from the

    end of the sequence, and the sequence of two UTF-16 code units addressed by

    the index constitutes a well-formed UTF-16 code unit sequence, the computed

    code point is the scalar value encoded by that UTF-16 code unit sequence.

    - Otherwise, the computed code point is the UTF-16 code unit addressed by

    the index.  (This last case catches unmatched surrogates as well as indices

    pointing into the middle of surrogate pairs.)

    @param string

    pointer to a valid string; must not be null.

    @param indexUtf16

    pointer to a UTF-16 based index into the given string; must not be null.  On

    entry, the index must be in the range from zero to the length of the string

    (in UTF-16 code units), inclusive.  Upon successful return, the index will

    be updated to address the UTF-16 code unit that is the given

    postIncrementCodePoints away from the initial index.

    @param postIncrementCodePoints

    the number of code points to move the given indexUtf16; can be negative.

    The value must be such that the resulting UTF-16 based index is in the range

    from zero to the length of the string (in UTF-16 code units), inclusive.

    @return

    the code point (an integer in the range from 0 to 0x10FFFF, inclusive) or

    the special marker SAL_UINT_MAX that is represented at the given indexUtf16

    starting index within the given string.

    @since UDK 3.2.7

*/

sal_uInt32 SAL_CALL rtl_uString_iterateCodePoints(

    rtl_uString const * string, sal_Int32 * indexUtf16,

    sal_Int32 postIncrementCodePoints);

    /** Iterate through this string based on code points instead of UTF-16 code

        units.

        See Chapter 3 of The Unicode Standard 5.0 (Addison--Wesley, 2006) for

        definitions of the various terms used in this description.

        This string is interpreted as a sequence of zero or more UTF-16 code

        units.  For each index into this sequence (from zero to the length of

        the sequence, inclusive), a code point represented starting at the

        given index is computed as follows:

        - If the index points to the end of the sequence, the computed code

        point is the special marker SAL_MAX_UINT32.

        - Otherwise, if the UTF-16 code unit addressed by the index constitutes

        a well-formed UTF-16 code unit sequence, the computed code point is the

        scalar value encoded by that UTF-16 code unit sequence.

        - Otherwise, if the index is at least two UTF-16 code units away from

        the end of the sequence, and the sequence of two UTF-16 code units

        addressed by the index constitutes a well-formed UTF-16 code unit

        sequence, the computed code point is the scalar value encoded by that

        UTF-16 code unit sequence.

        - Otherwise, the computed code point is the UTF-16 code unit addressed

        by the index.  (This last case catches unmatched surrogates as well as

        indices pointing into the middle of surrogate pairs.)

        @param indexUtf16

        pointer to a UTF-16 based index into this string; must not be null.  On

        entry, the index must be in the range from zero to the length of this

        string (in UTF-16 code units), inclusive.  Upon successful return, the

        index will be updated to address the UTF-16 code unit that is the given

        postIncrementCodePoints away from the initial index.

        @param postIncrementCodePoints

        the number of code points to move the given indexUtf16; can be negative.

        The value must be such that the resulting UTF-16 based index is in the

        range from zero to the length of this string (in UTF-16 code units),

        inclusive.

        @return

        the code point (an integer in the range from 0 to 0x10FFFF, inclusive)

        or the special marker SAL_UINT_MAX that is represented at the given

        indexUtf16 starting index within this string.

        @since UDK 3.2.7

    */

    inline sal_uInt32 iterateCodePoints(

        sal_Int32 * indexUtf16, sal_Int32 postIncrementCodePoints = 1)

    {

        return rtl_uString_iterateCodePoints(

            pData, indexUtf16, postIncrementCodePoints);

    }

class iterateCodePoints: public CppUnit::TestFixture {

public:

    void testEmpty();

    void testNotWellFormed();

    CPPUNIT_TEST_SUITE(iterateCodePoints);

    CPPUNIT_TEST(testEmpty);

    CPPUNIT_TEST(testNotWellFormed);

    CPPUNIT_TEST_SUITE_END();

};

void iterateCodePoints::testEmpty() {

    sal_Int32 i = 0;

    CPPUNIT_ASSERT_EQUAL(

        SAL_MAX_UINT32, rtl::OUString().iterateCodePoints(&i, 0));

    CPPUNIT_ASSERT_EQUAL(sal_Int32(0), i);

}

void iterateCodePoints::testNotWellFormed() {

    static sal_Unicode const utf16[] =

        { 0xD800, 0xDC00, 0x0041, 0xDBFF, 0xDFFF, 0xDDEF, 0xD9AB };

    rtl::OUString s(utf16, sizeof utf16 / sizeof (sal_Unicode));

    sal_Int32 i = 0;

    CPPUNIT_ASSERT_EQUAL(sal_uInt32(0x10000), s.iterateCodePoints(&i));

    CPPUNIT_ASSERT_EQUAL(sal_Int32(2), i);

    CPPUNIT_ASSERT_EQUAL(sal_uInt32(0x0041), s.iterateCodePoints(&i));

    CPPUNIT_ASSERT_EQUAL(sal_Int32(3), i);

    CPPUNIT_ASSERT_EQUAL(sal_uInt32(0x10FFFF), s.iterateCodePoints(&i));

    CPPUNIT_ASSERT_EQUAL(sal_Int32(5), i);

    CPPUNIT_ASSERT_EQUAL(sal_uInt32(0xDDEF), s.iterateCodePoints(&i));

    CPPUNIT_ASSERT_EQUAL(sal_Int32(6), i);

    CPPUNIT_ASSERT_EQUAL(sal_uInt32(0xD9AB), s.iterateCodePoints(&i));

    CPPUNIT_ASSERT_EQUAL(sal_Int32(7), i);

    CPPUNIT_ASSERT_EQUAL(SAL_MAX_UINT32, s.iterateCodePoints(&i, -1));

    CPPUNIT_ASSERT_EQUAL(sal_Int32(6), i);

    CPPUNIT_ASSERT_EQUAL(sal_uInt32(0xD9AB), s.iterateCodePoints(&i, -1));

    CPPUNIT_ASSERT_EQUAL(sal_Int32(5), i);

    CPPUNIT_ASSERT_EQUAL(sal_uInt32(0xDDEF), s.iterateCodePoints(&i, -1));

    CPPUNIT_ASSERT_EQUAL(sal_Int32(3), i);

    CPPUNIT_ASSERT_EQUAL(sal_uInt32(0x10FFFF), s.iterateCodePoints(&i, -1));

    CPPUNIT_ASSERT_EQUAL(sal_Int32(2), i);

    CPPUNIT_ASSERT_EQUAL(sal_uInt32(0x0041), s.iterateCodePoints(&i, -1));

    CPPUNIT_ASSERT_EQUAL(sal_Int32(0), i);

    CPPUNIT_ASSERT_EQUAL(sal_uInt32(0x10000), s.iterateCodePoints(&i, 0));

    CPPUNIT_ASSERT_EQUAL(sal_Int32(0), i);

    i = 1;

    CPPUNIT_ASSERT_EQUAL(sal_uInt32(0xDC00), s.iterateCodePoints(&i, 2));

    CPPUNIT_ASSERT_EQUAL(sal_Int32(3), i);

    i = 4;

    CPPUNIT_ASSERT_EQUAL(sal_uInt32(0xDFFF), s.iterateCodePoints(&i, -3));

    CPPUNIT_ASSERT_EQUAL(sal_Int32(0), i);

}

CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(

    rtl_OUString::iterateCodePoints, "rtl_OUString");

#include "surrogates.h"

/*************************************************************************

 *

 *  OpenOffice.org - a multi-platform office productivity suite

 *

 *  $RCSfile: $

 *

 *  $Revision: $

 *

 *  last change: $Author: $ $Date: $

 *

 *  The Contents of this file are made available subject to

 *  the terms of GNU Lesser General Public License Version 2.1.

 *

 *

 *    GNU Lesser General Public License Version 2.1

 *    =============================================

 *    Copyright 2007 by Sun Microsystems, Inc.

 *    901 San Antonio Road, Palo Alto, CA 94303, USA

 *

 *    This library is free software; you can redistribute it and/or

 *    modify it under the terms of the GNU Lesser General Public

 *    License version 2.1, as published by the Free Software Foundation.

 *

 *    This library is distributed in the hope that it will be useful,

 *    but WITHOUT ANY WARRANTY; without even the implied warranty of

 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 *    Lesser General Public License for more details.

 *

 *    You should have received a copy of the GNU Lesser General Public

 *    License along with this library; if not, write to the Free Software

 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,

 *    MA  02111-1307  USA

 *

 ************************************************************************/

#ifndef INCLUDED_SAL_RTL_SOURCE_SURROGATES_H

#define INCLUDED_SAL_RTL_SOURCE_SURROGATES_H

#include "sal/config.h"

#define SAL_RTL_FIRST_HIGH_SURROGATE 0xD800

#define SAL_RTL_LAST_HIGH_SURROGATE 0xDBFF

#define SAL_RTL_FIRST_LOW_SURROGATE 0xDC00

#define SAL_RTL_LAST_LOW_SURROGATE 0xDFFF

#define SAL_RTL_IS_HIGH_SURROGATE(utf16) \

    ((utf16) >= SAL_RTL_FIRST_HIGH_SURROGATE && \

     (utf16) <= SAL_RTL_LAST_HIGH_SURROGATE)

#define SAL_RTL_IS_LOW_SURROGATE(utf16) \

    ((utf16) >= SAL_RTL_FIRST_LOW_SURROGATE && \

     (utf16) <= SAL_RTL_LAST_LOW_SURROGATE)

#define SAL_RTL_COMBINE_SURROGATES(high, low) \

    ((((high) - SAL_RTL_FIRST_HIGH_SURROGATE) << 10) + \

     ((low) - SAL_RTL_FIRST_LOW_SURROGATE) + 0x10000)

#endif

#include "surrogates.h"

#include "surrogates.h"

sal_uInt32 SAL_CALL rtl_uString_iterateCodePoints(

    rtl_uString const * string, sal_Int32 * indexUtf16,

    sal_Int32 postIncrementCodePoints)

{

    sal_Int32 n;

    sal_uInt32 cp;

    OSL_ASSERT(

        string != NULL && indexUtf16 != NULL && *indexUtf16 >= 0 &&

        *indexUtf16 <= string->length);

    n = *indexUtf16;

    if (n == string->length) {

        cp = SAL_MAX_UINT32;

    } else {

        sal_Unicode cu = string->buffer[n];

        if (SAL_RTL_IS_HIGH_SURROGATE(cu) && string->length - n >= 2 &&

            SAL_RTL_IS_LOW_SURROGATE(string->buffer[n + 1]))

        {

            cp = SAL_RTL_COMBINE_SURROGATES(cu, string->buffer[n + 1]);

        } else {

            cp = cu;

        }

    }

    while (postIncrementCodePoints > 0) {

        sal_Unicode cu;

        OSL_ASSERT(n < string->length);

        cu = string->buffer[n++];

        if (SAL_RTL_IS_HIGH_SURROGATE(cu) && n != string->length &&

            SAL_RTL_IS_LOW_SURROGATE(string->buffer[n]))

        {

            ++n;

        }

        --postIncrementCodePoints;

    }

    while (postIncrementCodePoints < 0) {

        sal_Unicode cu;

        OSL_ASSERT(n > 0);

        cu = string->buffer[--n];

        if (SAL_RTL_IS_LOW_SURROGATE(cu) && n != 0 &&

            SAL_RTL_IS_HIGH_SURROGATE(string->buffer[n - 1]))

        {

            --n;

        }

        ++postIncrementCodePoints;

    }

    OSL_ASSERT(n >= 0 && n <= string->length);

    *indexUtf16 = n;

    return cp;

}

        rtl_uString_iterateCodePoints;