Imported protobuf-csharp-port into csharp/ tree

1 files changed, 274 insertions, 0 deletions

diff --git a/csharp/src/ProtocolBuffers/ExtendableMessage.cs b/csharp/src/ProtocolBuffers/ExtendableMessage.cs
new file mode 100644
index 00000000..71cd1b38
--- /dev/null
+++ b/csharp/src/ProtocolBuffers/ExtendableMessage.cs
@@ -0,0 +1,274 @@
+#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 Google.ProtocolBuffers.Collections;

+using Google.ProtocolBuffers.Descriptors;

+

+namespace Google.ProtocolBuffers

+{

+    public abstract partial class ExtendableMessage<TMessage, TBuilder> : GeneratedMessage<TMessage, TBuilder>

+        where TMessage : GeneratedMessage<TMessage, TBuilder>

+        where TBuilder : GeneratedBuilder<TMessage, TBuilder>, new()

+    {

+        protected ExtendableMessage()

+        {

+        }

+

+        private readonly FieldSet extensions = FieldSet.CreateInstance();

+

+        /// <summary>

+        /// Access for the builder.

+        /// </summary>

+        internal FieldSet Extensions

+        {

+            get { return extensions; }

+        }

+

+        /// <summary>

+        /// Checks if a singular extension is present.

+        /// </summary>

+        public bool HasExtension<TExtension>(GeneratedExtensionBase<TExtension> extension)

+        {

+            return extensions.HasField(extension.Descriptor);

+        }

+

+        /// <summary>

+        /// Returns the number of elements in a repeated extension.

+        /// </summary>

+        public int GetExtensionCount<TExtension>(GeneratedExtensionBase<IList<TExtension>> extension)

+        {

+            return extensions.GetRepeatedFieldCount(extension.Descriptor);

+        }

+

+        /// <summary>

+        /// Returns the value of an extension.

+        /// </summary>

+        public TExtension GetExtension<TExtension>(GeneratedExtensionBase<TExtension> extension)

+        {

+            object value = extensions[extension.Descriptor];

+            if (value == null)

+            {

+                return (TExtension) extension.MessageDefaultInstance;

+            }

+            else

+            {

+                return (TExtension) extension.FromReflectionType(value);

+            }

+        }

+

+        /// <summary>

+        /// Returns one element of a repeated extension.

+        /// </summary>

+        public TExtension GetExtension<TExtension>(GeneratedExtensionBase<IList<TExtension>> extension, int index)

+        {

+            return (TExtension) extension.SingularFromReflectionType(extensions[extension.Descriptor, index]);

+        }

+

+        /// <summary>

+        /// Called to check if all extensions are initialized.

+        /// </summary>

+        protected bool ExtensionsAreInitialized

+        {

+            get { return extensions.IsInitialized; }

+        }

+

+        public override bool IsInitialized

+        {

+            get { return base.IsInitialized && ExtensionsAreInitialized; }

+        }

+

+        #region Reflection

+

+        public override IDictionary<FieldDescriptor, object> AllFields

+        {

+            get

+            {

+                IDictionary<FieldDescriptor, object> result = GetMutableFieldMap();

+                foreach (KeyValuePair<IFieldDescriptorLite, object> entry in extensions.AllFields)

+                {

+                    result[(FieldDescriptor) entry.Key] = entry.Value;

+                }

+                return Dictionaries.AsReadOnly(result);

+            }

+        }

+

+        public override bool HasField(FieldDescriptor field)

+        {

+            if (field.IsExtension)

+            {

+                VerifyContainingType(field);

+                return extensions.HasField(field);

+            }

+            else

+            {

+                return base.HasField(field);

+            }

+        }

+

+        public override object this[FieldDescriptor field]

+        {

+            get

+            {

+                if (field.IsExtension)

+                {

+                    VerifyContainingType(field);

+                    object value = extensions[field];

+                    if (value == null)

+                    {

+                        // Lacking an ExtensionRegistry, we have no way to determine the

+                        // extension's real type, so we return a DynamicMessage.

+                        // TODO(jonskeet): Work out what this means

+                        return DynamicMessage.GetDefaultInstance(field.MessageType);

+                    }

+                    else

+                    {

+                        return value;

+                    }

+                }

+                else

+                {

+                    return base[field];

+                }

+            }

+        }

+

+        public override int GetRepeatedFieldCount(FieldDescriptor field)

+        {

+            if (field.IsExtension)

+            {

+                VerifyContainingType(field);

+                return extensions.GetRepeatedFieldCount(field);

+            }

+            else

+            {

+                return base.GetRepeatedFieldCount(field);

+            }

+        }

+

+        public override object this[FieldDescriptor field, int index]

+        {

+            get

+            {

+                if (field.IsExtension)

+                {

+                    VerifyContainingType(field);

+                    return extensions[field, index];

+                }

+                else

+                {

+                    return base[field, index];

+                }

+            }

+        }

+

+        internal void VerifyContainingType(FieldDescriptor field)

+        {

+            if (field.ContainingType != DescriptorForType)

+            {

+                throw new ArgumentException("FieldDescriptor does not match message type.");

+            }

+        }

+

+        #endregion

+

+        /// <summary>

+        /// Used by subclasses to serialize extensions. Extension ranges may be

+        /// interleaves with field numbers, but we must write them in canonical

+        /// (sorted by field number) order. This class helps us to write individual

+        /// ranges of extensions at once.

+        /// 

+        /// TODO(jonskeet): See if we can improve this in terms of readability.

+        /// </summary>

+        protected class ExtensionWriter

+        {

+            private readonly IEnumerator<KeyValuePair<IFieldDescriptorLite, object>> iterator;

+            private readonly FieldSet extensions;

+            private KeyValuePair<IFieldDescriptorLite, object>? next = null;

+

+            internal ExtensionWriter(ExtendableMessage<TMessage, TBuilder> message)

+            {

+                extensions = message.extensions;

+                iterator = message.extensions.GetEnumerator();

+                if (iterator.MoveNext())

+                {

+                    next = iterator.Current;

+                }

+            }

+

+            public void WriteUntil(int end, ICodedOutputStream output)

+            {

+                while (next != null && next.Value.Key.FieldNumber < end)

+                {

+                    extensions.WriteField(next.Value.Key, next.Value.Value, output);

+                    if (iterator.MoveNext())

+                    {

+                        next = iterator.Current;

+                    }

+                    else

+                    {

+                        next = null;

+                    }

+                }

+            }

+        }

+

+        protected ExtensionWriter CreateExtensionWriter(ExtendableMessage<TMessage, TBuilder> message)

+        {

+            return new ExtensionWriter(message);

+        }

+

+        /// <summary>

+        /// Called by subclasses to compute the size of extensions.

+        /// </summary>

+        protected int ExtensionsSerializedSize

+        {

+            get { return extensions.SerializedSize; }

+        }

+

+        internal void VerifyExtensionContainingType<TExtension>(GeneratedExtensionBase<TExtension> extension)

+        {

+            if (extension.Descriptor.ContainingType != DescriptorForType)

+            {

+                // This can only happen if someone uses unchecked operations.

+                throw new ArgumentException("Extension is for type \"" + extension.Descriptor.ContainingType.FullName

+                                            + "\" which does not match message type \"" + DescriptorForType.FullName +

+                                            "\".");

+            }

+        }

+    }

+}
\ No newline at end of file