unicode converter

git-svn-id: svn://fileserver/activex/AVS/Sources/TeamlabOffice/trunk/ServerComponents@64552 954022d7-b5bf-4e40-9824-e11837661b57

.gitattributes

@@ -9186,6 +9186,36 @@ Test/HtmlTextEditor/Table/images/pencil.png svn_mime_002dtype=application%2Focte
 Test/Units/DocxOdtTxt/OdtTemplate/Thumbnails/Thumbs.db svn_mime_002dtype=application%2Foctet-stream
 Test/Units/DocxOdtTxt/OdtTemplate/Thumbnails/thumbnail.png svn_mime_002dtype=application%2Foctet-stream
 Test/Units/DocxOdtTxt/image1.emf svn_mime_002dtype=application%2Foctet-stream
+/UnicodeConverter svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/linux64 svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/linux64/usr svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/linux64/usr/local svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/linux64/usr/local/include svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/linux64/usr/local/include/layout svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/linux64/usr/local/include/unicode svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/linux64/usr/local/lib svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/win32 svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/win32/bin svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/win32/bin/icudt55.dll svn_mime_002dtype=application%2Foctet-stream
+UnicodeConverter/icubuilds/win32/bin/icuuc55.dll svn_mime_002dtype=application%2Foctet-stream
+UnicodeConverter/icubuilds/win32/include svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/win32/include/layout svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/win32/include/unicode svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/win32/lib svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/win32/lib/icudt.lib svn_mime_002dtype=application%2Foctet-stream
+UnicodeConverter/icubuilds/win32/lib/icuuc.lib svn_mime_002dtype=application%2Foctet-stream
+UnicodeConverter/icubuilds/win64 svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/win64/bin svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/win64/bin/icudt55.dll svn_mime_002dtype=application%2Foctet-stream
+UnicodeConverter/icubuilds/win64/bin/icuuc55.dll svn_mime_002dtype=application%2Foctet-stream
+UnicodeConverter/icubuilds/win64/include svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/win64/include/layout svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/win64/include/unicode svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/win64/lib svnc_tsvn_003alogminsize=5
+UnicodeConverter/icubuilds/win64/lib/icudt.lib svn_mime_002dtype=application%2Foctet-stream
+UnicodeConverter/icubuilds/win64/lib/icuuc.lib svn_mime_002dtype=application%2Foctet-stream
+UnicodeConverter/test svnc_tsvn_003alogminsize=5
 /XpsFile svnc_tsvn_003alogminsize=5
 XpsFile/XpsFileTest svnc_tsvn_003alogminsize=5
 XpsFile/XpsLib svnc_tsvn_003alogminsize=5

UnicodeConverter/UnicodeConverter.cpp

+#include "./UnicodeConverter.h"
+
+#include "unicode/utypes.h"   /* Basic ICU data types */
+#include "unicode/ucnv.h"     /* C   Converter API    */
+
+#include "../DesktopEditor/common/File.h"
+
+namespace NSUnicodeConverter
+{
+    class CUnicodeConverter_Private
+    {
+    public:
+        CUnicodeConverter_Private()
+        {
+#if 1
+            std::wstring sDumpPath = NSFile::GetProcessDirectory() + L"/codepages.txt";
+            NSFile::CFileBinary oFile;
+            oFile.CreateFileW(sDumpPath);
+
+            int32_t count = ucnv_countAvailable();
+
+            for (int i = 0; i < count; ++i)
+            {
+                std::string sCodePage = ucnv_getAvailableName(i);
+
+                UErrorCode _error = U_ZERO_ERROR;
+                int nCountAliases = ucnv_countAliases(sCodePage.c_str(), &_error);
+
+                char** palices = new char*[nCountAliases];
+                ucnv_getAliases(sCodePage.c_str(), (const char**)palices, &_error);
+
+                oFile.WriteStringUTF8(L"-----------------------------\r\n");
+                oFile.WriteFile((BYTE*)sCodePage.c_str(), sCodePage.length());
+                oFile.WriteStringUTF8(L"\r\n");
+
+                for (int j = 0; j < nCountAliases; ++j)
+                {
+                    oFile.WriteFile((BYTE*)palices[j], strlen(palices[j]));
+                    oFile.WriteStringUTF8(L"\r\n");
+                }
+            }
+
+            oFile.CloseFile();
+#endif
+        }
+        ~CUnicodeConverter_Private()
+        {
+        }
+
+    public:
+        std::string fromUnicode(const std::wstring& sInput, const char* converterName)
+        {
+            std::string sRes = "";
+            UErrorCode status = U_ZERO_ERROR;
+            UConverter* conv = ucnv_open(converterName, &status);
+            if (U_SUCCESS(status))
+            {
+                int32_t nUCharCapacity = sInput.size();// UTF-16 uses 2 code-points per char
+                UChar* pUChar = (UChar*)malloc(nUCharCapacity * sizeof(UChar));
+                const UChar* pUCharStart = pUChar;
+                int32_t nUCharLength = 0;
+                u_strFromWCS(pUChar, nUCharCapacity, &nUCharLength, &sInput[0], sInput.size(), &status);
+                if (U_SUCCESS(status))
+                {
+                    const UChar* pUCharLimit = pUCharStart + nUCharLength;
+                    sRes.resize(nUCharLength * ucnv_getMaxCharSize(conv));// UTF-16 uses 2 code-points per char
+                    char *sResStart = &sRes[0];
+                    const char *sResLimit = sResStart + sRes.size();
+                    ucnv_fromUnicode(conv, &sResStart, sResLimit, &pUCharStart, pUCharLimit, NULL, TRUE, &status);
+                }
+                ucnv_close(conv);
+            }
+            return sRes;
+        }
+
+        std::wstring toUnicode(const std::string& sInput, const char* converterName)
+        {
+            std::wstring sRes = L"";
+            UErrorCode status = U_ZERO_ERROR;
+            UConverter* conv = ucnv_open(converterName, &status);
+            //UConverter* conv = ucnv_openCCSID(5347, UCNV_IBM, &status);
+            if (U_SUCCESS(status))
+            {
+                const char* source = &sInput[0];
+                const char* sourceLimit = source + sInput.size();
+
+                unsigned int uBufSize = (sInput.size() / ucnv_getMinCharSize(conv));
+                UChar* targetStart = (UChar*)malloc(uBufSize * sizeof(UChar));
+                UChar* target = targetStart;
+                UChar* targetLimit = target + uBufSize;
+
+                ucnv_toUnicode(conv, &target, targetLimit, &source, sourceLimit, NULL, TRUE, &status);
+                if (U_SUCCESS(status))
+                {
+                    unsigned int nTargetSize = target - targetStart;
+                    sRes.resize(nTargetSize * 2);// UTF-16 uses 2 code-points per char
+                    int32_t nResLen = 0;
+                    u_strToWCS(&sRes[0], sRes.size(), &nResLen, targetStart, nTargetSize, &status);
+                    sRes.resize(nResLen);
+                }
+                ucnv_close(conv);
+            }
+            return sRes;
+        }
+    };
+}
+
+namespace NSUnicodeConverter
+{
+    CUnicodeConverter::CUnicodeConverter()
+    {
+        m_pInternal = new CUnicodeConverter_Private();
+    }
+    CUnicodeConverter::~CUnicodeConverter()
+    {
+        delete m_pInternal;
+    }
+
+    std::string CUnicodeConverter::fromUnicode(const std::wstring &sSrc, const char *sCodePage)
+    {
+        return m_pInternal->fromUnicode(sSrc, sCodePage);
+    }
+    std::wstring CUnicodeConverter::toUnicode(const std::string &sSrc, const char *sCodePage)
+    {
+        return m_pInternal->toUnicode(sSrc, sCodePage);
+    }
+}

UnicodeConverter/UnicodeConverter.h

+#ifndef _SERVER_COMPONENTS_UNICODE_CONVERTER_H
+#define _SERVER_COMPONENTS_UNICODE_CONVERTER_H
+
+#ifndef UNICODECONVERTER_USE_DYNAMIC_LIBRARY
+#define UNICODECONVERTER_DECL_EXPORT
+#else
+#include "../DesktopEditor/common/base_export.h"
+#define UNICODECONVERTER_DECL_EXPORT Q_DECL_EXPORT
+#endif
+
+#include <string>
+
+namespace NSUnicodeConverter
+{
+    class CUnicodeConverter_Private;
+    class UNICODECONVERTER_DECL_EXPORT CUnicodeConverter
+	{
+	public:
+        CUnicodeConverter();
+        ~CUnicodeConverter();
+
+    public:
+        std::string fromUnicode(const std::wstring& sSrc, const char* sCodePage);
+        std::wstring toUnicode(const std::string& sSrc, const char* sCodePage);
+
+    private:
+        CUnicodeConverter_Private* m_pInternal;
+	};
+}
+
+#endif // _SERVER_COMPONENTS_UNICODE_CONVERTER_H

UnicodeConverter/UnicodeConverter.pro

+#-------------------------------------------------
+#
+# Project created by QtCreator 2015-05-15T12:43:02
+#
+#-------------------------------------------------
+
+QT       -= core gui
+
+VERSION = 1.0.0.1
+TARGET = UnicodeConverter
+TEMPLATE = lib
+
+#CONFIG += staticlib
+CONFIG += shared
+CONFIG += c++11
+
+QMAKE_CXXFLAGS += -fvisibility=hidden
+QMAKE_CFLAGS += -fvisibility=hidden
+
+QMAKE_LFLAGS += -Wl,--rpath=./
+
+############### destination path ###############
+DESTINATION_SDK_PATH = $$PWD/../SDK/lib
+ICU_BUILDS_PLATFORM = mac
+
+# WINDOWS
+win32:contains(QMAKE_TARGET.arch, x86_64):{
+CONFIG(debug, debug|release) {
+    DESTDIR = $$DESTINATION_SDK_PATH/win_64/DEBUG
+} else {
+    DESTDIR = $$DESTINATION_SDK_PATH/win_64
+}
+ICU_BUILDS_PLATFORM = win64
+}
+win32:!contains(QMAKE_TARGET.arch, x86_64):{
+CONFIG(debug, debug|release) {
+    DESTDIR = $$DESTINATION_SDK_PATH/win_32/DEBUG
+} else {
+    DESTDIR = $$DESTINATION_SDK_PATH/win_32
+}
+ICU_BUILDS_PLATFORM = win32
+}
+
+linux-g++:contains(QMAKE_HOST.arch, x86_64):{
+    DESTDIR = $$DESTINATION_SDK_PATH/linux_64
+    ICU_BUILDS_PLATFORM = linux64
+}
+linux-g++:!contains(QMAKE_HOST.arch, x86_64):{
+    DESTDIR = $$DESTINATION_SDK_PATH/linux_32
+    ICU_BUILDS_PLATFORM = linux32
+}
+
+################################################
+
+############# dynamic dependencies #############
+shared {
+    DEFINES += UNICODECONVERTER_USE_DYNAMIC_LIBRARY
+}
+################################################
+
+linux-g++ | linux-g++-64 | linux-g++-32 {
+    CONFIG += plugin
+    TARGET_EXT = .so
+
+    INCLUDEPATH += $$PWD/icubuilds/$$ICU_BUILDS_PLATFORM/usr/local/include
+    LIBS        += $$PWD/icubuilds/$$ICU_BUILDS_PLATFORM/usr/local/lib/libicuuc.so.55
+    LIBS        += $$PWD/icubuilds/$$ICU_BUILDS_PLATFORM/usr/local/lib/libicudata.so.55
+    message(linux)
+}
+
+win32 {
+    QMAKE_CXXFLAGS_RELEASE -= -Zc:strictStrings
+    TARGET_EXT = .dll
+
+    INCLUDEPATH += $$PWD/icubuilds/$$ICU_BUILDS_PLATFORM/include
+    LIBS        += -L$$PWD/icubuilds/$$ICU_BUILDS_PLATFORM/lib -licuuc
+    message(windows)
+}
+
+SOURCES += \
+    UnicodeConverter.cpp
+
+HEADERS +=\
+    UnicodeConverter.h

UnicodeConverter/icubuilds/linux64/readme.txt

+ICU Version: 55.1
+HOST: x86_64-unknown-linux-gnu
+CC Compiler: gcc
+CXX Compiler: g++

UnicodeConverter/icubuilds/linux64/usr/local/include/layout/LEGlyphFilter.h

+/*
+ *
+ * (C) Copyright IBM Corp. 1998-2011 - All Rights Reserved
+ *
+ */
+
+#ifndef __LEGLYPHFILTER__H
+#define __LEGLYPHFILTER__H
+
+#include "LETypes.h"
+
+U_NAMESPACE_BEGIN
+
+#ifndef U_HIDE_INTERNAL_API
+/**
+ * This is a helper class that is used to
+ * recognize a set of glyph indices.
+ *
+ * @internal
+ */
+class LEGlyphFilter /* not : public UObject because this is an interface/mixin class */ {
+public:
+    /**
+     * Destructor.
+     * @internal
+     */
+    virtual ~LEGlyphFilter();
+
+    /**
+     * This method is used to test a particular
+     * glyph index to see if it is in the set
+     * recognized by the filter.
+     *
+     * @param glyph - the glyph index to be tested
+     *
+     * @return TRUE if the glyph index is in the set.
+     *
+     * @internal
+     */
+    virtual le_bool accept(LEGlyphID glyph) const = 0;
+};
+#endif  /* U_HIDE_INTERNAL_API */
+
+U_NAMESPACE_END
+#endif

UnicodeConverter/icubuilds/linux64/usr/local/include/layout/LEInsertionList.h

+/*
+ **********************************************************************
+ *   Copyright (C) 1998-2014, International Business Machines
+ *   Corporation and others.  All Rights Reserved.
+ **********************************************************************
+ */
+
+#ifndef __LEINSERTIONLIST_H
+#define __LEINSERTIONLIST_H
+
+#include "LETypes.h"
+
+U_NAMESPACE_BEGIN
+
+struct InsertionRecord;
+
+#ifndef U_HIDE_INTERNAL_API
+/**
+ * This class encapsulates the callback used by <code>LEInsertionList</code>
+ * to apply an insertion from the insertion list.
+ *
+ * @internal
+ */
+class U_LAYOUT_API LEInsertionCallback
+{
+public:
+    /**
+     * This method will be called by <code>LEInsertionList::applyInsertions</code> for each
+     * entry on the insertion list.
+     *
+     * @param atPosition the position of the insertion
+     * @param count the number of glyphs to insert
+     * @param newGlyphs the address of the glyphs to insert
+     *
+     * @return <code>TRUE</code> if <code>LEInsertions::applyInsertions</code> should
+     *         stop after applying this insertion.
+     *
+     * @internal
+     */
+    virtual le_bool applyInsertion(le_int32 atPosition, le_int32 count, LEGlyphID newGlyphs[]) = 0;
+    
+    /**
+     * The destructor
+     */
+     virtual ~LEInsertionCallback();
+};
+
+/**
+ * This class is used to keep track of insertions to an array of
+ * <code>LEGlyphIDs</code>. The insertions are kept on a linked
+ * list of <code>InsertionRecords</code> so that the glyph array
+ * doesn't have to be grown for each insertion. The insertions are
+ * stored on the list from leftmost to rightmost to make it easier
+ * to do the insertions.
+ *
+ * The insertions are applied to the array by calling the
+ * <code>applyInsertions</code> method, which calls a client
+ * supplied <code>LEInsertionCallback</code> object to actually
+ * apply the individual insertions.
+ *
+ * @internal
+ */
+class LEInsertionList : public UObject
+{
+public:
+    /**
+     * Construct an empty insertion list.
+     *
+     * @param rightToLeft <code>TRUE</code> if the glyphs are stored
+     *                    in the array in right to left order.
+     *
+     * @internal
+     */
+    LEInsertionList(le_bool rightToLeft);
+
+    /**
+     * The destructor.
+     */
+    ~LEInsertionList();
+
+    /**
+     * Add an entry to the insertion list.
+     *
+     * @param position the glyph at this position in the array will be
+     *                 replaced by the new glyphs.
+     * @param count the number of new glyphs
+     * @param success set to an error code if the auxillary data cannot be retrieved.
+     *
+     * @return the address of an array in which to store the new glyphs. This will
+     *         <em>not</em> be in the glyph array.
+     *
+     * @internal
+     */
+    LEGlyphID *insert(le_int32 position, le_int32 count, LEErrorCode &success);
+
+    /**
+     * Return the number of new glyphs that have been inserted.
+     *
+     * @return the number of new glyphs which have been inserted
+     *
+     * @internal
+     */
+    le_int32 getGrowAmount();
+
+    /**
+     * Call the <code>LEInsertionCallback</code> once for each
+     * entry on the insertion list.
+     *
+     * @param callback the <code>LEInsertionCallback</code> to call for each insertion.
+     *
+     * @return <code>TRUE</code> if <code>callback</code> returned <code>TRUE</code> to
+     *         terminate the insertion list processing.
+     *
+     * @internal
+     */
+    le_bool applyInsertions(LEInsertionCallback *callback);
+
+    /**
+     * Empty the insertion list and free all associated
+     * storage.
+     *
+     * @internal
+     */
+    void reset();
+
+    /**
+     * ICU "poor man's RTTI", returns a UClassID for the actual class.
+     *
+     * @deprecated ICU 54. See {@link icu::LayoutEngine}
+     */
+    virtual UClassID getDynamicClassID() const;
+
+    /**
+     * ICU "poor man's RTTI", returns a UClassID for this class.
+     *
+     * @deprecated ICU 54. See {@link icu::LayoutEngine}
+     */
+    static UClassID getStaticClassID();
+
+private:
+
+    /**
+     * The head of the insertion list.
+     *
+     * @internal
+     */
+    InsertionRecord *head;
+
+    /**
+     * The tail of the insertion list.
+     *
+     * @internal
+     */
+    InsertionRecord *tail;
+
+    /**
+     * The total number of new glyphs on the insertion list.
+     *
+     * @internal
+     */
+    le_int32 growAmount;
+
+    /**
+     * Set to <code>TRUE</code> if the glyphs are in right
+     * to left order. Since we want the rightmost insertion
+     * to be first on the list, we need to append the
+     * insertions in this case. Otherwise they're prepended.
+     *
+     * @internal
+     */
+    le_bool  append;
+};
+#endif  /* U_HIDE_INTERNAL_API */
+
+U_NAMESPACE_END
+#endif
+

UnicodeConverter/icubuilds/linux64/usr/local/include/layout/LELanguages.h

+/*
+ *
+ * (C) Copyright IBM Corp. 1998-2014. All Rights Reserved.
+ *
+ * WARNING: THIS FILE IS MACHINE GENERATED. DO NOT HAND EDIT IT UNLESS
+ * YOU REALLY KNOW WHAT YOU'RE DOING.
+ *
+ * Generated on: 10/26/2010 02:53:33 PM PDT
+ */
+
+#ifndef __LELANGUAGES_H
+#define __LELANGUAGES_H
+
+#include "LETypes.h"
+
+/**
+ * \file
+ * \brief C++ API: List of language codes for LayoutEngine
+ */
+
+U_NAMESPACE_BEGIN
+
+/**
+ * A provisional list of language codes. For now,
+ * this is just a list of languages which the LayoutEngine
+ * supports.
+ *
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+
+enum LanguageCodes {
+    nullLanguageCode =  0,
+    araLanguageCode =  1,
+    asmLanguageCode =  2,
+    benLanguageCode =  3,
+    farLanguageCode =  4,
+    gujLanguageCode =  5,
+    hinLanguageCode =  6,
+    iwrLanguageCode =  7,
+    jiiLanguageCode =  8,
+    janLanguageCode =  9,
+    kanLanguageCode = 10,
+    kokLanguageCode = 11,
+    korLanguageCode = 12,
+    kshLanguageCode = 13,
+    malLanguageCode = 14,
+    marLanguageCode = 15,
+    mlrLanguageCode = 16,
+    mniLanguageCode = 17,
+    oriLanguageCode = 18,
+    sanLanguageCode = 19,
+    sndLanguageCode = 20,
+    snhLanguageCode = 21,
+    syrLanguageCode = 22,
+    tamLanguageCode = 23,
+    telLanguageCode = 24,
+    thaLanguageCode = 25,
+    urdLanguageCode = 26,
+    zhpLanguageCode = 27,
+    zhsLanguageCode = 28,
+    zhtLanguageCode = 29,
+
+    /** New language codes added 03/13/2008 @deprecated ICU 54. See {@link icu::LayoutEngine}
+     */
+    afkLanguageCode = 30,
+    belLanguageCode = 31,
+    bgrLanguageCode = 32,
+    catLanguageCode = 33,
+    cheLanguageCode = 34,
+    copLanguageCode = 35,
+    csyLanguageCode = 36,
+    danLanguageCode = 37,
+    deuLanguageCode = 38,
+    dznLanguageCode = 39,
+    ellLanguageCode = 40,
+    engLanguageCode = 41,
+    espLanguageCode = 42,
+    etiLanguageCode = 43,
+    euqLanguageCode = 44,
+    finLanguageCode = 45,
+    fraLanguageCode = 46,
+    gaeLanguageCode = 47,
+    hauLanguageCode = 48,
+    hrvLanguageCode = 49,
+    hunLanguageCode = 50,
+    hyeLanguageCode = 51,
+    indLanguageCode = 52,
+    itaLanguageCode = 53,
+    khmLanguageCode = 54,
+    mngLanguageCode = 55,
+    mtsLanguageCode = 56,
+    nepLanguageCode = 57,
+    nldLanguageCode = 58,
+    pasLanguageCode = 59,
+    plkLanguageCode = 60,
+    ptgLanguageCode = 61,
+    romLanguageCode = 62,
+    rusLanguageCode = 63,
+    skyLanguageCode = 64,
+    slvLanguageCode = 65,
+    sqiLanguageCode = 66,
+    srbLanguageCode = 67,
+    sveLanguageCode = 68,
+    tibLanguageCode = 69,
+    trkLanguageCode = 70,
+    welLanguageCode = 71,
+
+    languageCodeCount = 72
+};
+
+U_NAMESPACE_END
+#endif

UnicodeConverter/icubuilds/linux64/usr/local/include/layout/LEScripts.h

+/*
+ *
+ * (C) Copyright IBM Corp. 1998-2014. All Rights Reserved.
+ *
+ * WARNING: THIS FILE IS MACHINE GENERATED. DO NOT HAND EDIT IT UNLESS
+ * YOU REALLY KNOW WHAT YOU'RE DOING.
+ *
+ * Generated on: 04/08/2014 03:20:04 PM PDT
+ */
+
+#ifndef __LESCRIPTS_H
+#define __LESCRIPTS_H
+
+#include "LETypes.h"
+
+/**
+ * \file
+ * \brief C++ API: Constants for Unicode script values
+ */
+
+U_NAMESPACE_BEGIN
+
+/**
+ * Constants for Unicode script values, generated using
+ * ICU4J's <code>UScript</code> class.
+ *
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+
+enum ScriptCodes {
+    zyyyScriptCode =  0,
+    zinhScriptCode =  1,
+    qaaiScriptCode = zinhScriptCode,  /* manually added alias, for API stability */
+    arabScriptCode =  2,
+    armnScriptCode =  3,
+    bengScriptCode =  4,
+    bopoScriptCode =  5,
+    cherScriptCode =  6,
+    coptScriptCode =  7,
+    cyrlScriptCode =  8,
+    dsrtScriptCode =  9,
+    devaScriptCode = 10,
+    ethiScriptCode = 11,
+    georScriptCode = 12,
+    gothScriptCode = 13,
+    grekScriptCode = 14,
+    gujrScriptCode = 15,
+    guruScriptCode = 16,
+    haniScriptCode = 17,
+    hangScriptCode = 18,
+    hebrScriptCode = 19,
+    hiraScriptCode = 20,
+    kndaScriptCode = 21,
+    kanaScriptCode = 22,
+    khmrScriptCode = 23,
+    laooScriptCode = 24,
+    latnScriptCode = 25,
+    mlymScriptCode = 26,
+    mongScriptCode = 27,
+    mymrScriptCode = 28,
+    ogamScriptCode = 29,
+    italScriptCode = 30,
+    oryaScriptCode = 31,
+    runrScriptCode = 32,
+    sinhScriptCode = 33,
+    syrcScriptCode = 34,
+    tamlScriptCode = 35,
+    teluScriptCode = 36,
+    thaaScriptCode = 37,
+    thaiScriptCode = 38,
+    tibtScriptCode = 39,
+/**
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+
+    cansScriptCode = 40,
+/**
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+
+    yiiiScriptCode = 41,
+    tglgScriptCode = 42,
+    hanoScriptCode = 43,
+    buhdScriptCode = 44,
+    tagbScriptCode = 45,
+/**
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+
+    braiScriptCode = 46,
+    cprtScriptCode = 47,
+    limbScriptCode = 48,
+    linbScriptCode = 49,
+    osmaScriptCode = 50,
+    shawScriptCode = 51,
+    taleScriptCode = 52,
+    ugarScriptCode = 53,
+/**
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+
+    hrktScriptCode = 54,
+/**
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+
+    bugiScriptCode = 55,
+    glagScriptCode = 56,
+    kharScriptCode = 57,
+    syloScriptCode = 58,
+    taluScriptCode = 59,
+    tfngScriptCode = 60,
+    xpeoScriptCode = 61,
+/**
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+
+    baliScriptCode = 62,
+    batkScriptCode = 63,
+    blisScriptCode = 64,
+    brahScriptCode = 65,
+    chamScriptCode = 66,
+    cirtScriptCode = 67,
+    cyrsScriptCode = 68,
+    egydScriptCode = 69,
+    egyhScriptCode = 70,
+    egypScriptCode = 71,
+    geokScriptCode = 72,
+    hansScriptCode = 73,
+    hantScriptCode = 74,
+    hmngScriptCode = 75,
+    hungScriptCode = 76,
+    indsScriptCode = 77,
+    javaScriptCode = 78,
+    kaliScriptCode = 79,
+    latfScriptCode = 80,
+    latgScriptCode = 81,
+    lepcScriptCode = 82,
+    linaScriptCode = 83,
+    mandScriptCode = 84,
+    mayaScriptCode = 85,
+    meroScriptCode = 86,
+    nkooScriptCode = 87,
+    orkhScriptCode = 88,
+    permScriptCode = 89,
+    phagScriptCode = 90,
+    phnxScriptCode = 91,
+    plrdScriptCode = 92,
+    roroScriptCode = 93,
+    saraScriptCode = 94,
+    syreScriptCode = 95,
+    syrjScriptCode = 96,
+    syrnScriptCode = 97,
+    tengScriptCode = 98,
+    vaiiScriptCode = 99,
+    vispScriptCode = 100,
+    xsuxScriptCode = 101,
+    zxxxScriptCode = 102,
+    zzzzScriptCode = 103,
+/**
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+
+    cariScriptCode = 104,
+    jpanScriptCode = 105,
+    lanaScriptCode = 106,
+    lyciScriptCode = 107,
+    lydiScriptCode = 108,
+    olckScriptCode = 109,
+    rjngScriptCode = 110,
+    saurScriptCode = 111,
+    sgnwScriptCode = 112,
+    sundScriptCode = 113,
+    moonScriptCode = 114,
+    mteiScriptCode = 115,
+/**
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+
+    armiScriptCode = 116,
+    avstScriptCode = 117,
+    cakmScriptCode = 118,
+    koreScriptCode = 119,
+    kthiScriptCode = 120,
+    maniScriptCode = 121,
+    phliScriptCode = 122,
+    phlpScriptCode = 123,
+    phlvScriptCode = 124,
+    prtiScriptCode = 125,
+    samrScriptCode = 126,
+    tavtScriptCode = 127,
+    zmthScriptCode = 128,
+    zsymScriptCode = 129,
+/**
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+
+    bamuScriptCode = 130,
+    lisuScriptCode = 131,
+    nkgbScriptCode = 132,
+    sarbScriptCode = 133,
+/**
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+
+    bassScriptCode = 134,
+    duplScriptCode = 135,
+    elbaScriptCode = 136,
+    granScriptCode = 137,
+    kpelScriptCode = 138,
+    lomaScriptCode = 139,
+    mendScriptCode = 140,
+    mercScriptCode = 141,
+    narbScriptCode = 142,
+    nbatScriptCode = 143,
+    palmScriptCode = 144,
+    sindScriptCode = 145,
+    waraScriptCode = 146,
+/**
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+
+    afakScriptCode = 147,
+    jurcScriptCode = 148,
+    mrooScriptCode = 149,
+    nshuScriptCode = 150,
+    shrdScriptCode = 151,
+    soraScriptCode = 152,
+    takrScriptCode = 153,
+    tangScriptCode = 154,
+    woleScriptCode = 155,
+/**
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+
+    hluwScriptCode = 156,
+    khojScriptCode = 157,
+    tirhScriptCode = 158,
+/**
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+
+    aghbScriptCode = 159,
+    mahjScriptCode = 160,
+/**
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+
+    ahomScriptCode = 161,
+    hatrScriptCode = 162,
+    modiScriptCode = 163,
+    multScriptCode = 164,
+    paucScriptCode = 165,
+    siddScriptCode = 166,
+
+/**
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+    scriptCodeCount
+};
+
+U_NAMESPACE_END
+#endif

UnicodeConverter/icubuilds/linux64/usr/local/include/layout/LESwaps.h

+/*
+ *
+ * (C) Copyright IBM Corp. 1998-2014 - All Rights Reserved
+ *
+ */
+
+#ifndef __LESWAPS_H
+#define __LESWAPS_H
+
+#include "LETypes.h"
+
+/**
+ * \file 
+ * \brief C++ API: Endian independent access to data for LayoutEngine
+ */
+
+U_NAMESPACE_BEGIN
+
+/**
+ * A convenience macro which invokes the swapWord member function
+ * from a concise call.
+ *
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+#define SWAPW(value) LESwaps::swapWord((le_uint16)(value))
+
+/**
+ * A convenience macro which invokes the swapLong member function
+ * from a concise call.
+ *
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+#define SWAPL(value) LESwaps::swapLong((le_uint32)(value))
+
+/**
+ * This class is used to access data which stored in big endian order
+ * regardless of the conventions of the platform.
+ *
+ * All methods are static and inline in an attempt to induce the compiler
+ * to do most of the calculations at compile time.
+ *
+ * @deprecated ICU 54. See {@link icu::LayoutEngine}
+ */
+class U_LAYOUT_API LESwaps /* not : public UObject because all methods are static */ {
+public:
+
+    /**
+     * Reads a big-endian 16-bit word and returns a native-endian value.
+     * No-op on a big-endian platform, byte-swaps on a little-endian platform.
+     *
+     * @param value - the word to be byte swapped
+     *
+     * @return the byte swapped word
+     *
+     * @deprecated ICU 54. See {@link icu::LayoutEngine}
+     */
+    static le_uint16 swapWord(le_uint16 value)
+    {
+#if (defined(U_IS_BIG_ENDIAN) && U_IS_BIG_ENDIAN) || \
+    (defined(BYTE_ORDER) && defined(BIG_ENDIAN) && (BYTE_ORDER == BIG_ENDIAN)) || \
+    defined(__BIG_ENDIAN__)
+        // Fastpath when we know that the platform is big-endian.
+        return value;
+#else
+        // Reads a big-endian value on any platform.
+        const le_uint8 *p = reinterpret_cast<const le_uint8 *>(&value);
+        return (le_uint16)((p[0] << 8) | p[1]);
+#endif
+    };
+
+    /**
+     * Reads a big-endian 32-bit word and returns a native-endian value.
+     * No-op on a big-endian platform, byte-swaps on a little-endian platform.
+     *
+     * @param value - the long to be byte swapped
+     *
+     * @return the byte swapped long
+     *
+     * @deprecated ICU 54. See {@link icu::LayoutEngine}
+     */
+    static le_uint32 swapLong(le_uint32 value)
+    {
+#if (defined(U_IS_BIG_ENDIAN) && U_IS_BIG_ENDIAN) || \
+    (defined(BYTE_ORDER) && defined(BIG_ENDIAN) && (BYTE_ORDER == BIG_ENDIAN)) || \
+    defined(__BIG_ENDIAN__)
+        // Fastpath when we know that the platform is big-endian.
+        return value;
+#else
+        // Reads a big-endian value on any platform.
+        const le_uint8 *p = reinterpret_cast<const le_uint8 *>(&value);
+        return (le_uint32)((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
+#endif
+    };
+
+private:
+    LESwaps() {} // private - forbid instantiation
+};
+
+U_NAMESPACE_END
+#endif

UnicodeConverter/icubuilds/linux64/usr/local/include/layout/loengine.h

+/*
+ *
+ * (C) Copyright IBM Corp. 1998-2011 - All Rights Reserved
+ *
+ */
+
+#ifndef __LOENGINE_H
+#define __LOENGINE_H
+
+#include "LETypes.h"
+
+#ifndef U_HIDE_INTERNAL_API
+/**
+ * \file 
+ * \brief C API for complex text layout.
+ * \internal
+ *
+ * This is a technology preview. The API may
+ * change significantly.
+ *
+ */
+
+/**
+ * The opaque type for a LayoutEngine.
+ *
+ * @internal
+ */
+typedef void le_engine;
+
+/**
+ * The opaque type for a font instance.
+ *
+ * @internal
+ */
+typedef void le_font;
+
+/**
+ * This function returns an le_engine capable of laying out text
+ * in the given font, script and langauge. Note that the LayoutEngine
+ * returned may be a subclass of LayoutEngine.
+ *
+ * @param font - the font of the text
+ * @param scriptCode - the script of the text
+ * @param languageCode - the language of the text
+ * @param typo_flags - flags that control layout features like kerning and ligatures.
+ * @param success - output parameter set to an error code if the operation fails
+ *
+ * @return an le_engine which can layout text in the given font.
+ *
+ * @internal
+ */
+U_INTERNAL le_engine * U_EXPORT2
+le_create(const le_font *font,
+          le_int32 scriptCode,
+          le_int32 languageCode,
+          le_int32 typo_flags,
+          LEErrorCode *success);
+
+/**
+ * This function closes the given LayoutEngine. After
+ * it returns, the le_engine is no longer valid.
+ *
+ * @param engine - the LayoutEngine to close.
+ *
+ * @internal
+ */
+U_INTERNAL void U_EXPORT2
+le_close(le_engine *engine);
+
+/**
+ * This routine will compute the glyph, character index and position arrays.
+ *
+ * @param engine - the LayoutEngine
+ * @param chars - the input character context
+ * @param offset - the offset of the first character to process
+ * @param count - the number of characters to process
+ * @param max - the number of characters in the input context
+ * @param rightToLeft - TRUE if the characers are in a right to left directional run
+ * @param x - the initial X position
+ * @param y - the initial Y position
+ * @param success - output parameter set to an error code if the operation fails
+ *
+ * @return the number of glyphs in the glyph array
+ *
+ * Note: The glyph, character index and position array can be accessed
+ * using the getter routines below.
+ *
+ * Note: If you call this function more than once, you must call the reset()
+ * function first to free the glyph, character index and position arrays
+ * allocated by the previous call.
+ *
+ * @internal
+ */
+U_INTERNAL le_int32 U_EXPORT2
+le_layoutChars(le_engine *engine,
+               const LEUnicode chars[],
+               le_int32 offset,
+               le_int32 count,
+               le_int32 max,
+               le_bool rightToLeft,
+               float x,
+               float y,
+               LEErrorCode *success);
+
+/**
+ * This function returns the number of glyphs in the glyph array. Note
+ * that the number of glyphs will be greater than or equal to the number
+ * of characters used to create the LayoutEngine.
+ *
+ * @param engine - the LayoutEngine
+ * @param success - output parameter set to an error code if the operation fails.
+ *
+ * @return the number of glyphs in the glyph array
+ *
+ * @internal
+ */
+U_INTERNAL le_int32 U_EXPORT2
+le_getGlyphCount(le_engine *engine,
+                 LEErrorCode *success);
+
+/**
+ * This function copies the glyph array into a caller supplied array.
+ * The caller must ensure that the array is large enough to hold all
+ * the glyphs.
+ *
+ * @param engine - the LayoutEngine
+ * @param glyphs - the destiniation glyph array
+ * @param success - set to an error code if the operation fails
+ *
+ * @internal
+ */
+U_INTERNAL void U_EXPORT2
+le_getGlyphs(le_engine *engine,
+             LEGlyphID glyphs[],
+             LEErrorCode *success);
+
+/**
+ * This function copies the character index array into a caller supplied array.
+ * The caller must ensure that the array is large enough to hold a
+ * character index for each glyph.
+ *
+ * @param engine - the LayoutEngine
+ * @param charIndices - the destiniation character index array
+ * @param success - set to an error code if the operation fails
+ *
+ * @internal
+ */
+U_INTERNAL void U_EXPORT2
+le_getCharIndices(le_engine *engine,
+                  le_int32 charIndices[],
+                  LEErrorCode *success);
+
+/**
+ * This function copies the character index array into a caller supplied array.
+ * The caller must ensure that the array is large enough to hold a
+ * character index for each glyph.
+ *
+ * @param engine - the LayoutEngine
+ * @param charIndices - the destiniation character index array
+ * @param indexBase - an offset that will be added to each index.
+ * @param success - set to an error code if the operation fails
+ *
+ * @internal
+ */
+U_INTERNAL void U_EXPORT2
+le_getCharIndicesWithBase(le_engine *engine,
+                  le_int32 charIndices[],
+                  le_int32 indexBase,
+                  LEErrorCode *success);
+
+/**
+ * This function copies the position array into a caller supplied array.
+ * The caller must ensure that the array is large enough to hold an
+ * X and Y position for each glyph, plus an extra X and Y for the
+ * advance of the last glyph.
+ *
+ * @param engine - the LayoutEngine
+ * @param positions - the destiniation position array
+ * @param success - set to an error code if the operation fails
+ *
+ * @internal
+ */
+U_INTERNAL void U_EXPORT2
+le_getGlyphPositions(le_engine *engine,
+                     float positions[],
+                     LEErrorCode *success);
+
+/**
+ * This function returns the X and Y position of the glyph at
+ * the given index.
+ *
+ * Input parameters:
+ * @param engine - the LayoutEngine
+ * @param glyphIndex - the index of the glyph
+ *
+ * Output parameters:
+ * @param x - the glyph's X position
+ * @param y - the glyph's Y position
+ * @param success - set to an error code if the operation fails
+ *
+ * @internal
+ */
+U_INTERNAL void U_EXPORT2
+le_getGlyphPosition(le_engine *engine,
+                    le_int32 glyphIndex,
+                    float *x,
+                    float *y,
+                    LEErrorCode *success);
+
+/**
+ * This function frees the glyph, character index and position arrays
+ * so that the LayoutEngine can be reused to layout a different
+ * characer array. (This function is also called by le_close)
+ *
+ * @param engine - the LayoutEngine
+ * @param success - set to an error code if the operation fails
+ *
+ * @internal
+ */
+U_INTERNAL void U_EXPORT2
+le_reset(le_engine *engine,
+         LEErrorCode *success);
+#endif  /* U_HIDE_INTERNAL_API */
+
+#endif

UnicodeConverter/icubuilds/linux64/usr/local/include/unicode/appendable.h

+/*
+*******************************************************************************
+*   Copyright (C) 2011-2012, International Business Machines
+*   Corporation and others.  All Rights Reserved.
+*******************************************************************************
+*   file name:  appendable.h
+*   encoding:   US-ASCII
+*   tab size:   8 (not used)
+*   indentation:4
+*
+*   created on: 2010dec07
+*   created by: Markus W. Scherer
+*/
+
+#ifndef __APPENDABLE_H__
+#define __APPENDABLE_H__
+
+/**
+ * \file
+ * \brief C++ API: Appendable class: Sink for Unicode code points and 16-bit code units (UChars).
+ */
+
+#include "unicode/utypes.h"
+#include "unicode/uobject.h"
+
+U_NAMESPACE_BEGIN
+
+class UnicodeString;
+
+/**
+ * Base class for objects to which Unicode characters and strings can be appended.
+ * Combines elements of Java Appendable and ICU4C ByteSink.
+ *
+ * This class can be used in APIs where it does not matter whether the actual destination is
+ * a UnicodeString, a UChar[] array, a UnicodeSet, or any other object
+ * that receives and processes characters and/or strings.
+ *
+ * Implementation classes must implement at least appendCodeUnit(UChar).
+ * The base class provides default implementations for the other methods.
+ *
+ * The methods do not take UErrorCode parameters.
+ * If an error occurs (e.g., out-of-memory),
+ * in addition to returning FALSE from failing operations,
+ * the implementation must prevent unexpected behavior (e.g., crashes)
+ * from further calls and should make the error condition available separately
+ * (e.g., store a UErrorCode, make/keep a UnicodeString bogus).
+ * @stable ICU 4.8
+ */
+class U_COMMON_API Appendable : public UObject {
+public:
+    /**
+     * Destructor.
+     * @stable ICU 4.8
+     */
+    ~Appendable();
+
+    /**
+     * Appends a 16-bit code unit.
+     * @param c code unit
+     * @return TRUE if the operation succeeded
+     * @stable ICU 4.8
+     */
+    virtual UBool appendCodeUnit(UChar c) = 0;
+
+    /**
+     * Appends a code point.
+     * The default implementation calls appendCodeUnit(UChar) once or twice.
+     * @param c code point 0..0x10ffff
+     * @return TRUE if the operation succeeded
+     * @stable ICU 4.8
+     */
+    virtual UBool appendCodePoint(UChar32 c);
+
+    /**
+     * Appends a string.
+     * The default implementation calls appendCodeUnit(UChar) for each code unit.
+     * @param s string, must not be NULL if length!=0
+     * @param length string length, or -1 if NUL-terminated
+     * @return TRUE if the operation succeeded
+     * @stable ICU 4.8
+     */
+    virtual UBool appendString(const UChar *s, int32_t length);
+
+    /**
+     * Tells the object that the caller is going to append roughly
+     * appendCapacity UChars. A subclass might use this to pre-allocate
+     * a larger buffer if necessary.
+     * The default implementation does nothing. (It always returns TRUE.)
+     * @param appendCapacity estimated number of UChars that will be appended
+     * @return TRUE if the operation succeeded
+     * @stable ICU 4.8
+     */
+    virtual UBool reserveAppendCapacity(int32_t appendCapacity);
+
+    /**
+     * Returns a writable buffer for appending and writes the buffer's capacity to
+     * *resultCapacity. Guarantees *resultCapacity>=minCapacity.
+     * May return a pointer to the caller-owned scratch buffer which must have
+     * scratchCapacity>=minCapacity.
+     * The returned buffer is only valid until the next operation
+     * on this Appendable.
+     *
+     * After writing at most *resultCapacity UChars, call appendString() with the
+     * pointer returned from this function and the number of UChars written.
+     * Many appendString() implementations will avoid copying UChars if this function
+     * returned an internal buffer.
+     *
+     * Partial usage example:
+     * \code
+     *  int32_t capacity;
+     *  UChar* buffer = app.getAppendBuffer(..., &capacity);
+     *  ... Write n UChars into buffer, with n <= capacity.
+     *  app.appendString(buffer, n);
+     * \endcode
+     * In many implementations, that call to append will avoid copying UChars.
+     *
+     * If the Appendable allocates or reallocates an internal buffer, it should use
+     * the desiredCapacityHint if appropriate.
+     * If a caller cannot provide a reasonable guess at the desired capacity,
+     * it should pass desiredCapacityHint=0.
+     *
+     * If a non-scratch buffer is returned, the caller may only pass
+     * a prefix to it to appendString().
+     * That is, it is not correct to pass an interior pointer to appendString().
+     *
+     * The default implementation always returns the scratch buffer.
+     *
+     * @param minCapacity required minimum capacity of the returned buffer;
+     *                    must be non-negative
+     * @param desiredCapacityHint desired capacity of the returned buffer;
+     *                            must be non-negative
+     * @param scratch default caller-owned buffer
+     * @param scratchCapacity capacity of the scratch buffer
+     * @param resultCapacity pointer to an integer which will be set to the
+     *                       capacity of the returned buffer
+     * @return a buffer with *resultCapacity>=minCapacity
+     * @stable ICU 4.8
+     */
+    virtual UChar *getAppendBuffer(int32_t minCapacity,
+                                   int32_t desiredCapacityHint,
+                                   UChar *scratch, int32_t scratchCapacity,
+                                   int32_t *resultCapacity);
+};
+
+/**
+ * An Appendable implementation which writes to a UnicodeString.
+ *
+ * This class is not intended for public subclassing.
+ * @stable ICU 4.8
+ */
+class U_COMMON_API UnicodeStringAppendable : public Appendable {
+public:
+    /**
+     * Aliases the UnicodeString (keeps its reference) for writing.
+     * @param s The UnicodeString to which this Appendable will write.
+     * @stable ICU 4.8
+     */
+    explicit UnicodeStringAppendable(UnicodeString &s) : str(s) {}
+
+    /**
+     * Destructor.
+     * @stable ICU 4.8
+     */
+    ~UnicodeStringAppendable();
+
+    /**
+     * Appends a 16-bit code unit to the string.
+     * @param c code unit
+     * @return TRUE if the operation succeeded
+     * @stable ICU 4.8
+     */
+    virtual UBool appendCodeUnit(UChar c);
+
+    /**
+     * Appends a code point to the string.
+     * @param c code point 0..0x10ffff
+     * @return TRUE if the operation succeeded
+     * @stable ICU 4.8
+     */
+    virtual UBool appendCodePoint(UChar32 c);
+
+    /**
+     * Appends a string to the UnicodeString.
+     * @param s string, must not be NULL if length!=0
+     * @param length string length, or -1 if NUL-terminated
+     * @return TRUE if the operation succeeded
+     * @stable ICU 4.8
+     */
+    virtual UBool appendString(const UChar *s, int32_t length);
+
+    /**
+     * Tells the UnicodeString that the caller is going to append roughly
+     * appendCapacity UChars.
+     * @param appendCapacity estimated number of UChars that will be appended
+     * @return TRUE if the operation succeeded
+     * @stable ICU 4.8
+     */
+    virtual UBool reserveAppendCapacity(int32_t appendCapacity);
+
+    /**
+     * Returns a writable buffer for appending and writes the buffer's capacity to
+     * *resultCapacity. Guarantees *resultCapacity>=minCapacity.
+     * May return a pointer to the caller-owned scratch buffer which must have
+     * scratchCapacity>=minCapacity.
+     * The returned buffer is only valid until the next write operation
+     * on the UnicodeString.
+     *
+     * For details see Appendable::getAppendBuffer().
+     *
+     * @param minCapacity required minimum capacity of the returned buffer;
+     *                    must be non-negative
+     * @param desiredCapacityHint desired capacity of the returned buffer;
+     *                            must be non-negative
+     * @param scratch default caller-owned buffer
+     * @param scratchCapacity capacity of the scratch buffer
+     * @param resultCapacity pointer to an integer which will be set to the
+     *                       capacity of the returned buffer
+     * @return a buffer with *resultCapacity>=minCapacity
+     * @stable ICU 4.8
+     */
+    virtual UChar *getAppendBuffer(int32_t minCapacity,
+                                   int32_t desiredCapacityHint,
+                                   UChar *scratch, int32_t scratchCapacity,
+                                   int32_t *resultCapacity);
+
+private:
+    UnicodeString &str;
+};
+
+U_NAMESPACE_END
+
+#endif  // __APPENDABLE_H__

UnicodeConverter/icubuilds/linux64/usr/local/include/unicode/dbbi.h

+/*
+**********************************************************************
+*   Copyright (C) 1999-2006,2013 IBM Corp. All rights reserved.
+**********************************************************************
+*   Date        Name        Description
+*   12/1/99    rgillam     Complete port from Java.
+*   01/13/2000 helena      Added UErrorCode to ctors.
+**********************************************************************
+*/
+
+#ifndef DBBI_H
+#define DBBI_H
+
+#include "unicode/rbbi.h"
+
+#if !UCONFIG_NO_BREAK_ITERATION
+
+/**
+ * \file
+ * \brief C++ API: Dictionary Based Break Iterator
+ */
+ 
+U_NAMESPACE_BEGIN
+
+#ifndef U_HIDE_DEPRECATED_API
+/**
+ * An obsolete subclass of RuleBasedBreakIterator. Handling of dictionary-
+ * based break iteration has been folded into the base class. This class
+ * is deprecated as of ICU 3.6.
+ * @deprecated ICU 3.6
+ */
+typedef RuleBasedBreakIterator DictionaryBasedBreakIterator;
+
+#endif  /* U_HIDE_DEPRECATED_API */
+
+U_NAMESPACE_END
+
+#endif /* #if !UCONFIG_NO_BREAK_ITERATION */
+
+#endif

UnicodeConverter/icubuilds/linux64/usr/local/include/unicode/std_string.h

+/*
+*******************************************************************************
+*
+*   Copyright (C) 2009-2014, International Business Machines
+*   Corporation and others.  All Rights Reserved.
+*
+*******************************************************************************
+*   file name:  std_string.h
+*   encoding:   US-ASCII
+*   tab size:   8 (not used)
+*   indentation:4
+*
+*   created on: 2009feb19
+*   created by: Markus W. Scherer
+*/
+
+#ifndef __STD_STRING_H__
+#define __STD_STRING_H__
+
+/**
+ * \file
+ * \brief C++ API: Central ICU header for including the C++ standard <string>
+ *                 header and for related definitions.
+ */
+
+#include "unicode/utypes.h"
+
+#if U_HAVE_STD_STRING
+
+#if !defined(_MSC_VER)
+namespace std { class type_info; } // WORKAROUND: http://llvm.org/bugs/show_bug.cgi?id=13364
+#endif
+#include <string>
+
+#endif  // U_HAVE_STD_STRING
+
+#endif  // __STD_STRING_H__