Example #1
0
        /// <summary>
        /// Merges the message from the input stream based on the contentType provided
        /// </summary>
        /// <typeparam name="TBuilder">A type derived from IBuilderLite</typeparam>
        /// <param name="builder">An instance of a message builder</param>
        /// <param name="options">Options specific to reading this message and/or content type</param>
        /// <param name="contentType">The mime type of the input stream content</param>
        /// <param name="input">The stream to read the message from</param>
        /// <returns>The same builder instance that was supplied in the builder parameter</returns>
        public static TBuilder MergeFrom <TBuilder>(
#if !NOEXTENSIONS
            this
#endif
            TBuilder builder, MessageFormatOptions options, string contentType, Stream input) where TBuilder : IBuilderLite
        {
            ICodedInputStream codedInput = MessageFormatFactory.CreateInputStream(options, contentType, input);

            codedInput.ReadMessageStart();
            builder.WeakMergeFrom(codedInput, options.ExtensionRegistry);
            codedInput.ReadMessageEnd();
            return(builder);
        }
Example #2
0
 public void TestReadProtoMimeTypes()
 {
     foreach (string type in ProtobufTypes)
     {
         Assert.IsTrue(
             MessageFormatFactory.CreateInputStream(new MessageFormatOptions(), type, Stream.Null)
             is CodedInputStream);
     }
     Assert.IsTrue(
         MessageFormatFactory.CreateInputStream(new MessageFormatOptions()
     {
         DefaultContentType = "application/vnd.google.protobuf"
     }, null, Stream.Null)
         is CodedInputStream);
 }
Example #3
0
 public void TestWriteXmlMimeTypes()
 {
     foreach (string type in XmlTypes)
     {
         Assert.IsTrue(
             MessageFormatFactory.CreateOutputStream(new MessageFormatOptions(), type, Stream.Null)
             is XmlFormatWriter);
     }
     Assert.IsTrue(
         MessageFormatFactory.CreateOutputStream(new MessageFormatOptions()
     {
         DefaultContentType = "application/xml"
     }, null, Stream.Null)
         is XmlFormatWriter);
 }
Example #4
0
 public void TestReadJsonMimeTypes()
 {
     foreach (string type in JsonTypes)
     {
         Assert.IsTrue(
             MessageFormatFactory.CreateInputStream(new MessageFormatOptions(), type, Stream.Null)
             is JsonFormatReader);
     }
     Assert.IsTrue(
         MessageFormatFactory.CreateInputStream(new MessageFormatOptions()
     {
         DefaultContentType = "application/json"
     }, null, Stream.Null)
         is JsonFormatReader);
 }
Example #5
0
        /// <summary>
        /// Used to implement a service endpoint on an HTTP server.  This works with services generated with the
        /// service_generator_type option set to IRPCDISPATCH.
        /// </summary>
        /// <param name="stub">The service execution stub</param>
        /// <param name="methodName">The name of the method being invoked</param>
        /// <param name="options">optional arguments for the format reader/writer</param>
        /// <param name="contentType">The mime type for the input stream</param>
        /// <param name="input">The input stream</param>
        /// <param name="responseType">The mime type for the output stream</param>
        /// <param name="output">The output stream</param>
        public static void HttpCallMethod(
#if !NOEXTENSIONS
            this
#endif
            IRpcServerStub stub, string methodName, MessageFormatOptions options,
            string contentType, Stream input, string responseType, Stream output)
        {
            ICodedInputStream codedInput = MessageFormatFactory.CreateInputStream(options, contentType, input);

            codedInput.ReadMessageStart();
            IMessageLite response = stub.CallMethod(methodName, codedInput, options.ExtensionRegistry);

            codedInput.ReadMessageEnd();
            WriteTo(response, options, responseType, output);
        }
Example #6
0
        /// <summary>
        /// Writes the message instance to the stream using the content type provided
        /// </summary>
        /// <param name="message">An instance of a message</param>
        /// <param name="options">Options specific to writing this message and/or content type</param>
        /// <param name="contentType">The mime type of the content to be written</param>
        /// <param name="output">The stream to write the message to</param>
        public static void WriteTo(
#if !NOEXTENSIONS
            this
#endif
            IMessageLite message, MessageFormatOptions options, string contentType, Stream output)
        {
            ICodedOutputStream codedOutput = MessageFormatFactory.CreateOutputStream(options, contentType, output);

            // Output the appropriate message preamble
            codedOutput.WriteMessageStart();

            // Write the message content to the output
            message.WriteTo(codedOutput);

            // Write the closing message fragment
            codedOutput.WriteMessageEnd();
            codedOutput.Flush();
        }