ICU-2025 deprecate UnicodeFilterLogic

X-SVN-Rev: 9809

icu4c/source/common/unicode/unifilt.h

@@ -71,17 +71,6 @@ public:
      */
     virtual UnicodeMatcher* toMatcher() const;
 
-    /**
-     * UnicodeMatcher API.  This class stubs this out.
-     */
-    UnicodeString& toPattern(UnicodeString& result,
-                             UBool escapeUnprintable) const;
-
-    /**
-     * UnicodeMatcher API.  This class stubs this out.
-     */
-    UBool matchesIndexValue(uint8_t v) const;
-
     /**
      * Implement UnicodeMatcher API.
      */
@@ -109,13 +98,6 @@ public:
      */
     static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
 
-    /**
-     * Stubbed out implementation of UnicodeMatcher API.
-     * @param toUnionTo the set into which to union the source characters
-     * @return a reference to toUnionTo
-     */
-    virtual void addMatchSetTo(UnicodeSet& toUnionTo) const;
-
 protected:
 
     UnicodeFilter();

icu4c/source/common/unifilt.cpp

@@ -53,21 +53,6 @@ UMatchDegree UnicodeFilter::matches(const Replaceable& text,
     return U_MISMATCH;
 }
 
-// Stub this out for filters that do not implement a pattern
-UnicodeString& UnicodeFilter::toPattern(UnicodeString& result,
-                                        UBool escapeUnprintable) const {
-    return result;
-}
-
-// Stub this out for filters that do not implement indexing
-UBool UnicodeFilter::matchesIndexValue(uint8_t v) const {
-    return FALSE;
-}
-
-// Stub this out for filters that do not implement this
-void UnicodeFilter::addMatchSetTo(UnicodeSet& toUnionTo) const {
-}
-
 U_NAMESPACE_END
 
 //eof

icu4c/source/i18n/unicode/unifltlg.h

@@ -6,6 +6,15 @@
 *   11/17/99    aliu        Creation.
 **********************************************************************
 */
+
+//////////////////////////////////////////////////////////////
+//
+// NOTICE - Do not use
+//
+// This entire file has been deprecated as of ICU 2.4.
+//
+//////////////////////////////////////////////////////////////
+
 #ifndef UNIFLTLG_H
 #define UNIFLTLG_H
 
@@ -29,6 +38,8 @@ class UnicodeFilter;
  * Therefore, createNot(NULL) returns a filter that contains no
  * Unicode characters.  Likewise, createAnd(g, NULL) returns g->clone(),
  * and createAnd(NULL, NULL) returns NULL.
+ *
+ * @deprecated in ICU 2.4 2002-08/28.  Use UnicodeSet methods instead.
  */
 class U_I18N_API UnicodeFilterLogic /* not : public UObject because all methods are static */ {
 

icu4c/source/i18n/unifltlg.cpp

@@ -7,27 +7,52 @@
 *   11/17/99    aliu        Creation.
 **********************************************************************
 */
+
+//////////////////////////////////////////////////////////////
+//
+// NOTICE - Do not use
+//
+// This entire file has been deprecated as of ICU 2.4.
+//
+//////////////////////////////////////////////////////////////
+
 #include "unicode/unifltlg.h"
 #include "unicode/unifilt.h"
 
 U_NAMESPACE_BEGIN
 
+/**
+ * This class stubs out UnicodeMatcher API that we don't implement.
+ */
+class _UF: public UnicodeFilter {
+
+    // Stubs
+    virtual UnicodeString& toPattern(UnicodeString& result,
+                                     UBool escapeUnprintable) const {
+        return result;
+    }
+    virtual UBool matchesIndexValue(uint8_t v) const {
+        return FALSE;
+    }
+    virtual void addMatchSetTo(UnicodeSet& toUnionTo) const {}
+};
+
 /**
  * A NullFilter always returns a fixed value, either TRUE or FALSE.
  * A filter value of 0 (that is, a UnicodeFilter* f, where f == 0)
  * is equivalent to a NullFilter(TRUE).
  */
-class NullFilter : public UnicodeFilter {
+class NullFilter : public _UF {
     UBool result;
 public:
     NullFilter(UBool r) { result = r; }
-    NullFilter(const NullFilter& f) : UnicodeFilter(f) { result = f.result; }
+    NullFilter(const NullFilter& f) : _UF(f) { result = f.result; }
     virtual ~NullFilter() {}
     virtual UBool contains(UChar32 /*c*/) const { return result; }
     virtual UnicodeFunctor* clone() const { return new NullFilter(*this); }
 };
 
-class UnicodeNotFilter : public UnicodeFilter {
+class UnicodeNotFilter : public _UF {
     UnicodeFilter* filt;
 public:
     UnicodeNotFilter(UnicodeFilter* adopted);
@@ -39,7 +64,7 @@ public:
 
 UnicodeNotFilter::UnicodeNotFilter(UnicodeFilter* adopted) : filt(adopted) {}
 UnicodeNotFilter::UnicodeNotFilter(const UnicodeNotFilter& f)
- : UnicodeFilter(f), filt((UnicodeFilter*) f.filt->clone()) {}
+ : _UF(f), filt((UnicodeFilter*) f.filt->clone()) {}
 UnicodeNotFilter::~UnicodeNotFilter() { delete filt; }
 UBool UnicodeNotFilter::contains(UChar32 c) const { return !filt->contains(c); }
 UnicodeFunctor* UnicodeNotFilter::clone() const { return new UnicodeNotFilter(*this); }
@@ -56,7 +81,7 @@ UnicodeFilter* UnicodeFilterLogic::createNot(const UnicodeFilter* f) {
     }
 }
 
-class UnicodeAndFilter : public UnicodeFilter {
+class UnicodeAndFilter : public _UF {
     UnicodeFilter* filt1;
     UnicodeFilter* filt2;
 public:
@@ -69,7 +94,7 @@ public:
 
 UnicodeAndFilter::UnicodeAndFilter(UnicodeFilter* f1, UnicodeFilter* f2) : filt1(f1), filt2(f2) {}
 UnicodeAndFilter::UnicodeAndFilter(const UnicodeAndFilter& f)
- : UnicodeFilter(f), filt1((UnicodeFilter*)f.filt1->clone()), filt2((UnicodeFilter*)f.filt2->clone()) {}
+ : _UF(f), filt1((UnicodeFilter*)f.filt1->clone()), filt2((UnicodeFilter*)f.filt2->clone()) {}
 UnicodeAndFilter::~UnicodeAndFilter() { delete filt1; delete filt2; }
 UBool UnicodeAndFilter::contains(UChar32 c) const { return filt1->contains(c) && filt2->contains(c); }
 UnicodeFunctor* UnicodeAndFilter::clone() const { return new UnicodeAndFilter(*this); }
@@ -116,7 +141,7 @@ UnicodeFilter* UnicodeFilterLogic::createAdoptingAnd(UnicodeFilter* f,
     return new UnicodeAndFilter(f, g);
 }
 
-class UnicodeOrFilter : public UnicodeFilter {
+class UnicodeOrFilter : public _UF {
     UnicodeFilter* filt1;
     UnicodeFilter* filt2;
 public:
@@ -129,7 +154,7 @@ public:
 
 UnicodeOrFilter::UnicodeOrFilter(UnicodeFilter* f1, UnicodeFilter* f2) : filt1(f1), filt2(f2) {}
 UnicodeOrFilter::UnicodeOrFilter(const UnicodeOrFilter& f)
- : UnicodeFilter(f), filt1((UnicodeFilter*)f.filt1->clone()), filt2((UnicodeFilter*)f.filt2->clone()) {}
+ : _UF(f), filt1((UnicodeFilter*)f.filt1->clone()), filt2((UnicodeFilter*)f.filt2->clone()) {}
 UnicodeOrFilter::~UnicodeOrFilter() { delete filt1; delete filt2; }
 UBool UnicodeOrFilter::contains(UChar32 c) const { return filt1->contains(c) || filt2->contains(c); }
 UnicodeFunctor* UnicodeOrFilter::clone() const { return new UnicodeOrFilter(*this); }

icu4c/source/test/intltest/hxuntrts.cpp

@@ -64,6 +64,15 @@ class TestHexFilter : public UnicodeFilter {
        else
           return TRUE;
     }
+    // Stubs
+    virtual UnicodeString& toPattern(UnicodeString& result,
+                                     UBool escapeUnprintable) const {
+        return result;
+    }
+    virtual UBool matchesIndexValue(uint8_t v) const {
+        return FALSE;
+    }
+    virtual void addMatchSetTo(UnicodeSet& toUnionTo) const {}
 };
 void HexToUniTransliteratorTest::TestConstruction(){
     UErrorCode status=U_ZERO_ERROR;

icu4c/source/test/intltest/transapi.cpp

@@ -672,6 +672,15 @@ class TestFilter1 : public UnicodeFilter {
        else
           return TRUE;
     }
+    // Stubs
+    virtual UnicodeString& toPattern(UnicodeString& result,
+                                     UBool escapeUnprintable) const {
+        return result;
+    }
+    virtual UBool matchesIndexValue(uint8_t v) const {
+        return FALSE;
+    }
+    virtual void addMatchSetTo(UnicodeSet& toUnionTo) const {}
 };
 class TestFilter2 : public UnicodeFilter {
     virtual UnicodeFunctor* clone() const {
@@ -683,6 +692,15 @@ class TestFilter2 : public UnicodeFilter {
         else
            return TRUE;
     }
+    // Stubs
+    virtual UnicodeString& toPattern(UnicodeString& result,
+                                     UBool escapeUnprintable) const {
+        return result;
+    }
+    virtual UBool matchesIndexValue(uint8_t v) const {
+        return FALSE;
+    }
+    virtual void addMatchSetTo(UnicodeSet& toUnionTo) const {}
 };
 class TestFilter3 : public UnicodeFilter {
     virtual UnicodeFunctor* clone() const {
@@ -694,6 +712,15 @@ class TestFilter3 : public UnicodeFilter {
         else
            return TRUE;
     }
+    // Stubs
+    virtual UnicodeString& toPattern(UnicodeString& result,
+                                     UBool escapeUnprintable) const {
+        return result;
+    }
+    virtual UBool matchesIndexValue(uint8_t v) const {
+        return FALSE;
+    }
+    virtual void addMatchSetTo(UnicodeSet& toUnionTo) const {}
 };
 
 

icu4c/source/test/intltest/transtst.cpp

@@ -597,6 +597,15 @@ class TestFilter : public UnicodeFilter {
     virtual UBool contains(UChar32 c) const {
         return c != (UChar)0x0063 /*c*/;
     }
+    // Stubs
+    virtual UnicodeString& toPattern(UnicodeString& result,
+                                     UBool escapeUnprintable) const {
+        return result;
+    }
+    virtual UBool matchesIndexValue(uint8_t v) const {
+        return FALSE;
+    }
+    virtual void addMatchSetTo(UnicodeSet& toUnionTo) const {}
 };
 
 /**

icu4c/source/test/intltest/ufltlgts.cpp

@@ -41,6 +41,15 @@ class Filter1: public UnicodeFilter{
         else
             return TRUE;
     }
+    // Stubs
+    virtual UnicodeString& toPattern(UnicodeString& result,
+                                     UBool escapeUnprintable) const {
+        return result;
+    }
+    virtual UBool matchesIndexValue(uint8_t v) const {
+        return FALSE;
+    }
+    virtual void addMatchSetTo(UnicodeSet& toUnionTo) const {}
 };
 class Filter2: public UnicodeFilter{
     virtual UnicodeFunctor* clone() const{
@@ -52,6 +61,15 @@ class Filter2: public UnicodeFilter{
         else
             return TRUE;
     }
+    // Stubs
+    virtual UnicodeString& toPattern(UnicodeString& result,
+                                     UBool escapeUnprintable) const {
+        return result;
+    }
+    virtual UBool matchesIndexValue(uint8_t v) const {
+        return FALSE;
+    }
+    virtual void addMatchSetTo(UnicodeSet& toUnionTo) const {}
 };
 
 

icu4c/source/test/intltest/unhxtrts.cpp

@@ -77,6 +77,15 @@ class TestUniFilter : public UnicodeFilter {
        else
           return TRUE;
     }
+    // Stubs
+    virtual UnicodeString& toPattern(UnicodeString& result,
+                                     UBool escapeUnprintable) const {
+        return result;
+    }
+    virtual UBool matchesIndexValue(uint8_t v) const {
+        return FALSE;
+    }
+    virtual void addMatchSetTo(UnicodeSet& toUnionTo) const {}
 };
 void UniToHexTransliteratorTest::TestConstruction(){
     UErrorCode status=U_ZERO_ERROR;