protobuf/src/ProtocolBuffers/AbstractBuilderLite.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;
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
    }
}