csharp/src/ProtocolBuffers/UnknownField.cs - third_party/github/protocolbuffers/protobuf - Git at Google

 #region Copyright notice and license

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // http://github.com/jskeet/dotnet-protobufs/
 // Original C++/Java/Python code:
 // http://code.google.com/p/protobuf/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #endregion

 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using Google.ProtocolBuffers.Collections;

 namespace Google.ProtocolBuffers
 {
     /// <summary>
     /// Represents a single field in an UnknownFieldSet.
     ///
     /// An UnknownField consists of five lists of values. The lists correspond
     /// to the five "wire types" used in the protocol buffer binary format.
     /// The wire type of each field can be determined from the encoded form alone,
     /// without knowing the field's declared type. So, we are able to parse
     /// unknown values at least this far and separate them. Normally, only one
     /// of the five lists will contain any values, since it is impossible to
     /// define a valid message type that declares two different types for the
     /// same field number. However, the code is designed to allow for the case
     /// where the same unknown field number is encountered using multiple different
     /// wire types.
     ///
     /// UnknownField is an immutable class. To construct one, you must use an
     /// UnknownField.Builder.
     /// </summary>
     public sealed class UnknownField
     {
         public const string UnknownFieldName = "unknown_field";
         private static readonly UnknownField defaultInstance = CreateBuilder().Build();
         private readonly ReadOnlyCollection<ulong> varintList;
         private readonly ReadOnlyCollection<uint> fixed32List;
         private readonly ReadOnlyCollection<ulong> fixed64List;
         private readonly ReadOnlyCollection<ByteString> lengthDelimitedList;
         private readonly ReadOnlyCollection<UnknownFieldSet> groupList;

         private UnknownField(ReadOnlyCollection<ulong> varintList,
                              ReadOnlyCollection<uint> fixed32List,
                              ReadOnlyCollection<ulong> fixed64List,
                              ReadOnlyCollection<ByteString> lengthDelimitedList,
                              ReadOnlyCollection<UnknownFieldSet> groupList)
         {
             this.varintList = varintList;
             this.fixed32List = fixed32List;
             this.fixed64List = fixed64List;
             this.lengthDelimitedList = lengthDelimitedList;
             this.groupList = groupList;
         }

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

         /// <summary>
         /// The list of varint values for this field.
         /// </summary>
         public IList<ulong> VarintList
         {
             get { return varintList; }
         }

         /// <summary>
         /// The list of fixed32 values for this field.
         /// </summary>
         public IList<uint> Fixed32List
         {
             get { return fixed32List; }
         }

         /// <summary>
         /// The list of fixed64 values for this field.
         /// </summary>
         public IList<ulong> Fixed64List
         {
             get { return fixed64List; }
         }

         /// <summary>
         /// The list of length-delimited values for this field.
         /// </summary>
         public IList<ByteString> LengthDelimitedList
         {
             get { return lengthDelimitedList; }
         }

         /// <summary>
         /// The list of embedded group values for this field. These
         /// are represented using UnknownFieldSets rather than Messages
         /// since the group's type is presumably unknown.
         /// </summary>
         public IList<UnknownFieldSet> GroupList
         {
             get { return groupList; }
         }

         public override bool Equals(object other)
         {
             if (ReferenceEquals(this, other))
             {
                 return true;
             }
             UnknownField otherField = other as UnknownField;
             return otherField != null
                    && Lists.Equals(varintList, otherField.varintList)
                    && Lists.Equals(fixed32List, otherField.fixed32List)
                    && Lists.Equals(fixed64List, otherField.fixed64List)
                    && Lists.Equals(lengthDelimitedList, otherField.lengthDelimitedList)
                    && Lists.Equals(groupList, otherField.groupList);
         }

         public override int GetHashCode()
         {
             int hash = 43;
             hash = hash*47 + Lists.GetHashCode(varintList);
             hash = hash*47 + Lists.GetHashCode(fixed32List);
             hash = hash*47 + Lists.GetHashCode(fixed64List);
             hash = hash*47 + Lists.GetHashCode(lengthDelimitedList);
             hash = hash*47 + Lists.GetHashCode(groupList);
             return hash;
         }

         /// <summary>
         /// Constructs a new Builder.
         /// </summary>
         public static Builder CreateBuilder()
         {
             return new Builder();
         }

         /// <summary>
         /// Constructs a new Builder and initializes it to a copy of <paramref name="copyFrom"/>.
         /// </summary>
         public static Builder CreateBuilder(UnknownField copyFrom)
         {
             return new Builder().MergeFrom(copyFrom);
         }

         /// <summary>
         /// Serializes the field, including the field number, and writes it to
         /// <paramref name="output"/>.
         /// </summary>
         public void WriteTo(int fieldNumber, ICodedOutputStream output)
         {
             foreach (ulong value in varintList)
             {
                 output.WriteUnknownField(fieldNumber, WireFormat.WireType.Varint, value);
             }
             foreach (uint value in fixed32List)
             {
                 output.WriteUnknownField(fieldNumber, WireFormat.WireType.Fixed32, value);
             }
             foreach (ulong value in fixed64List)
             {
                 output.WriteUnknownField(fieldNumber, WireFormat.WireType.Fixed64, value);
             }
             foreach (ByteString value in lengthDelimitedList)
             {
                 output.WriteUnknownBytes(fieldNumber, value);
             }
             foreach (UnknownFieldSet value in groupList)
             {
 #pragma warning disable 0612
                 output.WriteUnknownGroup(fieldNumber, value);
 #pragma warning restore 0612
             }
         }

         /// <summary>
         /// Computes the number of bytes required to encode this field, including field
         /// number.
         /// </summary>
         public int GetSerializedSize(int fieldNumber)
         {
             int result = 0;
             foreach (ulong value in varintList)
             {
                 result += CodedOutputStream.ComputeUInt64Size(fieldNumber, value);
             }
             foreach (uint value in fixed32List)
             {
                 result += CodedOutputStream.ComputeFixed32Size(fieldNumber, value);
             }
             foreach (ulong value in fixed64List)
             {
                 result += CodedOutputStream.ComputeFixed64Size(fieldNumber, value);
             }
             foreach (ByteString value in lengthDelimitedList)
             {
                 result += CodedOutputStream.ComputeBytesSize(fieldNumber, value);
             }
             foreach (UnknownFieldSet value in groupList)
             {
 #pragma warning disable 0612
                 result += CodedOutputStream.ComputeUnknownGroupSize(fieldNumber, value);
 #pragma warning restore 0612
             }
             return result;
         }

         /// <summary>
         /// Serializes the length-delimited values of the field, including field
         /// number, and writes them to <paramref name="output"/> using the MessageSet wire format.
         /// </summary>
         /// <param name="fieldNumber"></param>
         /// <param name="output"></param>
         public void WriteAsMessageSetExtensionTo(int fieldNumber, ICodedOutputStream output)
         {
             foreach (ByteString value in lengthDelimitedList)
             {
                 output.WriteMessageSetExtension(fieldNumber, UnknownFieldName, value);
             }
         }

         /// <summary>
         /// Get the number of bytes required to encode this field, incuding field number,
         /// using the MessageSet wire format.
         /// </summary>
         public int GetSerializedSizeAsMessageSetExtension(int fieldNumber)
         {
             int result = 0;
             foreach (ByteString value in lengthDelimitedList)
             {
                 result += CodedOutputStream.ComputeRawMessageSetExtensionSize(fieldNumber, value);
             }
             return result;
         }

         /// <summary>
         /// Used to build instances of UnknownField.
         /// </summary>
         public sealed class Builder
         {
             private List<ulong> varintList;
             private List<uint> fixed32List;
             private List<ulong> fixed64List;
             private List<ByteString> lengthDelimitedList;
             private List<UnknownFieldSet> groupList;

             /// <summary>
             /// Builds the field. After building, the builder is reset to an empty
             /// state. (This is actually easier than making it unusable.)
             /// </summary>
             public UnknownField Build()
             {
                 return new UnknownField(MakeReadOnly(ref varintList),
                                         MakeReadOnly(ref fixed32List),
                                         MakeReadOnly(ref fixed64List),
                                         MakeReadOnly(ref lengthDelimitedList),
                                         MakeReadOnly(ref groupList));
             }

             /// <summary>
             /// Merge the values in <paramref name="other" /> into this field.  For each list
             /// of values, <paramref name="other"/>'s values are append to the ones in this
             /// field.
             /// </summary>
             public Builder MergeFrom(UnknownField other)
             {
                 varintList = AddAll(varintList, other.VarintList);
                 fixed32List = AddAll(fixed32List, other.Fixed32List);
                 fixed64List = AddAll(fixed64List, other.Fixed64List);
                 lengthDelimitedList = AddAll(lengthDelimitedList, other.LengthDelimitedList);
                 groupList = AddAll(groupList, other.GroupList);
                 return this;
             }

             /// <summary>
             /// Returns a new list containing all of the given specified values from
             /// both the <paramref name="current"/> and <paramref name="extras"/> lists.
             /// If <paramref name="current" /> is null and <paramref name="extras"/> is empty,
             /// null is returned. Otherwise, either a new list is created (if <paramref name="current" />
             /// is null) or the elements of <paramref name="extras"/> are added to <paramref name="current" />.
             /// </summary>
             private static List<T> AddAll<T>(List<T> current, IList<T> extras)
             {
                 if (extras.Count == 0)
                 {
                     return current;
                 }
                 if (current == null)
                 {
                     current = new List<T>(extras);
                 }
                 else
                 {
                     current.AddRange(extras);
                 }
                 return current;
             }

             /// <summary>
             /// Clears the contents of this builder.
             /// </summary>
             public Builder Clear()
             {
                 varintList = null;
                 fixed32List = null;
                 fixed64List = null;
                 lengthDelimitedList = null;
                 groupList = null;
                 return this;
             }

             /// <summary>
             /// Adds a varint value.
             /// </summary>
             [CLSCompliant(false)]
             public Builder AddVarint(ulong value)
             {
                 varintList = Add(varintList, value);
                 return this;
             }

             /// <summary>
             /// Adds a fixed32 value.
             /// </summary>
             [CLSCompliant(false)]
             public Builder AddFixed32(uint value)
             {
                 fixed32List = Add(fixed32List, value);
                 return this;
             }

             /// <summary>
             /// Adds a fixed64 value.
             /// </summary>
             [CLSCompliant(false)]
             public Builder AddFixed64(ulong value)
             {
                 fixed64List = Add(fixed64List, value);
                 return this;
             }

             /// <summary>
             /// Adds a length-delimited value.
             /// </summary>
             public Builder AddLengthDelimited(ByteString value)
             {
                 lengthDelimitedList = Add(lengthDelimitedList, value);
                 return this;
             }

             /// <summary>
             /// Adds an embedded group.
             /// </summary>
             /// <param name="value"></param>
             /// <returns></returns>
             public Builder AddGroup(UnknownFieldSet value)
             {
                 groupList = Add(groupList, value);
                 return this;
             }

             /// <summary>
             /// Adds <paramref name="value"/> to the <paramref name="list"/>, creating
             /// a new list if <paramref name="list"/> is null. The list is returned - either
             /// the original reference or the new list.
             /// </summary>
             private static List<T> Add<T>(List<T> list, T value)
             {
                 if (list == null)
                 {
                     list = new List<T>();
                 }
                 list.Add(value);
                 return list;
             }

             /// <summary>
             /// Returns a read-only version of the given IList, and clears
             /// the field used for <paramref name="list"/>. If the value
             /// is null, an empty list is produced using Lists.Empty.
             /// </summary>
             /// <returns></returns>
             private static ReadOnlyCollection<T> MakeReadOnly<T>(ref List<T> list)
             {
                 ReadOnlyCollection<T> ret = list == null ? Lists<T>.Empty : new ReadOnlyCollection<T>(list);
                 list = null;
                 return ret;
             }
         }
     }
 }
	#region Copyright notice and license

	// Protocol Buffers - Google's data interchange format
	// Copyright 2008 Google Inc. All rights reserved.
	// http://github.com/jskeet/dotnet-protobufs/
	// Original C++/Java/Python code:
	// http://code.google.com/p/protobuf/
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are
	// met:
	//
	// * Redistributions of source code must retain the above copyright
	// notice, this list of conditions and the following disclaimer.
	// * Redistributions in binary form must reproduce the above
	// copyright notice, this list of conditions and the following disclaimer
	// in the documentation and/or other materials provided with the
	// distribution.
	// * Neither the name of Google Inc. nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	#endregion

	using System;
	using System.Collections.Generic;
	using System.Collections.ObjectModel;
	using Google.ProtocolBuffers.Collections;

	namespace Google.ProtocolBuffers
	{
	/// <summary>
	/// Represents a single field in an UnknownFieldSet.
	///
	/// An UnknownField consists of five lists of values. The lists correspond
	/// to the five "wire types" used in the protocol buffer binary format.
	/// The wire type of each field can be determined from the encoded form alone,
	/// without knowing the field's declared type. So, we are able to parse
	/// unknown values at least this far and separate them. Normally, only one
	/// of the five lists will contain any values, since it is impossible to
	/// define a valid message type that declares two different types for the
	/// same field number. However, the code is designed to allow for the case
	/// where the same unknown field number is encountered using multiple different
	/// wire types.
	///
	/// UnknownField is an immutable class. To construct one, you must use an
	/// UnknownField.Builder.
	/// </summary>
	public sealed class UnknownField
	{
	public const string UnknownFieldName = "unknown_field";
	private static readonly UnknownField defaultInstance = CreateBuilder().Build();
	private readonly ReadOnlyCollection<ulong> varintList;
	private readonly ReadOnlyCollection<uint> fixed32List;
	private readonly ReadOnlyCollection<ulong> fixed64List;
	private readonly ReadOnlyCollection<ByteString> lengthDelimitedList;
	private readonly ReadOnlyCollection<UnknownFieldSet> groupList;

	private UnknownField(ReadOnlyCollection<ulong> varintList,
	ReadOnlyCollection<uint> fixed32List,
	ReadOnlyCollection<ulong> fixed64List,
	ReadOnlyCollection<ByteString> lengthDelimitedList,
	ReadOnlyCollection<UnknownFieldSet> groupList)
	{
	this.varintList = varintList;
	this.fixed32List = fixed32List;
	this.fixed64List = fixed64List;
	this.lengthDelimitedList = lengthDelimitedList;
	this.groupList = groupList;
	}

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

	/// <summary>
	/// The list of varint values for this field.
	/// </summary>
	public IList<ulong> VarintList
	{
	get { return varintList; }
	}

	/// <summary>
	/// The list of fixed32 values for this field.
	/// </summary>
	public IList<uint> Fixed32List
	{
	get { return fixed32List; }
	}

	/// <summary>
	/// The list of fixed64 values for this field.
	/// </summary>
	public IList<ulong> Fixed64List
	{
	get { return fixed64List; }
	}

	/// <summary>
	/// The list of length-delimited values for this field.
	/// </summary>
	public IList<ByteString> LengthDelimitedList
	{
	get { return lengthDelimitedList; }
	}

	/// <summary>
	/// The list of embedded group values for this field. These
	/// are represented using UnknownFieldSets rather than Messages
	/// since the group's type is presumably unknown.
	/// </summary>
	public IList<UnknownFieldSet> GroupList
	{
	get { return groupList; }
	}

	public override bool Equals(object other)
	{
	if (ReferenceEquals(this, other))
	{
	return true;
	}
	UnknownField otherField = other as UnknownField;
	return otherField != null
	&& Lists.Equals(varintList, otherField.varintList)
	&& Lists.Equals(fixed32List, otherField.fixed32List)
	&& Lists.Equals(fixed64List, otherField.fixed64List)
	&& Lists.Equals(lengthDelimitedList, otherField.lengthDelimitedList)
	&& Lists.Equals(groupList, otherField.groupList);
	}

	public override int GetHashCode()
	{
	int hash = 43;
	hash = hash*47 + Lists.GetHashCode(varintList);
	hash = hash*47 + Lists.GetHashCode(fixed32List);
	hash = hash*47 + Lists.GetHashCode(fixed64List);
	hash = hash*47 + Lists.GetHashCode(lengthDelimitedList);
	hash = hash*47 + Lists.GetHashCode(groupList);
	return hash;
	}

	/// <summary>
	/// Constructs a new Builder.
	/// </summary>
	public static Builder CreateBuilder()
	{
	return new Builder();
	}

	/// <summary>
	/// Constructs a new Builder and initializes it to a copy of <paramref name="copyFrom"/>.
	/// </summary>
	public static Builder CreateBuilder(UnknownField copyFrom)
	{
	return new Builder().MergeFrom(copyFrom);
	}

	/// <summary>
	/// Serializes the field, including the field number, and writes it to
	/// <paramref name="output"/>.
	/// </summary>
	public void WriteTo(int fieldNumber, ICodedOutputStream output)
	{
	foreach (ulong value in varintList)
	{
	output.WriteUnknownField(fieldNumber, WireFormat.WireType.Varint, value);
	}
	foreach (uint value in fixed32List)
	{
	output.WriteUnknownField(fieldNumber, WireFormat.WireType.Fixed32, value);
	}
	foreach (ulong value in fixed64List)
	{
	output.WriteUnknownField(fieldNumber, WireFormat.WireType.Fixed64, value);
	}
	foreach (ByteString value in lengthDelimitedList)
	{
	output.WriteUnknownBytes(fieldNumber, value);
	}
	foreach (UnknownFieldSet value in groupList)
	{
	#pragma warning disable 0612
	output.WriteUnknownGroup(fieldNumber, value);
	#pragma warning restore 0612
	}
	}

	/// <summary>
	/// Computes the number of bytes required to encode this field, including field
	/// number.
	/// </summary>
	public int GetSerializedSize(int fieldNumber)
	{
	int result = 0;
	foreach (ulong value in varintList)
	{
	result += CodedOutputStream.ComputeUInt64Size(fieldNumber, value);
	}
	foreach (uint value in fixed32List)
	{
	result += CodedOutputStream.ComputeFixed32Size(fieldNumber, value);
	}
	foreach (ulong value in fixed64List)
	{
	result += CodedOutputStream.ComputeFixed64Size(fieldNumber, value);
	}
	foreach (ByteString value in lengthDelimitedList)
	{
	result += CodedOutputStream.ComputeBytesSize(fieldNumber, value);
	}
	foreach (UnknownFieldSet value in groupList)
	{
	#pragma warning disable 0612
	result += CodedOutputStream.ComputeUnknownGroupSize(fieldNumber, value);
	#pragma warning restore 0612
	}
	return result;
	}

	/// <summary>
	/// Serializes the length-delimited values of the field, including field
	/// number, and writes them to <paramref name="output"/> using the MessageSet wire format.
	/// </summary>
	/// <param name="fieldNumber"></param>
	/// <param name="output"></param>
	public void WriteAsMessageSetExtensionTo(int fieldNumber, ICodedOutputStream output)
	{
	foreach (ByteString value in lengthDelimitedList)
	{
	output.WriteMessageSetExtension(fieldNumber, UnknownFieldName, value);
	}
	}

	/// <summary>
	/// Get the number of bytes required to encode this field, incuding field number,
	/// using the MessageSet wire format.
	/// </summary>
	public int GetSerializedSizeAsMessageSetExtension(int fieldNumber)
	{
	int result = 0;
	foreach (ByteString value in lengthDelimitedList)
	{
	result += CodedOutputStream.ComputeRawMessageSetExtensionSize(fieldNumber, value);
	}
	return result;
	}

	/// <summary>
	/// Used to build instances of UnknownField.
	/// </summary>
	public sealed class Builder
	{
	private List<ulong> varintList;
	private List<uint> fixed32List;
	private List<ulong> fixed64List;
	private List<ByteString> lengthDelimitedList;
	private List<UnknownFieldSet> groupList;

	/// <summary>
	/// Builds the field. After building, the builder is reset to an empty
	/// state. (This is actually easier than making it unusable.)
	/// </summary>
	public UnknownField Build()
	{
	return new UnknownField(MakeReadOnly(ref varintList),
	MakeReadOnly(ref fixed32List),
	MakeReadOnly(ref fixed64List),
	MakeReadOnly(ref lengthDelimitedList),
	MakeReadOnly(ref groupList));
	}

	/// <summary>
	/// Merge the values in <paramref name="other" /> into this field. For each list
	/// of values, <paramref name="other"/>'s values are append to the ones in this
	/// field.
	/// </summary>
	public Builder MergeFrom(UnknownField other)
	{
	varintList = AddAll(varintList, other.VarintList);
	fixed32List = AddAll(fixed32List, other.Fixed32List);
	fixed64List = AddAll(fixed64List, other.Fixed64List);
	lengthDelimitedList = AddAll(lengthDelimitedList, other.LengthDelimitedList);
	groupList = AddAll(groupList, other.GroupList);
	return this;
	}

	/// <summary>
	/// Returns a new list containing all of the given specified values from
	/// both the <paramref name="current"/> and <paramref name="extras"/> lists.
	/// If <paramref name="current" /> is null and <paramref name="extras"/> is empty,
	/// null is returned. Otherwise, either a new list is created (if <paramref name="current" />
	/// is null) or the elements of <paramref name="extras"/> are added to <paramref name="current" />.
	/// </summary>
	private static List<T> AddAll<T>(List<T> current, IList<T> extras)
	{
	if (extras.Count == 0)
	{
	return current;
	}
	if (current == null)
	{
	current = new List<T>(extras);
	}
	else
	{
	current.AddRange(extras);
	}
	return current;
	}

	/// <summary>
	/// Clears the contents of this builder.
	/// </summary>
	public Builder Clear()
	{
	varintList = null;
	fixed32List = null;
	fixed64List = null;
	lengthDelimitedList = null;
	groupList = null;
	return this;
	}

	/// <summary>
	/// Adds a varint value.
	/// </summary>
	[CLSCompliant(false)]
	public Builder AddVarint(ulong value)
	{
	varintList = Add(varintList, value);
	return this;
	}

	/// <summary>
	/// Adds a fixed32 value.
	/// </summary>
	[CLSCompliant(false)]
	public Builder AddFixed32(uint value)
	{
	fixed32List = Add(fixed32List, value);
	return this;
	}

	/// <summary>
	/// Adds a fixed64 value.
	/// </summary>
	[CLSCompliant(false)]
	public Builder AddFixed64(ulong value)
	{
	fixed64List = Add(fixed64List, value);
	return this;
	}

	/// <summary>
	/// Adds a length-delimited value.
	/// </summary>
	public Builder AddLengthDelimited(ByteString value)
	{
	lengthDelimitedList = Add(lengthDelimitedList, value);
	return this;
	}

	/// <summary>
	/// Adds an embedded group.
	/// </summary>
	/// <param name="value"></param>
	/// <returns></returns>
	public Builder AddGroup(UnknownFieldSet value)
	{
	groupList = Add(groupList, value);
	return this;
	}

	/// <summary>
	/// Adds <paramref name="value"/> to the <paramref name="list"/>, creating
	/// a new list if <paramref name="list"/> is null. The list is returned - either
	/// the original reference or the new list.
	/// </summary>
	private static List<T> Add<T>(List<T> list, T value)
	{
	if (list == null)
	{
	list = new List<T>();
	}
	list.Add(value);
	return list;
	}

	/// <summary>
	/// Returns a read-only version of the given IList, and clears
	/// the field used for <paramref name="list"/>. If the value
	/// is null, an empty list is produced using Lists.Empty.
	/// </summary>
	/// <returns></returns>
	private static ReadOnlyCollection<T> MakeReadOnly<T>(ref List<T> list)
	{
	ReadOnlyCollection<T> ret = list == null ? Lists<T>.Empty : new ReadOnlyCollection<T>(list);
	list = null;
	return ret;
	}
	}
	}
	}