protobuf/csharp/ProtocolBuffers/Descriptors/FieldDescriptor.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using Google.ProtocolBuffers.Collections;
using Google.ProtocolBuffers.DescriptorProtos;
using System.Collections.ObjectModel;

namespace Google.ProtocolBuffers.Descriptors {
  public class FieldDescriptor : IndexedDescriptorBase<FieldDescriptorProto, FieldOptions>, IComparable<FieldDescriptor> {

    private readonly MessageDescriptor extensionScope;
    private EnumDescriptor enumType;
    private MessageDescriptor messageType;
    private MessageDescriptor containingType;
    private object defaultValue;
    private FieldType fieldType;
    private MappedType mappedType;

    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);
    }

    /// <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; }
    }

    /// <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>
    /// 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 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>
    /// 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 = float.Parse(Proto.DefaultValue);
              break;
            case FieldType.Double:
              defaultValue = double.Parse(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.");
        }
      }
    }
  }
}