[apple/icu.git] / icuSources / common / norm2allmodes.h

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
* Copyright (C) 2014, International Business Machines
* Corporation and others.  All Rights Reserved.
*******************************************************************************
* loadednormalizer2impl.h
*
* created on: 2014sep07
* created by: Markus W. Scherer
*/

#ifndef __NORM2ALLMODES_H__
#define __NORM2ALLMODES_H__

#include "unicode/utypes.h"

#if !UCONFIG_NO_NORMALIZATION

#include "unicode/normalizer2.h"
#include "unicode/unistr.h"
#include "cpputils.h"
#include "normalizer2impl.h"

U_NAMESPACE_BEGIN

// Intermediate class:
// Has Normalizer2Impl and does boilerplate argument checking and setup.
class Normalizer2WithImpl : public Normalizer2 {
public:
    Normalizer2WithImpl(const Normalizer2Impl &ni) : impl(ni) {}
    virtual ~Normalizer2WithImpl();

    // normalize
    virtual UnicodeString &
    normalize(const UnicodeString &src,
              UnicodeString &dest,
              UErrorCode &errorCode) const {
        if(U_FAILURE(errorCode)) {
            dest.setToBogus();
            return dest;
        }
        const UChar *sArray=src.getBuffer();
        if(&dest==&src || sArray==NULL) {
            errorCode=U_ILLEGAL_ARGUMENT_ERROR;
            dest.setToBogus();
            return dest;
        }
        dest.remove();
        ReorderingBuffer buffer(impl, dest);
        if(buffer.init(src.length(), errorCode)) {
            normalize(sArray, sArray+src.length(), buffer, errorCode);
        }
        return dest;
    }
    virtual void
    normalize(const UChar *src, const UChar *limit,
              ReorderingBuffer &buffer, UErrorCode &errorCode) const = 0;

    // normalize and append
    virtual UnicodeString &
    normalizeSecondAndAppend(UnicodeString &first,
                             const UnicodeString &second,
                             UErrorCode &errorCode) const {
        return normalizeSecondAndAppend(first, second, TRUE, errorCode);
    }
    virtual UnicodeString &
    append(UnicodeString &first,
           const UnicodeString &second,
           UErrorCode &errorCode) const {
        return normalizeSecondAndAppend(first, second, FALSE, errorCode);
    }
    UnicodeString &
    normalizeSecondAndAppend(UnicodeString &first,
                             const UnicodeString &second,
                             UBool doNormalize,
                             UErrorCode &errorCode) const {
        uprv_checkCanGetBuffer(first, errorCode);
        if(U_FAILURE(errorCode)) {
            return first;
        }
        const UChar *secondArray=second.getBuffer();
        if(&first==&second || secondArray==NULL) {
            errorCode=U_ILLEGAL_ARGUMENT_ERROR;
            return first;
        }
        int32_t firstLength=first.length();
        UnicodeString safeMiddle;
        {
            ReorderingBuffer buffer(impl, first);
            if(buffer.init(firstLength+second.length(), errorCode)) {
                normalizeAndAppend(secondArray, secondArray+second.length(), doNormalize,
                                   safeMiddle, buffer, errorCode);
            }
        }  // The ReorderingBuffer destructor finalizes the first string.
        if(U_FAILURE(errorCode)) {
            // Restore the modified suffix of the first string.
            first.replace(firstLength-safeMiddle.length(), 0x7fffffff, safeMiddle);
        }
        return first;
    }
    virtual void
    normalizeAndAppend(const UChar *src, const UChar *limit, UBool doNormalize,
                       UnicodeString &safeMiddle,
                       ReorderingBuffer &buffer, UErrorCode &errorCode) const = 0;
    virtual UBool
    getDecomposition(UChar32 c, UnicodeString &decomposition) const {
        UChar buffer[4];
        int32_t length;
        const UChar *d=impl.getDecomposition(c, buffer, length);
        if(d==NULL) {
            return FALSE;
        }
        if(d==buffer) {
            decomposition.setTo(buffer, length);  // copy the string (Jamos from Hangul syllable c)
        } else {
            decomposition.setTo(FALSE, d, length);  // read-only alias
        }
        return TRUE;
    }
    virtual UBool
    getRawDecomposition(UChar32 c, UnicodeString &decomposition) const {
        UChar buffer[30];
        int32_t length;
        const UChar *d=impl.getRawDecomposition(c, buffer, length);
        if(d==NULL) {
            return FALSE;
        }
        if(d==buffer) {
            decomposition.setTo(buffer, length);  // copy the string (algorithmic decomposition)
        } else {
            decomposition.setTo(FALSE, d, length);  // read-only alias
        }
        return TRUE;
    }
    virtual UChar32
    composePair(UChar32 a, UChar32 b) const {
        return impl.composePair(a, b);
    }

    virtual uint8_t
    getCombiningClass(UChar32 c) const {
        return impl.getCC(impl.getNorm16(c));
    }

    // quick checks
    virtual UBool
    isNormalized(const UnicodeString &s, UErrorCode &errorCode) const {
        if(U_FAILURE(errorCode)) {
            return FALSE;
        }
        const UChar *sArray=s.getBuffer();
        if(sArray==NULL) {
            errorCode=U_ILLEGAL_ARGUMENT_ERROR;
            return FALSE;
        }
        const UChar *sLimit=sArray+s.length();
        return sLimit==spanQuickCheckYes(sArray, sLimit, errorCode);
    }
    virtual UNormalizationCheckResult
    quickCheck(const UnicodeString &s, UErrorCode &errorCode) const {
        return Normalizer2WithImpl::isNormalized(s, errorCode) ? UNORM_YES : UNORM_NO;
    }
    virtual int32_t
    spanQuickCheckYes(const UnicodeString &s, UErrorCode &errorCode) const {
        if(U_FAILURE(errorCode)) {
            return 0;
        }
        const UChar *sArray=s.getBuffer();
        if(sArray==NULL) {
            errorCode=U_ILLEGAL_ARGUMENT_ERROR;
            return 0;
        }
        return (int32_t)(spanQuickCheckYes(sArray, sArray+s.length(), errorCode)-sArray);
    }
    virtual const UChar *
    spanQuickCheckYes(const UChar *src, const UChar *limit, UErrorCode &errorCode) const = 0;

    virtual UNormalizationCheckResult getQuickCheck(UChar32) const {
        return UNORM_YES;
    }

    const Normalizer2Impl &impl;
};

class DecomposeNormalizer2 : public Normalizer2WithImpl {
public:
    DecomposeNormalizer2(const Normalizer2Impl &ni) : Normalizer2WithImpl(ni) {}
    virtual ~DecomposeNormalizer2();

private:
    virtual void
    normalize(const UChar *src, const UChar *limit,
              ReorderingBuffer &buffer, UErrorCode &errorCode) const {
        impl.decompose(src, limit, &buffer, errorCode);
    }
    using Normalizer2WithImpl::normalize;  // Avoid warning about hiding base class function.
    virtual void
    normalizeAndAppend(const UChar *src, const UChar *limit, UBool doNormalize,
                       UnicodeString &safeMiddle,
                       ReorderingBuffer &buffer, UErrorCode &errorCode) const {
        impl.decomposeAndAppend(src, limit, doNormalize, safeMiddle, buffer, errorCode);
    }
    virtual const UChar *
    spanQuickCheckYes(const UChar *src, const UChar *limit, UErrorCode &errorCode) const {
        return impl.decompose(src, limit, NULL, errorCode);
    }
    using Normalizer2WithImpl::spanQuickCheckYes;  // Avoid warning about hiding base class function.
    virtual UNormalizationCheckResult getQuickCheck(UChar32 c) const {
        return impl.isDecompYes(impl.getNorm16(c)) ? UNORM_YES : UNORM_NO;
    }
    virtual UBool hasBoundaryBefore(UChar32 c) const { return impl.hasDecompBoundary(c, TRUE); }
    virtual UBool hasBoundaryAfter(UChar32 c) const { return impl.hasDecompBoundary(c, FALSE); }
    virtual UBool isInert(UChar32 c) const { return impl.isDecompInert(c); }
};

class ComposeNormalizer2 : public Normalizer2WithImpl {
public:
    ComposeNormalizer2(const Normalizer2Impl &ni, UBool fcc) :
        Normalizer2WithImpl(ni), onlyContiguous(fcc) {}
    virtual ~ComposeNormalizer2();

private:
    virtual void
    normalize(const UChar *src, const UChar *limit,
              ReorderingBuffer &buffer, UErrorCode &errorCode) const {
        impl.compose(src, limit, onlyContiguous, TRUE, buffer, errorCode);
    }
    using Normalizer2WithImpl::normalize;  // Avoid warning about hiding base class function.
    virtual void
    normalizeAndAppend(const UChar *src, const UChar *limit, UBool doNormalize,
                       UnicodeString &safeMiddle,
                       ReorderingBuffer &buffer, UErrorCode &errorCode) const {
        impl.composeAndAppend(src, limit, doNormalize, onlyContiguous, safeMiddle, buffer, errorCode);
    }

    virtual UBool
    isNormalized(const UnicodeString &s, UErrorCode &errorCode) const {
        if(U_FAILURE(errorCode)) {
            return FALSE;
        }
        const UChar *sArray=s.getBuffer();
        if(sArray==NULL) {
            errorCode=U_ILLEGAL_ARGUMENT_ERROR;
            return FALSE;
        }
        UnicodeString temp;
        ReorderingBuffer buffer(impl, temp);
        if(!buffer.init(5, errorCode)) {  // small destCapacity for substring normalization
            return FALSE;
        }
        return impl.compose(sArray, sArray+s.length(), onlyContiguous, FALSE, buffer, errorCode);
    }
    virtual UNormalizationCheckResult
    quickCheck(const UnicodeString &s, UErrorCode &errorCode) const {
        if(U_FAILURE(errorCode)) {
            return UNORM_MAYBE;
        }
        const UChar *sArray=s.getBuffer();
        if(sArray==NULL) {
            errorCode=U_ILLEGAL_ARGUMENT_ERROR;
            return UNORM_MAYBE;
        }
        UNormalizationCheckResult qcResult=UNORM_YES;
        impl.composeQuickCheck(sArray, sArray+s.length(), onlyContiguous, &qcResult);
        return qcResult;
    }
    virtual const UChar *
    spanQuickCheckYes(const UChar *src, const UChar *limit, UErrorCode &) const {
        return impl.composeQuickCheck(src, limit, onlyContiguous, NULL);
    }
    using Normalizer2WithImpl::spanQuickCheckYes;  // Avoid warning about hiding base class function.
    virtual UNormalizationCheckResult getQuickCheck(UChar32 c) const {
        return impl.getCompQuickCheck(impl.getNorm16(c));
    }
    virtual UBool hasBoundaryBefore(UChar32 c) const {
        return impl.hasCompBoundaryBefore(c);
    }
    virtual UBool hasBoundaryAfter(UChar32 c) const {
        return impl.hasCompBoundaryAfter(c, onlyContiguous, FALSE);
    }
    virtual UBool isInert(UChar32 c) const {
        return impl.hasCompBoundaryAfter(c, onlyContiguous, TRUE);
    }

    const UBool onlyContiguous;
};

class FCDNormalizer2 : public Normalizer2WithImpl {
public:
    FCDNormalizer2(const Normalizer2Impl &ni) : Normalizer2WithImpl(ni) {}
    virtual ~FCDNormalizer2();

private:
    virtual void
    normalize(const UChar *src, const UChar *limit,
              ReorderingBuffer &buffer, UErrorCode &errorCode) const {
        impl.makeFCD(src, limit, &buffer, errorCode);
    }
    using Normalizer2WithImpl::normalize;  // Avoid warning about hiding base class function.
    virtual void
    normalizeAndAppend(const UChar *src, const UChar *limit, UBool doNormalize,
                       UnicodeString &safeMiddle,
                       ReorderingBuffer &buffer, UErrorCode &errorCode) const {
        impl.makeFCDAndAppend(src, limit, doNormalize, safeMiddle, buffer, errorCode);
    }
    virtual const UChar *
    spanQuickCheckYes(const UChar *src, const UChar *limit, UErrorCode &errorCode) const {
        return impl.makeFCD(src, limit, NULL, errorCode);
    }
    using Normalizer2WithImpl::spanQuickCheckYes;  // Avoid warning about hiding base class function.
    virtual UBool hasBoundaryBefore(UChar32 c) const { return impl.hasFCDBoundaryBefore(c); }
    virtual UBool hasBoundaryAfter(UChar32 c) const { return impl.hasFCDBoundaryAfter(c); }
    virtual UBool isInert(UChar32 c) const { return impl.isFCDInert(c); }
};

struct Norm2AllModes : public UMemory {
    Norm2AllModes(Normalizer2Impl *i)
            : impl(i), comp(*i, FALSE), decomp(*i), fcd(*i), fcc(*i, TRUE) {}
    ~Norm2AllModes();

    static Norm2AllModes *createInstance(Normalizer2Impl *impl, UErrorCode &errorCode);
    static Norm2AllModes *createNFCInstance(UErrorCode &errorCode);
    static Norm2AllModes *createInstance(const char *packageName,
                                         const char *name,
                                         UErrorCode &errorCode);

    static const Norm2AllModes *getNFCInstance(UErrorCode &errorCode);
    static const Norm2AllModes *getNFKCInstance(UErrorCode &errorCode);
    static const Norm2AllModes *getNFKC_CFInstance(UErrorCode &errorCode);

    Normalizer2Impl *impl;
    ComposeNormalizer2 comp;
    DecomposeNormalizer2 decomp;
    FCDNormalizer2 fcd;
    ComposeNormalizer2 fcc;
};

U_NAMESPACE_END

#endif  // !UCONFIG_NO_NORMALIZATION
#endif  // __NORM2ALLMODES_H__
Commit	Line	Data
f3c0d7a5 A	1	// © 2016 and later: Unicode, Inc. and others.
f3c0d7a5 A	2	// License & terms of use: http://www.unicode.org/copyright.html
b331163b A	3	/*
	4	*******************************************************************************
	5	* Copyright (C) 2014, International Business Machines
	6	* Corporation and others. All Rights Reserved.
	7	*******************************************************************************
	8	* loadednormalizer2impl.h
	9	*
	10	* created on: 2014sep07
	11	* created by: Markus W. Scherer
	12	*/
	13
	14	#ifndef __NORM2ALLMODES_H__
	15	#define __NORM2ALLMODES_H__
	16
	17	#include "unicode/utypes.h"
	18
	19	#if !UCONFIG_NO_NORMALIZATION
	20
	21	#include "unicode/normalizer2.h"
	22	#include "unicode/unistr.h"
	23	#include "cpputils.h"
	24	#include "normalizer2impl.h"
	25
	26	U_NAMESPACE_BEGIN
	27
	28	// Intermediate class:
	29	// Has Normalizer2Impl and does boilerplate argument checking and setup.
	30	class Normalizer2WithImpl : public Normalizer2 {
	31	public:
	32	Normalizer2WithImpl(const Normalizer2Impl &ni) : impl(ni) {}
	33	virtual ~Normalizer2WithImpl();
	34
	35	// normalize
	36	virtual UnicodeString &
	37	normalize(const UnicodeString &src,
	38	UnicodeString &dest,
	39	UErrorCode &errorCode) const {
	40	if(U_FAILURE(errorCode)) {
	41	dest.setToBogus();
	42	return dest;
	43	}
	44	const UChar *sArray=src.getBuffer();
	45	if(&dest==&src \|\| sArray==NULL) {
	46	errorCode=U_ILLEGAL_ARGUMENT_ERROR;
	47	dest.setToBogus();
	48	return dest;
	49	}
	50	dest.remove();
	51	ReorderingBuffer buffer(impl, dest);
	52	if(buffer.init(src.length(), errorCode)) {
	53	normalize(sArray, sArray+src.length(), buffer, errorCode);
	54	}
	55	return dest;
	56	}
	57	virtual void
	58	normalize(const UChar src, const UChar limit,
	59	ReorderingBuffer &buffer, UErrorCode &errorCode) const = 0;
	60
	61	// normalize and append
	62	virtual UnicodeString &
	63	normalizeSecondAndAppend(UnicodeString &first,
	64	const UnicodeString &second,
	65	UErrorCode &errorCode) const {
	66	return normalizeSecondAndAppend(first, second, TRUE, errorCode);
67	}
68	virtual UnicodeString &
69	append(UnicodeString &first,
70	const UnicodeString &second,
71	UErrorCode &errorCode) const {
72	return normalizeSecondAndAppend(first, second, FALSE, errorCode);
73	}
74	UnicodeString &
75	normalizeSecondAndAppend(UnicodeString &first,
76	const UnicodeString &second,
77	UBool doNormalize,
78	UErrorCode &errorCode) const {
79	uprv_checkCanGetBuffer(first, errorCode);
80	if(U_FAILURE(errorCode)) {
81	return first;
82	}
83	const UChar *secondArray=second.getBuffer();
84	if(&first==&second \|\| secondArray==NULL) {
85	errorCode=U_ILLEGAL_ARGUMENT_ERROR;
86	return first;
87	}
88	int32_t firstLength=first.length();
89	UnicodeString safeMiddle;
90	{
91	ReorderingBuffer buffer(impl, first);
92	if(buffer.init(firstLength+second.length(), errorCode)) {
93	normalizeAndAppend(secondArray, secondArray+second.length(), doNormalize,
94	safeMiddle, buffer, errorCode);
95	}
96	} // The ReorderingBuffer destructor finalizes the first string.
97	if(U_FAILURE(errorCode)) {
98	// Restore the modified suffix of the first string.
99	first.replace(firstLength-safeMiddle.length(), 0x7fffffff, safeMiddle);
100	}
101	return first;
102	}
103	virtual void
104	normalizeAndAppend(const UChar src, const UChar limit, UBool doNormalize,
105	UnicodeString &safeMiddle,
106	ReorderingBuffer &buffer, UErrorCode &errorCode) const = 0;
107	virtual UBool
108	getDecomposition(UChar32 c, UnicodeString &decomposition) const {
109	UChar buffer[4];
110	int32_t length;
111	const UChar *d=impl.getDecomposition(c, buffer, length);
112	if(d==NULL) {
113	return FALSE;
114	}
115	if(d==buffer) {
116	decomposition.setTo(buffer, length); // copy the string (Jamos from Hangul syllable c)
117	} else {
118	decomposition.setTo(FALSE, d, length); // read-only alias
119	}
120	return TRUE;
121	}
122	virtual UBool
123	getRawDecomposition(UChar32 c, UnicodeString &decomposition) const {
124	UChar buffer[30];
125	int32_t length;
126	const UChar *d=impl.getRawDecomposition(c, buffer, length);
127	if(d==NULL) {
128	return FALSE;
129	}
130	if(d==buffer) {
131	decomposition.setTo(buffer, length); // copy the string (algorithmic decomposition)
132	} else {
133	decomposition.setTo(FALSE, d, length); // read-only alias
134	}
135	return TRUE;
136	}
137	virtual UChar32
138	composePair(UChar32 a, UChar32 b) const {
139	return impl.composePair(a, b);
140	}
141
142	virtual uint8_t
143	getCombiningClass(UChar32 c) const {
144	return impl.getCC(impl.getNorm16(c));
145	}
146
147	// quick checks
148	virtual UBool
149	isNormalized(const UnicodeString &s, UErrorCode &errorCode) const {
150	if(U_FAILURE(errorCode)) {
151	return FALSE;
152	}
153	const UChar *sArray=s.getBuffer();
154	if(sArray==NULL) {
155	errorCode=U_ILLEGAL_ARGUMENT_ERROR;
156	return FALSE;
157	}
158	const UChar *sLimit=sArray+s.length();
159	return sLimit==spanQuickCheckYes(sArray, sLimit, errorCode);
160	}
161	virtual UNormalizationCheckResult
162	quickCheck(const UnicodeString &s, UErrorCode &errorCode) const {
163	return Normalizer2WithImpl::isNormalized(s, errorCode) ? UNORM_YES : UNORM_NO;
164	}
165	virtual int32_t
166	spanQuickCheckYes(const UnicodeString &s, UErrorCode &errorCode) const {
167	if(U_FAILURE(errorCode)) {
168	return 0;
169	}
170	const UChar *sArray=s.getBuffer();
171	if(sArray==NULL) {
172	errorCode=U_ILLEGAL_ARGUMENT_ERROR;
173	return 0;
174	}
175	return (int32_t)(spanQuickCheckYes(sArray, sArray+s.length(), errorCode)-sArray);
176	}
177	virtual const UChar *
178	spanQuickCheckYes(const UChar src, const UChar limit, UErrorCode &errorCode) const = 0;
179
180	virtual UNormalizationCheckResult getQuickCheck(UChar32) const {
181	return UNORM_YES;
182	}
183
184	const Normalizer2Impl &impl;
185	};
186
187	class DecomposeNormalizer2 : public Normalizer2WithImpl {
188	public:
189	DecomposeNormalizer2(const Normalizer2Impl &ni) : Normalizer2WithImpl(ni) {}
190	virtual ~DecomposeNormalizer2();
191
192	private:
193	virtual void
194	normalize(const UChar src, const UChar limit,
195	ReorderingBuffer &buffer, UErrorCode &errorCode) const {
196	impl.decompose(src, limit, &buffer, errorCode);
197	}
198	using Normalizer2WithImpl::normalize; // Avoid warning about hiding base class function.
199	virtual void
200	normalizeAndAppend(const UChar src, const UChar limit, UBool doNormalize,
201	UnicodeString &safeMiddle,
202	ReorderingBuffer &buffer, UErrorCode &errorCode) const {
203	impl.decomposeAndAppend(src, limit, doNormalize, safeMiddle, buffer, errorCode);
204	}
205	virtual const UChar *
206	spanQuickCheckYes(const UChar src, const UChar limit, UErrorCode &errorCode) const {
207	return impl.decompose(src, limit, NULL, errorCode);
208	}
209	using Normalizer2WithImpl::spanQuickCheckYes; // Avoid warning about hiding base class function.
210	virtual UNormalizationCheckResult getQuickCheck(UChar32 c) const {
211	return impl.isDecompYes(impl.getNorm16(c)) ? UNORM_YES : UNORM_NO;
212	}
213	virtual UBool hasBoundaryBefore(UChar32 c) const { return impl.hasDecompBoundary(c, TRUE); }
214	virtual UBool hasBoundaryAfter(UChar32 c) const { return impl.hasDecompBoundary(c, FALSE); }
215	virtual UBool isInert(UChar32 c) const { return impl.isDecompInert(c); }
216	};
217
218	class ComposeNormalizer2 : public Normalizer2WithImpl {
219	public:
220	ComposeNormalizer2(const Normalizer2Impl &ni, UBool fcc) :
221	Normalizer2WithImpl(ni), onlyContiguous(fcc) {}
222	virtual ~ComposeNormalizer2();
223
224	private:
225	virtual void
226	normalize(const UChar src, const UChar limit,
227	ReorderingBuffer &buffer, UErrorCode &errorCode) const {
228	impl.compose(src, limit, onlyContiguous, TRUE, buffer, errorCode);
229	}
230	using Normalizer2WithImpl::normalize; // Avoid warning about hiding base class function.
231	virtual void
232	normalizeAndAppend(const UChar src, const UChar limit, UBool doNormalize,
233	UnicodeString &safeMiddle,
234	ReorderingBuffer &buffer, UErrorCode &errorCode) const {
235	impl.composeAndAppend(src, limit, doNormalize, onlyContiguous, safeMiddle, buffer, errorCode);
236	}
237
238	virtual UBool
239	isNormalized(const UnicodeString &s, UErrorCode &errorCode) const {
240	if(U_FAILURE(errorCode)) {
241	return FALSE;
242	}
243	const UChar *sArray=s.getBuffer();
244	if(sArray==NULL) {
245	errorCode=U_ILLEGAL_ARGUMENT_ERROR;
246	return FALSE;
247	}
248	UnicodeString temp;
249	ReorderingBuffer buffer(impl, temp);
250	if(!buffer.init(5, errorCode)) { // small destCapacity for substring normalization
251	return FALSE;
252	}
253	return impl.compose(sArray, sArray+s.length(), onlyContiguous, FALSE, buffer, errorCode);
254	}
255	virtual UNormalizationCheckResult
256	quickCheck(const UnicodeString &s, UErrorCode &errorCode) const {
257	if(U_FAILURE(errorCode)) {
258	return UNORM_MAYBE;
259	}
260	const UChar *sArray=s.getBuffer();
261	if(sArray==NULL) {
262	errorCode=U_ILLEGAL_ARGUMENT_ERROR;
263	return UNORM_MAYBE;
264	}
265	UNormalizationCheckResult qcResult=UNORM_YES;
266	impl.composeQuickCheck(sArray, sArray+s.length(), onlyContiguous, &qcResult);
267	return qcResult;
268	}
269	virtual const UChar *
270	spanQuickCheckYes(const UChar src, const UChar limit, UErrorCode &) const {
271	return impl.composeQuickCheck(src, limit, onlyContiguous, NULL);
272	}
273	using Normalizer2WithImpl::spanQuickCheckYes; // Avoid warning about hiding base class function.
274	virtual UNormalizationCheckResult getQuickCheck(UChar32 c) const {
275	return impl.getCompQuickCheck(impl.getNorm16(c));
276	}
277	virtual UBool hasBoundaryBefore(UChar32 c) const {
278	return impl.hasCompBoundaryBefore(c);
279	}
280	virtual UBool hasBoundaryAfter(UChar32 c) const {
281	return impl.hasCompBoundaryAfter(c, onlyContiguous, FALSE);
282	}
283	virtual UBool isInert(UChar32 c) const {
284	return impl.hasCompBoundaryAfter(c, onlyContiguous, TRUE);
285	}
286
287	const UBool onlyContiguous;
288	};
289
290	class FCDNormalizer2 : public Normalizer2WithImpl {
291	public:
292	FCDNormalizer2(const Normalizer2Impl &ni) : Normalizer2WithImpl(ni) {}
293	virtual ~FCDNormalizer2();
294
295	private:
296	virtual void
297	normalize(const UChar src, const UChar limit,
298	ReorderingBuffer &buffer, UErrorCode &errorCode) const {
299	impl.makeFCD(src, limit, &buffer, errorCode);
300	}
301	using Normalizer2WithImpl::normalize; // Avoid warning about hiding base class function.
302	virtual void
303	normalizeAndAppend(const UChar src, const UChar limit, UBool doNormalize,
304	UnicodeString &safeMiddle,
305	ReorderingBuffer &buffer, UErrorCode &errorCode) const {
306	impl.makeFCDAndAppend(src, limit, doNormalize, safeMiddle, buffer, errorCode);
307	}
308	virtual const UChar *
309	spanQuickCheckYes(const UChar src, const UChar limit, UErrorCode &errorCode) const {
310	return impl.makeFCD(src, limit, NULL, errorCode);
311	}
312	using Normalizer2WithImpl::spanQuickCheckYes; // Avoid warning about hiding base class function.
313	virtual UBool hasBoundaryBefore(UChar32 c) const { return impl.hasFCDBoundaryBefore(c); }
314	virtual UBool hasBoundaryAfter(UChar32 c) const { return impl.hasFCDBoundaryAfter(c); }
315	virtual UBool isInert(UChar32 c) const { return impl.isFCDInert(c); }
316	};
317
318	struct Norm2AllModes : public UMemory {
319	Norm2AllModes(Normalizer2Impl *i)
320	: impl(i), comp(i, FALSE), decomp(i), fcd(i), fcc(i, TRUE) {}
321	~Norm2AllModes();
322
323	static Norm2AllModes createInstance(Normalizer2Impl impl, UErrorCode &errorCode);
324	static Norm2AllModes *createNFCInstance(UErrorCode &errorCode);
325	static Norm2AllModes createInstance(const char packageName,
326	const char *name,
327	UErrorCode &errorCode);
328
329	static const Norm2AllModes *getNFCInstance(UErrorCode &errorCode);
330	static const Norm2AllModes *getNFKCInstance(UErrorCode &errorCode);
331	static const Norm2AllModes *getNFKC_CFInstance(UErrorCode &errorCode);
332
333	Normalizer2Impl *impl;
334	ComposeNormalizer2 comp;
335	DecomposeNormalizer2 decomp;
336	FCDNormalizer2 fcd;
337	ComposeNormalizer2 fcc;
338	};
339
340	U_NAMESPACE_END
341
342	#endif // !UCONFIG_NO_NORMALIZATION
343	#endif // __NORM2ALLMODES_H__