org.apache.brooklyn.util.text.StringPredicates Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of brooklyn-utils-common Show documentation
Utility classes and methods developed for Brooklyn but not dependendent on Brooklyn or much else
There is a newer version: 1.1.0
Show newest version
/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.brooklyn.util.text;

import java.io.Serializable;
import java.util.Arrays;
import java.util.List;
import java.util.Set;

import javax.annotation.Nullable;

import org.apache.brooklyn.util.collections.MutableSet;
import org.apache.brooklyn.util.text.StringEscapes.JavaStringEscapes;

import com.google.common.base.Function;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;

public class StringPredicates {

    /** predicate form of {@link Strings#isBlank(CharSequence)} */
    public static  Predicate isBlank() {
        return new IsBlank();
    }

    private static final class IsBlank implements Predicate {
        @Override
        public boolean apply(@Nullable CharSequence input) {
            return Strings.isBlank(input);
        }

        @Override
        public String toString() {
            return "isBlank()";
        }
    }

    /** @deprecated since 0.7.0 kept only to allow conversion of anonymous inner classes */
    @SuppressWarnings("unused") @Deprecated 
    private static Predicate isBlankOld() {
        return new Predicate() {
            @Override
            public boolean apply(@Nullable CharSequence input) {
                return Strings.isBlank(input);
            }
            @Override
            public String toString() {
                return "isBlank";
            }
        };
    }


    /** Tests if object is non-null and not a blank string.
     * 
     * Predicate form of {@link Strings#isNonBlank(CharSequence)} also accepting objects non-null, for convenience */
    public static  Predicate isNonBlank() {
        return new IsNonBlank();
    }

    private static final class IsNonBlank implements Predicate {
        @Override
        public boolean apply(@Nullable Object input) {
            if (input==null) return false;
            if (!(input instanceof CharSequence)) return true;
            return Strings.isNonBlank((CharSequence)input);
        }

        @Override
        public String toString() {
            return "isNonBlank()";
        }
    }
    
    // -----------------
    
    public static  Predicate containsLiteralIgnoreCase(final String fragment) {
        return new ContainsLiteralIgnoreCase(fragment);
    }

    private static final class ContainsLiteralIgnoreCase implements Predicate {
        private final String fragment;

        private ContainsLiteralIgnoreCase(String fragment) {
            this.fragment = fragment;
        }

        @Override
        public boolean apply(@Nullable CharSequence input) {
            return Strings.containsLiteralIgnoreCase(input, fragment);
        }

        @Override
        public String toString() {
            return "containsLiteralCaseInsensitive("+JavaStringEscapes.wrapJavaString(fragment)+")";
        }
    }

    public static  Predicate containsLiteral(final String fragment) {
        return new ContainsLiteral(fragment);
    }
    
    private static final class ContainsLiteral implements Predicate {
        private final String fragment;

        private ContainsLiteral(String fragment) {
            this.fragment = fragment;
        }

        @Override
        public boolean apply(@Nullable CharSequence input) {
            return Strings.containsLiteral(input, fragment);
        }

        @Override
        public String toString() {
            return "containsLiteral("+JavaStringEscapes.wrapJavaString(fragment)+")";
        }
    }

    /** @deprecated since 0.7.0 kept only to allow conversion of anonymous inner classes */
    @SuppressWarnings("unused") @Deprecated 
    private static Predicate containsLiteralCaseInsensitiveOld(final String fragment) {
        return new Predicate() {
            @Override
            public boolean apply(@Nullable CharSequence input) {
                return Strings.containsLiteralIgnoreCase(input, fragment);
            }
            @Override
            public String toString() {
                return "containsLiteralCaseInsensitive("+fragment+")";
            }
        };
    }

    /** @deprecated since 0.7.0 kept only to allow conversion of anonymous inner classes */
    @SuppressWarnings("unused") @Deprecated 
    private static Predicate containsLiteralOld(final String fragment) {
        return new Predicate() {
            @Override
            public boolean apply(@Nullable CharSequence input) {
                return Strings.containsLiteral(input, fragment);
            }
            @Override
            public String toString() {
                return "containsLiteral("+fragment+")";
            }
        };
    }
    
    // -----------------
    
    public static  Predicate containsAllLiterals(final String... fragments) {
        List> fragmentPredicates = Lists.newArrayList();
        for (String fragment : fragments) {
            fragmentPredicates.add(containsLiteral(fragment));
        }
        return Predicates.and(fragmentPredicates);
    }

    /** @deprecated since 0.7.0 kept only to allow conversion of anonymous inner classes */
    @SuppressWarnings("unused") @Deprecated 
    private static Predicate containsAllLiteralsOld(final String... fragments) {
        return Predicates.and(Iterables.transform(Arrays.asList(fragments), new Function>() {
            @Override
            public Predicate apply(String input) {
                return containsLiteral(input);
            }
        }));
    }
    
    // -----------------

    public static Predicate containsRegex(final String regex) {
        // "Pattern" ... what a bad name :)
        return Predicates.containsPattern(regex);
    }

    // -----------------
    
    public static  Predicate startsWith(final String prefix) {
        return new StartsWith(prefix);
    }

    private static final class StartsWith implements Predicate {
        private final String prefix;
        private StartsWith(String prefix) {
            this.prefix = prefix;
        }
        @Override
        public boolean apply(CharSequence input) {
            return (input != null) && input.toString().startsWith(prefix);
        }
        @Override
        public String toString() {
            return "startsWith("+JavaStringEscapes.wrapJavaString(prefix)+")";
        }
    }

    /** @deprecated since 0.7.0 kept only to allow conversion of anonymous inner classes */
    @SuppressWarnings("unused") @Deprecated 
    private static Predicate startsWithOld(final String prefix) {
        return new Predicate() {
            @Override
            public boolean apply(CharSequence input) {
                return (input != null) && input.toString().startsWith(prefix);
            }
        };
    }

    // -----------------
    
    /** true if the object *is* a {@link CharSequence} starting with the given prefix */
    public static Predicate