翰林优商.apk(点击下载) / RuntimeMessageAdapter.java

package com.czhj.wire;

import com.czhj.wire.Message;
import com.czhj.wire.Message.Builder;
import com.czhj.wire.ProtoAdapter;
import com.czhj.wire.WireField;
import com.czhj.wire.internal.Internal;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

final class RuntimeMessageAdapter<M extends Message<M, B>, B extends Message.Builder<M, B>> extends ProtoAdapter<M> {
    private static final String a = "██";
    private final Class<M> b;
    private final Class<B> c;
    private final Map<Integer, FieldBinding<M, B>> d;

    RuntimeMessageAdapter(Class<M> cls, Class<B> cls2, Map<Integer, FieldBinding<M, B>> map) {
        super(FieldEncoding.LENGTH_DELIMITED, cls);
        this.b = cls;
        this.c = cls2;
        this.d = map;
    }

    static <M extends Message<M, B>, B extends Message.Builder<M, B>> RuntimeMessageAdapter<M, B> a(Class<M> cls) {
        Class b2 = b(cls);
        LinkedHashMap linkedHashMap = new LinkedHashMap();
        Field[] declaredFields = cls.getDeclaredFields();
        for (Field field : declaredFields) {
            WireField wireField = (WireField) field.getAnnotation(WireField.class);
            if (wireField != null) {
                linkedHashMap.put(Integer.valueOf(wireField.tag()), new FieldBinding(wireField, field, b2));
            }
        }
        return new RuntimeMessageAdapter<>(cls, b2, Collections.unmodifiableMap(linkedHashMap));
    }

    private static <M extends Message<M, B>, B extends Message.Builder<M, B>> Class<B> b(Class<M> cls) {
        try {
            return (Class<B>) Class.forName(cls.getName() + "$Builder");
        } catch (ClassNotFoundException unused) {
            throw new IllegalArgumentException("No builder class found for message type " + cls.getName());
        }
    }

    /* access modifiers changed from: package-private */
    public Map<Integer, FieldBinding<M, B>> a() {
        return this.d;
    }

    /* access modifiers changed from: package-private */
    public B b() {
        try {
            return this.c.newInstance();
        } catch (Throwable th) {
            throw new AssertionError(th);
        }
    }

    @Override // com.czhj.wire.ProtoAdapter
    public M decode(ProtoReader protoReader) throws IOException {
        B b2 = b();
        long beginMessage = protoReader.beginMessage();
        while (true) {
            int nextTag = protoReader.nextTag();
            if (nextTag != -1) {
                FieldBinding<M, B> fieldBinding = this.d.get(Integer.valueOf(nextTag));
                if (fieldBinding != null) {
                    try {
                        fieldBinding.a(b2, (fieldBinding.a() ? fieldBinding.d() : fieldBinding.b()).decode(protoReader));
                    } catch (ProtoAdapter.EnumConstantNotFoundException e) {
                        b2.addUnknownField(nextTag, FieldEncoding.VARINT, Long.valueOf((long) e.value));
                    }
                } else {
                    FieldEncoding peekFieldEncoding = protoReader.peekFieldEncoding();
                    b2.addUnknownField(nextTag, peekFieldEncoding, peekFieldEncoding.rawProtoAdapter().decode(protoReader));
                }
            } else {
                protoReader.endMessage(beginMessage);
                return (M) b2.build();
            }
        }
    }

    public void encode(ProtoWriter protoWriter, M m) throws IOException {
        for (FieldBinding<M, B> fieldBinding : this.d.values()) {
            Object a2 = fieldBinding.a(m);
            if (a2 != null) {
                fieldBinding.d().encodeWithTag(protoWriter, fieldBinding.tag, a2);
            }
        }
        protoWriter.writeBytes(m.unknownFields());
    }

    public int encodedSize(M m) {
        int i = m.cachedSerializedSize;
        if (i != 0) {
            return i;
        }
        int i2 = 0;
        for (FieldBinding<M, B> fieldBinding : this.d.values()) {
            Object a2 = fieldBinding.a(m);
            if (a2 != null) {
                i2 += fieldBinding.d().encodedSizeWithTag(fieldBinding.tag, a2);
            }
        }
        int size = i2 + m.unknownFields().size();
        m.cachedSerializedSize = size;
        return size;
    }

    public boolean equals(Object obj) {
        return (obj instanceof RuntimeMessageAdapter) && ((RuntimeMessageAdapter) obj).b == this.b;
    }

    public int hashCode() {
        return this.b.hashCode();
    }

    public M redact(M m) {
        Message.Builder newBuilder = m.newBuilder();
        for (FieldBinding<M, B> fieldBinding : this.d.values()) {
            if (!fieldBinding.redacted || fieldBinding.label != WireField.Label.REQUIRED) {
                boolean isAssignableFrom = Message.class.isAssignableFrom(fieldBinding.b().javaType);
                if (fieldBinding.redacted || (isAssignableFrom && !fieldBinding.label.a())) {
                    Object a2 = fieldBinding.a(newBuilder);
                    if (a2 != null) {
                        fieldBinding.b(newBuilder, fieldBinding.d().redact(a2));
                    }
                } else if (isAssignableFrom && fieldBinding.label.a()) {
                    Internal.redactElements((List) fieldBinding.a(newBuilder), fieldBinding.b());
                }
            } else {
                throw new UnsupportedOperationException(String.format("Field '%s' in %s is required and cannot be redacted.", fieldBinding.name, this.javaType.getName()));
            }
        }
        newBuilder.clearUnknownFields();
        return (M) newBuilder.build();
    }

    public String toString(M m) {
        StringBuilder sb = new StringBuilder();
        for (FieldBinding<M, B> fieldBinding : this.d.values()) {
            Object a2 = fieldBinding.a(m);
            if (a2 != null) {
                sb.append(", ");
                sb.append(fieldBinding.name);
                sb.append('=');
                if (fieldBinding.redacted) {
                    a2 = a;
                }
                sb.append(a2);
            }
        }
        sb.replace(0, 2, this.b.getSimpleName() + '{');
        sb.append('}');
        return sb.toString();
    }
}