导航菜单
登录 注册

页面标题

页面副标题

Weicon v2.1.4 - SpecificationVersion.java 源代码

正在查看： Weicon v2.1.4 应用的 SpecificationVersion.java JAVA 源代码文件

本页面展示 JAVA 反编译生成的源代码文件，支持语法高亮显示。 仅供安全研究与技术分析使用，严禁用于任何非法用途。请遵守相关法律法规。 


package org.everit.json.schema.loader;

import com.damnhandy.uri.template.MalformedUriTemplateException;
import com.damnhandy.uri.template.UriTemplate;
import java.net.URI;
import java.net.URISyntaxException;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import java.util.stream.Stream;
import okhttp3.HttpUrl;
import org.everit.json.schema.FormatValidator;
import org.everit.json.schema.JSONPointer;
import org.everit.json.schema.internal.DateTimeFormatValidator;
import org.everit.json.schema.internal.EmailFormatValidator;
import org.everit.json.schema.internal.HostnameFormatValidator;
import org.everit.json.schema.internal.IPV4Validator;
import org.everit.json.schema.internal.IPV6Validator;
import org.everit.json.schema.internal.TemporalFormatValidator;
import org.everit.json.schema.internal.URIFormatValidator;
import retrofit2.Platform$$ExternalSyntheticApiModelOutline0;

public enum SpecificationVersion {
    DRAFT_4 {
        @Override
        List<String> arrayKeywords() {
            return SpecificationVersion.V4_ARRAY_KEYWORDS;
        }

        @Override
        List<String> objectKeywords() {
            return SpecificationVersion.V4_OBJECT_KEYWORDS;
        }

        @Override
        public String idKeyword() {
            return "id";
        }

        @Override
        List<String> metaSchemaUrls() {
            return Arrays.asList("http://json-schema.org/draft-04/schema", "https://json-schema.org/draft-04/schema");
        }

        @Override
        Map<String, FormatValidator> defaultFormatValidators() {
            return SpecificationVersion.V4_VALIDATORS;
        }
    },
    DRAFT_6 {
        @Override
        List<String> arrayKeywords() {
            return SpecificationVersion.V6_ARRAY_KEYWORDS;
        }

        @Override
        List<String> objectKeywords() {
            return SpecificationVersion.V6_OBJECT_KEYWORDS;
        }

        @Override
        public String idKeyword() {
            return "$id";
        }

        @Override
        List<String> metaSchemaUrls() {
            return Arrays.asList("http://json-schema.org/draft-06/schema", "https://json-schema.org/draft-06/schema");
        }

        @Override
        Map<String, FormatValidator> defaultFormatValidators() {
            return SpecificationVersion.V6_VALIDATORS;
        }
    },
    DRAFT_7 {
        @Override
        List<String> arrayKeywords() {
            return SpecificationVersion.V6_ARRAY_KEYWORDS;
        }

        @Override
        List<String> objectKeywords() {
            return SpecificationVersion.V6_OBJECT_KEYWORDS;
        }

        @Override
        public String idKeyword() {
            return DRAFT_6.idKeyword();
        }

        @Override
        List<String> metaSchemaUrls() {
            return Arrays.asList("http://json-schema.org/draft-07/schema", "https://json-schema.org/draft-07/schema");
        }

        @Override
        Map<String, FormatValidator> defaultFormatValidators() {
            return SpecificationVersion.V7_VALIDATORS;
        }
    };

    private static final Map<String, FormatValidator> V4_VALIDATORS;
    private static final Map<String, FormatValidator> V6_VALIDATORS;
    private static final Map<String, FormatValidator> V7_VALIDATORS;
    private static final List<String> V6_OBJECT_KEYWORDS = keywords("properties", "required", "minProperties", "maxProperties", "dependencies", "patternProperties", "additionalProperties", "propertyNames");
    private static final List<String> V6_ARRAY_KEYWORDS = keywords("items", "additionalItems", "minItems", "maxItems", "uniqueItems", "contains");
    private static final List<String> V4_OBJECT_KEYWORDS = keywords("properties", "required", "minProperties", "maxProperties", "dependencies", "patternProperties", "additionalProperties");
    private static final List<String> V4_ARRAY_KEYWORDS = keywords("items", "additionalItems", "minItems", "maxItems", "uniqueItems");

    abstract List<String> arrayKeywords();

    abstract Map<String, FormatValidator> defaultFormatValidators();

    public abstract String idKeyword();

    abstract List<String> metaSchemaUrls();

    abstract List<String> objectKeywords();

    static {
        Map<String, FormatValidator> formatValidators = formatValidators(null, new DateTimeFormatValidator(), new FormatValidator() {
            @Override
            public Optional<String> validate(String str) {
                Optional<String> empty;
                try {
                    new URI(str);
                    empty = Optional.empty();
                    return empty;
                } catch (NullPointerException | URISyntaxException unused) {
                    return failure(str);
                }
            }

            protected Optional<String> failure(String str) {
                Optional<String> of;
                of = Optional.of(String.format("[%s] is not a valid URI", str));
                return of;
            }

            @Override
            public String formatName() {
                return "uri";
            }
        }, new EmailFormatValidator(), new IPV4Validator(), new IPV6Validator(), new HostnameFormatValidator());
        V4_VALIDATORS = formatValidators;
        Map<String, FormatValidator> formatValidators2 = formatValidators(formatValidators, new FormatValidator() {
            @Override
            public Optional<String> validate(String str) {
                Optional<String> empty;
                if (HttpUrl.FRAGMENT_ENCODE_SET.equals(str)) {
                    empty = Optional.empty();
                    return empty;
                }
                try {
                    new JSONPointer(str);
                    if (str.startsWith("#")) {
                        return failure(str);
                    }
                    return checkEscaping(str);
                } catch (IllegalArgumentException unused) {
                    return failure(str);
                }
            }

            protected Optional<String> failure(String str) {
                Optional<String> of;
                of = Optional.of(String.format("[%s] is not a valid JSON pointer", str));
                return of;
            }

            protected Optional<String> checkEscaping(String str) {
                Optional<String> empty;
                char charAt;
                for (int i = 0; i < str.length() - 1; i++) {
                    if (str.charAt(i) == '~' && (charAt = str.charAt(i + 1)) != '1' && charAt != '0') {
                        return failure(str);
                    }
                }
                if (str.charAt(str.length() - 1) == '~') {
                    return failure(str);
                }
                empty = Optional.empty();
                return empty;
            }

            @Override
            public String formatName() {
                return "json-pointer";
            }
        }, new URIFormatValidator(), new FormatValidator() {
            @Override
            public Optional<String> validate(String str) {
                Optional<String> empty;
                try {
                    new URI(str);
                    empty = Optional.empty();
                    return empty;
                } catch (URISyntaxException unused) {
                    return failure(str);
                }
            }

            protected Optional<String> failure(String str) {
                Optional<String> of;
                of = Optional.of(String.format("[%s] is not a valid URI reference", str));
                return of;
            }

            @Override
            public String formatName() {
                return "uri-reference";
            }
        }, new FormatValidator() {
            @Override
            public Optional<String> validate(String str) {
                Optional<String> of;
                Optional<String> empty;
                try {
                    UriTemplate.fromTemplate(str);
                    empty = Optional.empty();
                    return empty;
                } catch (MalformedUriTemplateException unused) {
                    of = Optional.of(String.format("[%s] is not a valid URI template", str));
                    return of;
                }
            }

            @Override
            public String formatName() {
                return "uri-template";
            }
        });
        V6_VALIDATORS = formatValidators2;
        V7_VALIDATORS = formatValidators(formatValidators2, new TemporalFormatValidator() {
            {
                DateTimeFormatter dateTimeFormatter;
                dateTimeFormatter = DateTimeFormatter.ISO_LOCAL_DATE;
                Collections.singletonList("yyyy-MM-dd").toString();
            }

            @Override
            public String formatName() {
                return "date";
            }
        }, new URIFormatValidator(false), new TemporalFormatValidator() {
            private static final String FORMATS_ACCEPTED = Arrays.asList("HH:mm:ssZ", "HH:mm:ss.[0-9]{1,9}Z", "HH:mm:ss[+-]HH:mm", "HH:mm:ss.[0-9]{1,9}[+-]HH:mm").toString();
            private static final DateTimeFormatter FORMATTER;
            private static final String PARTIAL_TIME_PATTERN = "HH:mm:ss";

            static {
                DateTimeFormatterBuilder appendPattern;
                DateTimeFormatterBuilder appendOptional;
                DateTimeFormatterBuilder appendPattern2;
                DateTimeFormatter formatter;
                appendPattern = Platform$$ExternalSyntheticApiModelOutline0.m1915m().appendPattern(PARTIAL_TIME_PATTERN);
                appendOptional = appendPattern.appendOptional(SECONDS_FRACTION_FORMATTER);
                appendPattern2 = appendOptional.appendPattern("XXX");
                formatter = appendPattern2.toFormatter();
                FORMATTER = formatter;
            }

            {
                DateTimeFormatter dateTimeFormatter = FORMATTER;
                String str = FORMATS_ACCEPTED;
            }

            @Override
            public String formatName() {
                return "time";
            }
        }, new FormatValidator() {
            @Override
            public Optional<String> validate(String str) {
                Optional<String> of;
                Optional<String> empty;
                try {
                    Pattern.compile(str);
                    empty = Optional.empty();
                    return empty;
                } catch (PatternSyntaxException unused) {
                    of = Optional.of(String.format("[%s] is not a valid regular expression", str));
                    return of;
                }
            }

            @Override
            public String formatName() {
                return "regex";
            }
        }, new FormatValidator() {

            private static class ParseException extends Exception {
                public ParseException(String str) {
                    super(String.format("[%s] is not a valid relative JSON Pointer", str));
                }
            }

            private static final class Parser {
                public static final int EOF = 26;
                private String input;
                private int pos = 0;

                private static boolean isDigit(char c) {
                    return '0' <= c && c <= '9';
                }

                public Parser(String str) {
                    this.input = str;
                }

                public void parse() throws ParseException {
                    parseUpwardsStepCount();
                    parseJsonPointer();
                    parseTrailingHashmark();
                }

                private void parseTrailingHashmark() throws ParseException {
                    if (this.pos == this.input.length()) {
                        return;
                    }
                    if (this.pos == this.input.length() - 1 && this.input.charAt(this.pos) == '#') {
                        return;
                    }
                    fail();
                }

                private char next() {
                    int i = this.pos + 1;
                    this.pos = i;
                    if (i == this.input.length()) {
                        return (char) 26;
                    }
                    return curr();
                }

                private char curr() {
                    if (this.pos == this.input.length()) {
                        return (char) 26;
                    }
                    return this.input.charAt(this.pos);
                }

                private void parseUpwardsStepCount() throws ParseException {
                    if (!isDigit(curr())) {
                        fail();
                    } else if (curr() == '0') {
                        next();
                        if (curr() == '/' || curr() == '#' || curr() == 26) {
                            this.pos--;
                        } else {
                            fail();
                        }
                    }
                    while (isDigit(next()) && this.pos < this.input.length()) {
                    }
                }

                private void fail() throws ParseException {
                    throw new ParseException(this.input);
                }

                private void parseJsonPointer() throws ParseException {
                    StringBuilder sb = new StringBuilder();
                    char curr = curr();
                    while (this.pos < this.input.length() && curr != '#') {
                        sb.append(curr);
                        curr = next();
                    }
                    String sb2 = sb.toString();
                    if (sb2.length() == 0) {
                        return;
                    }
                    if (sb2.startsWith("#")) {
                        fail();
                    }
                    try {
                        new JSONPointer(sb2);
                    } catch (IllegalArgumentException unused) {
                        fail();
                    }
                }
            }

            @Override
            public Optional<String> validate(String str) {
                Optional<String> of;
                Optional<String> empty;
                try {
                    new Parser(str).parse();
                    empty = Optional.empty();
                    return empty;
                } catch (ParseException e) {
                    of = Optional.of(e.getMessage());
                    return of;
                }
            }

            @Override
            public String formatName() {
                return "relative-json-pointer";
            }
        });
    }

    static SpecificationVersion getByMetaSchemaUrl(final String str) {
        Object orElseThrow;
        orElseThrow = lookupByMetaSchemaUrl(str).orElseThrow(new Supplier() {
            @Override
            public final Object get() {
                return SpecificationVersion.lambda$getByMetaSchemaUrl$0(str);
            }
        });
        return (SpecificationVersion) orElseThrow;
    }

    static IllegalArgumentException lambda$getByMetaSchemaUrl$0(String str) {
        return new IllegalArgumentException(String.format("could not determine schema version: no meta-schema is known with URL [%s]", str));
    }

    public static Optional<SpecificationVersion> lookupByMetaSchemaUrl(final String str) {
        Stream stream;
        Stream filter;
        Optional<SpecificationVersion> findFirst;
        stream = Arrays.stream(values());
        filter = stream.filter(new Predicate() {
            @Override
            public final boolean test(Object obj) {
                return SpecificationVersion.lambda$lookupByMetaSchemaUrl$1(str, (SpecificationVersion) obj);
            }
        });
        findFirst = filter.findFirst();
        return findFirst;
    }

    static boolean lambda$lookupByMetaSchemaUrl$1(String str, SpecificationVersion specificationVersion) {
        Stream stream;
        boolean anyMatch;
        stream = specificationVersion.metaSchemaUrls().stream();
        str.getClass();
        anyMatch = stream.anyMatch(new ClassPathAwareSchemaClient$$ExternalSyntheticLambda3(str));
        return anyMatch;
    }

    private static List<String> keywords(String... strArr) {
        return Collections.unmodifiableList(Arrays.asList(strArr));
    }

    private static Map<String, FormatValidator> formatValidators(Map<String, FormatValidator> map, FormatValidator... formatValidatorArr) {
        HashMap hashMap = map == null ? new HashMap() : new HashMap(map);
        for (FormatValidator formatValidator : formatValidatorArr) {
            hashMap.put(formatValidator.formatName(), formatValidator);
        }
        return Collections.unmodifiableMap(hashMap);
    }

    public boolean isAtLeast(SpecificationVersion specificationVersion) {
        return ordinal() >= specificationVersion.ordinal();
    }
}