path: root/src/ProtocolBuffers/AbstractMessageLite.cs

#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() {
    //}

    public abstract void PrintTo(TextWriter writer);

    #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
  }
}