SpeedCash v6.5.1482 - NameResolverRegistry.java 源代码

package io.grpc;

import com.bumptech.glide.request.target.Target;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import io.grpc.NameResolver;
import io.grpc.ServiceProviders;
import io.grpc.internal.DnsNameResolverProvider;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.Nullable;
import javax.annotation.concurrent.GuardedBy;
import javax.annotation.concurrent.ThreadSafe;

@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4159")
@ThreadSafe
public final class NameResolverRegistry {
    public static final Logger e = Logger.getLogger(NameResolverRegistry.class.getName());
    public static NameResolverRegistry f;
    public final NameResolver.Factory a = new b();

    @GuardedBy("this")
    public String b = "unknown";

    @GuardedBy("this")
    public final LinkedHashSet<NameResolverProvider> c = new LinkedHashSet<>();

    @GuardedBy("this")
    public ImmutableMap<String, NameResolverProvider> d = ImmutableMap.of();

    public final class b extends NameResolver.Factory {
        public b() {
        }

        @Override
        public String getDefaultScheme() {
            String str;
            synchronized (NameResolverRegistry.this) {
                str = NameResolverRegistry.this.b;
            }
            return str;
        }

        @Override
        @Nullable
        public NameResolver newNameResolver(URI uri, NameResolver.Args args) {
            NameResolverProvider nameResolverProvider = NameResolverRegistry.this.d().get(uri.getScheme());
            if (nameResolverProvider == null) {
                return null;
            }
            return nameResolverProvider.newNameResolver(uri, args);
        }
    }

    public static final class c implements ServiceProviders.PriorityAccessor<NameResolverProvider> {
        public c() {
        }

        @Override
        public int getPriority(NameResolverProvider nameResolverProvider) {
            return nameResolverProvider.priority();
        }

        @Override
        public boolean isAvailable(NameResolverProvider nameResolverProvider) {
            return nameResolverProvider.isAvailable();
        }
    }

    @VisibleForTesting
    public static List<Class<?>> c() {
        ArrayList arrayList = new ArrayList();
        try {
            arrayList.add(DnsNameResolverProvider.class);
        } catch (ClassNotFoundException e2) {
            e.log(Level.FINE, "Unable to find DNS NameResolver", (Throwable) e2);
        }
        return Collections.unmodifiableList(arrayList);
    }

    public static synchronized NameResolverRegistry getDefaultRegistry() {
        NameResolverRegistry nameResolverRegistry;
        synchronized (NameResolverRegistry.class) {
            if (f == null) {
                List<NameResolverProvider> f2 = ServiceProviders.f(NameResolverProvider.class, c(), NameResolverProvider.class.getClassLoader(), new c());
                if (f2.isEmpty()) {
                    e.warning("No NameResolverProviders found via ServiceLoader, including for DNS. This is probably due to a broken build. If using ProGuard, check your configuration");
                }
                f = new NameResolverRegistry();
                for (NameResolverProvider nameResolverProvider : f2) {
                    e.fine("Service loader found " + nameResolverProvider);
                    f.b(nameResolverProvider);
                }
                f.e();
            }
            nameResolverRegistry = f;
        }
        return nameResolverRegistry;
    }

    public NameResolver.Factory asFactory() {
        return this.a;
    }

    public final synchronized void b(NameResolverProvider nameResolverProvider) {
        Preconditions.checkArgument(nameResolverProvider.isAvailable(), "isAvailable() returned false");
        this.c.add(nameResolverProvider);
    }

    @VisibleForTesting
    public synchronized Map<String, NameResolverProvider> d() {
        return this.d;
    }

    public synchronized void deregister(NameResolverProvider nameResolverProvider) {
        this.c.remove(nameResolverProvider);
        e();
    }

    public final synchronized void e() {
        HashMap hashMap = new HashMap();
        String str = "unknown";
        Iterator<NameResolverProvider> it = this.c.iterator();
        int i = Target.SIZE_ORIGINAL;
        while (it.hasNext()) {
            NameResolverProvider next = it.next();
            String scheme = next.getScheme();
            NameResolverProvider nameResolverProvider = (NameResolverProvider) hashMap.get(scheme);
            if (nameResolverProvider == null || nameResolverProvider.priority() < next.priority()) {
                hashMap.put(scheme, next);
            }
            if (i < next.priority()) {
                i = next.priority();
                str = next.getScheme();
            }
        }
        this.d = ImmutableMap.copyOf(hashMap);
        this.b = str;
    }

    public synchronized void register(NameResolverProvider nameResolverProvider) {
        b(nameResolverProvider);
        e();
    }
}