// 
// Decompiled by Procyon v0.6.0
// 

package com.google.protobuf;

import java.io.InputStream;
import java.nio.ByteBuffer;
import java.util.Iterator;
import java.io.IOException;
import java.util.Map;

public final class Struct extends GeneratedMessage implements StructOrBuilder
{
    private static final long serialVersionUID = 0L;
    public static final int FIELDS_FIELD_NUMBER = 1;
    private MapField<String, Value> fields_;
    private byte memoizedIsInitialized;
    private static final Struct DEFAULT_INSTANCE;
    private static final Parser<Struct> PARSER;
    
    private Struct(final GeneratedMessage.Builder<?> builder) {
        super(builder);
        this.memoizedIsInitialized = -1;
    }
    
    private Struct() {
        this.memoizedIsInitialized = -1;
    }
    
    public static final Descriptors.Descriptor getDescriptor() {
        return StructProto.internal_static_google_protobuf_Struct_descriptor;
    }
    
    @Override
    protected MapFieldReflectionAccessor internalGetMapFieldReflection(final int number) {
        switch (number) {
            case 1: {
                return this.internalGetFields();
            }
            default: {
                throw new RuntimeException("Invalid map field number: " + number);
            }
        }
    }
    
    @Override
    protected FieldAccessorTable internalGetFieldAccessorTable() {
        return StructProto.internal_static_google_protobuf_Struct_fieldAccessorTable.ensureFieldAccessorsInitialized(Struct.class, Builder.class);
    }
    
    private MapField<String, Value> internalGetFields() {
        if (this.fields_ == null) {
            return MapField.emptyMapField(FieldsDefaultEntryHolder.defaultEntry);
        }
        return this.fields_;
    }
    
    @Override
    public int getFieldsCount() {
        return this.internalGetFields().getMap().size();
    }
    
    @Override
    public boolean containsFields(final String key) {
        if (key == null) {
            throw new NullPointerException("map key");
        }
        return this.internalGetFields().getMap().containsKey(key);
    }
    
    @Deprecated
    @Override
    public Map<String, Value> getFields() {
        return this.getFieldsMap();
    }
    
    @Override
    public Map<String, Value> getFieldsMap() {
        return this.internalGetFields().getMap();
    }
    
    @Override
    public Value getFieldsOrDefault(final String key, final Value defaultValue) {
        if (key == null) {
            throw new NullPointerException("map key");
        }
        final Map<String, Value> map = this.internalGetFields().getMap();
        return map.containsKey(key) ? map.get(key) : defaultValue;
    }
    
    @Override
    public Value getFieldsOrThrow(final String key) {
        if (key == null) {
            throw new NullPointerException("map key");
        }
        final Map<String, Value> map = this.internalGetFields().getMap();
        if (!map.containsKey(key)) {
            throw new IllegalArgumentException();
        }
        return map.get(key);
    }
    
    @Override
    public final boolean isInitialized() {
        final byte isInitialized = this.memoizedIsInitialized;
        if (isInitialized == 1) {
            return true;
        }
        if (isInitialized == 0) {
            return false;
        }
        this.memoizedIsInitialized = 1;
        return true;
    }
    
    @Override
    public void writeTo(final CodedOutputStream output) throws IOException {
        GeneratedMessage.serializeStringMapTo(output, this.internalGetFields(), FieldsDefaultEntryHolder.defaultEntry, 1);
        this.getUnknownFields().writeTo(output);
    }
    
    @Override
    public int getSerializedSize() {
        int size = this.memoizedSize;
        if (size != -1) {
            return size;
        }
        size = 0;
        for (final Map.Entry<String, Value> entry : this.internalGetFields().getMap().entrySet()) {
            final MapEntry<String, Value> fields__ = FieldsDefaultEntryHolder.defaultEntry.newBuilderForType().setKey(entry.getKey()).setValue(entry.getValue()).build();
            size += CodedOutputStream.computeMessageSize(1, fields__);
        }
        size += this.getUnknownFields().getSerializedSize();
        return this.memoizedSize = size;
    }
    
    @Override
    public boolean equals(final Object obj) {
        if (obj == this) {
            return true;
        }
        if (!(obj instanceof Struct)) {
            return super.equals(obj);
        }
        final Struct other = (Struct)obj;
        return this.internalGetFields().equals(other.internalGetFields()) && this.getUnknownFields().equals(other.getUnknownFields());
    }
    
    @Override
    public int hashCode() {
        if (this.memoizedHashCode != 0) {
            return this.memoizedHashCode;
        }
        int hash = 41;
        hash = 19 * hash + getDescriptor().hashCode();
        if (!this.internalGetFields().getMap().isEmpty()) {
            hash = 37 * hash + 1;
            hash = 53 * hash + this.internalGetFields().hashCode();
        }
        hash = 29 * hash + this.getUnknownFields().hashCode();
        return this.memoizedHashCode = hash;
    }
    
    public static Struct parseFrom(final ByteBuffer data) throws InvalidProtocolBufferException {
        return Struct.PARSER.parseFrom(data);
    }
    
    public static Struct parseFrom(final ByteBuffer data, final ExtensionRegistryLite extensionRegistry) throws InvalidProtocolBufferException {
        return Struct.PARSER.parseFrom(data, extensionRegistry);
    }
    
    public static Struct parseFrom(final ByteString data) throws InvalidProtocolBufferException {
        return Struct.PARSER.parseFrom(data);
    }
    
    public static Struct parseFrom(final ByteString data, final ExtensionRegistryLite extensionRegistry) throws InvalidProtocolBufferException {
        return Struct.PARSER.parseFrom(data, extensionRegistry);
    }
    
    public static Struct parseFrom(final byte[] data) throws InvalidProtocolBufferException {
        return Struct.PARSER.parseFrom(data);
    }
    
    public static Struct parseFrom(final byte[] data, final ExtensionRegistryLite extensionRegistry) throws InvalidProtocolBufferException {
        return Struct.PARSER.parseFrom(data, extensionRegistry);
    }
    
    public static Struct parseFrom(final InputStream input) throws IOException {
        return GeneratedMessage.parseWithIOException(Struct.PARSER, input);
    }
    
    public static Struct parseFrom(final InputStream input, final ExtensionRegistryLite extensionRegistry) throws IOException {
        return GeneratedMessage.parseWithIOException(Struct.PARSER, input, extensionRegistry);
    }
    
    public static Struct parseDelimitedFrom(final InputStream input) throws IOException {
        return GeneratedMessage.parseDelimitedWithIOException(Struct.PARSER, input);
    }
    
    public static Struct parseDelimitedFrom(final InputStream input, final ExtensionRegistryLite extensionRegistry) throws IOException {
        return GeneratedMessage.parseDelimitedWithIOException(Struct.PARSER, input, extensionRegistry);
    }
    
    public static Struct parseFrom(final CodedInputStream input) throws IOException {
        return GeneratedMessage.parseWithIOException(Struct.PARSER, input);
    }
    
    public static Struct parseFrom(final CodedInputStream input, final ExtensionRegistryLite extensionRegistry) throws IOException {
        return GeneratedMessage.parseWithIOException(Struct.PARSER, input, extensionRegistry);
    }
    
    @Override
    public Builder newBuilderForType() {
        return newBuilder();
    }
    
    public static Builder newBuilder() {
        return Struct.DEFAULT_INSTANCE.toBuilder();
    }
    
    public static Builder newBuilder(final Struct prototype) {
        return Struct.DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
    }
    
    @Override
    public Builder toBuilder() {
        return (this == Struct.DEFAULT_INSTANCE) ? new Builder() : new Builder().mergeFrom(this);
    }
    
    @Override
    protected Builder newBuilderForType(final BuilderParent parent) {
        final Builder builder = new Builder(parent);
        return builder;
    }
    
    public static Struct getDefaultInstance() {
        return Struct.DEFAULT_INSTANCE;
    }
    
    public static Parser<Struct> parser() {
        return Struct.PARSER;
    }
    
    @Override
    public Parser<Struct> getParserForType() {
        return Struct.PARSER;
    }
    
    @Override
    public Struct getDefaultInstanceForType() {
        return Struct.DEFAULT_INSTANCE;
    }
    
    static {
        RuntimeVersion.validateProtobufGencodeVersion(RuntimeVersion.RuntimeDomain.PUBLIC, 4, 33, 0, "", "Struct");
        DEFAULT_INSTANCE = new Struct();
        PARSER = new AbstractParser<Struct>() {
            @Override
            public Struct parsePartialFrom(final CodedInputStream input, final ExtensionRegistryLite extensionRegistry) throws InvalidProtocolBufferException {
                final Builder builder = Struct.newBuilder();
                try {
                    builder.mergeFrom(input, extensionRegistry);
                }
                catch (final InvalidProtocolBufferException e) {
                    throw e.setUnfinishedMessage(builder.buildPartial());
                }
                catch (final UninitializedMessageException e2) {
                    throw e2.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
                }
                catch (final IOException e3) {
                    throw new InvalidProtocolBufferException(e3).setUnfinishedMessage(builder.buildPartial());
                }
                return builder.buildPartial();
            }
        };
    }
    
    private static final class FieldsDefaultEntryHolder
    {
        static final MapEntry<String, Value> defaultEntry;
        
        static {
            defaultEntry = MapEntry.newDefaultInstance(StructProto.internal_static_google_protobuf_Struct_FieldsEntry_descriptor, WireFormat.FieldType.STRING, "", WireFormat.FieldType.MESSAGE, Value.getDefaultInstance());
        }
    }
    
    public static final class Builder extends GeneratedMessage.Builder<Builder> implements StructOrBuilder
    {
        private int bitField0_;
        private static final FieldsConverter fieldsConverter;
        private MapFieldBuilder<String, ValueOrBuilder, Value, Value.Builder> fields_;
        
        public static final Descriptors.Descriptor getDescriptor() {
            return StructProto.internal_static_google_protobuf_Struct_descriptor;
        }
        
        @Override
        protected MapFieldReflectionAccessor internalGetMapFieldReflection(final int number) {
            switch (number) {
                case 1: {
                    return this.internalGetFields();
                }
                default: {
                    throw new RuntimeException("Invalid map field number: " + number);
                }
            }
        }
        
        @Override
        protected MapFieldReflectionAccessor internalGetMutableMapFieldReflection(final int number) {
            switch (number) {
                case 1: {
                    return this.internalGetMutableFields();
                }
                default: {
                    throw new RuntimeException("Invalid map field number: " + number);
                }
            }
        }
        
        @Override
        protected FieldAccessorTable internalGetFieldAccessorTable() {
            return StructProto.internal_static_google_protobuf_Struct_fieldAccessorTable.ensureFieldAccessorsInitialized(Struct.class, Builder.class);
        }
        
        private Builder() {
        }
        
        private Builder(final BuilderParent parent) {
            super(parent);
        }
        
        @Override
        public Builder clear() {
            super.clear();
            this.bitField0_ = 0;
            this.internalGetMutableFields().clear();
            return this;
        }
        
        @Override
        public Descriptors.Descriptor getDescriptorForType() {
            return StructProto.internal_static_google_protobuf_Struct_descriptor;
        }
        
        @Override
        public Struct getDefaultInstanceForType() {
            return Struct.getDefaultInstance();
        }
        
        @Override
        public Struct build() {
            final Struct result = this.buildPartial();
            if (!result.isInitialized()) {
                throw AbstractMessage.Builder.newUninitializedMessageException(result);
            }
            return result;
        }
        
        @Override
        public Struct buildPartial() {
            final Struct result = new Struct(this, null);
            if (this.bitField0_ != 0) {
                this.buildPartial0(result);
            }
            this.onBuilt();
            return result;
        }
        
        private void buildPartial0(final Struct result) {
            final int from_bitField0_ = this.bitField0_;
            if ((from_bitField0_ & 0x1) != 0x0) {
                result.fields_ = this.internalGetFields().build(FieldsDefaultEntryHolder.defaultEntry);
            }
        }
        
        @Override
        public Builder mergeFrom(final Message other) {
            if (other instanceof Struct) {
                return this.mergeFrom((Struct)other);
            }
            super.mergeFrom(other);
            return this;
        }
        
        public Builder mergeFrom(final Struct other) {
            if (other == Struct.getDefaultInstance()) {
                return this;
            }
            this.internalGetMutableFields().mergeFrom(other.internalGetFields());
            this.bitField0_ |= 0x1;
            this.mergeUnknownFields(other.getUnknownFields());
            this.onChanged();
            return this;
        }
        
        @Override
        public final boolean isInitialized() {
            return true;
        }
        
        @Override
        public Builder mergeFrom(final CodedInputStream input, final ExtensionRegistryLite extensionRegistry) throws IOException {
            if (extensionRegistry == null) {
                throw new NullPointerException();
            }
            try {
                boolean done = false;
                while (!done) {
                    final int tag = input.readTag();
                    switch (tag) {
                        case 0: {
                            done = true;
                            continue;
                        }
                        case 10: {
                            final MapEntry<String, Value> fields__ = input.readMessage(FieldsDefaultEntryHolder.defaultEntry.getParserForType(), extensionRegistry);
                            this.internalGetMutableFields().ensureBuilderMap().put(fields__.getKey(), fields__.getValue());
                            this.bitField0_ |= 0x1;
                            continue;
                        }
                        default: {
                            if (!super.parseUnknownField(input, extensionRegistry, tag)) {
                                done = true;
                                continue;
                            }
                            continue;
                        }
                    }
                }
            }
            catch (final InvalidProtocolBufferException e) {
                throw e.unwrapIOException();
            }
            finally {
                this.onChanged();
            }
            return this;
        }
        
        private MapFieldBuilder<String, ValueOrBuilder, Value, Value.Builder> internalGetFields() {
            if (this.fields_ == null) {
                return new MapFieldBuilder<String, ValueOrBuilder, Value, Value.Builder>(Builder.fieldsConverter);
            }
            return this.fields_;
        }
        
        private MapFieldBuilder<String, ValueOrBuilder, Value, Value.Builder> internalGetMutableFields() {
            if (this.fields_ == null) {
                this.fields_ = new MapFieldBuilder<String, ValueOrBuilder, Value, Value.Builder>(Builder.fieldsConverter);
            }
            this.bitField0_ |= 0x1;
            this.onChanged();
            return this.fields_;
        }
        
        @Override
        public int getFieldsCount() {
            return this.internalGetFields().ensureBuilderMap().size();
        }
        
        @Override
        public boolean containsFields(final String key) {
            if (key == null) {
                throw new NullPointerException("map key");
            }
            return this.internalGetFields().ensureBuilderMap().containsKey(key);
        }
        
        @Deprecated
        @Override
        public Map<String, Value> getFields() {
            return this.getFieldsMap();
        }
        
        @Override
        public Map<String, Value> getFieldsMap() {
            return this.internalGetFields().getImmutableMap();
        }
        
        @Override
        public Value getFieldsOrDefault(final String key, final Value defaultValue) {
            if (key == null) {
                throw new NullPointerException("map key");
            }
            final Map<String, ValueOrBuilder> map = this.internalGetMutableFields().ensureBuilderMap();
            return map.containsKey(key) ? Builder.fieldsConverter.build((ValueOrBuilder)map.get(key)) : defaultValue;
        }
        
        @Override
        public Value getFieldsOrThrow(final String key) {
            if (key == null) {
                throw new NullPointerException("map key");
            }
            final Map<String, ValueOrBuilder> map = this.internalGetMutableFields().ensureBuilderMap();
            if (!map.containsKey(key)) {
                throw new IllegalArgumentException();
            }
            return Builder.fieldsConverter.build((ValueOrBuilder)map.get(key));
        }
        
        public Builder clearFields() {
            this.bitField0_ &= 0xFFFFFFFE;
            this.internalGetMutableFields().clear();
            return this;
        }
        
        public Builder removeFields(final String key) {
            if (key == null) {
                throw new NullPointerException("map key");
            }
            this.internalGetMutableFields().ensureBuilderMap().remove(key);
            return this;
        }
        
        @Deprecated
        public Map<String, Value> getMutableFields() {
            this.bitField0_ |= 0x1;
            return this.internalGetMutableFields().ensureMessageMap();
        }
        
        public Builder putFields(final String key, final Value value) {
            if (key == null) {
                throw new NullPointerException("map key");
            }
            if (value == null) {
                throw new NullPointerException("map value");
            }
            this.internalGetMutableFields().ensureBuilderMap().put(key, value);
            this.bitField0_ |= 0x1;
            return this;
        }
        
        public Builder putAllFields(final Map<String, Value> values) {
            for (final Map.Entry<String, Value> e : values.entrySet()) {
                if (e.getKey() == null || e.getValue() == null) {
                    throw new NullPointerException();
                }
            }
            this.internalGetMutableFields().ensureBuilderMap().putAll(values);
            this.bitField0_ |= 0x1;
            return this;
        }
        
        public Value.Builder putFieldsBuilderIfAbsent(final String key) {
            final Map<String, ValueOrBuilder> builderMap = this.internalGetMutableFields().ensureBuilderMap();
            ValueOrBuilder entry = builderMap.get(key);
            if (entry == null) {
                entry = Value.newBuilder();
                builderMap.put(key, entry);
            }
            if (entry instanceof Value) {
                entry = ((Value)entry).toBuilder();
                builderMap.put(key, entry);
            }
            return (Value.Builder)entry;
        }
        
        static {
            fieldsConverter = new FieldsConverter();
        }
        
        private static final class FieldsConverter implements MapFieldBuilder.Converter<String, ValueOrBuilder, Value>
        {
            @Override
            public Value build(final ValueOrBuilder val) {
                if (val instanceof Value) {
                    return (Value)val;
                }
                return ((Value.Builder)val).build();
            }
            
            @Override
            public MapEntry<String, Value> defaultEntry() {
                return FieldsDefaultEntryHolder.defaultEntry;
            }
        }
    }
}