#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.IO; | |
namespace Google.ProtocolBuffers | |
{ | |
/// <summary> | |
/// Implementation of the non-generic IMessage interface as far as possible. | |
/// </summary> | |
public abstract partial class AbstractBuilderLite<TMessage, TBuilder> : IBuilderLite<TMessage, TBuilder> | |
where TMessage : AbstractMessageLite<TMessage, TBuilder> | |
where TBuilder : AbstractBuilderLite<TMessage, TBuilder> | |
{ | |
protected abstract TBuilder ThisBuilder { get; } | |
public abstract bool IsInitialized { get; } | |
public abstract TBuilder Clear(); | |
public abstract TBuilder Clone(); | |
public abstract TMessage Build(); | |
public abstract TMessage BuildPartial(); | |
public abstract TBuilder MergeFrom(IMessageLite other); | |
public abstract TBuilder MergeFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry); | |
public abstract TMessage DefaultInstanceForType { get; } | |
#region IBuilderLite<TMessage,TBuilder> Members | |
public virtual TBuilder MergeFrom(ICodedInputStream input) | |
{ | |
return MergeFrom(input, ExtensionRegistry.CreateInstance()); | |
} | |
public TBuilder MergeDelimitedFrom(Stream input) | |
{ | |
return MergeDelimitedFrom(input, ExtensionRegistry.CreateInstance()); | |
} | |
public TBuilder MergeDelimitedFrom(Stream input, ExtensionRegistry extensionRegistry) | |
{ | |
int size = (int) CodedInputStream.ReadRawVarint32(input); | |
Stream limitedStream = new LimitedInputStream(input, size); | |
return MergeFrom(limitedStream, extensionRegistry); | |
} | |
public TBuilder MergeFrom(ByteString data) | |
{ | |
return MergeFrom(data, ExtensionRegistry.CreateInstance()); | |
} | |
public TBuilder MergeFrom(ByteString data, ExtensionRegistry extensionRegistry) | |
{ | |
CodedInputStream input = data.CreateCodedInput(); | |
MergeFrom(input, extensionRegistry); | |
input.CheckLastTagWas(0); | |
return ThisBuilder; | |
} | |
public TBuilder MergeFrom(byte[] data) | |
{ | |
CodedInputStream input = CodedInputStream.CreateInstance(data); | |
MergeFrom(input); | |
input.CheckLastTagWas(0); | |
return ThisBuilder; | |
} | |
public TBuilder MergeFrom(byte[] data, ExtensionRegistry extensionRegistry) | |
{ | |
CodedInputStream input = CodedInputStream.CreateInstance(data); | |
MergeFrom(input, extensionRegistry); | |
input.CheckLastTagWas(0); | |
return ThisBuilder; | |
} | |
public TBuilder MergeFrom(Stream input) | |
{ | |
CodedInputStream codedInput = CodedInputStream.CreateInstance(input); | |
MergeFrom(codedInput); | |
codedInput.CheckLastTagWas(0); | |
return ThisBuilder; | |
} | |
public TBuilder MergeFrom(Stream input, ExtensionRegistry extensionRegistry) | |
{ | |
CodedInputStream codedInput = CodedInputStream.CreateInstance(input); | |
MergeFrom(codedInput, extensionRegistry); | |
codedInput.CheckLastTagWas(0); | |
return ThisBuilder; | |
} | |
#endregion | |
#region Explicit definitions | |
IBuilderLite IBuilderLite.WeakClear() | |
{ | |
return Clear(); | |
} | |
IBuilderLite IBuilderLite.WeakMergeFrom(IMessageLite message) | |
{ | |
return MergeFrom(message); | |
} | |
IBuilderLite IBuilderLite.WeakMergeFrom(ByteString data) | |
{ | |
return MergeFrom(data); | |
} | |
IBuilderLite IBuilderLite.WeakMergeFrom(ByteString data, ExtensionRegistry registry) | |
{ | |
return MergeFrom(data, registry); | |
} | |
IBuilderLite IBuilderLite.WeakMergeFrom(ICodedInputStream input) | |
{ | |
return MergeFrom(input); | |
} | |
IBuilderLite IBuilderLite.WeakMergeFrom(ICodedInputStream input, ExtensionRegistry registry) | |
{ | |
return MergeFrom(input, registry); | |
} | |
IMessageLite IBuilderLite.WeakBuild() | |
{ | |
return Build(); | |
} | |
IMessageLite IBuilderLite.WeakBuildPartial() | |
{ | |
return BuildPartial(); | |
} | |
IBuilderLite IBuilderLite.WeakClone() | |
{ | |
return Clone(); | |
} | |
IMessageLite IBuilderLite.WeakDefaultInstanceForType | |
{ | |
get { return DefaultInstanceForType; } | |
} | |
#endregion | |
#region LimitedInputStream | |
/// <summary> | |
/// Stream implementation which proxies another stream, only allowing a certain amount | |
/// of data to be read. Note that this is only used to read delimited streams, so it | |
/// doesn't attempt to implement everything. | |
/// </summary> | |
private class LimitedInputStream : Stream | |
{ | |
private readonly Stream proxied; | |
private int bytesLeft; | |
internal LimitedInputStream(Stream proxied, int size) | |
{ | |
this.proxied = proxied; | |
bytesLeft = size; | |
} | |
public override bool CanRead | |
{ | |
get { return true; } | |
} | |
public override bool CanSeek | |
{ | |
get { return false; } | |
} | |
public override bool CanWrite | |
{ | |
get { return false; } | |
} | |
public override void Flush() | |
{ | |
} | |
public override long Length | |
{ | |
get { throw new NotSupportedException(); } | |
} | |
public override long Position | |
{ | |
get { throw new NotSupportedException(); } | |
set { throw new NotSupportedException(); } | |
} | |
public override int Read(byte[] buffer, int offset, int count) | |
{ | |
if (bytesLeft > 0) | |
{ | |
int bytesRead = proxied.Read(buffer, offset, Math.Min(bytesLeft, count)); | |
bytesLeft -= bytesRead; | |
return bytesRead; | |
} | |
return 0; | |
} | |
public override long Seek(long offset, SeekOrigin origin) | |
{ | |
throw new NotSupportedException(); | |
} | |
public override void SetLength(long value) | |
{ | |
throw new NotSupportedException(); | |
} | |
public override void Write(byte[] buffer, int offset, int count) | |
{ | |
throw new NotSupportedException(); | |
} | |
} | |
#endregion | |
} | |
} |