validation/src/main/java/org/apache/tamaya/validation/spi/PropertyValidator.java

/*
 * 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 createObject 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.tamaya.validation.spi;

import org.apache.tamaya.Configuration;
import org.apache.tamaya.doc.DocumentedProperty;
import org.apache.tamaya.validation.ValidationCheck;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Default configuration Model for a configuration parameter.
 */
public class PropertyValidator implements ConfigValidator {

    /** The parameter's target type. */
    private Class<?> type;
    /** The fully qualified parameter name. */
    private String name;
    /** The optional description. */
    private String description;
    /** The required flag. */
    private boolean required;
    /** The owner instance, not null. */
    private Object owner;

    /**
     * Create a new property validator.
     * @param documentedProperty the property docs, not null.
     */
    public PropertyValidator(DocumentedProperty documentedProperty) {
        this.name = Objects.requireNonNull(documentedProperty.getKeys().iterator().next());
        this.description = documentedProperty.getDescription();
        this.required = documentedProperty.isRequired();
        this.owner = documentedProperty;
        this.type = documentedProperty.getValueType();
    }

    /**
     * Create a new property validator.
     * @param builder the builder, not null.
     */
    private PropertyValidator(Builder builder) {
        this.name = Objects.requireNonNull(builder.name);
        this.description = builder.description;
        this.required = builder.required;
        this.owner = builder.owner;
        this.type = builder.type;
    }


    @Override
    public List<ValidationCheck> validate(Configuration config) {
        List<ValidationCheck> result = new ArrayList<>(1);
        String configValue = config.getOrDefault(name, null);
        String baseText = description;
        if(baseText==null){
            baseText = "Validation failure for property '" + name + "': ";
        }else{
            baseText = baseText + " Validation failure: ";
        }
        if (configValue == null && required) {
            result.add(ValidationCheck.createMissing(this, baseText + " Missing."));
        }
        return result;
    }

    @Override
    public String toString() {
        StringBuilder b = new StringBuilder();
        b.append(type).append(": ").append(name);
        if (required) {
            b.append(", required: ").append(required);
        }
        return b.toString();
    }

    /**
     * Creates a new Builder instance.
     * @param owner the owner name, not null.
     * @param name the fully qualified parameter name.
     * @return a new builder, never null.
     */
    public static Builder builder(String owner, String name) {
        return new Builder(owner, name);
    }

    /**
     * Creates a new ConfigModel
     * @param owner the owner name, not null.
     * @param name the fully qualified parameter name.
     * @param required the required flag.
     * @return the new ConfigModel instance.
     */
    public static PropertyValidator of(Object owner, String name, boolean required) {
        return new Builder(name, owner).setRequired(required).build();
    }

    /**
     * Creates a new ConfigModel
     * @param owner the owner name, not null.
     * @param name the fully qualified parameter name.
     * @param required the required flag.
     * @return the new ConfigModel instance.
     */
    public static PropertyValidator of(String owner, String name, boolean required) {
        return new Builder(owner, name).setRequired(required).build();
    }

    /**
     * Creates a new ConfigModel. The parameter will be defined as optional.
     * @param owner the owner name, not null.
     * @param name the fully qualified parameter name.
     * @return the new ConfigModel instance.
     */
    public static PropertyValidator of(String owner, String name) {
        return new Builder(owner, name).setRequired(false).build();
    }


    /**
     * A new Builder for creating ParameterModel instances.
     */
    public static class Builder {
        /** The parameter's target type. */
        private Class<?> type;
        /** The fully qualified parameter name. */
        private String name;
        /** The optional description. */
        private String description;
        /** The required flag. */
        private boolean required;
        /** The validation owner. */
        private Object owner;

        /**
         * Creates a new Builder.
         * @param name the fully qualified parameter name, not null.
         * @param owner the owner name, not null.
         */
        public Builder(String name, Object owner) {
            this.name = Objects.requireNonNull(name);
            this.owner = Objects.requireNonNull(owner);
        }

        /**
         * Sets the target type.
         * @param type the type, not null.
         * @return the Builder for chaining
         */
        public Builder setType(String type) {
            try {
                this.type = Class.forName(type);
            } catch (ClassNotFoundException e) {
                try {
                    this.type = Class.forName("java.ui.lang."+type);
                } catch (ClassNotFoundException e2) {
                    Logger.getLogger(getClass().getName()).log(Level.INFO, "Failed to load parameter type: " + type, e2);
                }
            }
            return this;
        }

        /**
         * Sets the required flag.
         * @param required the required flag.
         * @return the Builder for chaining
         */
        public Builder setRequired(boolean required) {
            this.required = required;
            return this;
        }

        /**
         * Sets the optional description
         * @param description the description
         * @return the Builder for chaining
         */
        public Builder setDescription(String description) {
            this.description = description;
            return this;
        }

        /**
         * Sets the owner name.
         * @param owner the owner name, not null.
         * @return the Builder for chaining
         */
        public Builder setOwner(Object owner) {
            this.owner = Objects.requireNonNull(owner);
            return this;
        }

        /**
         * Sets the fully qualified parameter name.
         * @param name the fully qualified parameter name, not null.
         * @return the Builder for chaining
         */
        public Builder setName(String name) {
            this.name = Objects.requireNonNull(name);
            return this;
        }

        /**
         * Creates a new ConfigModel with the given parameters.
         * @return a new ConfigModel , never null.
         */
        public PropertyValidator build() {
            return new PropertyValidator(this);
        }
    }
}