/// <summary>
 /// Adds each of the characters in this string to the set. Thus "ch" =&gt; {"c", "h"}
 /// If this set already any particular character, it has no effect on that character.
 /// </summary>
 /// <param name="set">This set.</param>
 /// <param name="s">The source string.</param>
 /// <returns>this object, for chaining.</returns>
 /// <draft>ICU4N 60.1</draft>
 /// <provisional>This API might change or be removed in a future release.</provisional>
 public static UnicodeSet AddAll(this UnicodeSet set, string s)
 {
     if (set == null)
     {
         throw new ArgumentNullException(nameof(set));
     }
     return(set.AddAll(s));
 }
Beispiel #2
0
 /// <summary>
 /// Complements in this set all elements contained in the specified
 /// set.  Any character in the other set will be removed if it is
 /// in this set, or will be added if it is not in this set.
 /// </summary>
 /// <param name="c">Set that defines which elements will be complemented from
 /// this set.</param>
 /// <draft>ICU4N 60.1</draft>
 /// <provisional>This API might change or be removed in a future release.</provisional>
 public virtual UnicodeSet SymmetricExceptWith(UnicodeSet c)
 {
     if (c == null)
     {
         throw new ArgumentNullException(nameof(c));
     }
     return(ComplementAll(c));
 }
Beispiel #3
0
        /// <seealso cref="UnicodeSet.AddAll(UnicodeSet)"/>
        /// <draft>ICU4N 60.1</draft>
        /// <provisional>This API might change or be removed in a future release.</provisional>
        // See ticket #11395, this is safe.

        public static UnicodeSet AddAll(this UnicodeSet set, params string[] collection)
        {
            if (set == null)
            {
                throw new ArgumentNullException(nameof(set));
            }
            return(set.AddAll(collection));
        }
Beispiel #4
0
 /// <summary>
 /// Returns true if this set contains all the characters and strings
 /// of the given set.
 /// </summary>
 /// <param name="b">Set to be checked for containment.</param>
 /// <returns>true if the test condition is met.</returns>
 /// <draft>ICU4N 60.1</draft>
 /// <provisional>This API might change or be removed in a future release.</provisional>
 public virtual bool IsSupersetOf(UnicodeSet b)
 {
     if (b == null)
     {
         throw new ArgumentNullException(nameof(b));
     }
     return(ContainsAll(b));
 }
Beispiel #5
0
 /// <summary>
 /// Complement EACH of the characters in this string. Note: "ch" == {"c", "h"}
 /// If this set already any particular character, it has no effect on that character.
 /// </summary>
 /// <param name="set">This set.</param>
 /// <param name="s">The source string.</param>
 /// <returns>This object, for chaining.</returns>
 /// <draft>ICU4N 60.1</draft>
 /// <provisional>This API might change or be removed in a future release.</provisional>
 public static UnicodeSet ComplementAll(this UnicodeSet set, StringBuilder s)
 {
     if (set == null)
     {
         throw new ArgumentNullException(nameof(set));
     }
     return(set.ComplementAll(s));
 }
 /// <seealso cref="UnicodeSet.RetainAll(UnicodeSet)"/>
 /// <draft>ICU4N 60.1</draft>
 /// <provisional>This API might change or be removed in a future release.</provisional>
 public static UnicodeSet RetainAll <T>(this UnicodeSet set, IEnumerable <T> collection) where T : ICharSequence
 {
     if (set == null)
     {
         throw new ArgumentNullException(nameof(set));
     }
     return(set.RetainAll(collection));
 }
 /// <summary>
 /// Retains EACH of the characters in this string. Note: "ch" == {"c", "h"}
 /// If this set already any particular character, it has no effect on that character.
 /// </summary>
 /// <param name="set">This set.</param>
 /// <param name="s">The source string.</param>
 /// <returns>This object, for chaining.</returns>
 /// <draft>ICU4N 60.1</draft>
 /// <provisional>This API might change or be removed in a future release.</provisional>
 public static UnicodeSet RetainAll(this UnicodeSet set, ICharSequence s)
 {
     if (set == null)
     {
         throw new ArgumentNullException(nameof(set));
     }
     return(set.RetainAll(s));
 }
Beispiel #8
0
 /// <summary>
 /// Complement the specified string in this set.
 /// The set will not contain the specified string once the call
 /// returns.
 /// <para/>
 /// <b>Warning: you cannot add an empty string ("") to a UnicodeSet.</b>
 /// </summary>
 /// <param name="set">This set.</param>
 /// <param name="s">The string to complement.</param>
 /// <returns>This object, for chaining.</returns>
 /// <draft>ICU4N 60.1</draft>
 /// <provisional>This API might change or be removed in a future release.</provisional>
 public static UnicodeSet Complement(this UnicodeSet set, char[] s)
 {
     if (set == null)
     {
         throw new ArgumentNullException(nameof(set));
     }
     return(set.Complement(s));
 }
 /// <seealso cref="UnicodeSet.RetainAll(UnicodeSet)"/>
 /// <draft>ICU4N 60.1</draft>
 /// <provisional>This API might change or be removed in a future release.</provisional>
 public static UnicodeSet RetainAll(this UnicodeSet set, IEnumerable <char[]> collection)
 {
     if (set == null)
     {
         throw new ArgumentNullException(nameof(set));
     }
     return(set.RetainAll(collection));
 }
 /// <seealso cref="UnicodeSet.ContainsSome(UnicodeSet)"/>
 /// <draft>ICU4N 60.1</draft>
 /// <provisional>This API might change or be removed in a future release.</provisional>
 public static bool ContainsSome(this UnicodeSet set, IEnumerable <char[]> collection)
 {
     if (set == null)
     {
         throw new ArgumentNullException(nameof(set));
     }
     return(set.ContainsSome(collection));
 }
 /// <seealso cref="UnicodeSet.RemoveAll(UnicodeSet)"/>
 /// <draft>ICU4N 60.1</draft>
 /// <provisional>This API might change or be removed in a future release.</provisional>
 public static UnicodeSet RemoveAll(this UnicodeSet set, IEnumerable <StringBuilder> collection)
 {
     if (set == null)
     {
         throw new ArgumentNullException(nameof(set));
     }
     return(set.RemoveAll(collection));
 }
 /// <summary>
 /// Returns true if this set contains one or more of the characters
 /// of the given string.
 /// </summary>
 /// <param name="set">This set.</param>
 /// <param name="s">String containing characters to be checked for containment.</param>
 /// <returns>true if the condition is met.</returns>
 /// <draft>ICU4N 60.1</draft>
 /// <provisional>This API might change or be removed in a future release.</provisional>
 public static bool ContainsSome(this UnicodeSet set, StringBuilder s)
 {
     if (set == null)
     {
         throw new ArgumentNullException(nameof(set));
     }
     return(set.ContainsSome(s));
 }
 /// <summary>
 /// Returns true if this set contains one or more of the characters
 /// of the given string.
 /// </summary>
 /// <param name="set">This set.</param>
 /// <param name="s">String containing characters to be checked for containment.</param>
 /// <returns>true if the condition is met.</returns>
 /// <draft>ICU4N 60.1</draft>
 /// <provisional>This API might change or be removed in a future release.</provisional>
 public static bool ContainsSome(this UnicodeSet set, ICharSequence s)
 {
     if (set == null)
     {
         throw new ArgumentNullException(nameof(set));
     }
     return(set.ContainsSome(s));
 }
Beispiel #14
0
 /// <summary>
 /// Adds all of the elements in the specified set to this set if
 /// they're not already present.  This operation effectively
 /// modifies this set so that its value is the <i>union</i> of the two
 /// sets.  The behavior of this operation is unspecified if the specified
 /// collection is modified while the operation is in progress.
 /// </summary>
 /// <param name="c">Set whose elements are to be added to this set.</param>
 /// <draft>ICU4N 60.1</draft>
 /// <provisional>This API might change or be removed in a future release.</provisional>
 public virtual UnicodeSet UnionWith(UnicodeSet c)
 {
     if (c == null)
     {
         throw new ArgumentNullException(nameof(c));
     }
     return(AddAll(c));
 }
Beispiel #15
0
 /// <summary>
 /// Retains only the elements in this set that are contained in the
 /// specified set.  In other words, removes from this set all of
 /// its elements that are not contained in the specified set.  This
 /// operation effectively modifies this set so that its value is
 /// the <i>intersection</i> of the two sets.
 /// </summary>
 /// <param name="c">Set that defines which elements this set will retain.</param>
 /// <stable>ICU 2.0</stable>
 public virtual UnicodeSet IntersectWith(UnicodeSet c)
 {
     if (c == null)
     {
         throw new ArgumentNullException(nameof(c));
     }
     return(RetainAll(c));
 }
Beispiel #16
0
 /// <summary>
 /// Returns true if this set contains one or more of the characters
 /// and strings of the given set.
 /// </summary>
 /// <param name="s">Set to be checked for containment.</param>
 /// <returns>True if the condition is met.</returns>
 /// <draft>ICU4N 60.1</draft>
 /// <provisional>This API might change or be removed in a future release.</provisional>
 public bool Overlaps(UnicodeSet s)
 {
     if (s == null)
     {
         throw new ArgumentNullException(nameof(s));
     }
     return(ContainsSome(s));
 }
Beispiel #17
0
 /// <summary>
 /// Complement the specified string in this set.
 /// The set will not contain the specified string once the call
 /// returns.
 /// <para/>
 /// <b>Warning: you cannot add an empty string ("") to a UnicodeSet.</b>
 /// </summary>
 /// <param name="set">This set.</param>
 /// <param name="s">The string to complement.</param>
 /// <returns>This object, for chaining.</returns>
 /// <draft>ICU4N 60.1</draft>
 /// <provisional>This API might change or be removed in a future release.</provisional>
 internal static UnicodeSet Complement(this UnicodeSet set, ICharSequence s)
 {
     if (set == null)
     {
         throw new ArgumentNullException(nameof(set));
     }
     return(set.Complement(s));
 }
 /// <summary>
 /// Retain the specified string in this set if it is present.
 /// Upon return this set will be empty if it did not contain <paramref name="cs"/>, or
 /// will only contain <paramref name="cs"/> if it did contain <paramref name="cs"/>.
 /// </summary>
 /// <param name="set">This set.</param>
 /// <param name="cs">The string to be retained.</param>
 /// <returns>This object, for chaining.</returns>
 /// <draft>ICU4N 60.1</draft>
 /// <provisional>This API might change or be removed in a future release.</provisional>
 public static UnicodeSet Retain(this UnicodeSet set, char[] cs)
 {
     if (set == null)
     {
         throw new ArgumentNullException(nameof(set));
     }
     return(set.Retain(cs));
 }
Beispiel #19
0
 /// <summary>
 /// Union the set of all characters that may output by this object
 /// into the given set.
 /// </summary>
 /// <param name="toUnionTo">The set into which to union the output characters.</param>
 public virtual void AddReplacementSetTo(UnicodeSet toUnionTo)
 {
     // The output of this replacer varies; it is the source text between
     // matchStart and matchLimit.  Since this varies depending on the
     // input text, we can't compute it here.  We can either do nothing
     // or we can add ALL characters to the set.  It's probably more useful
     // to do nothing.
 }
Beispiel #20
0
 public CompoundRBTEntry(string theID, IList <string> theIDBlockVector,
                         IList <Data> theDataVector,
                         UnicodeSet theCompoundFilter)
 {
     id             = theID;
     idBlockVector  = theIDBlockVector;
     dataVector     = theDataVector;
     compoundFilter = theCompoundFilter;
 }
Beispiel #21
0
        /// <summary>
        /// Determines whether a <see cref="UnicodeSet"/> object is a subset of the specified <see cref="UnicodeSet"/>.
        /// </summary>
        /// <param name="other">The collection to compare to the current <see cref="UnicodeSet"/> object.</param>
        /// <returns>true if the <see cref="UnicodeSet"/> object is a subset of other; otherwise, false.</returns>
        /// <draft>ICU4N 60.1</draft>
        /// <provisional>This API might change or be removed in a future release.</provisional>
        public virtual bool IsSubsetOf(UnicodeSet other)
        {
            if (other == null)
            {
                throw new ArgumentNullException(nameof(other));
            }

            return(IsSubsetOfInternal(other));
        }
Beispiel #22
0
        /// <summary>
        /// Temporary hack for registry problem. Needs to be replaced by better architecture.
        /// </summary>
        public virtual Transliterator SafeClone()
        {
            UnicodeFilter filter = Filter;

            if (filter != null && filter is UnicodeSet)
            {
                filter = new UnicodeSet((UnicodeSet)filter);
            }
            return(new AnyTransliterator(ID, filter, target, targetScript, widthFix, cache));
        }
Beispiel #23
0
        /// <summary>
        /// Temporary hack for registry problem. Needs to be replaced by better architecture.
        /// </summary>
        public virtual Transliterator SafeClone()
        {
            UnicodeFilter filter = Filter;

            if (filter != null && filter is UnicodeSet)
            {
                filter = new UnicodeSet((UnicodeSet)filter);
            }
            return(new CompoundTransliterator(ID, filter, trans, numAnonymousRBTs));
        }
        public Transliterator SafeClone()
        {
            UnicodeFilter filter = Filter;

            if (filter != null && filter is UnicodeSet)
            {
                filter = new UnicodeSet((UnicodeSet)filter);
            }
            return(new RuleBasedTransliterator(ID, data, filter));
        }
Beispiel #25
0
        /// <seealso cref="Transliterator.AddSourceTargetSet(UnicodeSet, UnicodeSet, UnicodeSet)"/>
        public override void AddSourceTargetSet(UnicodeSet inputFilter, UnicodeSet sourceSet, UnicodeSet targetSet)
        {
            UnicodeSet myFilter = GetFilterAsUnicodeSet(inputFilter);

            // Doesn't actually modify the source characters, so leave them alone.
            // add the characters inserted
            if (myFilter.Count != 0)
            {
                targetSet.AddAll(insertion);
            }
        }
Beispiel #26
0
        //
        //  RBBISymbolTable::lookupMatcher   This function from the abstract symbol table
        //                                   interface maps a single stand-in character to a
        //                                   pointer to a Unicode Set.   The Unicode Set code uses this
        //                                   mechanism to get all references to the same $variable
        //                                   name to refer to a single common Unicode Set instance.
        //
        //    This implementation cheats a little, and does not maintain a map of stand-in chars
        //    to sets.  Instead, it takes advantage of the fact that  the UnicodeSet
        //    constructor will always call this function right after calling lookup(),
        //    and we just need to remember what set to return between these two calls.
        public virtual IUnicodeMatcher LookupMatcher(int ch)
        {
            UnicodeSet retVal = null;

            if (ch == 0xffff)
            {
                retVal           = fCachedSetLookup;
                fCachedSetLookup = null;
            }
            return(retVal);
        }
            public CompoundRBTEntry(string theID, IList <string> theIDBlockVector,
#pragma warning disable 612, 618
                                    IList <Data> theDataVector,
#pragma warning restore 612, 618
                                    UnicodeSet theCompoundFilter)
            {
                id             = theID;
                idBlockVector  = theIDBlockVector;
                dataVector     = theDataVector;
                compoundFilter = theCompoundFilter;
            }
Beispiel #28
0
 private bool IsSubsetOfInternal(UnicodeSet other)
 {
     foreach (var item in this)
     {
         if (!other.Contains(item))
         {
             return(false);
         }
     }
     return(true);
 }
Beispiel #29
0
        /// <seealso cref="Transliterator.AddSourceTargetSet(UnicodeSet, UnicodeSet, UnicodeSet)"/>
        public override void AddSourceTargetSet(UnicodeSet inputFilter, UnicodeSet sourceSet, UnicodeSet targetSet)
        {
            UnicodeSet myFilter = GetFilterAsUnicodeSet(inputFilter);

            // Assume that it can modify any character to any other character
            sourceSet.AddAll(myFilter);
            if (myFilter.Count != 0)
            {
                targetSet.AddAll(0, 0x10FFFF);
            }
        }
Beispiel #30
0
        // TODO Handle the case where we have :: [a] ; a > |b ; b > c ;
        // TODO Merge into r.addSourceTargetSet, to avoid duplicate testing
        internal virtual void AddSourceTargetSet(UnicodeSet filter, UnicodeSet sourceSet, UnicodeSet targetSet)
        {
            UnicodeSet currentFilter = new UnicodeSet(filter);
            UnicodeSet revisiting    = new UnicodeSet();
            int        count         = ruleVector.Count;

            for (int i = 0; i < count; ++i)
            {
                TransliterationRule r = ruleVector[i];
                r.AddSourceTargetSet(currentFilter, sourceSet, targetSet, revisiting.Clear());
                currentFilter.AddAll(revisiting);
            }
        }