| #region Copyright notice and license |
| // Protocol Buffers - Google's data interchange format |
| // Copyright 2015 Google Inc. All rights reserved. |
| // https://developers.google.com/protocol-buffers/ |
| // |
| // 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; |
| |
| namespace Google.Protobuf |
| { |
| /// <summary> |
| /// Factory methods for <see cref="FieldCodec{T}"/>. |
| /// </summary> |
| public static class FieldCodec |
| { |
| // TODO: Avoid the "dual hit" of lambda expressions: create open delegates instead. (At least test...) |
| public static FieldCodec<string> ForString(uint tag) |
| { |
| return new FieldCodec<string>(input => input.ReadString(), (output, value) => output.WriteString(value), CodedOutputStream.ComputeStringSize, tag); |
| } |
| |
| public static FieldCodec<ByteString> ForBytes(uint tag) |
| { |
| return new FieldCodec<ByteString>(input => input.ReadBytes(), (output, value) => output.WriteBytes(value), CodedOutputStream.ComputeBytesSize, tag); |
| } |
| |
| public static FieldCodec<bool> ForBool(uint tag) |
| { |
| return new FieldCodec<bool>(input => input.ReadBool(), (output, value) => output.WriteBool(value), CodedOutputStream.ComputeBoolSize, tag); |
| } |
| |
| public static FieldCodec<int> ForInt32(uint tag) |
| { |
| return new FieldCodec<int>(input => input.ReadInt32(), (output, value) => output.WriteInt32(value), CodedOutputStream.ComputeInt32Size, tag); |
| } |
| |
| public static FieldCodec<int> ForSInt32(uint tag) |
| { |
| return new FieldCodec<int>(input => input.ReadSInt32(), (output, value) => output.WriteSInt32(value), CodedOutputStream.ComputeSInt32Size, tag); |
| } |
| |
| public static FieldCodec<uint> ForFixed32(uint tag) |
| { |
| return new FieldCodec<uint>(input => input.ReadFixed32(), (output, value) => output.WriteFixed32(value), 4, tag); |
| } |
| |
| public static FieldCodec<int> ForSFixed32(uint tag) |
| { |
| return new FieldCodec<int>(input => input.ReadSFixed32(), (output, value) => output.WriteSFixed32(value), 4, tag); |
| } |
| |
| public static FieldCodec<uint> ForUInt32(uint tag) |
| { |
| return new FieldCodec<uint>(input => input.ReadUInt32(), (output, value) => output.WriteUInt32(value), CodedOutputStream.ComputeUInt32Size, tag); |
| } |
| |
| public static FieldCodec<long> ForInt64(uint tag) |
| { |
| return new FieldCodec<long>(input => input.ReadInt64(), (output, value) => output.WriteInt64(value), CodedOutputStream.ComputeInt64Size, tag); |
| } |
| |
| public static FieldCodec<long> ForSInt64(uint tag) |
| { |
| return new FieldCodec<long>(input => input.ReadSInt64(), (output, value) => output.WriteSInt64(value), CodedOutputStream.ComputeSInt64Size, tag); |
| } |
| |
| public static FieldCodec<ulong> ForFixed64(uint tag) |
| { |
| return new FieldCodec<ulong>(input => input.ReadFixed64(), (output, value) => output.WriteFixed64(value), 8, tag); |
| } |
| |
| public static FieldCodec<long> ForSFixed64(uint tag) |
| { |
| return new FieldCodec<long>(input => input.ReadSFixed64(), (output, value) => output.WriteSFixed64(value), 8, tag); |
| } |
| |
| public static FieldCodec<ulong> ForUInt64(uint tag) |
| { |
| return new FieldCodec<ulong>(input => input.ReadUInt64(), (output, value) => output.WriteUInt64(value), CodedOutputStream.ComputeUInt64Size, tag); |
| } |
| |
| public static FieldCodec<float> ForFloat(uint tag) |
| { |
| return new FieldCodec<float>(input => input.ReadFloat(), (output, value) => output.WriteFloat(value), CodedOutputStream.ComputeFloatSize, tag); |
| } |
| |
| public static FieldCodec<double> ForDouble(uint tag) |
| { |
| return new FieldCodec<double>(input => input.ReadDouble(), (output, value) => output.WriteDouble(value), CodedOutputStream.ComputeDoubleSize, tag); |
| } |
| |
| // Enums are tricky. We can probably use expression trees to build these delegates automatically, |
| // but it's easy to generate the code for it. |
| public static FieldCodec<T> ForEnum<T>(uint tag, Func<T, int> toInt32, Func<int, T> fromInt32) |
| { |
| return new FieldCodec<T>(input => fromInt32( |
| input.ReadEnum()), |
| (output, value) => output.WriteEnum(toInt32(value)), |
| value => CodedOutputStream.ComputeEnumSize(toInt32(value)), tag); |
| } |
| |
| public static FieldCodec<T> ForMessage<T>(uint tag, MessageParser<T> parser) where T : IMessage<T> |
| { |
| return new FieldCodec<T>(input => { T message = parser.CreateTemplate(); input.ReadMessage(message); return message; }, |
| (output, value) => output.WriteMessage(value), message => CodedOutputStream.ComputeMessageSize(message), tag); |
| } |
| |
| /// <summary> |
| /// Creates a codec for a wrapper type of a class - which must be string or ByteString. |
| /// </summary> |
| public static FieldCodec<T> ForClassWrapper<T>(uint tag) where T : class |
| { |
| var nestedCodec = WrapperCodecs.GetCodec<T>(); |
| return new FieldCodec<T>( |
| input => WrapperCodecs.Read<T>(input, nestedCodec), |
| (output, value) => WrapperCodecs.Write<T>(output, value, nestedCodec), |
| value => WrapperCodecs.CalculateSize<T>(value, nestedCodec), |
| tag, |
| null); // Default value for the wrapper |
| } |
| |
| /// <summary> |
| /// Creates a codec for a wrapper type of a struct - which must be Int32, Int64, UInt32, UInt64, |
| /// Bool, Single or Double. |
| /// </summary> |
| public static FieldCodec<T?> ForStructWrapper<T>(uint tag) where T : struct |
| { |
| var nestedCodec = WrapperCodecs.GetCodec<T>(); |
| return new FieldCodec<T?>( |
| input => WrapperCodecs.Read<T>(input, nestedCodec), |
| (output, value) => WrapperCodecs.Write<T>(output, value.Value, nestedCodec), |
| value => value == null ? 0 : WrapperCodecs.CalculateSize<T>(value.Value, nestedCodec), |
| tag, |
| null); // Default value for the wrapper |
| } |
| |
| /// <summary> |
| /// Helper code to create codecs for wrapper types. |
| /// </summary> |
| /// <remarks> |
| /// Somewhat ugly with all the static methods, but the conversions involved to/from nullable types make it |
| /// slightly tricky to improve. So long as we keep the public API (ForClassWrapper, ForStructWrapper) in place, |
| /// we can refactor later if we come up with something cleaner. |
| /// </remarks> |
| private static class WrapperCodecs |
| { |
| // All the field numbers are the same (1). |
| private const int WrapperValueFieldNumber = Google.Protobuf.WellKnownTypes.Int32Value.ValueFieldNumber; |
| |
| private static readonly Dictionary<Type, object> Codecs = new Dictionary<Type, object> |
| { |
| { typeof(bool), ForBool(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.Varint)) }, |
| { typeof(int), ForInt32(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.Varint)) }, |
| { typeof(long), ForInt64(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.Varint)) }, |
| { typeof(uint), ForUInt32(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.Varint)) }, |
| { typeof(ulong), ForUInt64(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.Varint)) }, |
| { typeof(float), ForFloat(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.Fixed32)) }, |
| { typeof(double), ForDouble(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.Fixed64)) }, |
| { typeof(string), ForString(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.LengthDelimited)) }, |
| { typeof(ByteString), ForBytes(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.LengthDelimited)) } |
| }; |
| |
| /// <summary> |
| /// Returns a field codec which effectively wraps a value of type T in a message. |
| /// |
| /// </summary> |
| internal static FieldCodec<T> GetCodec<T>() |
| { |
| object value; |
| if (!Codecs.TryGetValue(typeof(T), out value)) |
| { |
| throw new InvalidOperationException("Invalid type argument requested for wrapper codec: " + typeof(T)); |
| } |
| return (FieldCodec<T>) value; |
| } |
| |
| internal static T Read<T>(CodedInputStream input, FieldCodec<T> codec) |
| { |
| int length = input.ReadLength(); |
| int oldLimit = input.PushLimit(length); |
| |
| uint tag; |
| T value = codec.DefaultValue; |
| while (input.ReadTag(out tag)) |
| { |
| if (tag == 0) |
| { |
| throw InvalidProtocolBufferException.InvalidTag(); |
| } |
| if (tag == codec.Tag) |
| { |
| value = codec.Read(input); |
| } |
| if (WireFormat.IsEndGroupTag(tag)) |
| { |
| break; |
| } |
| } |
| input.CheckLastTagWas(0); |
| input.PopLimit(oldLimit); |
| |
| return value; |
| } |
| |
| internal static void Write<T>(CodedOutputStream output, T value, FieldCodec<T> codec) |
| { |
| output.WriteLength(codec.CalculateSizeWithTag(value)); |
| codec.WriteTagAndValue(output, value); |
| } |
| |
| internal static int CalculateSize<T>(T value, FieldCodec<T> codec) |
| { |
| int fieldLength = codec.CalculateSizeWithTag(value); |
| return CodedOutputStream.ComputeLengthSize(fieldLength) + fieldLength; |
| } |
| } |
| } |
| |
| /// <summary> |
| /// An encode/decode pair for a single field. This effectively encapsulates |
| /// all the information needed to read or write the field value from/to a coded |
| /// stream. |
| /// </summary> |
| /// <remarks> |
| /// This never writes default values to the stream, and is not currently designed |
| /// to play well with packed arrays. |
| /// </remarks> |
| public sealed class FieldCodec<T> |
| { |
| private static readonly T DefaultDefault; |
| |
| static FieldCodec() |
| { |
| if (typeof(T) == typeof(string)) |
| { |
| DefaultDefault = (T)(object)""; |
| } |
| else if (typeof(T) == typeof(ByteString)) |
| { |
| DefaultDefault = (T)(object)ByteString.Empty; |
| } |
| // Otherwise it's the default value of the CLR type |
| } |
| |
| private static Func<T, bool> CreateDefaultValueCheck<TTmp>(Func<TTmp, bool> check) |
| { |
| return (Func<T, bool>)(object)check; |
| } |
| |
| private readonly Func<CodedInputStream, T> reader; |
| private readonly Action<CodedOutputStream, T> writer; |
| private readonly Func<T, int> sizeCalculator; |
| private readonly uint tag; |
| private readonly int tagSize; |
| private readonly int fixedSize; |
| // Default value for this codec. Usually the same for every instance of the same type, but |
| // for string/ByteString wrapper fields the codec's default value is null, whereas for |
| // other string/ByteString fields it's "" or ByteString.Empty. |
| private readonly T defaultValue; |
| |
| internal FieldCodec( |
| Func<CodedInputStream, T> reader, |
| Action<CodedOutputStream, T> writer, |
| Func<T, int> sizeCalculator, |
| uint tag) : this(reader, writer, sizeCalculator, tag, DefaultDefault) |
| { |
| } |
| |
| internal FieldCodec( |
| Func<CodedInputStream, T> reader, |
| Action<CodedOutputStream, T> writer, |
| Func<T, int> sizeCalculator, |
| uint tag, |
| T defaultValue) |
| { |
| this.reader = reader; |
| this.writer = writer; |
| this.sizeCalculator = sizeCalculator; |
| this.fixedSize = 0; |
| this.tag = tag; |
| this.defaultValue = defaultValue; |
| tagSize = CodedOutputStream.ComputeRawVarint32Size(tag); |
| } |
| |
| internal FieldCodec( |
| Func<CodedInputStream, T> reader, |
| Action<CodedOutputStream, T> writer, |
| int fixedSize, |
| uint tag) |
| { |
| this.reader = reader; |
| this.writer = writer; |
| this.sizeCalculator = _ => fixedSize; |
| this.fixedSize = fixedSize; |
| this.tag = tag; |
| tagSize = CodedOutputStream.ComputeRawVarint32Size(tag); |
| } |
| |
| /// <summary> |
| /// Returns the size calculator for just a value. |
| /// </summary> |
| internal Func<T, int> ValueSizeCalculator { get { return sizeCalculator; } } |
| |
| /// <summary> |
| /// Returns a delegate to write a value (unconditionally) to a coded output stream. |
| /// </summary> |
| internal Action<CodedOutputStream, T> ValueWriter { get { return writer; } } |
| |
| /// <summary> |
| /// Returns a delegate to read a value from a coded input stream. It is assumed that |
| /// the stream is already positioned on the appropriate tag. |
| /// </summary> |
| internal Func<CodedInputStream, T> ValueReader { get { return reader; } } |
| |
| /// <summary> |
| /// Returns the fixed size for an entry, or 0 if sizes vary. |
| /// </summary> |
| internal int FixedSize { get { return fixedSize; } } |
| |
| public uint Tag { get { return tag; } } |
| |
| public T DefaultValue { get { return defaultValue; } } |
| |
| /// <summary> |
| /// Write a tag and the given value, *if* the value is not the default. |
| /// </summary> |
| public void WriteTagAndValue(CodedOutputStream output, T value) |
| { |
| if (!IsDefault(value)) |
| { |
| output.WriteTag(tag); |
| writer(output, value); |
| } |
| } |
| |
| public T Read(CodedInputStream input) |
| { |
| return reader(input); |
| } |
| |
| /// <summary> |
| /// Calculates the size required to write the given value, with a tag, |
| /// if the value is not the default. |
| /// </summary> |
| public int CalculateSizeWithTag(T value) |
| { |
| return IsDefault(value) ? 0 : sizeCalculator(value) + tagSize; |
| } |
| |
| private bool IsDefault(T value) |
| { |
| return EqualityComparer<T>.Default.Equals(value, defaultValue); |
| } |
| } |
| } |