source: stable/HeuristicLab.ExtLibs/HeuristicLab.ProtobufCS/2.4.1/ProtobufCS/src/ProtocolBuffers/MessageStreamIterator.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.Collections;
using System.Collections.Generic;
using System.IO;
using System.Reflection;

namespace Google.ProtocolBuffers
{
    /// <summary>
    /// Iterates over data created using a <see cref="MessageStreamWriter{T}" />.
    /// Unlike MessageStreamWriter, this class is not usually constructed directly with
    /// a stream; instead it is provided with a way of opening a stream when iteration
    /// is started. The stream is closed when the iteration is completed or the enumerator
    /// is disposed. (This occurs naturally when using <c>foreach</c>.)
    /// </summary>
    public class MessageStreamIterator<TMessage> : IEnumerable<TMessage>
        where TMessage : IMessage<TMessage>
    {
        private readonly StreamProvider streamProvider;
        private readonly ExtensionRegistry extensionRegistry;
        private readonly int sizeLimit;

        // Type.EmptyTypes isn't present on the compact framework
        private static readonly Type[] EmptyTypes = new Type[0];

        /// <summary>
        /// Delegate created via reflection trickery (once per type) to create a builder
        /// and read a message from a CodedInputStream with it. Note that unlike in Java,
        /// there's one static field per constructed type.
        /// </summary>
        private static readonly Func<CodedInputStream, ExtensionRegistry, TMessage> messageReader = BuildMessageReader();

        /// <summary>
        /// Any exception (within reason) thrown within messageReader is caught and rethrown in the constructor.
        /// This makes life a lot simpler for the caller.
        /// </summary>
        private static Exception typeInitializationException;

        /// <summary>
        /// Creates the delegate later used to read messages. This is only called once per type, but to
        /// avoid exceptions occurring at confusing times, if this fails it will set typeInitializationException
        /// to the appropriate error and return null.
        /// </summary>
        private static Func<CodedInputStream, ExtensionRegistry, TMessage> BuildMessageReader()
        {
            try
            {
                Type builderType = FindBuilderType();

                // Yes, it's redundant to find this again, but it's only the once...
                MethodInfo createBuilderMethod = typeof (TMessage).GetMethod("CreateBuilder", EmptyTypes);
                Delegate builderBuilder = Delegate.CreateDelegate(
                    typeof (Func<>).MakeGenericType(builderType), null, createBuilderMethod);

                MethodInfo buildMethod = typeof (MessageStreamIterator<TMessage>)
                    .GetMethod("BuildImpl", BindingFlags.Static | BindingFlags.NonPublic)
                    .MakeGenericMethod(typeof (TMessage), builderType);

                return (Func<CodedInputStream, ExtensionRegistry, TMessage>) Delegate.CreateDelegate(
                    typeof (Func<CodedInputStream, ExtensionRegistry, TMessage>), builderBuilder, buildMethod);
            }
            catch (ArgumentException e)
            {
                typeInitializationException = e;
            }
            catch (InvalidOperationException e)
            {
                typeInitializationException = e;
            }
            catch (InvalidCastException e)
            {
                // Can't see why this would happen, but best to know about it.
                typeInitializationException = e;
            }
            return null;
        }

        /// <summary>
        /// Works out the builder type for TMessage, or throws an ArgumentException to explain why it can't.
        /// </summary>
        private static Type FindBuilderType()
        {
            MethodInfo createBuilderMethod = typeof (TMessage).GetMethod("CreateBuilder", EmptyTypes);
            if (createBuilderMethod == null)
            {
                throw new ArgumentException("Message type " + typeof (TMessage).FullName +
                                            " has no CreateBuilder method.");
            }
            if (createBuilderMethod.ReturnType == typeof (void))
            {
                throw new ArgumentException("CreateBuilder method in " + typeof (TMessage).FullName +
                                            " has void return type");
            }
            Type builderType = createBuilderMethod.ReturnType;
            Type messageInterface = typeof (IMessage<,>).MakeGenericType(typeof (TMessage), builderType);
            Type builderInterface = typeof (IBuilder<,>).MakeGenericType(typeof (TMessage), builderType);
            if (Array.IndexOf(typeof (TMessage).GetInterfaces(), messageInterface) == -1)
            {
                throw new ArgumentException("Message type " + typeof (TMessage) + " doesn't implement " +
                                            messageInterface.FullName);
            }
            if (Array.IndexOf(builderType.GetInterfaces(), builderInterface) == -1)
            {
                throw new ArgumentException("Builder type " + typeof (TMessage) + " doesn't implement " +
                                            builderInterface.FullName);
            }
            return builderType;
        }

// This is only ever fetched by reflection, so the compiler may
// complain that it's unused
#pragma warning disable 0169
        /// <summary>
        /// Method we'll use to build messageReader, with the first parameter fixed to TMessage.CreateBuilder. Note that we
        /// have to introduce another type parameter (TMessage2) as we can't constrain TMessage for just a single method
        /// (and we can't do it at the type level because we don't know TBuilder). However, by constraining TMessage2
        /// to not only implement IMessage appropriately but also to derive from TMessage2, we can avoid doing a cast
        /// for every message; the implicit reference conversion will be fine. In practice, TMessage2 and TMessage will
        /// be the same type when we construct the generic method by reflection.
        /// </summary>
        private static TMessage BuildImpl<TMessage2, TBuilder>(Func<TBuilder> builderBuilder, CodedInputStream input,
                                                               ExtensionRegistry registry)
            where TBuilder : IBuilder<TMessage2, TBuilder>
            where TMessage2 : TMessage, IMessage<TMessage2, TBuilder>
        {
            TBuilder builder = builderBuilder();
            input.ReadMessage(builder, registry);
            return builder.Build();
        }
#pragma warning restore 0414

        private static readonly uint ExpectedTag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited);

        private MessageStreamIterator(StreamProvider streamProvider, ExtensionRegistry extensionRegistry, int sizeLimit)
        {
            if (messageReader == null)
            {
                throw typeInitializationException;
            }
            this.streamProvider = streamProvider;
            this.extensionRegistry = extensionRegistry;
            this.sizeLimit = sizeLimit;
        }

        private MessageStreamIterator(StreamProvider streamProvider, ExtensionRegistry extensionRegistry)
            : this(streamProvider, extensionRegistry, CodedInputStream.DefaultSizeLimit)
        {
        }

        /// <summary>
        /// Creates a new instance which uses the same stream provider as this one,
        /// but the specified extension registry.
        /// </summary>
        public MessageStreamIterator<TMessage> WithExtensionRegistry(ExtensionRegistry newRegistry)
        {
            return new MessageStreamIterator<TMessage>(streamProvider, newRegistry, sizeLimit);
        }

        /// <summary>
        /// Creates a new instance which uses the same stream provider and extension registry as this one,
        /// but with the specified size limit. Note that this must be big enough for the largest message
        /// and the tag and size preceding it.
        /// </summary>
        public MessageStreamIterator<TMessage> WithSizeLimit(int newSizeLimit)
        {
            return new MessageStreamIterator<TMessage>(streamProvider, extensionRegistry, newSizeLimit);
        }

        public static MessageStreamIterator<TMessage> FromFile(string file)
        {
            return new MessageStreamIterator<TMessage>(() => File.OpenRead(file), ExtensionRegistry.Empty);
        }

        public static MessageStreamIterator<TMessage> FromStreamProvider(StreamProvider streamProvider)
        {
            return new MessageStreamIterator<TMessage>(streamProvider, ExtensionRegistry.Empty);
        }

        public IEnumerator<TMessage> GetEnumerator()
        {
            using (Stream stream = streamProvider())
            {
                CodedInputStream input = CodedInputStream.CreateInstance(stream);
                input.SetSizeLimit(sizeLimit);
                uint tag;
                string name;
                while (input.ReadTag(out tag, out name))
                {
                    if ((tag == 0 && name == "item") || (tag == ExpectedTag))
                    {
                        yield return messageReader(input, extensionRegistry);
                    }
                    else
                    {
                        throw InvalidProtocolBufferException.InvalidMessageStreamTag();
                    }

                    input.ResetSizeCounter();
                }
            }
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }
}