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

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