| /* |
| ********************************************************************** |
| * Copyright (C) 1999, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ********************************************************************** |
| * Date Name Description |
| * 11/17/99 aliu Creation. |
| ********************************************************************** |
| */ |
| #include "unicode/unifltlg.h" |
| #include "unicode/unifilt.h" |
| |
| class UnicodeNotFilter : public UnicodeFilter { |
| UnicodeFilter* filt; |
| public: |
| UnicodeNotFilter(UnicodeFilter* adopted); |
| UnicodeNotFilter(const UnicodeNotFilter&); |
| virtual ~UnicodeNotFilter(); |
| virtual bool_t contains(UChar c) const; |
| virtual UnicodeFilter* clone() const; |
| }; |
| |
| UnicodeNotFilter::UnicodeNotFilter(UnicodeFilter* adopted) : filt(adopted) {} |
| UnicodeNotFilter::UnicodeNotFilter(const UnicodeNotFilter& f) : filt(f.filt->clone()) {} |
| UnicodeNotFilter::~UnicodeNotFilter() { delete filt; } |
| bool_t UnicodeNotFilter::contains(UChar c) const { return !filt->contains(c); } |
| UnicodeFilter* UnicodeNotFilter::clone() const { return new UnicodeNotFilter(*this); } |
| |
| /** |
| * Returns a <tt>UnicodeFilter</tt> that implements the inverse of |
| * the given filter. |
| */ |
| UnicodeFilter* UnicodeFilterLogic::createNot(const UnicodeFilter& f) { |
| return new UnicodeNotFilter(f.clone()); |
| } |
| |
| class UnicodeAndFilter : public UnicodeFilter { |
| UnicodeFilter* filt1; |
| UnicodeFilter* filt2; |
| public: |
| UnicodeAndFilter(UnicodeFilter* adopted1, UnicodeFilter* adopted2); |
| UnicodeAndFilter(const UnicodeAndFilter&); |
| virtual ~UnicodeAndFilter(); |
| virtual bool_t contains(UChar c) const; |
| virtual UnicodeFilter* clone() const; |
| }; |
| |
| UnicodeAndFilter::UnicodeAndFilter(UnicodeFilter* f1, UnicodeFilter* f2) : filt1(f1), filt2(f2) {} |
| UnicodeAndFilter::UnicodeAndFilter(const UnicodeAndFilter& f) : |
| filt1(f.filt1->clone()), filt2(f.filt2->clone()) {} |
| UnicodeAndFilter::~UnicodeAndFilter() { delete filt1; delete filt2; } |
| bool_t UnicodeAndFilter::contains(UChar c) const { return filt1->contains(c) && filt2->contains(c); } |
| UnicodeFilter* UnicodeAndFilter::clone() const { return new UnicodeAndFilter(*this); } |
| |
| /** |
| * Returns a <tt>UnicodeFilter</tt> that implements a short |
| * circuit AND of the result of the two given filters. That is, |
| * if <tt>f.contains()</tt> is <tt>false</tt>, then <tt>g.contains()</tt> |
| * is not called, and <tt>contains()</tt> returns <tt>false</tt>. |
| * |
| * <p>Either <tt>f</tt> or <tt>g</tt> must be non-null. |
| */ |
| UnicodeFilter* UnicodeFilterLogic::createAnd(const UnicodeFilter& f, |
| const UnicodeFilter& g) { |
| return new UnicodeAndFilter(f.clone(), g.clone()); |
| } |
| |
| /** |
| * Returns a <tt>UnicodeFilter</tt> that implements a short |
| * circuit AND of the result of the given filters. That is, if |
| * <tt>f[i].contains()</tt> is <tt>false</tt>, then |
| * <tt>f[j].contains()</tt> is not called, where <tt>j > i</tt>, and |
| * <tt>contains()</tt> returns <tt>false</tt>. |
| */ |
| //!UnicodeFilter* UnicodeFilterLogic::and(const UnicodeFilter** f) { |
| //! return new UnicodeFilter() { |
| //! public bool_t contains(UChar c) { |
| //! for (int32_t i=0; i<f.length; ++i) { |
| //! if (!f[i].contains(c)) { |
| //! return FALSE; |
| //! } |
| //! } |
| //! return TRUE; |
| //! } |
| //! }; |
| //!} |
| |
| class UnicodeOrFilter : public UnicodeFilter { |
| UnicodeFilter* filt1; |
| UnicodeFilter* filt2; |
| public: |
| UnicodeOrFilter(UnicodeFilter* adopted1, UnicodeFilter* adopted2); |
| UnicodeOrFilter(const UnicodeOrFilter&); |
| virtual ~UnicodeOrFilter(); |
| virtual bool_t contains(UChar c) const; |
| virtual UnicodeFilter* clone() const; |
| }; |
| |
| UnicodeOrFilter::UnicodeOrFilter(UnicodeFilter* f1, UnicodeFilter* f2) : filt1(f1), filt2(f2) {} |
| UnicodeOrFilter::UnicodeOrFilter(const UnicodeOrFilter& f) : |
| filt1(f.filt1->clone()), filt2(f.filt2->clone()) {} |
| UnicodeOrFilter::~UnicodeOrFilter() { delete filt1; delete filt2; } |
| bool_t UnicodeOrFilter::contains(UChar c) const { return filt1->contains(c) || filt2->contains(c); } |
| UnicodeFilter* UnicodeOrFilter::clone() const { return new UnicodeOrFilter(*this); } |
| |
| /** |
| * Returns a <tt>UnicodeFilter</tt> that implements a short |
| * circuit OR of the result of the two given filters. That is, if |
| * <tt>f.contains()</tt> is <tt>true</tt>, then <tt>g.contains()</tt> is |
| * not called, and <tt>contains()</tt> returns <tt>true</tt>. |
| * |
| * <p>Either <tt>f</tt> or <tt>g</tt> must be non-null. |
| */ |
| UnicodeFilter* UnicodeFilterLogic::createOr(const UnicodeFilter& f, |
| const UnicodeFilter& g) { |
| return new UnicodeOrFilter(f.clone(), g.clone()); |
| } |
| |
| /** |
| * Returns a <tt>UnicodeFilter</tt> that implements a short |
| * circuit OR of the result of the given filters. That is, if |
| * <tt>f[i].contains()</tt> is <tt>false</tt>, then |
| * <tt>f[j].contains()</tt> is not called, where <tt>j > i</tt>, and |
| * <tt>contains()</tt> returns <tt>true</tt>. |
| */ |
| //!UnicodeFilter* UnicodeFilterLogic::or(const UnicodeFilter** f) { |
| //! return new UnicodeFilter() { |
| //! public bool_t contains(UChar c) { |
| //! for (int32_t i=0; i<f.length; ++i) { |
| //! if (f[i].contains(c)) { |
| //! return TRUE; |
| //! } |
| //! } |
| //! return FALSE; |
| //! } |
| //! }; |
| //!} |
| |
| // TODO: Add nand() & nor() for convenience, if needed. |