edu.stanford.protege.webprotege.match.LiteralMatcher Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of webprotege-backend-service Show documentation
The newest version!
package edu.stanford.protege.webprotege.match;

import org.semanticweb.owlapi.model.OWLDatatype;
import org.semanticweb.owlapi.model.OWLLiteral;

import javax.annotation.Nonnull;
import java.util.function.Predicate;
import java.util.regex.Pattern;

import static com.google.common.base.Preconditions.checkNotNull;

/**
 * Matthew Horridge
 * Stanford Center for Biomedical Informatics Research
 * 7 Jun 2018
 */
public class LiteralMatcher implements Matcher {

    @Nonnull
    private final Matcher lexicalValueMatcher;

    @Nonnull
    private final Matcher languageTagMatcher;

    @Nonnull
    private final Matcher datatypeMatcher;

    public LiteralMatcher(@Nonnull Matcher lexicalValueMatcher,
                          @Nonnull Matcher languageTagMatcher,
                          @Nonnull Matcher datatypeMatcher) {
        this.lexicalValueMatcher = checkNotNull(lexicalValueMatcher);
        this.languageTagMatcher = checkNotNull(languageTagMatcher);
        this.datatypeMatcher = checkNotNull(datatypeMatcher);
    }

    @Override
    public boolean matches(@Nonnull OWLLiteral literal) {
        return lexicalValueMatcher.matches(literal.getLiteral())
                && languageTagMatcher.matches(literal.getLang())
                && datatypeMatcher.matches(literal.getDatatype());
    }

    public static LiteralMatcher forLexicalPattern(@Nonnull Pattern pattern) {
        return new LiteralMatcher(
                lexicalValue -> pattern.matcher(lexicalValue).find(),
                langTag -> true,
                datatype -> true
        );
    }

    public static Matcher forPredicate(@Nonnull Predicate predicate) {
        return new LiteralMatcher(
                predicate::test,
                langTag -> true,
                datatype -> true
        );
    }

    public static Matcher forHasAnyLangTag() {
        return new LiteralMatcher(lexicalValue -> true,
                                  langTag -> !langTag.isEmpty(),
                                  datatype -> true);
    }

    public static Matcher forLexicalValue(Matcher lexicalValueMatcher) {
        return new LiteralMatcher(lexicalValueMatcher, langTag -> true, datatype -> true);
    }

    public static Matcher forLangTag(Matcher languageTagMatcher) {
        return new LiteralMatcher(Matcher.matchesAny(),
                                  languageTagMatcher,
                                  Matcher.matchesAny());
    }

    public static Matcher forHasLangTag(@Nonnull String langTagMatch) {
        return new LiteralMatcher(lexicalValue -> true,
                                  langTagMatch::equalsIgnoreCase,
                                  datatype -> true);
    }


    public static Matcher forNoLangTag() {
        return new LiteralMatcher(lexicalValue -> true,
                                  String::isEmpty,
                                  datatype -> true);
    }

    public static Matcher forXsdBooleanTrue() {
        return new LiteralMatcher(lexicalValue -> lexicalValue.equals("true") || lexicalValue.equals("1"),
                                  String::isEmpty,
                                  OWLDatatype::isBoolean);
    }

    public static Matcher forXsdBooleanFalse() {
        return new LiteralMatcher(lexicalValue -> !lexicalValue.equals("false") && !lexicalValue.equals("1"),
                                  String::isEmpty,
                                  OWLDatatype::isBoolean);
    }
}