package k.a.q;

import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.function.Function;
import k.a.q.y.h0;

/* JADX INFO: compiled from: JsonElement.kt */
/* JADX INFO: loaded from: classes.dex */
@k.a.g(with = u.class)
public final class t extends h implements Map<String, h>, j.p0.d.i0.a {
    public static final a Companion = new a(null);
    private final Map<String, h> b;

    /* JADX INFO: compiled from: JsonElement.kt */
    public static final class a {
        private a() {
        }

        public /* synthetic */ a(j.p0.d.j jVar) {
            this();
        }

        public final k.a.b<t> serializer() {
            return u.a;
        }
    }

    /* JADX INFO: compiled from: JsonElement.kt */
    static final class b extends j.p0.d.s implements j.p0.c.l<Map.Entry<? extends String, ? extends h>, CharSequence> {
        public static final b b = new b();

        b() {
            super(1);
        }

        @Override // j.p0.c.l
        /* JADX INFO: renamed from: a, reason: merged with bridge method [inline-methods] */
        public final CharSequence invoke(Map.Entry<String, ? extends h> entry) {
            j.p0.d.r.f(entry, "<name for destructuring parameter 0>");
            String key = entry.getKey();
            h value = entry.getValue();
            StringBuilder sb = new StringBuilder();
            h0.c(sb, key);
            sb.append(':');
            sb.append(value);
            String string = sb.toString();
            j.p0.d.r.e(string, "StringBuilder().apply(builderAction).toString()");
            return string;
        }
    }

    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
    /* JADX WARN: Multi-variable type inference failed */
    public t(Map<String, ? extends h> map) {
        super(null);
        j.p0.d.r.f(map, "content");
        this.b = map;
    }

    public boolean b(String str) {
        j.p0.d.r.f(str, "key");
        return this.b.containsKey(str);
    }

    public boolean c(h hVar) {
        j.p0.d.r.f(hVar, "value");
        return this.b.containsValue(hVar);
    }

    @Override // java.util.Map
    public void clear() {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public /* bridge */ /* synthetic */ h compute(String str, BiFunction<? super String, ? super h, ? extends h> biFunction) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public /* bridge */ /* synthetic */ h computeIfAbsent(String str, Function<? super String, ? extends h> function) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public /* bridge */ /* synthetic */ h computeIfPresent(String str, BiFunction<? super String, ? super h, ? extends h> biFunction) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public final /* bridge */ boolean containsKey(Object obj) {
        if (obj instanceof String) {
            return b((String) obj);
        }
        return false;
    }

    @Override // java.util.Map
    public final /* bridge */ boolean containsValue(Object obj) {
        if (obj instanceof h) {
            return c((h) obj);
        }
        return false;
    }

    public h d(String str) {
        j.p0.d.r.f(str, "key");
        return this.b.get(str);
    }

    public Set<Map.Entry<String, h>> e() {
        return this.b.entrySet();
    }

    @Override // java.util.Map
    public final /* bridge */ Set<Map.Entry<String, h>> entrySet() {
        return e();
    }

    @Override // java.util.Map
    public boolean equals(Object obj) {
        return j.p0.d.r.a(this.b, obj);
    }

    public Set<String> f() {
        return this.b.keySet();
    }

    public int g() {
        return this.b.size();
    }

    @Override // java.util.Map
    public final /* bridge */ /* synthetic */ h get(Object obj) {
        if (obj instanceof String) {
            return d((String) obj);
        }
        return null;
    }

    public Collection<h> h() {
        return this.b.values();
    }

    @Override // java.util.Map
    public int hashCode() {
        return this.b.hashCode();
    }

    public h i(Object obj) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public boolean isEmpty() {
        return this.b.isEmpty();
    }

    @Override // java.util.Map
    public final /* bridge */ Set<String> keySet() {
        return f();
    }

    @Override // java.util.Map
    public /* bridge */ /* synthetic */ h merge(String str, h hVar, BiFunction<? super h, ? super h, ? extends h> biFunction) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public /* bridge */ /* synthetic */ h put(String str, h hVar) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public void putAll(Map<? extends String, ? extends h> map) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public /* bridge */ /* synthetic */ h putIfAbsent(String str, h hVar) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public /* bridge */ /* synthetic */ h remove(Object obj) {
        i(obj);
        throw null;
    }

    @Override // java.util.Map
    public boolean remove(Object obj, Object obj2) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public /* bridge */ /* synthetic */ h replace(String str, h hVar) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public /* bridge */ /* synthetic */ boolean replace(String str, h hVar, h hVar2) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public void replaceAll(BiFunction<? super String, ? super h, ? extends h> biFunction) {
        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
    }

    @Override // java.util.Map
    public final /* bridge */ int size() {
        return g();
    }

    public String toString() {
        return j.k0.w.C(this.b.entrySet(), ",", "{", "}", 0, null, b.b, 24, null);
    }

    @Override // java.util.Map
    public final /* bridge */ Collection<h> values() {
        return h();
    }
}