← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/icu/gutsy-updates

« back to all changes in this revision

Viewing changes to source/i18n/unifltlg.cpp

  • Committer: Package Import Robot
  • Author(s): Jay Berkenbilt
  • Date: 2005-11-19 11:29:31 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20051119112931-vcizkrp10tli4enw
Tags: 3.4-3
Explicitly build with g++ 3.4.  The current ICU fails its test suite
with 4.0 but not with 3.4.  Future versions should work properly with
4.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/i18n/unifltlg.cpp
1
 
/*
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
 
**********************************************************************
9
 
*/
10
 
#include "unicode/unifltlg.h"
11
 
#include "unicode/unifilt.h"
12
 
 
13
 
U_NAMESPACE_BEGIN
14
 
 
15
 
/**
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).
19
 
 */
20
 
class NullFilter : public UnicodeFilter {
21
 
    UBool result;
22
 
public:
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); }
28
 
};
29
 
 
30
 
class UnicodeNotFilter : public UnicodeFilter {
31
 
    UnicodeFilter* filt;
32
 
public:
33
 
    UnicodeNotFilter(UnicodeFilter* adopted);
34
 
    UnicodeNotFilter(const UnicodeNotFilter&);
35
 
    virtual ~UnicodeNotFilter();
36
 
    virtual UBool contains(UChar32 c) const;
37
 
    virtual UnicodeFunctor* clone() const;
38
 
};
39
 
 
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); }
46
 
 
47
 
/**
48
 
 * Returns a <tt>UnicodeFilter</tt> that implements the inverse of
49
 
 * the given filter.
50
 
 */
51
 
UnicodeFilter* UnicodeFilterLogic::createNot(const UnicodeFilter* f) {
52
 
    if (f == 0) {
53
 
        return new NullFilter(FALSE);
54
 
    } else {
55
 
        return new UnicodeNotFilter((UnicodeFilter*)f->clone());
56
 
    }
57
 
}
58
 
 
59
 
class UnicodeAndFilter : public UnicodeFilter {
60
 
    UnicodeFilter* filt1;
61
 
    UnicodeFilter* filt2;
62
 
public:
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;
68
 
};
69
 
 
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); }
76
 
 
77
 
/**
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>.
82
 
 */
83
 
UnicodeFilter* UnicodeFilterLogic::createAnd(const UnicodeFilter* f,
84
 
                                             const UnicodeFilter* g) {
85
 
    if (f == 0) {
86
 
        if (g == 0) {
87
 
            return NULL;
88
 
        }
89
 
        return (UnicodeFilter*)g->clone();
90
 
    }
91
 
    if (g == 0) {
92
 
        return (UnicodeFilter*)f->clone();
93
 
    }
94
 
    return new UnicodeAndFilter((UnicodeFilter*)f->clone(), (UnicodeFilter*)g->clone());
95
 
}
96
 
 
97
 
/**
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>.
102
 
 *
103
 
 * ADOPTS both arguments.
104
 
 */
105
 
UnicodeFilter* UnicodeFilterLogic::createAdoptingAnd(UnicodeFilter* f,
106
 
                                                     UnicodeFilter* g) {
107
 
    if (f == 0) {
108
 
        if (g == 0) {
109
 
            return NULL;
110
 
        }
111
 
        return g;
112
 
    }
113
 
    if (g == 0) {
114
 
        return f;
115
 
    }
116
 
    return new UnicodeAndFilter(f, g);
117
 
}
118
 
 
119
 
class UnicodeOrFilter : public UnicodeFilter {
120
 
    UnicodeFilter* filt1;
121
 
    UnicodeFilter* filt2;
122
 
public:
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;
128
 
};
129
 
 
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); }
136
 
 
137
 
/**
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>.
142
 
 */
143
 
UnicodeFilter* UnicodeFilterLogic::createOr(const UnicodeFilter* f,
144
 
                                            const UnicodeFilter* g) {
145
 
    if (f == 0) {
146
 
        if (g == 0) {
147
 
            return NULL;
148
 
        }
149
 
        return (UnicodeFilter*)g->clone();
150
 
    }
151
 
    if (g == 0) {
152
 
        return (UnicodeFilter*)f->clone();
153
 
    }
154
 
    return new UnicodeOrFilter((UnicodeFilter*)f->clone(), (UnicodeFilter*)g->clone());
155
 
}
156
 
 
157
 
U_NAMESPACE_END
158