BlockHeader

public sealed partial class BlockHeader : pb::GeneratedMessage<BlockHeader, BlockHeader.Builder>
{
    private BlockHeader() { }
    private static readonly BlockHeader defaultInstance = new BlockHeader().MakeReadOnly();
    private static readonly string[] _blockHeaderFieldNames = new string[] { "datasize", "indexdata", "type" };
    private static readonly uint[] _blockHeaderFieldTags = new uint[] { 24, 18, 10 };

    public static BlockHeader DefaultInstance
    {
        get { return defaultInstance; }
    }

    public override BlockHeader DefaultInstanceForType
    {
        get { return DefaultInstance; }
    }

    protected override BlockHeader ThisMessage
    {
        get { return this; }
    }

    public static pbd::MessageDescriptor Descriptor
    {
        get { return global::Fileformat.internal__static_BlockHeader__Descriptor; }
    }

    protected override pb::FieldAccess.FieldAccessorTable<BlockHeader, BlockHeader.Builder> InternalFieldAccessors
    {
        get { return global::Fileformat.internal__static_BlockHeader__FieldAccessorTable; }
    }

    public const int TypeFieldNumber = 1;
    private bool hasType;
    private string type_ = "";

    public bool HasType
    {
        get { return hasType; }
    }

    public string Type
    {
        get { return type_; }
    }

    public const int IndexdataFieldNumber = 2;
    private bool hasIndexdata;
    private pb::ByteString indexdata_ = pb::ByteString.Empty;

    public bool HasIndexdata
    {
        get { return hasIndexdata; }
    }

    public pb::ByteString Indexdata
    {
        get { return indexdata_; }
    }

    public const int DatasizeFieldNumber = 3;
    private bool hasDatasize;
    private int datasize_;

    public bool HasDatasize
    {
        get { return hasDatasize; }
    }

    public int Datasize
    {
        get { return datasize_; }
    }

    public override bool IsInitialized
    {
        get
        {
            if (!hasType) return false;
            if (!hasDatasize) return false;
            return true;
        }
    }

    public override void WriteTo(pb::ICodedOutputStream output)
    {
        int size = SerializedSize;
        string[] field_names = _blockHeaderFieldNames;
        if (hasType)
        {
            output.WriteString(1, field_names[2], Type);
        }
        if (hasIndexdata)
        {
            output.WriteBytes(2, field_names[1], Indexdata);
        }
        if (hasDatasize)
        {
            output.WriteInt32(3, field_names[0], Datasize);
        }
        UnknownFields.WriteTo(output);
    }

    private int memoizedSerializedSize = -1;

    public override int SerializedSize
    {
        get
        {
            int size = memoizedSerializedSize;
            if (size != -1) return size;

            size = 0;
            if (hasType)
            {
                size += pb::CodedOutputStream.ComputeStringSize(1, Type);
            }
            if (hasIndexdata)
            {
                size += pb::CodedOutputStream.ComputeBytesSize(2, Indexdata);
            }
            if (hasDatasize)
            {
                size += pb::CodedOutputStream.ComputeInt32Size(3, Datasize);
            }
            size += UnknownFields.SerializedSize;
            memoizedSerializedSize = size;
            return size;
        }
    }

    public static BlockHeader ParseFrom(pb::ByteString data)
    {
        return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
    }

    public static BlockHeader ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry)
    {
        return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }

    public static BlockHeader ParseFrom(byte[] data)
    {
        return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
    }

    public static BlockHeader ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry)
    {
        return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }

    public static BlockHeader ParseFrom(global::System.IO.Stream input)
    {
        return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
    }

    public static BlockHeader ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
    {
        return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }

    public static BlockHeader ParseDelimitedFrom(global::System.IO.Stream input)
    {
        return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
    }

    public static BlockHeader ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
    {
        return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
    }

    public static BlockHeader ParseFrom(pb::ICodedInputStream input)
    {
        return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
    }

    public static BlockHeader ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
    {
        return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }

    private BlockHeader MakeReadOnly()
    {
        return this;
    }

    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder ToBuilder() { return CreateBuilder(this); }
    public override Builder CreateBuilderForType() { return new Builder(); }

    public static Builder CreateBuilder(BlockHeader prototype)
    {
        return new Builder(prototype);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.4.1.473")]

    public sealed partial class Builder : pb::GeneratedBuilder<BlockHeader, Builder>
    {
        protected override Builder ThisBuilder
        {
            get { return this; }
        }

        public Builder()
        {
            result = DefaultInstance;
            resultIsReadOnly = true;
        }

        internal Builder(BlockHeader cloneFrom)
        {
            result = cloneFrom;
            resultIsReadOnly = true;
        }

        private bool resultIsReadOnly;
        private BlockHeader result;

        private BlockHeader PrepareBuilder()
        {
            if (resultIsReadOnly)
            {
                BlockHeader original = result;
                result = new BlockHeader();
                resultIsReadOnly = false;
                MergeFrom(original);
            }
            return result;
        }

        public override bool IsInitialized
        {
            get { return result.IsInitialized; }
        }

        protected override BlockHeader MessageBeingBuilt
        {
            get { return PrepareBuilder(); }
        }

        public override Builder Clear()
        {
            result = DefaultInstance;
            resultIsReadOnly = true;
            return this;
        }

        public override Builder Clone()
        {
            if (resultIsReadOnly)
            {
                return new Builder(result);
            }
            else
            {
                return new Builder().MergeFrom(result);
            }
        }

        public override pbd::MessageDescriptor DescriptorForType
        {
            get { return global::BlockHeader.Descriptor; }
        }

        public override BlockHeader DefaultInstanceForType
        {
            get { return global::BlockHeader.DefaultInstance; }
        }

        public override BlockHeader BuildPartial()
        {
            if (resultIsReadOnly)
            {
                return result;
            }
            resultIsReadOnly = true;
            return result.MakeReadOnly();
        }

        public override Builder MergeFrom(pb::IMessage other)
        {
            if (other is BlockHeader)
            {
                return MergeFrom((BlockHeader)other);
            }
            else
            {
                base.MergeFrom(other);
                return this;
            }
        }

        public override Builder MergeFrom(BlockHeader other)
        {
            if (other == global::BlockHeader.DefaultInstance) return this;
            PrepareBuilder();
            if (other.HasType)
            {
                Type = other.Type;
            }
            if (other.HasIndexdata)
            {
                Indexdata = other.Indexdata;
            }
            if (other.HasDatasize)
            {
                Datasize = other.Datasize;
            }
            this.MergeUnknownFields(other.UnknownFields);
            return this;
        }

        public override Builder MergeFrom(pb::ICodedInputStream input)
        {
            return MergeFrom(input, pb::ExtensionRegistry.Empty);
        }

        public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
        {
            PrepareBuilder();
            pb::UnknownFieldSet.Builder unknownFields = null;
            uint tag;
            string field_name;
            while (input.ReadTag(out tag, out field_name))
            {
                if (tag == 0 && field_name != null)
                {
                    int field_ordinal = global::System.Array.BinarySearch(_blockHeaderFieldNames, field_name, global::System.StringComparer.Ordinal);
                    if (field_ordinal >= 0)
                        tag = _blockHeaderFieldTags[field_ordinal];
                    else
                    {
                        if (unknownFields == null)
                        {
                            unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                        }
                        ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                        continue;
                    }
                }
                switch (tag)
                {
                    case 0:
                        {
                            throw pb::InvalidProtocolBufferException.InvalidTag();
                        }
                    default:
                        {
                            if (pb::WireFormat.IsEndGroupTag(tag))
                            {
                                if (unknownFields != null)
                                {
                                    this.UnknownFields = unknownFields.Build();
                                }
                                return this;
                            }
                            if (unknownFields == null)
                            {
                                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                            }
                            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                            break;
                        }
                    case 10:
                        {
                            result.hasType = input.ReadString(ref result.type_);
                            break;
                        }
                    case 18:
                        {
                            result.hasIndexdata = input.ReadBytes(ref result.indexdata_);
                            break;
                        }
                    case 24:
                        {
                            result.hasDatasize = input.ReadInt32(ref result.datasize_);
                            break;
                        }
                }
            }

            if (unknownFields != null)
            {
                this.UnknownFields = unknownFields.Build();
            }
            return this;
        }

        public bool HasType
        {
            get { return result.hasType; }
        }

        public string Type
        {
            get { return result.Type; }
            set { SetType(value); }
        }

        public Builder SetType(string value)
        {
            pb::ThrowHelper.ThrowIfNull(value, "value");
            PrepareBuilder();
            result.hasType = true;
            result.type_ = value;
            return this;
        }

        public Builder ClearType()
        {
            PrepareBuilder();
            result.hasType = false;
            result.type_ = "";
            return this;
        }

        public bool HasIndexdata
        {
            get { return result.hasIndexdata; }
        }

        public pb::ByteString Indexdata
        {
            get { return result.Indexdata; }
            set { SetIndexdata(value); }
        }

        public Builder SetIndexdata(pb::ByteString value)
        {
            pb::ThrowHelper.ThrowIfNull(value, "value");
            PrepareBuilder();
            result.hasIndexdata = true;
            result.indexdata_ = value;
            return this;
        }

        public Builder ClearIndexdata()
        {
            PrepareBuilder();
            result.hasIndexdata = false;
            result.indexdata_ = pb::ByteString.Empty;
            return this;
        }

        public bool HasDatasize
        {
            get { return result.hasDatasize; }
        }

        public int Datasize
        {
            get { return result.Datasize; }
            set { SetDatasize(value); }
        }

        public Builder SetDatasize(int value)
        {
            PrepareBuilder();
            result.hasDatasize = true;
            result.datasize_ = value;
            return this;
        }

        public Builder ClearDatasize()
        {
            PrepareBuilder();
            result.hasDatasize = false;
            result.datasize_ = 0;
            return this;
        }
    }

    static BlockHeader()
    {
        object.ReferenceEquals(global::Fileformat.Descriptor, null);
    }
}