FieldDescriptor.cs | searchcode

/src/ProtocolBuffers/Descriptors/FieldDescriptor.cs

https://code.google.com/p/protobuf-csharp-port/
C# | 671 lines | 508 code | 42 blank | 121 comment | 77 complexity | 26543288fc9256916a78db9ff5c924b0 MD5 | raw file
Possible License(s): BSD-3-Clause, Apache-2.0, GPL-2.0

// 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.

using System;

using System.Collections.Generic;

using System.Reflection;

using Google.ProtocolBuffers.Collections;

using Google.ProtocolBuffers.DescriptorProtos;



namespace Google.ProtocolBuffers.Descriptors

{

    /// <summary>

    /// Descriptor for a field or extension within a message in a .proto file.

    /// </summary>

    public sealed class FieldDescriptor : IndexedDescriptorBase<FieldDescriptorProto, FieldOptions>,

                                          IComparable<FieldDescriptor>, IFieldDescriptorLite

    {

        private readonly MessageDescriptor extensionScope;

        private EnumDescriptor enumType;

        private MessageDescriptor messageType;

        private MessageDescriptor containingType;

        private object defaultValue;

        private FieldType fieldType;

        private MappedType mappedType;



        private CSharpFieldOptions csharpFieldOptions;

        private readonly object optionsLock = new object();



        internal FieldDescriptor(FieldDescriptorProto proto, FileDescriptor file,

                                 MessageDescriptor parent, int index, bool isExtension)

            : base(proto, file, ComputeFullName(file, parent, proto.Name), index)

        {

            if (proto.HasType)

            {

                fieldType = GetFieldTypeFromProtoType(proto.Type);

                mappedType = FieldTypeToMappedTypeMap[fieldType];

            }



            if (FieldNumber <= 0)

            {

                throw new DescriptorValidationException(this,

                                                        "Field numbers must be positive integers.");

            }



            if (isExtension)

            {

                if (!proto.HasExtendee)

                {

                    throw new DescriptorValidationException(this,

                                                            "FieldDescriptorProto.Extendee not set for extension field.");

                }

                containingType = null; // Will be filled in when cross-linking

                if (parent != null)

                {

                    extensionScope = parent;

                }

                else

                {

                    extensionScope = null;

                }

            }

            else

            {

                if (proto.HasExtendee)

                {

                    throw new DescriptorValidationException(this,

                                                            "FieldDescriptorProto.Extendee set for non-extension field.");

                }

                containingType = parent;

                extensionScope = null;

            }



            file.DescriptorPool.AddSymbol(this);

        }



        private CSharpFieldOptions BuildOrFakeCSharpOptions()

        {

            // TODO(jonskeet): Check if we could use FileDescriptorProto.Descriptor.Name - interesting bootstrap issues

            if (File.Proto.Name == "google/protobuf/csharp_options.proto")

            {

                if (Name == "csharp_field_options")

                {

                    return new CSharpFieldOptions.Builder {PropertyName = "CSharpFieldOptions"}.Build();

                }

                if (Name == "csharp_file_options")

                {

                    return new CSharpFieldOptions.Builder {PropertyName = "CSharpFileOptions"}.Build();

                }

            }

            CSharpFieldOptions.Builder builder = CSharpFieldOptions.CreateBuilder();

            if (Proto.Options.HasExtension(DescriptorProtos.CSharpOptions.CSharpFieldOptions))

            {

                builder.MergeFrom(Proto.Options.GetExtension(DescriptorProtos.CSharpOptions.CSharpFieldOptions));

            }

            if (!builder.HasPropertyName)

            {

                string fieldName = FieldType == FieldType.Group ? MessageType.Name : Name;

                string propertyName = NameHelpers.UnderscoresToPascalCase(fieldName);

                if (propertyName == ContainingType.Name)

                {

                    propertyName += "_";

                }

                builder.PropertyName = propertyName;

            }

            return builder.Build();

        }



        /// <summary>

        /// Maps a field type as included in the .proto file to a FieldType.

        /// </summary>

        private static FieldType GetFieldTypeFromProtoType(FieldDescriptorProto.Types.Type type)

        {

            switch (type)

            {

                case FieldDescriptorProto.Types.Type.TYPE_DOUBLE:

                    return FieldType.Double;

                case FieldDescriptorProto.Types.Type.TYPE_FLOAT:

                    return FieldType.Float;

                case FieldDescriptorProto.Types.Type.TYPE_INT64:

                    return FieldType.Int64;

                case FieldDescriptorProto.Types.Type.TYPE_UINT64:

                    return FieldType.UInt64;

                case FieldDescriptorProto.Types.Type.TYPE_INT32:

                    return FieldType.Int32;

                case FieldDescriptorProto.Types.Type.TYPE_FIXED64:

                    return FieldType.Fixed64;

                case FieldDescriptorProto.Types.Type.TYPE_FIXED32:

                    return FieldType.Fixed32;

                case FieldDescriptorProto.Types.Type.TYPE_BOOL:

                    return FieldType.Bool;

                case FieldDescriptorProto.Types.Type.TYPE_STRING:

                    return FieldType.String;

                case FieldDescriptorProto.Types.Type.TYPE_GROUP:

                    return FieldType.Group;

                case FieldDescriptorProto.Types.Type.TYPE_MESSAGE:

                    return FieldType.Message;

                case FieldDescriptorProto.Types.Type.TYPE_BYTES:

                    return FieldType.Bytes;

                case FieldDescriptorProto.Types.Type.TYPE_UINT32:

                    return FieldType.UInt32;

                case FieldDescriptorProto.Types.Type.TYPE_ENUM:

                    return FieldType.Enum;

                case FieldDescriptorProto.Types.Type.TYPE_SFIXED32:

                    return FieldType.SFixed32;

                case FieldDescriptorProto.Types.Type.TYPE_SFIXED64:

                    return FieldType.SFixed64;

                case FieldDescriptorProto.Types.Type.TYPE_SINT32:

                    return FieldType.SInt32;

                case FieldDescriptorProto.Types.Type.TYPE_SINT64:

                    return FieldType.SInt64;

                default:

                    throw new ArgumentException("Invalid type specified");

            }

        }



        /// <summary>

        /// Returns the default value for a mapped type.

        /// </summary>

        private static object GetDefaultValueForMappedType(MappedType type)

        {

            switch (type)

            {

                case MappedType.Int32:

                    return 0;

                case MappedType.Int64:

                    return (long) 0;

                case MappedType.UInt32:

                    return (uint) 0;

                case MappedType.UInt64:

                    return (ulong) 0;

                case MappedType.Single:

                    return (float) 0;

                case MappedType.Double:

                    return (double) 0;

                case MappedType.Boolean:

                    return false;

                case MappedType.String:

                    return "";

                case MappedType.ByteString:

                    return ByteString.Empty;

                case MappedType.Message:

                    return null;

                case MappedType.Enum:

                    return null;

                default:

                    throw new ArgumentException("Invalid type specified");

            }

        }



        public bool IsRequired

        {

            get { return Proto.Label == FieldDescriptorProto.Types.Label.LABEL_REQUIRED; }

        }



        public bool IsOptional

        {

            get { return Proto.Label == FieldDescriptorProto.Types.Label.LABEL_OPTIONAL; }

        }



        public bool IsRepeated

        {

            get { return Proto.Label == FieldDescriptorProto.Types.Label.LABEL_REPEATED; }

        }



        public bool IsPacked

        {

            get { return Proto.Options.Packed; }

        }



        /// <valule>

        /// Indicates whether or not the field had an explicitly-defined default value.

        /// </value>

        public bool HasDefaultValue

        {

            get { return Proto.HasDefaultValue; }

        }



        /// <value>

        /// The field's default value. Valid for all types except messages

        /// and groups. For all other types, the object returned is of the

        /// same class that would be returned by IMessage[this].

        /// For repeated fields this will always be an empty immutable list compatible with IList[object].

        /// For message fields it will always be null. For singular values, it will depend on the descriptor.

        /// </value>

        public object DefaultValue

        {

            get

            {

                if (MappedType == MappedType.Message)

                {

                    throw new InvalidOperationException(

                        "FieldDescriptor.DefaultValue called on an embedded message field.");

                }

                return defaultValue;

            }

        }



        /// <value>

        /// Indicates whether or not this field is an extension.

        /// </value>

        public bool IsExtension

        {

            get { return Proto.HasExtendee; }

        }



        /*

     * Get the field's containing type. For extensions, this is the type being

     * extended, not the location where the extension was defined.  See

     * {@link #getExtensionScope()}.

     */



        /// <summary>

        /// Get the field's containing type. For extensions, this is the type being

        /// extended, not the location where the extension was defined. See

        /// <see cref="ExtensionScope" />.

        /// </summary>

        public MessageDescriptor ContainingType

        {

            get { return containingType; }

        }



        /// <summary>

        /// Returns the C#-specific options for this field descriptor. This will always be

        /// completely filled in.

        /// </summary>

        public CSharpFieldOptions CSharpOptions

        {

            get

            {

                lock (optionsLock)

                {

                    if (csharpFieldOptions == null)

                    {

                        csharpFieldOptions = BuildOrFakeCSharpOptions();

                    }

                }

                return csharpFieldOptions;

            }

        }



        /// <summary>

        /// For extensions defined nested within message types, gets

        /// the outer type. Not valid for non-extension fields.

        /// </summary>

        /// <example>

        /// <code>

        /// message Foo {

        ///   extensions 1000 to max;

        /// }

        /// extend Foo {

        ///   optional int32 baz = 1234;

        /// }

        /// message Bar {

        ///   extend Foo {

        ///     optional int32 qux = 4321;

        ///   }

        /// }

        /// </code>

        /// The containing type for both <c>baz</c> and <c>qux</c> is <c>Foo</c>.

        /// However, the extension scope for <c>baz</c> is <c>null</c> while

        /// the extension scope for <c>qux</c> is <c>Bar</c>.

        /// </example>

        public MessageDescriptor ExtensionScope

        {

            get

            {

                if (!IsExtension)

                {

                    throw new InvalidOperationException("This field is not an extension.");

                }

                return extensionScope;

            }

        }



        public MappedType MappedType

        {

            get { return mappedType; }

        }



        public FieldType FieldType

        {

            get { return fieldType; }

        }



        public bool IsCLSCompliant

        {

            get 

            { 

                return mappedType != MappedType.UInt32 && 

                    mappedType != MappedType.UInt64 &&

                    !NameHelpers.UnderscoresToPascalCase(Name).StartsWith("_");

            }

        }



        public int FieldNumber

        {

            get { return Proto.Number; }

        }



        /// <summary>

        /// Compares this descriptor with another one, ordering in "canonical" order

        /// which simply means ascending order by field number. <paramref name="other"/>

        /// must be a field of the same type, i.e. the <see cref="ContainingType"/> of

        /// both fields must be the same.

        /// </summary>

        public int CompareTo(FieldDescriptor other)

        {

            if (other.containingType != containingType)

            {

                throw new ArgumentException("FieldDescriptors can only be compared to other FieldDescriptors " +

                                            "for fields of the same message type.");

            }

            return FieldNumber - other.FieldNumber;

        }



        /// <summary>

        /// Compares this descriptor with another one, ordering in "canonical" order

        /// which simply means ascending order by field number. <paramref name="other"/>

        /// must be a field of the same type, i.e. the <see cref="ContainingType"/> of

        /// both fields must be the same.

        /// </summary>

        public int CompareTo(IFieldDescriptorLite other)

        {

            return FieldNumber - other.FieldNumber;

        }



        IEnumLiteMap IFieldDescriptorLite.EnumType

        {

            get { return EnumType; }

        }



        bool IFieldDescriptorLite.MessageSetWireFormat

        {

            get { return ContainingType.Options.MessageSetWireFormat; }

        }



        /// <summary>

        /// For enum fields, returns the field's type.

        /// </summary>

        public EnumDescriptor EnumType

        {

            get

            {

                if (MappedType != MappedType.Enum)

                {

                    throw new InvalidOperationException("EnumType is only valid for enum fields.");

                }

                return enumType;

            }

        }



        /// <summary>

        /// For embedded message and group fields, returns the field's type.

        /// </summary>

        public MessageDescriptor MessageType

        {

            get

            {

                if (MappedType != MappedType.Message)

                {

                    throw new InvalidOperationException("MessageType is only valid for enum fields.");

                }

                return messageType;

            }

        }



        /// <summary>

        /// Immutable mapping from field type to mapped type. Built using the attributes on

        /// FieldType values.

        /// </summary>

        public static readonly IDictionary<FieldType, MappedType> FieldTypeToMappedTypeMap = MapFieldTypes();



        private static IDictionary<FieldType, MappedType> MapFieldTypes()

        {

            var map = new Dictionary<FieldType, MappedType>();

            foreach (FieldInfo field in typeof (FieldType).GetFields(BindingFlags.Static | BindingFlags.Public))

            {

                FieldType fieldType = (FieldType) field.GetValue(null);

                FieldMappingAttribute mapping =

                    (FieldMappingAttribute) field.GetCustomAttributes(typeof (FieldMappingAttribute), false)[0];

                map[fieldType] = mapping.MappedType;

            }

            return Dictionaries.AsReadOnly(map);

        }



        /// <summary>

        /// Look up and cross-link all field types etc.

        /// </summary>

        internal void CrossLink()

        {

            if (Proto.HasExtendee)

            {

                IDescriptor extendee = File.DescriptorPool.LookupSymbol(Proto.Extendee, this);

                if (!(extendee is MessageDescriptor))

                {

                    throw new DescriptorValidationException(this, "\"" + Proto.Extendee + "\" is not a message type.");

                }

                containingType = (MessageDescriptor) extendee;



                if (!containingType.IsExtensionNumber(FieldNumber))

                {

                    throw new DescriptorValidationException(this,

                                                            "\"" + containingType.FullName + "\" does not declare " +

                                                            FieldNumber + " as an extension number.");

                }

            }



            if (Proto.HasTypeName)

            {

                IDescriptor typeDescriptor =

                    File.DescriptorPool.LookupSymbol(Proto.TypeName, this);



                if (!Proto.HasType)

                {

                    // Choose field type based on symbol.

                    if (typeDescriptor is MessageDescriptor)

                    {

                        fieldType = FieldType.Message;

                        mappedType = MappedType.Message;

                    }

                    else if (typeDescriptor is EnumDescriptor)

                    {

                        fieldType = FieldType.Enum;

                        mappedType = MappedType.Enum;

                    }

                    else

                    {

                        throw new DescriptorValidationException(this, "\"" + Proto.TypeName + "\" is not a type.");

                    }

                }



                if (MappedType == MappedType.Message)

                {

                    if (!(typeDescriptor is MessageDescriptor))

                    {

                        throw new DescriptorValidationException(this,

                                                                "\"" + Proto.TypeName + "\" is not a message type.");

                    }

                    messageType = (MessageDescriptor) typeDescriptor;



                    if (Proto.HasDefaultValue)

                    {

                        throw new DescriptorValidationException(this, "Messages can't have default values.");

                    }

                }

                else if (MappedType == Descriptors.MappedType.Enum)

                {

                    if (!(typeDescriptor is EnumDescriptor))

                    {

                        throw new DescriptorValidationException(this, "\"" + Proto.TypeName + "\" is not an enum type.");

                    }

                    enumType = (EnumDescriptor) typeDescriptor;

                }

                else

                {

                    throw new DescriptorValidationException(this, "Field with primitive type has type_name.");

                }

            }

            else

            {

                if (MappedType == MappedType.Message || MappedType == MappedType.Enum)

                {

                    throw new DescriptorValidationException(this, "Field with message or enum type missing type_name.");

                }

            }



            // We don't attempt to parse the default value until here because for

            // enums we need the enum type's descriptor.

            if (Proto.HasDefaultValue)

            {

                if (IsRepeated)

                {

                    throw new DescriptorValidationException(this, "Repeated fields cannot have default values.");

                }



                try

                {

                    switch (FieldType)

                    {

                        case FieldType.Int32:

                        case FieldType.SInt32:

                        case FieldType.SFixed32:

                            defaultValue = TextFormat.ParseInt32(Proto.DefaultValue);

                            break;

                        case FieldType.UInt32:

                        case FieldType.Fixed32:

                            defaultValue = TextFormat.ParseUInt32(Proto.DefaultValue);

                            break;

                        case FieldType.Int64:

                        case FieldType.SInt64:

                        case FieldType.SFixed64:

                            defaultValue = TextFormat.ParseInt64(Proto.DefaultValue);

                            break;

                        case FieldType.UInt64:

                        case FieldType.Fixed64:

                            defaultValue = TextFormat.ParseUInt64(Proto.DefaultValue);

                            break;

                        case FieldType.Float:

                            defaultValue = TextFormat.ParseFloat(Proto.DefaultValue);

                            break;

                        case FieldType.Double:

                            defaultValue = TextFormat.ParseDouble(Proto.DefaultValue);

                            break;

                        case FieldType.Bool:

                            if (Proto.DefaultValue == "true")

                            {

                                defaultValue = true;

                            }

                            else if (Proto.DefaultValue == "false")

                            {

                                defaultValue = false;

                            }

                            else

                            {

                                throw new FormatException("Boolean values must be \"true\" or \"false\"");

                            }

                            break;

                        case FieldType.String:

                            defaultValue = Proto.DefaultValue;

                            break;

                        case FieldType.Bytes:

                            try

                            {

                                defaultValue = TextFormat.UnescapeBytes(Proto.DefaultValue);

                            }

                            catch (FormatException e)

                            {

                                throw new DescriptorValidationException(this,

                                                                        "Couldn't parse default value: " + e.Message);

                            }

                            break;

                        case FieldType.Enum:

                            defaultValue = enumType.FindValueByName(Proto.DefaultValue);

                            if (defaultValue == null)

                            {

                                throw new DescriptorValidationException(this,

                                                                        "Unknown enum default value: \"" +

                                                                        Proto.DefaultValue + "\"");

                            }

                            break;

                        case FieldType.Message:

                        case FieldType.Group:

                            throw new DescriptorValidationException(this, "Message type had default value.");

                    }

                }

                catch (FormatException e)

                {

                    DescriptorValidationException validationException =

                        new DescriptorValidationException(this,

                                                          "Could not parse default value: \"" + Proto.DefaultValue +

                                                          "\"", e);

                    throw validationException;

                }

            }

            else

            {

                // Determine the default default for this field.

                if (IsRepeated)

                {

                    defaultValue = Lists<object>.Empty;

                }

                else

                {

                    switch (MappedType)

                    {

                        case MappedType.Enum:

                            // We guarantee elsewhere that an enum type always has at least

                            // one possible value.

                            defaultValue = enumType.Values[0];

                            break;

                        case MappedType.Message:

                            defaultValue = null;

                            break;

                        default:

                            defaultValue = GetDefaultValueForMappedType(MappedType);

                            break;

                    }

                }

            }



            if (!IsExtension)

            {

                File.DescriptorPool.AddFieldByNumber(this);

            }



            if (containingType != null && containingType.Options.MessageSetWireFormat)

            {

                if (IsExtension)

                {

                    if (!IsOptional || FieldType != FieldType.Message)

                    {

                        throw new DescriptorValidationException(this,

                                                                "Extensions of MessageSets must be optional messages.");

                    }

                }

                else

                {

                    throw new DescriptorValidationException(this, "MessageSets cannot have fields, only extensions.");

                }

            }

        }

    }

}