2
**********************************************************************
3
* Copyright (C) 1999-2001, International Business Machines
4
* Corporation and others. All Rights Reserved.
5
**********************************************************************
6
* Date Name Description
7
* 11/17/99 aliu Creation.
8
**********************************************************************
10
#include "unicode/unifltlg.h"
11
#include "unicode/unifilt.h"
16
* A NullFilter always returns a fixed value, either TRUE or FALSE.
17
* A filter value of 0 (that is, a UnicodeFilter* f, where f == 0)
18
* is equivalent to a NullFilter(TRUE).
20
class NullFilter : public UnicodeFilter {
23
NullFilter(UBool r) { result = r; }
24
NullFilter(const NullFilter& f) : UnicodeFilter(f) { result = f.result; }
25
virtual ~NullFilter() {}
26
virtual UBool contains(UChar32 /*c*/) const { return result; }
27
virtual UnicodeFunctor* clone() const { return new NullFilter(*this); }
30
class UnicodeNotFilter : public UnicodeFilter {
33
UnicodeNotFilter(UnicodeFilter* adopted);
34
UnicodeNotFilter(const UnicodeNotFilter&);
35
virtual ~UnicodeNotFilter();
36
virtual UBool contains(UChar32 c) const;
37
virtual UnicodeFunctor* clone() const;
40
UnicodeNotFilter::UnicodeNotFilter(UnicodeFilter* adopted) : filt(adopted) {}
41
UnicodeNotFilter::UnicodeNotFilter(const UnicodeNotFilter& f)
42
: UnicodeFilter(f), filt((UnicodeFilter*) f.filt->clone()) {}
43
UnicodeNotFilter::~UnicodeNotFilter() { delete filt; }
44
UBool UnicodeNotFilter::contains(UChar32 c) const { return !filt->contains(c); }
45
UnicodeFunctor* UnicodeNotFilter::clone() const { return new UnicodeNotFilter(*this); }
48
* Returns a <tt>UnicodeFilter</tt> that implements the inverse of
51
UnicodeFilter* UnicodeFilterLogic::createNot(const UnicodeFilter* f) {
53
return new NullFilter(FALSE);
55
return new UnicodeNotFilter((UnicodeFilter*)f->clone());
59
class UnicodeAndFilter : public UnicodeFilter {
63
UnicodeAndFilter(UnicodeFilter* adopted1, UnicodeFilter* adopted2);
64
UnicodeAndFilter(const UnicodeAndFilter&);
65
virtual ~UnicodeAndFilter();
66
virtual UBool contains(UChar32 c) const;
67
virtual UnicodeFunctor* clone() const;
70
UnicodeAndFilter::UnicodeAndFilter(UnicodeFilter* f1, UnicodeFilter* f2) : filt1(f1), filt2(f2) {}
71
UnicodeAndFilter::UnicodeAndFilter(const UnicodeAndFilter& f)
72
: UnicodeFilter(f), filt1((UnicodeFilter*)f.filt1->clone()), filt2((UnicodeFilter*)f.filt2->clone()) {}
73
UnicodeAndFilter::~UnicodeAndFilter() { delete filt1; delete filt2; }
74
UBool UnicodeAndFilter::contains(UChar32 c) const { return filt1->contains(c) && filt2->contains(c); }
75
UnicodeFunctor* UnicodeAndFilter::clone() const { return new UnicodeAndFilter(*this); }
78
* Returns a <tt>UnicodeFilter</tt> that implements a short
79
* circuit AND of the result of the two given filters. That is,
80
* if <tt>f.contains()</tt> is <tt>false</tt>, then <tt>g.contains()</tt>
81
* is not called, and <tt>contains()</tt> returns <tt>false</tt>.
83
UnicodeFilter* UnicodeFilterLogic::createAnd(const UnicodeFilter* f,
84
const UnicodeFilter* g) {
89
return (UnicodeFilter*)g->clone();
92
return (UnicodeFilter*)f->clone();
94
return new UnicodeAndFilter((UnicodeFilter*)f->clone(), (UnicodeFilter*)g->clone());
98
* Returns a <tt>UnicodeFilter</tt> that implements a short
99
* circuit AND of the result of the two given filters. That is,
100
* if <tt>f.contains()</tt> is <tt>false</tt>, then <tt>g.contains()</tt>
101
* is not called, and <tt>contains()</tt> returns <tt>false</tt>.
103
* ADOPTS both arguments.
105
UnicodeFilter* UnicodeFilterLogic::createAdoptingAnd(UnicodeFilter* f,
116
return new UnicodeAndFilter(f, g);
119
class UnicodeOrFilter : public UnicodeFilter {
120
UnicodeFilter* filt1;
121
UnicodeFilter* filt2;
123
UnicodeOrFilter(UnicodeFilter* adopted1, UnicodeFilter* adopted2);
124
UnicodeOrFilter(const UnicodeOrFilter&);
125
virtual ~UnicodeOrFilter();
126
virtual UBool contains(UChar32 c) const;
127
virtual UnicodeFunctor* clone() const;
130
UnicodeOrFilter::UnicodeOrFilter(UnicodeFilter* f1, UnicodeFilter* f2) : filt1(f1), filt2(f2) {}
131
UnicodeOrFilter::UnicodeOrFilter(const UnicodeOrFilter& f)
132
: UnicodeFilter(f), filt1((UnicodeFilter*)f.filt1->clone()), filt2((UnicodeFilter*)f.filt2->clone()) {}
133
UnicodeOrFilter::~UnicodeOrFilter() { delete filt1; delete filt2; }
134
UBool UnicodeOrFilter::contains(UChar32 c) const { return filt1->contains(c) || filt2->contains(c); }
135
UnicodeFunctor* UnicodeOrFilter::clone() const { return new UnicodeOrFilter(*this); }
138
* Returns a <tt>UnicodeFilter</tt> that implements a short
139
* circuit OR of the result of the two given filters. That is, if
140
* <tt>f.contains()</tt> is <tt>true</tt>, then <tt>g.contains()</tt> is
141
* not called, and <tt>contains()</tt> returns <tt>true</tt>.
143
UnicodeFilter* UnicodeFilterLogic::createOr(const UnicodeFilter* f,
144
const UnicodeFilter* g) {
149
return (UnicodeFilter*)g->clone();
152
return (UnicodeFilter*)f->clone();
154
return new UnicodeOrFilter((UnicodeFilter*)f->clone(), (UnicodeFilter*)g->clone());