FileNormalizer normalizer = FileParameterUtils.normalizerOrDefault(fileNormalizer);
        specs.add(new DefaultInputFilePropertySpec(
            propertyName,
            normalizer,
            new PropertyFileCollection(ownerDisplayName, propertyName, "input", actualValue),
            value,
            behavior,
            normalizeDirectorySensitivity(normalizer, directorySensitivity),

                originalUrls.forEach { name, originalUrl ->
                    if (normalizeUrl(originalUrl) == normalizeUrl(this.url.toString()) && mirrorUrls.containsKey(name)) {
                        mirrorUrls.get(name)?.let { this.setUrl(it) }
                    }
                }
            }
        }
    }

    fun normalizeUrl(url: String): String {
        val result = url.replace("https://", "http://")

                NON_INCREMENTAL,
                new InputFileValueSupplier(fileInput, normalizer, DirectorySensitivity.DEFAULT, LineEndingSensitivity.DEFAULT, { fileInput }))
            visitor.visitInputFileProperty(
                "archiveTree",
                NON_INCREMENTAL,
                new InputFileValueSupplier(fileInput, normalizer, DirectorySensitivity.DEFAULT, LineEndingSensitivity.DEFAULT, { archiveTreeInput }))
        }

 * limitations under the License.
 */
@file:Suppress("ktlint:standard:filename")

package okhttp3.internal

import java.text.Normalizer
import java.text.Normalizer.Form.NFC

    }

    public void setReadingConverter(final ReadingConverter readingConverter) {
        this.readingConverter = readingConverter;
    }

    public void setNormalizer(final Normalizer normalizer) {
        this.normalizer = normalizer;
    }

    public void setPrefixMatchWeight(final float prefixMatchWeight) {
        this.prefixMatchWeight = prefixMatchWeight;
    }

        } else if (api == Api.RUNTIME_API) {
            Class<?> normalizer;
            if (inputAnnotation == Classpath) {
                normalizer = ClasspathNormalizer
            } else if (inputAnnotation == CompileClasspath) {
                normalizer = CompileClasspathNormalizer
            } else {
                normalizer = null
            }

        ignoreEmptyDirectories && !normalizer && pathSensitivity != PathSensitivity.NONE ? "DIRECTORY_SENSITIVITY_IGNORE_DIRECTORIES" : "DIRECTORY_SENSITIVITY_DEFAULT"
    }

    static String attributeFromPathSensitivity(PathSensitivity pathSensitivity, Class<? extends FileNormalizer> normalizer) {
        if (normalizer) {

import org.gradle.api.tasks.PathSensitivity;
import org.gradle.internal.fingerprint.FileNormalizer;

import java.util.Locale;

// TODO Break this up between simple normalizers and Java classpath normalizers
//      The latter should be moved to :normalization-java
public enum InputNormalizer implements FileNormalizer {
    ABSOLUTE_PATH(false),
    RELATIVE_PATH(false),
    NAME_ONLY(false),

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.suggest.normalizer;

public class FullWidthToHalfWidthAlphabetNormalizer implements Normalizer {
    @Override
    public String normalize(final String text, final String field, final String... langs) {
        final char[] chars = new char[text.length()];

     * Does not block waiting for the input.
     */
    void readAndForwardText(Normalizer normalizer);

    /**
     * Requests that bytes should be read from this process' stdin and forwarded to the daemon.
     * Does not block waiting for the input.
     */
    void readAndForwardStdin();

    interface Normalizer {
        /**
         * Validates and normalizes the given text received from the user.
         *