using System;
using System.Collections.Generic;
namespace Google.Protobuf
{
///
/// Factory methods for .
///
public static class FieldCodec
{
public static FieldCodec ForString(uint tag)
{
return new FieldCodec(input => input.ReadString(), (output, value) => output.WriteString(value), CodedOutputStream.ComputeStringSize, tag);
}
public static FieldCodec ForBytes(uint tag)
{
return new FieldCodec(input => input.ReadBytes(), (output, value) => output.WriteBytes(value), CodedOutputStream.ComputeBytesSize, tag);
}
public static FieldCodec ForBool(uint tag)
{
return new FieldCodec(input => input.ReadBool(), (output, value) => output.WriteBool(value), CodedOutputStream.ComputeBoolSize, tag);
}
public static FieldCodec ForInt32(uint tag)
{
return new FieldCodec(input => input.ReadInt32(), (output, value) => output.WriteInt32(value), CodedOutputStream.ComputeInt32Size, tag);
}
public static FieldCodec ForSInt32(uint tag)
{
return new FieldCodec(input => input.ReadSInt32(), (output, value) => output.WriteSInt32(value), CodedOutputStream.ComputeSInt32Size, tag);
}
public static FieldCodec ForFixed32(uint tag)
{
return new FieldCodec(input => input.ReadFixed32(), (output, value) => output.WriteFixed32(value), CodedOutputStream.ComputeFixed32Size, tag);
}
public static FieldCodec ForSFixed32(uint tag)
{
return new FieldCodec(input => input.ReadSFixed32(), (output, value) => output.WriteSFixed32(value), CodedOutputStream.ComputeSFixed32Size, tag);
}
public static FieldCodec ForUInt32(uint tag)
{
return new FieldCodec(input => input.ReadUInt32(), (output, value) => output.WriteUInt32(value), CodedOutputStream.ComputeUInt32Size, tag);
}
public static FieldCodec ForInt64(uint tag)
{
return new FieldCodec(input => input.ReadInt64(), (output, value) => output.WriteInt64(value), CodedOutputStream.ComputeInt64Size, tag);
}
public static FieldCodec ForSInt64(uint tag)
{
return new FieldCodec(input => input.ReadSInt64(), (output, value) => output.WriteSInt64(value), CodedOutputStream.ComputeSInt64Size, tag);
}
public static FieldCodec ForFixed64(uint tag)
{
return new FieldCodec(input => input.ReadFixed64(), (output, value) => output.WriteFixed64(value), CodedOutputStream.ComputeFixed64Size, tag);
}
public static FieldCodec ForSFixed64(uint tag)
{
return new FieldCodec(input => input.ReadSFixed64(), (output, value) => output.WriteSFixed64(value), CodedOutputStream.ComputeSFixed64Size, tag);
}
public static FieldCodec ForUInt64(uint tag)
{
return new FieldCodec(input => input.ReadUInt64(), (output, value) => output.WriteUInt64(value), CodedOutputStream.ComputeUInt64Size, tag);
}
public static FieldCodec ForFloat(uint tag)
{
return new FieldCodec(input => input.ReadFloat(), (output, value) => output.WriteFloat(value), CodedOutputStream.ComputeFloatSize, tag);
}
public static FieldCodec ForDouble(uint tag)
{
return new FieldCodec(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 fdor it.
public static FieldCodec ForEnum(uint tag, Func toInt32, Func fromInt32)
{
return new FieldCodec(input => fromInt32(
input.ReadEnum()),
(output, value) => output.WriteEnum(toInt32(value)),
value => CodedOutputStream.ComputeEnumSize(toInt32(value)), tag);
}
public static FieldCodec ForMessage(uint tag, MessageParser parser) where T : IMessage
{
return new FieldCodec(input => { T message = parser.CreateTemplate(); input.ReadMessage(message); return message; },
(output, value) => output.WriteMessage(value), message => CodedOutputStream.ComputeMessageSize(message), tag);
}
}
///
/// 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.
///
///
/// This never writes default values to the stream, and is not currently designed
/// to play well with packed arrays.
///
public sealed class FieldCodec
{
private static readonly Func IsDefault;
private static readonly T Default;
static FieldCodec()
{
if (typeof(T) == typeof(string))
{
Default = (T)(object)"";
IsDefault = CreateDefaultValueCheck(x => x.Length == 0);
}
else if (typeof(T) == typeof(ByteString))
{
Default = (T)(object)ByteString.Empty;
IsDefault = CreateDefaultValueCheck(x => x.Length == 0);
}
else if (!typeof(T).IsValueType)
{
// Default default
IsDefault = CreateDefaultValueCheck(x => x == null);
}
else
{
// Default default
IsDefault = CreateDefaultValueCheck(x => EqualityComparer.Default.Equals(x, default(T)));
}
}
private static Func CreateDefaultValueCheck(Func check)
{
return (Func)(object)check;
}
private readonly Func reader;
private readonly Action writer;
private readonly Func sizeCalculator;
private readonly uint tag;
private readonly int tagSize;
private readonly int fixedSize;
internal FieldCodec(
Func reader,
Action writer,
Func sizeCalculator,
uint tag)
{
this.reader = reader;
this.writer = writer;
this.sizeCalculator = sizeCalculator;
this.fixedSize = 0;
this.tag = tag;
tagSize = CodedOutputStream.ComputeRawVarint32Size(tag);
}
internal FieldCodec(
Func reader,
Action writer,
int fixedSize,
uint tag)
{
this.reader = reader;
this.writer = writer;
this.sizeCalculator = _ => fixedSize;
this.fixedSize = fixedSize;
this.tag = tag;
tagSize = CodedOutputStream.ComputeRawVarint32Size(tag);
}
///
/// Returns the size calculator for just a value.
///
internal Func ValueSizeCalculator { get { return sizeCalculator; } }
///
/// Returns a delegate to write a value (unconditionally) to a coded output stream.
///
internal Action ValueWriter { get { return writer; } }
///
/// 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.
///
internal Func ValueReader { get { return reader; } }
///
/// Returns the fixed size for an entry, or 0 if sizes vary.
///
internal int FixedSize { get { return fixedSize; } }
public uint Tag { get { return tag; } }
public T DefaultValue { get { return Default; } }
///
/// Write a tag and the given value, *if* the value is not the default.
///
public void WriteTagAndValue(CodedOutputStream output, T value)
{
if (!IsDefault(value))
{
output.WriteTag(tag);
writer(output, value);
}
}
public T Read(CodedInputStream input)
{
return reader(input);
}
///
/// Calculates the size required to write the given value, with a tag,
/// if the value is not the default.
///
public int CalculateSizeWithTag(T value)
{
return IsDefault(value) ? 0 : sizeCalculator(value) + tagSize;
}
}
}