From c07571a79b37a4be4551ff0cded0b160d4e8ee6c Mon Sep 17 00:00:00 2001 From: csharptest Date: Thu, 4 Nov 2010 14:25:56 -0500 Subject: [PATCH] Added copy of existing classes that will be made Lite --- src/ProtocolBuffers/ExtensionRegistryLite.cs | 245 ++++++++++++++ src/ProtocolBuffers/IBuilderLite.cs | 317 +++++++++++++++++++ src/ProtocolBuffers/IMessageLite.cs | 236 ++++++++++++++ 3 files changed, 798 insertions(+) create mode 100644 src/ProtocolBuffers/ExtensionRegistryLite.cs create mode 100644 src/ProtocolBuffers/IBuilderLite.cs create mode 100644 src/ProtocolBuffers/IMessageLite.cs diff --git a/src/ProtocolBuffers/ExtensionRegistryLite.cs b/src/ProtocolBuffers/ExtensionRegistryLite.cs new file mode 100644 index 0000000000..154b690277 --- /dev/null +++ b/src/ProtocolBuffers/ExtensionRegistryLite.cs @@ -0,0 +1,245 @@ +#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.Generic; +using Google.ProtocolBuffers.Descriptors; +using System; + +namespace Google.ProtocolBuffers { + /// + /// A table of known extensions, searchable by name or field number. When + /// parsing a protocol message that might have extensions, you must provide + /// an in which you have registered any extensions + /// that you want to be able to parse. Otherwise, those extensions will just + /// be treated like unknown fields. + /// + /// + /// For example, if you had the .proto file: + /// + /// option java_class = "MyProto"; + /// + /// message Foo { + /// extensions 1000 to max; + /// } + /// + /// extend Foo { + /// optional int32 bar; + /// } + /// + /// + /// Then you might write code like: + /// + /// + /// ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); + /// registry.Add(MyProto.Bar); + /// MyProto.Foo message = MyProto.Foo.ParseFrom(input, registry); + /// + /// + /// + /// + /// You might wonder why this is necessary. Two alternatives might come to + /// mind. First, you might imagine a system where generated extensions are + /// automatically registered when their containing classes are loaded. This + /// is a popular technique, but is bad design; among other things, it creates a + /// situation where behavior can change depending on what classes happen to be + /// loaded. It also introduces a security vulnerability, because an + /// unprivileged class could cause its code to be called unexpectedly from a + /// privileged class by registering itself as an extension of the right type. + /// + /// Another option you might consider is lazy parsing: do not parse an + /// extension until it is first requested, at which point the caller must + /// provide a type to use. This introduces a different set of problems. First, + /// it would require a mutex lock any time an extension was accessed, which + /// would be slow. Second, corrupt data would not be detected until first + /// access, at which point it would be much harder to deal with it. Third, it + /// could violate the expectation that message objects are immutable, since the + /// type provided could be any arbitrary message class. An unprivileged user + /// could take advantage of this to inject a mutable object into a message + /// belonging to privileged code and create mischief. + /// + public sealed class ExtensionRegistry { + + private static readonly ExtensionRegistry empty = new ExtensionRegistry( + new Dictionary(), + new Dictionary(), + true); + + private readonly IDictionary extensionsByName; + private readonly IDictionary extensionsByNumber; + private readonly bool readOnly; + + private ExtensionRegistry(IDictionary extensionsByName, + IDictionary extensionsByNumber, + bool readOnly) { + this.extensionsByName = extensionsByName; + this.extensionsByNumber = extensionsByNumber; + this.readOnly = readOnly; + } + + /// + /// Construct a new, empty instance. + /// + public static ExtensionRegistry CreateInstance() { + return new ExtensionRegistry(new Dictionary(), + new Dictionary(), false); + } + + /// + /// Get the unmodifiable singleton empty instance. + /// + public static ExtensionRegistry Empty { + get { return empty; } + } + + public ExtensionRegistry AsReadOnly() { + return new ExtensionRegistry(extensionsByName, extensionsByNumber, true); + } + + /// + /// Finds an extension by fully-qualified field name, in the + /// proto namespace, i.e. result.Descriptor.FullName will match + /// if a match is found. A null + /// reference is returned if the extension can't be found. + /// + public ExtensionInfo this[string fullName] { + get { + ExtensionInfo ret; + extensionsByName.TryGetValue(fullName, out ret); + return ret; + } + } + + /// + /// Finds an extension by containing type and field number. + /// A null reference is returned if the extension can't be found. + /// + public ExtensionInfo this[MessageDescriptor containingType, int fieldNumber] { + get { + ExtensionInfo ret; + extensionsByNumber.TryGetValue(new DescriptorIntPair(containingType, fieldNumber), out ret); + return ret; + } + } + + /// + /// Add an extension from a generated file to the registry. + /// + public void Add (GeneratedExtensionBase extension) { + if (extension.Descriptor.MappedType == MappedType.Message) { + Add(new ExtensionInfo(extension.Descriptor, extension.MessageDefaultInstance)); + } else { + Add(new ExtensionInfo(extension.Descriptor, null)); + } + } + + /// + /// Adds a non-message-type extension to the registry by descriptor. + /// + /// + public void Add(FieldDescriptor type) { + if (type.MappedType == MappedType.Message) { + throw new ArgumentException("ExtensionRegistry.Add() must be provided a default instance " + + "when adding an embedded message extension."); + } + Add(new ExtensionInfo(type, null)); + } + + /// + /// Adds a message-type-extension to the registry by descriptor. + /// + /// + /// + public void Add(FieldDescriptor type, IMessage defaultInstance) { + if (type.MappedType != MappedType.Message) { + throw new ArgumentException("ExtensionRegistry.Add() provided a default instance for a " + + "non-message extension."); + } + Add(new ExtensionInfo(type, defaultInstance)); + } + + private void Add(ExtensionInfo extension) { + if (readOnly) { + throw new InvalidOperationException("Cannot add entries to a read-only extension registry"); + } + if (!extension.Descriptor.IsExtension) { + throw new ArgumentException("ExtensionRegistry.add() was given a FieldDescriptor for a " + + "regular (non-extension) field."); + } + + extensionsByName[extension.Descriptor.FullName] = extension; + extensionsByNumber[new DescriptorIntPair(extension.Descriptor.ContainingType, + extension.Descriptor.FieldNumber)] = extension; + + FieldDescriptor field = extension.Descriptor; + if (field.ContainingType.Options.MessageSetWireFormat + && field.FieldType == FieldType.Message + && field.IsOptional + && field.ExtensionScope == field.MessageType) { + // This is an extension of a MessageSet type defined within the extension + // type's own scope. For backwards-compatibility, allow it to be looked + // up by type name. + extensionsByName[field.MessageType.FullName] = extension; + } + } + + /// + /// Nested type just used to represent a pair of MessageDescriptor and int, as + /// the key into the "by number" map. + /// + private struct DescriptorIntPair : IEquatable { + readonly MessageDescriptor descriptor; + readonly int number; + + internal DescriptorIntPair(MessageDescriptor descriptor, int number) { + this.descriptor = descriptor; + this.number = number; + } + + public override int GetHashCode() { + return descriptor.GetHashCode() * ((1 << 16) - 1) + number; + } + + public override bool Equals(object obj) { + if (!(obj is DescriptorIntPair)) { + return false; + } + return Equals((DescriptorIntPair)obj); + } + + public bool Equals(DescriptorIntPair other) { + return descriptor == other.descriptor && number == other.number; + } + } + } +} diff --git a/src/ProtocolBuffers/IBuilderLite.cs b/src/ProtocolBuffers/IBuilderLite.cs new file mode 100644 index 0000000000..b1aa4fb1d4 --- /dev/null +++ b/src/ProtocolBuffers/IBuilderLite.cs @@ -0,0 +1,317 @@ +#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.Generic; +using System.IO; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers { + + /// + /// Non-generic interface for all members whose signatures don't require knowledge of + /// the type being built. The generic interface extends this one. Some methods return + /// either an IBuilder or an IMessage; in these cases the generic interface redeclares + /// the same method with a type-specific signature. Implementations are encouraged to + /// use explicit interface implemenation for the non-generic form. This mirrors + /// how IEnumerable and IEnumerable<T> work. + /// + public interface IBuilder { + /// + /// Returns true iff all required fields in the message and all + /// embedded messages are set. + /// + bool IsInitialized { get; } + + /// + /// Only present in the nongeneric interface - useful for tests, but + /// not as much in real life. + /// + IBuilder SetField(FieldDescriptor field, object value); + + /// + /// Only present in the nongeneric interface - useful for tests, but + /// not as much in real life. + /// + IBuilder SetRepeatedField(FieldDescriptor field, int index, object value); + + /// + /// Behaves like the equivalent property in IMessage<T>. + /// The returned map may or may not reflect future changes to the builder. + /// Either way, the returned map is unmodifiable. + /// + IDictionary AllFields { get; } + + /// + /// Allows getting and setting of a field. + /// + /// + /// + /// + object this[FieldDescriptor field] { get; set; } + + /// + /// Get the message's type descriptor. + /// + /// + MessageDescriptor DescriptorForType { get; } + + /// + /// + /// + /// + /// + int GetRepeatedFieldCount(FieldDescriptor field); + + /// + /// Allows getting and setting of a repeated field value. + /// + /// + object this[FieldDescriptor field, int index] { get; set; } + + /// + /// + /// + bool HasField(FieldDescriptor field); + + /// + /// + /// + UnknownFieldSet UnknownFields { get; set; } + + /// + /// Create a builder for messages of the appropriate type for the given field. + /// Messages built with this can then be passed to the various mutation properties + /// and methods. + /// + IBuilder CreateBuilderForField(FieldDescriptor field); + + #region Methods which are like those of the generic form, but without any knowledge of the type parameters + IBuilder WeakAddRepeatedField(FieldDescriptor field, object value); + IBuilder WeakClear(); + IBuilder WeakClearField(FieldDescriptor field); + IBuilder WeakMergeFrom(IMessage message); + IBuilder WeakMergeFrom(ByteString data); + IBuilder WeakMergeFrom(ByteString data, ExtensionRegistry registry); + IBuilder WeakMergeFrom(CodedInputStream input); + IBuilder WeakMergeFrom(CodedInputStream input, ExtensionRegistry registry); + IMessage WeakBuild(); + IMessage WeakBuildPartial(); + IBuilder WeakClone(); + IMessage WeakDefaultInstanceForType { get; } + #endregion + } + + /// + /// Interface implemented by Protocol Message builders. + /// TODO(jonskeet): Consider "SetXXX" methods returning the builder, as well as the properties. + /// + /// Type of message + /// Type of builder + public interface IBuilder : IBuilder + where TMessage : IMessage + where TBuilder : IBuilder { + + TBuilder SetUnknownFields(UnknownFieldSet unknownFields); + + /// + /// Resets all fields to their default values. + /// + TBuilder Clear(); + + /// + /// Merge the specified other message into the message being + /// built. Merging occurs as follows. For each field: + /// For singular primitive fields, if the field is set in , + /// then 's value overwrites the value in this message. + /// For singular message fields, if the field is set in , + /// it is merged into the corresponding sub-message of this message using the same + /// merging rules. + /// For repeated fields, the elements in are concatenated + /// with the elements in this message. + /// + /// + /// + TBuilder MergeFrom(TMessage other); + + /// + /// Merge the specified other message which may be a different implementation of + /// the same message descriptor. + /// + TBuilder MergeFrom(IMessage other); + + /// + /// Constructs the final message. Once this is called, this Builder instance + /// is no longer valid, and calling any other method may throw a + /// NullReferenceException. If you need to continue working with the builder + /// after calling Build, call Clone first. + /// + /// the message + /// is missing one or more required fields; use BuildPartial to bypass + /// this check + TMessage Build(); + + /// + /// Like Build(), but does not throw an exception if the message is missing + /// required fields. Instead, a partial message is returned. + /// + TMessage BuildPartial(); + + /// + /// Clones this builder. + /// TODO(jonskeet): Explain depth of clone. + /// + TBuilder Clone(); + + /// + /// Parses a message of this type from the input and merges it with this + /// message, as if using MergeFrom(IMessage<T>). + /// + /// + /// Warning: This does not verify that all required fields are present + /// in the input message. If you call Build() without setting all + /// required fields, it will throw an UninitializedMessageException. + /// There are a few good ways to deal with this: + /// + /// Call IsInitialized to verify to verify that all required fields are + /// set before building. + /// Parse the message separately using one of the static ParseFrom + /// methods, then use MergeFrom(IMessage<T>) to merge it with + /// this one. ParseFrom will throw an InvalidProtocolBufferException + /// (an IOException) if some required fields are missing. + /// Use BuildPartial to build, which ignores missing required fields. + /// + /// + TBuilder MergeFrom(CodedInputStream input); + + /// + /// Like MergeFrom(CodedInputStream), but also parses extensions. + /// The extensions that you want to be able to parse must be registered + /// in . Extensions not in the registry + /// will be treated as unknown fields. + /// + TBuilder MergeFrom(CodedInputStream input, ExtensionRegistry extensionRegistry); + + /// + /// Get's the message's type's default instance. + /// + /// + TMessage DefaultInstanceForType { get; } + + /// + /// Clears the field. This is exactly equivalent to calling the generated + /// Clear method corresponding to the field. + /// + /// + /// + TBuilder ClearField(FieldDescriptor field); + + /// + /// Appends the given value as a new element for the specified repeated field. + /// + /// the field is not a repeated field, + /// the field does not belong to this builder's type, or the value is + /// of the incorrect type + /// + TBuilder AddRepeatedField(FieldDescriptor field, object value); + + /// + /// Merge some unknown fields into the set for this message. + /// + TBuilder MergeUnknownFields(UnknownFieldSet unknownFields); + + /// + /// Like MergeFrom(Stream), but does not read until the end of the file. + /// Instead, the size of the message (encoded as a varint) is read first, + /// then the message data. Use Message.WriteDelimitedTo(Stream) to + /// write messages in this format. + /// + /// + TBuilder MergeDelimitedFrom(Stream input); + + /// + /// Like MergeDelimitedFrom(Stream) but supporting extensions. + /// + TBuilder MergeDelimitedFrom(Stream input, ExtensionRegistry extensionRegistry); + + #region Convenience methods + /// + /// Parse as a message of this type and merge + /// it with the message being built. This is just a small wrapper around + /// MergeFrom(CodedInputStream). + /// + TBuilder MergeFrom(ByteString data); + + /// + /// Parse as a message of this type and merge + /// it with the message being built. This is just a small wrapper around + /// MergeFrom(CodedInputStream, ExtensionRegistry). + /// + TBuilder MergeFrom(ByteString data, ExtensionRegistry extensionRegistry); + + /// + /// Parse as a message of this type and merge + /// it with the message being built. This is just a small wrapper around + /// MergeFrom(CodedInputStream). + /// + TBuilder MergeFrom(byte[] data); + + /// + /// Parse as a message of this type and merge + /// it with the message being built. This is just a small wrapper around + /// MergeFrom(CodedInputStream, ExtensionRegistry). + /// + TBuilder MergeFrom(byte[] data, ExtensionRegistry extensionRegistry); + + /// + /// Parse as a message of this type and merge + /// it with the message being built. This is just a small wrapper around + /// MergeFrom(CodedInputStream). Note that this method always reads + /// the entire input (unless it throws an exception). If you want it to + /// stop earlier, you will need to wrap the input in a wrapper + /// stream which limits reading. Or, use IMessage.WriteDelimitedTo(Stream) + /// to write your message and MmergeDelimitedFrom(Stream) to read it. + /// Despite usually reading the entire stream, this method never closes the stream. + /// + TBuilder MergeFrom(Stream input); + + /// + /// Parse as a message of this type and merge + /// it with the message being built. This is just a small wrapper around + /// MergeFrom(CodedInputStream, ExtensionRegistry). + /// + TBuilder MergeFrom(Stream input, ExtensionRegistry extensionRegistry); + #endregion + } +} diff --git a/src/ProtocolBuffers/IMessageLite.cs b/src/ProtocolBuffers/IMessageLite.cs new file mode 100644 index 0000000000..ec955c6d39 --- /dev/null +++ b/src/ProtocolBuffers/IMessageLite.cs @@ -0,0 +1,236 @@ +#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.Generic; +using System.IO; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers { + + /// + /// Non-generic interface used for all parts of the API which don't require + /// any type knowledge. + /// + public interface IMessage { + /// + /// Returns the message's type's descriptor. This differs from the + /// Descriptor property of each generated message class in that this + /// method is an abstract method of IMessage whereas Descriptor is + /// a static property of a specific class. They return the same thing. + /// + MessageDescriptor DescriptorForType { get; } + /// + /// Returns a collection of all the fields in this message which are set + /// and their corresponding values. A singular ("required" or "optional") + /// field is set iff HasField() returns true for that field. A "repeated" + /// field is set iff GetRepeatedFieldSize() is greater than zero. The + /// values are exactly what would be returned by calling + /// GetField(FieldDescriptor) for each field. The map + /// is guaranteed to be a sorted map, so iterating over it will return fields + /// in order by field number. + /// + IDictionary AllFields { get; } + + /// + /// Returns true if the given field is set. This is exactly equivalent + /// to calling the generated "Has" property corresponding to the field. + /// + /// the field is a repeated field, + /// or it's not a field of this type + bool HasField(FieldDescriptor field); + + /// + /// Obtains the value of the given field, or the default value if + /// it isn't set. For value type fields, the boxed value is returned. + /// For enum fields, the EnumValueDescriptor for the enum is returned. + /// For embedded message fields, the sub-message + /// is returned. For repeated fields, an IList<T> is returned. + /// + object this[FieldDescriptor field] { get; } + + /// + /// Returns the number of elements of a repeated field. This is + /// exactly equivalent to calling the generated "Count" property + /// corresponding to the field. + /// + /// the field is not a repeated field, + /// or it's not a field of this type + int GetRepeatedFieldCount(FieldDescriptor field); + + /// + /// Gets an element of a repeated field. For value type fields + /// excluding enums, the boxed value is returned. For embedded + /// message fields, the sub-message is returned. For enums, the + /// relevant EnumValueDescriptor is returned. + /// + /// the field is not a repeated field, + /// or it's not a field of this type + /// the index is out of + /// range for the repeated field's value + object this[FieldDescriptor field, int index] { get; } + + /// + /// Returns the unknown fields for this message. + /// + UnknownFieldSet UnknownFields { get; } + + /// + /// Returns true iff all required fields in the message and all embedded + /// messages are set. + /// + bool IsInitialized { get; } + + /// + /// Serializes the message and writes it to the given output stream. + /// This does not flush or close the stream. + /// + /// + /// Protocol Buffers are not self-delimiting. Therefore, if you write + /// any more data to the stream after the message, you must somehow ensure + /// that the parser on the receiving end does not interpret this as being + /// part of the protocol message. One way of doing this is by writing the size + /// of the message before the data, then making sure you limit the input to + /// that size when receiving the data. Alternatively, use WriteDelimitedTo(Stream). + /// + void WriteTo(CodedOutputStream output); + + /// + /// 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. + /// + /// + void WriteDelimitedTo(Stream output); + + /// + /// Returns the number of bytes required to encode this message. + /// The result is only computed on the first call and memoized after that. + /// + int SerializedSize { get; } + + #region Comparison and hashing + /// + /// Compares the specified object with this message for equality. + /// Returns true iff the given object is a message of the same type + /// (as defined by DescriptorForType) and has identical values + /// for all its fields. + /// + bool Equals(object other); + + /// + /// Returns the hash code value for this message. + /// TODO(jonskeet): Specify the hash algorithm, but better than the Java one! + /// + int GetHashCode(); + #endregion + + #region Convenience methods + /// + /// Converts the message to a string in protocol buffer text format. + /// This is just a trivial wrapper around TextFormat.PrintToString. + /// + string ToString(); + + /// + /// Serializes the message to a ByteString. This is a trivial wrapper + /// around WriteTo(CodedOutputStream). + /// + ByteString ToByteString(); + + /// + /// Serializes the message to a byte array. This is a trivial wrapper + /// around WriteTo(CodedOutputStream). + /// + byte[] ToByteArray(); + + /// + /// 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. + /// + /// + void WriteTo(Stream output); + #endregion + + /// + /// Creates a builder for the type, but in a weakly typed manner. This + /// is typically implemented by strongly typed messages by just returning + /// the result of CreateBuilderForType. + /// + IBuilder WeakCreateBuilderForType(); + + /// + /// Creates a builder with the same contents as this message. This + /// is typically implemented by strongly typed messages by just returning + /// the result of ToBuilder. + /// + IBuilder WeakToBuilder(); + + IMessage WeakDefaultInstanceForType { get; } + } + + public interface IMessage : IMessage { + /// + /// Returns an instance of this message type with all fields set to + /// their default values. This may or may not be a singleton. This differs + /// from the DefaultInstance property of each generated message class in that this + /// method is an abstract method of IMessage whereas DefaultInstance is + /// a static property of a specific class. They return the same thing. + /// + TMessage DefaultInstanceForType { get; } + } + + /// + /// Type-safe interface for all generated messages to implement. + /// + public interface IMessage : IMessage + where TMessage : IMessage + where TBuilder : IBuilder { + #region Builders + /// + /// Constructs a new builder for a message of the same type as this message. + /// + TBuilder CreateBuilderForType(); + /// + /// Creates a builder with the same contents as this current instance. + /// This is typically implemented by strongly typed messages by just + /// returning the result of ToBuilder(). + /// + TBuilder ToBuilder(); + #endregion + } +}