DefinitionQuery

/**
 * This file Copyright (c) 2014-2018 Magnolia International
 * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
 *
 *
 * This file is dual-licensed under both the Magnolia
 * Network Agreement and the GNU General Public License.
 * You may elect to use one or the other of these licenses.
 *
 * This file is distributed in the hope that it will be
 * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
 * Redistribution, except as permitted by whichever of the GPL
 * or MNA you select, is prohibited.
 *
 * 1. For the GPL license (GPL), you can redistribute and/or
 * modify this file under the terms of the GNU General
 * Public License, Version 3, as published by the Free Software
 * Foundation.  You should have received a copy of the GNU
 * General Public License, Version 3 along with this program;
 * if not, write to the Free Software Foundation, Inc., 51
 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * 2. For the Magnolia Network Agreement (MNA), this file
 * and the accompanying materials are made available under the
 * terms of the MNA which accompanies this distribution, and
 * is available at http://www.magnolia-cms.com/mna.html
 *
 * Any modifications to this file must keep this entire header
 * intact.
 *
 */
package info.magnolia.config.registry;

import info.magnolia.config.source.ConfigurationSourceType;

import java.util.Collection;
import java.util.Optional;
import java.util.regex.Pattern;

/**
 * DefinitionQuery aggregates metadata search criteria allowing for specifying
 * it in a builder-pattern fashion.
 *
 * @param <T> type of the expected query result
 */
public abstract class DefinitionQuery<T> {
    private String module;
    private String name;
    private DefinitionType type;
    private ConfigurationSourceType configurationSourceType;
    private Pattern locationPattern;

    protected DefinitionQuery() {
    }

    /**
     * Create a new query instance based on another one.
     * All properties are initially adopted, but can still be overridden.
     * @param query The query to wrap/fork
     */
    protected DefinitionQuery"../../../../info/magnolia/config/registry/DefinitionQuery.html#DefinitionQuery">DefinitionQuery(DefinitionQuery query) {
        this.module = query.module;
        this.name = query.name;
        this.type = query.type;
        this.configurationSourceType = query.configurationSourceType;
        this.locationPattern = query.locationPattern;
    }

    /**
     * Start building a DefinitionQuery for a Registry.
     */
    public static <T> DefinitionQuery<T> build(Registry<T> registry) {
        return new DefinitionQueryImpl<>(registry);
    }

    /**
     * Start building a DefinitionQuery for a Registry, copying properties of an existing query.
     * @param baseQuery A {@link DefinitionQuery} to base the new one upon
     */
    public static <T> DefinitionQuery<T> build(Registry<T> registry, DefinitionQuery<T> baseQuery) {
        return new DefinitionQueryImpl<>(registry, baseQuery);
    }

    public DefinitionQuery<T> from(String moduleName) {
        this.module = moduleName;
        return this;
    }

    public DefinitionQuery<T> named(String defName) {
        this.name = defName;
        return this;
    }

    public DefinitionQuery<T> ofType(DefinitionType type) {
        this.type = type;
        return this;
    }

    public DefinitionQuery<T> ofConfigurationSourceType(ConfigurationSourceType configurationSourceType) {
        this.configurationSourceType = configurationSourceType;
        return this;
    }

    public DefinitionQuery<T> at(String locationRegexPattern) {
        this.locationPattern = Pattern.compile(locationRegexPattern);
        return this;
    }

    public DefinitionQuery<T> at(Pattern locationRegexPattern) {
        this.locationPattern = locationRegexPattern;
        return this;
    }

    public String getModule() {
        return module;
    }

    public String getName() {
        return name;
    }

    public DefinitionType getType() {
        return type;
    }

    public ConfigurationSourceType getConfigurationSourceType() {
        return configurationSourceType;
    }

    public Pattern getLocationPattern() {
        return locationPattern;
    }

    /**
     * Returns a single provider matching the criteria or throws an exception if not unique.
     *
     * @throws Registry.NoSuchDefinitionException (which is a RuntimeException) if the query doesn't match any definition.
     */
    public DefinitionProvider<T> findSingle() {
        return findAny().orElseThrow(() -> new Registry.NoSuchDefinitionException("No match found for " + this));
    }

    /**
     * Optionally returns a single provider matching the criteria.
     */
    abstract Optional<DefinitionProvider<T>> findAny();

    /**
     * Returns all providers matching the given criteria or an empty collection if there are no matches.
     */
    public abstract Collection<DefinitionProvider<T>> findMultiple();

    @Override
    public String toString() {
        final StringBuilder s = new StringBuilder();
        s.append("DefinitionQuery(");
        if (this.getModule() != null) {
            s.append("[module: ").append(this.getModule()).append("]");
        }
        if (this.getName() != null) {
            s.append("[name: ").append(this.getName()).append("]");
        }
        if (this.getType() != null) {
            s.append("[type: ").append(this.getType()).append("]");
        }
        if (this.getConfigurationSourceType() != null) {
            s.append("[configurationSourceType: ").append(this.getConfigurationSourceType()).append("]");
        }
        if (this.getLocationPattern() != null) {
            s.append("[locationPattern: ").append(this.getLocationPattern()).append("]");
        }
        s.append(")");
        return s.toString();
    }
}