package o;

import o.AQX;
import o.KUw;
import o.jrE;
import o.ldG;
import o.uOO;

/* loaded from: classes2.dex */
public final class sbb extends KUw<sbb, LWm> implements CVV {
    public static final int ARRAY_VALUE_FIELD_NUMBER = 9;
    public static final int BOOLEAN_VALUE_FIELD_NUMBER = 1;
    public static final int BYTES_VALUE_FIELD_NUMBER = 18;
    private static final sbb DEFAULT_INSTANCE;
    public static final int DOUBLE_VALUE_FIELD_NUMBER = 3;
    public static final int GEO_POINT_VALUE_FIELD_NUMBER = 8;
    public static final int INTEGER_VALUE_FIELD_NUMBER = 2;
    public static final int MAP_VALUE_FIELD_NUMBER = 6;
    public static final int NULL_VALUE_FIELD_NUMBER = 11;
    private static volatile XgX<sbb> PARSER = null;
    public static final int REFERENCE_VALUE_FIELD_NUMBER = 5;
    public static final int STRING_VALUE_FIELD_NUMBER = 17;
    public static final int TIMESTAMP_VALUE_FIELD_NUMBER = 10;
    public int valueTypeCase_ = 0;
    public Object valueType_;

    static /* synthetic */ void a(sbb sbbVar, long j) {
        sbbVar.valueTypeCase_ = 2;
        sbbVar.valueType_ = Long.valueOf(j);
    }

    static /* synthetic */ void c(sbb sbbVar, double d) {
        sbbVar.valueTypeCase_ = 3;
        sbbVar.valueType_ = Double.valueOf(d);
    }

    static /* synthetic */ void c(sbb sbbVar, boolean z) {
        sbbVar.valueTypeCase_ = 1;
        sbbVar.valueType_ = Boolean.valueOf(z);
    }

    private sbb() {
    }

    /* loaded from: classes2.dex */
    public enum HBt {
        NULL_VALUE(11),
        BOOLEAN_VALUE(1),
        INTEGER_VALUE(2),
        DOUBLE_VALUE(3),
        TIMESTAMP_VALUE(10),
        STRING_VALUE(17),
        BYTES_VALUE(18),
        REFERENCE_VALUE(5),
        GEO_POINT_VALUE(8),
        ARRAY_VALUE(9),
        MAP_VALUE(6),
        VALUETYPE_NOT_SET(0);

        private final int value;

        HBt(int i) {
            this.value = i;
        }

        public static HBt c(int i) {
            if (i == 0) {
                return VALUETYPE_NOT_SET;
            }
            if (i == 1) {
                return BOOLEAN_VALUE;
            }
            if (i == 2) {
                return INTEGER_VALUE;
            }
            if (i == 3) {
                return DOUBLE_VALUE;
            }
            if (i == 5) {
                return REFERENCE_VALUE;
            }
            if (i == 6) {
                return MAP_VALUE;
            }
            if (i == 17) {
                return STRING_VALUE;
            }
            if (i == 18) {
                return BYTES_VALUE;
            }
            switch (i) {
                case 8:
                    return GEO_POINT_VALUE;
                case 9:
                    return ARRAY_VALUE;
                case 10:
                    return TIMESTAMP_VALUE;
                case 11:
                    return NULL_VALUE;
                default:
                    return null;
            }
        }
    }

    public static LWm d() {
        return DEFAULT_INSTANCE.createBuilder();
    }

    /* loaded from: classes2.dex */
    public static final class LWm extends KUw.LWm<sbb, LWm> implements CVV {
        /* synthetic */ LWm(byte b) {
            this();
        }

        private LWm() {
            super(sbb.DEFAULT_INSTANCE);
        }

        public final LWm b(EnumC15686hkD enumC15686hkD) {
            copyOnWrite();
            sbb.d((sbb) this.instance, enumC15686hkD);
            return this;
        }

        public final LWm a(boolean z) {
            copyOnWrite();
            sbb.c((sbb) this.instance, z);
            return this;
        }

        public final LWm e(long j) {
            copyOnWrite();
            sbb.a((sbb) this.instance, j);
            return this;
        }

        public final LWm b(double d) {
            copyOnWrite();
            sbb.c((sbb) this.instance, d);
            return this;
        }

        public final LWm e(AQX.IeS ieS) {
            copyOnWrite();
            sbb.a((sbb) this.instance, ieS.build());
            return this;
        }

        public final LWm e(String str) {
            copyOnWrite();
            sbb.b((sbb) this.instance, str);
            return this;
        }

        public final LWm e(QwV qwV) {
            copyOnWrite();
            sbb.a((sbb) this.instance, qwV);
            return this;
        }

        public final LWm b(String str) {
            copyOnWrite();
            sbb.d((sbb) this.instance, str);
            return this;
        }

        public final LWm c(jrE.HBt hBt) {
            copyOnWrite();
            sbb.d((sbb) this.instance, hBt.build());
            return this;
        }

        public final LWm e(uOO uoo) {
            copyOnWrite();
            sbb.b((sbb) this.instance, uoo);
            return this;
        }

        public final LWm b(uOO.IeS ieS) {
            copyOnWrite();
            sbb.b((sbb) this.instance, ieS.build());
            return this;
        }

        public final LWm c(ldG ldg) {
            copyOnWrite();
            sbb.c((sbb) this.instance, ldg);
            return this;
        }

        public final LWm d(ldG.RVV rvv) {
            copyOnWrite();
            sbb.c((sbb) this.instance, rvv.build());
            return this;
        }
    }

    /* renamed from: o.sbb$1, reason: invalid class name */
    /* loaded from: classes2.dex */
    static /* synthetic */ class AnonymousClass1 {
        static final int[] c;

        static {
            int[] iArr = new int[KUw.ojQ.values().length];
            c = iArr;
            try {
                iArr[KUw.ojQ.NEW_MUTABLE_INSTANCE.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                c[KUw.ojQ.NEW_BUILDER.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                c[KUw.ojQ.BUILD_MESSAGE_INFO.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                c[KUw.ojQ.GET_DEFAULT_INSTANCE.ordinal()] = 4;
            } catch (NoSuchFieldError unused4) {
            }
            try {
                c[KUw.ojQ.GET_PARSER.ordinal()] = 5;
            } catch (NoSuchFieldError unused5) {
            }
            try {
                c[KUw.ojQ.GET_MEMOIZED_IS_INITIALIZED.ordinal()] = 6;
            } catch (NoSuchFieldError unused6) {
            }
            try {
                c[KUw.ojQ.SET_MEMOIZED_IS_INITIALIZED.ordinal()] = 7;
            } catch (NoSuchFieldError unused7) {
            }
        }
    }

    @Override // o.KUw
    public final Object dynamicMethod(KUw.ojQ ojq, Object obj, Object obj2) {
        XgX xgX;
        switch (AnonymousClass1.c[ojq.ordinal()]) {
            case 1:
                return new sbb();
            case 2:
                return new LWm((byte) 0);
            case 3:
                return newMessageInfo(DEFAULT_INSTANCE, "\u0000\u000b\u0001\u0000\u0001\u0012\u000b\u0000\u0000\u0000\u0001:\u0000\u00025\u0000\u00033\u0000\u0005Ȼ\u0000\u0006<\u0000\b<\u0000\t<\u0000\n<\u0000\u000b?\u0000\u0011Ȼ\u0000\u0012=\u0000", new Object[]{"valueType_", "valueTypeCase_", ldG.class, jrE.class, uOO.class, AQX.class});
            case 4:
                return DEFAULT_INSTANCE;
            case 5:
                XgX<sbb> xgX2 = PARSER;
                if (xgX2 != null) {
                    return xgX2;
                }
                synchronized (sbb.class) {
                    xgX = PARSER;
                    if (xgX == null) {
                        xgX = new KUw.HBt(DEFAULT_INSTANCE);
                        PARSER = xgX;
                    }
                }
                return xgX;
            case 6:
                return (byte) 1;
            case 7:
                return null;
            default:
                throw new UnsupportedOperationException();
        }
    }

    static {
        sbb sbbVar = new sbb();
        DEFAULT_INSTANCE = sbbVar;
        KUw.registerDefaultInstance(sbb.class, sbbVar);
    }

    static /* synthetic */ void a(sbb sbbVar, AQX aqx) {
        sbbVar.valueType_ = aqx;
        sbbVar.valueTypeCase_ = 10;
    }

    static /* synthetic */ void b(sbb sbbVar, String str) {
        sbbVar.valueTypeCase_ = 17;
        sbbVar.valueType_ = str;
    }

    static /* synthetic */ void a(sbb sbbVar, QwV qwV) {
        sbbVar.valueTypeCase_ = 18;
        sbbVar.valueType_ = qwV;
    }

    static /* synthetic */ void d(sbb sbbVar, String str) {
        sbbVar.valueTypeCase_ = 5;
        sbbVar.valueType_ = str;
    }

    static /* synthetic */ void d(sbb sbbVar, jrE jre) {
        sbbVar.valueType_ = jre;
        sbbVar.valueTypeCase_ = 8;
    }

    static /* synthetic */ void b(sbb sbbVar, uOO uoo) {
        sbbVar.valueType_ = uoo;
        sbbVar.valueTypeCase_ = 9;
    }

    static /* synthetic */ void c(sbb sbbVar, ldG ldg) {
        sbbVar.valueType_ = ldg;
        sbbVar.valueTypeCase_ = 6;
    }

    static /* synthetic */ void d(sbb sbbVar, EnumC15686hkD enumC15686hkD) {
        if (enumC15686hkD == EnumC15686hkD.UNRECOGNIZED) {
            throw new IllegalArgumentException("Can't get the number of an unknown enum value.");
        }
        sbbVar.valueType_ = Integer.valueOf(enumC15686hkD.value);
        sbbVar.valueTypeCase_ = 11;
    }

    public static sbb a() {
        return DEFAULT_INSTANCE;
    }
}