Completed abstract lite builder and message

2 files changed, 363 insertions, 0 deletions

diff --git a/src/ProtocolBuffers/AbstractBuilderLite.cs b/src/ProtocolBuffers/AbstractBuilderLite.cs
new file mode 100644
index 00000000..c5fbf0ce
--- /dev/null
+++ b/src/ProtocolBuffers/AbstractBuilderLite.cs
@@ -0,0 +1,232 @@
+#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;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Google.ProtocolBuffers {
+  /// <summary>
+  /// Implementation of the non-generic IMessage interface as far as possible.
+  /// </summary>
+  public abstract 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(CodedInputStream input, ExtensionRegistry extensionRegistry);
+
+    public abstract TMessage DefaultInstanceForType { get; }
+
+    #region IBuilderLite<TMessage,TBuilder> Members
+
+    public virtual TBuilder MergeFrom(CodedInputStream 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(CodedInputStream input) {
+      return MergeFrom(input);
+    }
+
+    IBuilderLite IBuilderLite.WeakMergeFrom(CodedInputStream 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
+  }
+}
diff --git a/src/ProtocolBuffers/AbstractMessageLite.cs b/src/ProtocolBuffers/AbstractMessageLite.cs
new file mode 100644
index 00000000..96884753
--- /dev/null
+++ b/src/ProtocolBuffers/AbstractMessageLite.cs
@@ -0,0 +1,131 @@
+#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.Collections;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Google.ProtocolBuffers {
+  /// <summary>
+  /// Implementation of the non-generic IMessage interface as far as possible.
+  /// </summary>
+  public abstract class AbstractMessageLite<TMessage, TBuilder> : IMessageLite<TMessage, TBuilder>
+    where TMessage : AbstractMessageLite<TMessage, TBuilder>
+    where TBuilder : AbstractBuilderLite<TMessage, TBuilder> {
+ 
+    
+    public abstract TBuilder CreateBuilderForType();
+
+    public abstract TBuilder ToBuilder();
+
+    public abstract TMessage DefaultInstanceForType { get; }
+
+    public abstract bool IsInitialized { get; }
+
+    public abstract void WriteTo(CodedOutputStream output);
+
+    public abstract int SerializedSize { get; }
+
+    //public override bool Equals(object other) {
+    //}
+
+    //public override int GetHashCode() {
+    //}
+
+    #region IMessageLite<TMessage,TBuilder> Members
+
+    /// <summary>
+    /// Serializes the message to a ByteString. This is a trivial wrapper
+    /// around WriteTo(CodedOutputStream).
+    /// </summary>
+    public ByteString ToByteString() {
+      ByteString.CodedBuilder output = new ByteString.CodedBuilder(SerializedSize);
+      WriteTo(output.CodedOutput);
+      return output.Build();
+    }
+
+    /// <summary>
+    /// Serializes the message to a byte array. This is a trivial wrapper
+    /// around WriteTo(CodedOutputStream).
+    /// </summary>
+    public byte[] ToByteArray() {
+      byte[] result = new byte[SerializedSize];
+      CodedOutputStream output = CodedOutputStream.CreateInstance(result);
+      WriteTo(output);
+      output.CheckNoSpaceLeft();
+      return result;
+    }
+
+    /// <summary>
+    /// Serializes the message and writes it to the given stream.
+    /// This is just a wrapper around WriteTo(CodedOutputStream). This
+    /// does not flush or close the stream.
+    /// </summary>
+    /// <param name="output"></param>
+    public void WriteTo(Stream output) {
+      CodedOutputStream codedOutput = CodedOutputStream.CreateInstance(output);
+      WriteTo(codedOutput);
+      codedOutput.Flush();
+    }
+
+    /// <summary>
+    /// Like WriteTo(Stream) but writes the size of the message as a varint before
+    /// writing the data. This allows more data to be written to the stream after the
+    /// message without the need to delimit the message data yourself. Use 
+    /// IBuilder.MergeDelimitedFrom(Stream) or the static method
+    /// YourMessageType.ParseDelimitedFrom(Stream) to parse messages written by this method.
+    /// </summary>
+    /// <param name="output"></param>
+    public void WriteDelimitedTo(Stream output) {
+      CodedOutputStream codedOutput = CodedOutputStream.CreateInstance(output);
+      codedOutput.WriteRawVarint32((uint)SerializedSize);
+      WriteTo(codedOutput);
+      codedOutput.Flush();
+    }
+
+    IBuilderLite IMessageLite.WeakCreateBuilderForType() {
+      return CreateBuilderForType();
+    }
+
+    IBuilderLite IMessageLite.WeakToBuilder() {
+      return ToBuilder();
+    }
+
+    IMessageLite IMessageLite.WeakDefaultInstanceForType {
+      get { return DefaultInstanceForType; }
+    }
+
+    #endregion
+  }
+}