Skip to content

P
protobuf
Commit 3351bb63 authored by Jon Skeet's avatar Jon Skeet
Browse files
Options

Descriptors are pretty much complete, with a slight issue of how to find the… 

Descriptors are pretty much complete, with a slight issue of how to find the default type for a repeated field.
parent 5f7b68eb
Hide whitespace changes
Inline Side-by-side
Showing with 1199 additions and 216 deletions
CSHARP-README.txt
View file @ 3351bb63
......@@ -34,5 +34,7 @@ o There's a mixture of generic and non-generic code. This
IEnumerable. As an aside, this becomes a pain when trying to
create "the read-only version of this list, whose type I don't
know but I know it's a List<something>". Oh for mumble types.
o Nested types always end up under a "Types" static class which
is merely present to avoid name clashes.
o FileDescriptor.FindByName has been made generic to allow simple
type-safe searching for any nested type.
\ No newline at end of file
csharp/ProtocolBuffers/DescriptorProtos/Autogenerated.cs deleted 100644 → 0
View file @ 5f7b68eb
// This file contains quick hacks to represent code that will be autogenerated.
namespace Google.ProtocolBuffers.DescriptorProtos {
/// <summary>
/// This only exists until we've got the real code...
/// </summary>
/*
public abstract class TemporaryMessage<T> : IMessage<T> where T : IMessage<T> {
#region IMessage<T> Members
public IMessage<T> DefaultInstanceForType {
get { throw new System.NotImplementedException(); }
}
public IBuilder<T> CreateBuilderForType() {
throw new System.NotImplementedException();
}
#endregion
#region IMessage Members
public Google.ProtocolBuffers.Descriptors.MessageDescriptor DescriptorForType {
get { throw new System.NotImplementedException(); }
}
public System.Collections.Generic.IDictionary<Google.ProtocolBuffers.Descriptors.FieldDescriptor, object> AllFields {
get { throw new System.NotImplementedException(); }
}
public bool HasField(Google.ProtocolBuffers.Descriptors.FieldDescriptor field) {
throw new System.NotImplementedException();
}
public object this[Google.ProtocolBuffers.Descriptors.FieldDescriptor field] {
get { throw new System.NotImplementedException(); }
}
public int GetRepeatedFieldCount(Google.ProtocolBuffers.Descriptors.FieldDescriptor field) {
throw new System.NotImplementedException();
}
public object this[Google.ProtocolBuffers.Descriptors.FieldDescriptor field, int index] {
get { throw new System.NotImplementedException(); }
}
public UnknownFieldSet UnknownFields {
get { throw new System.NotImplementedException(); }
}
public bool IsInitialized {
get { throw new System.NotImplementedException(); }
}
public void WriteTo(CodedOutputStream output) {
throw new System.NotImplementedException();
}
public int SerializedSize {
get { throw new System.NotImplementedException(); }
}
public ByteString ToByteString() {
throw new System.NotImplementedException();
}
public byte[] ToByteArray() {
throw new System.NotImplementedException();
}
public void WriteTo(System.IO.Stream output) {
throw new System.NotImplementedException();
}
IMessage IMessage.DefaultInstanceForType {
get { throw new System.NotImplementedException(); }
}
IBuilder IMessage.CreateBuilderForType() {
throw new System.NotImplementedException();
}
#endregion
}
public partial class MessageOptions : TemporaryMessage<MessageOptions> {
public bool MessageSetWireFormat;
}
public partial class DescriptorProto : TemporaryMessage<DescriptorProto> {
public string Name { get; set; }
public string FullName { get; set; }
public MessageOptions Options { get; set; }
}
public partial class EnumDescriptorProto : TemporaryMessage<EnumDescriptorProto> {
public string Name { get; set; }
public string FullName { get; set; }
public EnumOptions Options { get; set; }
}
public partial class EnumOptions : TemporaryMessage<EnumOptions> { }
public partial class EnumValueDescriptorProto : TemporaryMessage<EnumValueDescriptorProto> {
public string Name { get; set; }
public string FullName { get; set; }
public EnumValueOptions Options { get; set; }
}
public partial class EnumValueOptions : TemporaryMessage <EnumValueOptions> { }
public partial class FieldDescriptorProto : TemporaryMessage<FieldDescriptorProto> {
public string Name { get; set; }
public string FullName { get; set; }
public FieldOptions Options { get; set; }
}
public partial class FieldOptions : TemporaryMessage<FieldOptions> { }
public partial class FileDescriptorProto : TemporaryMessage<FileDescriptorProto> {
public string Name { get; set; }
public string FullName { get; set; }
public FileOptions Options { get; set; }
public string Package { get; set; }
}
public partial class FileOptions : TemporaryMessage<FileOptions> { }
public partial class MethodDescriptorProto : TemporaryMessage<MethodDescriptorProto> {
public string Name { get; set; }
public string FullName { get; set; }
public MethodOptions Options { get; set; }
}
public partial class MethodOptions : TemporaryMessage<MethodOptions> { }
public partial class ServiceDescriptorProto : TemporaryMessage<ServiceDescriptorProto> {
public string Name { get; set; }
public string FullName { get; set; }
public ServiceOptions Options { get; set; }
}
public partial class ServiceOptions : TemporaryMessage<ServiceOptions> { } */
}
csharp/ProtocolBuffers/Descriptors/DescriptorBase.cs
View file @ 3351bb63
......@@ -2,21 +2,39 @@
using System.Collections.Generic;
using System.Text;
using Google.ProtocolBuffers.DescriptorProtos;
using Google.ProtocolBuffers.Collections;
namespace Google.ProtocolBuffers.Descriptors {
/// <summary>
/// Base class for all descriptors, providing common functionality.
/// Base class for nearly all descriptors, providing common functionality.
/// </summary>
/// <typeparam name="TProto">Type of the protocol buffer form of this descriptor</typeparam>
/// <typeparam name="TOptions">Type of the options protocol buffer for this descriptor</typeparam>
public abstract class DescriptorBase<TProto, TOptions> where TProto : IMessage<TProto>, IDescriptorProto<TOptions> {
public abstract class DescriptorBase<TProto, TOptions> : IDescriptor<TProto>
where TProto : IMessage, IDescriptorProto<TOptions> {
private readonly TProto proto;
private readonly FileDescriptor file;
private readonly string fullName;
protected DescriptorBase(TProto proto, FileDescriptor file) {
protected DescriptorBase(TProto proto, FileDescriptor file, string fullName) {
this.proto = proto;
this.file = file;
this.fullName = fullName;
}
protected static string ComputeFullName(FileDescriptor file, MessageDescriptor parent, string name) {
if (parent != null) {
return parent.FullName + "." + name;
}
if (file.Package.Length > 0) {
return file.Package + "." + name;
}
return name;
}
IMessage IDescriptor.Proto {
get { return proto; }
}
/// <summary>
......@@ -32,10 +50,9 @@ namespace Google.ProtocolBuffers.Descriptors {
/// <summary>
/// The fully qualified name of the descriptor's target.
/// TODO(jonskeet): Implement!
/// </summary>
public string FullName {
get { return null; }
get { return fullName; }
}
/// <summary>
......
csharp/ProtocolBuffers/Descriptors/DescriptorPool.cs
View file @ 3351bb63
using System.Collections.Generic;
using System;
using System.Text;
using System.Text.RegularExpressions;
namespace Google.ProtocolBuffers.Descriptors {
/// <summary>
......@@ -6,17 +9,258 @@ namespace Google.ProtocolBuffers.Descriptors {
/// </summary>
internal class DescriptorPool {
IDictionary<string, object> byName;
private readonly IDictionary<string, IDescriptor> descriptorsByName =
new Dictionary<string, IDescriptor>();
private readonly IDictionary<DescriptorIntPair, FieldDescriptor> fieldsByNumber =
new Dictionary<DescriptorIntPair, FieldDescriptor>();
private readonly IDictionary<DescriptorIntPair, EnumValueDescriptor> enumValuesByNumber =
new Dictionary<DescriptorIntPair, EnumValueDescriptor>();
private readonly DescriptorPool[] dependencies;
internal DescriptorPool(FileDescriptor[] dependencyFiles) {
dependencies = new DescriptorPool[dependencyFiles.Length];
for (int i = 0; i < dependencyFiles.Length; i++) {
dependencies[i] = dependencyFiles[i].DescriptorPool;
}
foreach (FileDescriptor dependency in dependencyFiles) {
AddPackage(dependency.Package, dependency);
}
}
/// <summary>
/// Finds a symbol of the given name within the pool.
/// </summary>
/// <typeparam name="T">The type of symbol to look for</typeparam>
/// <param name="name">Name to look up</param>
/// <param name="fullName">Fully-qualified name to look up</param>
/// <returns>The symbol with the given name and type,
/// or null if the symbol doesn't exist or has the wrong type</returns>
internal T FindSymbol<T>(string name) where T : class {
return default(T);
internal T FindSymbol<T>(string fullName) where T : class, IDescriptor {
IDescriptor result;
descriptorsByName.TryGetValue(fullName, out result);
T descriptor = result as T;
if (descriptor != null) {
return descriptor;
}
foreach (DescriptorPool dependency in dependencies) {
dependency.descriptorsByName.TryGetValue(fullName, out result);
descriptor = result as T;
if (descriptor != null) {
return descriptor;
}
}
return null;
}
/// <summary>
/// Adds a package to the symbol tables. If a package by the same name
/// already exists, that is fine, but if some other kind of symbol
/// exists under the same name, an exception is thrown. If the package
/// has multiple components, this also adds the parent package(s).
/// </summary>
internal void AddPackage(string fullName, FileDescriptor file) {
int dotpos = fullName.LastIndexOf('.');
String name;
if (dotpos != -1) {
AddPackage(fullName.Substring(0, dotpos), file);
name = fullName.Substring(dotpos + 1);
} else {
name = fullName;
}
IDescriptor old;
if (descriptorsByName.TryGetValue(fullName, out old)) {
if (!(old is PackageDescriptor)) {
throw new DescriptorValidationException(file,
"\"" + name + "\" is already defined (as something other than a " +
"package) in file \"" + old.File.Name + "\".");
}
}
// TODO(jonskeet): Check issue 25 wrt the ordering of these parameters
descriptorsByName[fullName] = new PackageDescriptor(fullName, name, file);
}
/// <summary>
/// Adds a symbol to the symbol table.
/// </summary>
/// <exception cref="DescriptorValidationException">The symbol already existed
/// in the symbol table.</exception>
internal void AddSymbol(IDescriptor descriptor) {
ValidateSymbolName(descriptor);
String fullName = descriptor.FullName;
IDescriptor old;
if (descriptorsByName.TryGetValue(fullName, out old)) {
int dotPos = fullName.LastIndexOf('.');
string message;
if (descriptor.File == old.File) {
if (dotPos == -1) {
message = "\"" + fullName + "\" is already defined.";
} else {
message = "\"" + fullName.Substring(dotPos + 1) + "\" is already defined in \"" + fullName.Substring(0, dotPos) + "\".";
}
} else {
message = "\"" + fullName + "\" is already defined in file \"" + old.File.Name + "\".";
}
throw new DescriptorValidationException(descriptor, message);
}
descriptorsByName[fullName] = descriptor;
}
private static readonly Regex ValidationRegex = new Regex("^[_A-Za-z][_A-Za-z0-9]*$", RegexOptions.Compiled);
/// <summary>
/// Verifies that the descriptor's name is valid (i.e. it contains
/// only letters, digits and underscores, and does not start with a digit).
/// </summary>
/// <param name="descriptor"></param>
private static void ValidateSymbolName(IDescriptor descriptor) {
if (descriptor.Name == "") {
throw new DescriptorValidationException(descriptor, "Missing name.");
}
if (!ValidationRegex.IsMatch(descriptor.Name)) {
throw new DescriptorValidationException(descriptor,
"\"" + descriptor.Name + "\" is not a valid identifier.");
}
}
/// <summary>
/// Returns the field with the given number in the given descriptor,
/// or null if it can't be found.
/// </summary>
internal FieldDescriptor FindFieldByNumber(MessageDescriptor messageDescriptor, int number) {
FieldDescriptor ret;
fieldsByNumber.TryGetValue(new DescriptorIntPair(messageDescriptor, number), out ret);
return ret;
}
internal EnumValueDescriptor FindEnumValueByNumber(EnumDescriptor enumDescriptor, int number) {
EnumValueDescriptor ret;
enumValuesByNumber.TryGetValue(new DescriptorIntPair(enumDescriptor, number), out ret);
return ret;
}
/// <summary>
/// Adds a field to the fieldsByNumber table.
/// </summary>
/// <exception cref="DescriptorValidationException">A field with the same
/// containing type and number already exists.</exception>
internal void AddFieldByNumber(FieldDescriptor field) {
DescriptorIntPair key = new DescriptorIntPair(field.ContainingType, field.FieldNumber);
FieldDescriptor old;
if (fieldsByNumber.TryGetValue(key, out old)) {
throw new DescriptorValidationException(field, "Field number " + field.FieldNumber +
"has already been used in \"" + field.ContainingType.FullName +
"\" by field \"" + old.Name + "\".");
}
fieldsByNumber[key] = field;
}
/// <summary>
/// Adds an enum value to the enumValuesByNumber table. If an enum value
/// with the same type and number already exists, this method does nothing.
/// (This is allowed; the first value defined with the number takes precedence.)
/// </summary>
internal void AddEnumValueByNumber(EnumValueDescriptor enumValue) {
DescriptorIntPair key = new DescriptorIntPair(enumValue.EnumDescriptor, enumValue.Number);
if (!enumValuesByNumber.ContainsKey(key)) {
enumValuesByNumber[key] = enumValue;
}
}
/// <summary>
/// Looks up a descriptor by name, relative to some other descriptor.
/// The name may be fully-qualified (with a leading '.'), partially-qualified,
/// or unqualified. C++-like name lookup semantics are used to search for the
/// matching descriptor.
/// </summary>
public IDescriptor LookupSymbol(string name, IDescriptor relativeTo) {
// TODO(jonskeet): This could be optimized in a number of ways.
IDescriptor result;
if (name.StartsWith(".")) {
// Fully-qualified name.
result = FindSymbol<IDescriptor>(name.Substring(1));
} else {
// If "name" is a compound identifier, we want to search for the
// first component of it, then search within it for the rest.
int firstPartLength = name.IndexOf('.');
string firstPart = firstPartLength == -1 ? name : name.Substring(0, firstPartLength);
// We will search each parent scope of "relativeTo" looking for the
// symbol.
StringBuilder scopeToTry = new StringBuilder(relativeTo.FullName);
while (true) {
// Chop off the last component of the scope.
// TODO(jonskeet): Make this more efficient. May not be worth using StringBuilder at all
int dotpos = scopeToTry.ToString().LastIndexOf(".");
if (dotpos == -1) {
result = FindSymbol<IDescriptor>(name);
break;
} else {
scopeToTry.Length = dotpos + 1;
// Append firstPart and try to find.
scopeToTry.Append(firstPart);
result = FindSymbol<IDescriptor>(scopeToTry.ToString());
if (result != null) {
if (firstPartLength != -1) {
// We only found the first part of the symbol. Now look for
// the whole thing. If this fails, we *don't* want to keep
// searching parent scopes.
scopeToTry.Length = dotpos + 1;
scopeToTry.Append(name);
result = FindSymbol<IDescriptor>(scopeToTry.ToString());
}
break;
}
// Not found. Remove the name so we can try again.
scopeToTry.Length = dotpos;
}
}
}
if (result == null) {
throw new DescriptorValidationException(relativeTo, "\"" + name + "\" is not defined.");
} else {
return result;
}
}
/// <summary>
/// Struct used to hold the keys for the fieldByNumber table.
/// </summary>
struct DescriptorIntPair : IEquatable<DescriptorIntPair> {
private readonly int number;
private readonly IDescriptor descriptor;
internal DescriptorIntPair(IDescriptor descriptor, int number) {
this.number = number;
this.descriptor = descriptor;
}
public bool Equals(DescriptorIntPair other) {
return descriptor == other.descriptor
&& number == other.number;
}
public override bool Equals(object obj) {
if (obj is DescriptorIntPair) {
return Equals((DescriptorIntPair)obj);
}
return false;
}
public override int GetHashCode() {
return descriptor.GetHashCode() * ((1 << 16) - 1) + number;
}
}
}
}
csharp/ProtocolBuffers/Descriptors/DescriptorUtil.cs 0 → 100644
View file @ 3351bb63
using System.Collections.Generic;
using Google.ProtocolBuffers.Collections;
namespace Google.ProtocolBuffers.Descriptors {
/// <summary>
/// Internal class containing utility methods when working with descriptors.
/// </summary>
static class DescriptorUtil {
/// <summary>
/// Equivalent to Func[TInput, int, TOutput] but usable in .NET 2.0. Only used to convert
/// arrays.
/// </summary>
internal delegate TOutput IndexedConverter<TInput, TOutput>(TInput element, int index);
/// <summary>
/// Converts the given array into a read-only list, applying the specified conversion to
/// each input element.
/// </summary>
internal static IList<TOutput> ConvertAndMakeReadOnly<TInput, TOutput>(IList<TInput> input,
IndexedConverter<TInput, TOutput> converter) {
TOutput[] array = new TOutput[input.Count];
for (int i = 0; i < array.Length; i++) {
array[i] = converter(input[i], i);
}
return Lists<TOutput>.AsReadOnly(array);
}
}
}
csharp/ProtocolBuffers/Descriptors/DescriptorValidationException.cs 0 → 100644
View file @ 3351bb63
using System;
using System.Collections.Generic;
using System.Text;
namespace Google.ProtocolBuffers.Descriptors {
public class DescriptorValidationException : Exception {
private readonly String name;
private readonly IMessage proto;
private readonly string description;
/// <value>
/// The full name of the descriptor where the error occurred.
/// </value>
public String ProblemSymbolName {
get { return name; }
}
/// <value>
/// The protocol message representation of the invalid descriptor.
/// </value>
public IMessage ProblemProto {
get { return proto; }
}
/// <value>
/// A human-readable description of the error. (The Message property
/// is made up of the descriptor's name and this description.)
/// </value>
public string Description {
get { return description; }
}
internal DescriptorValidationException(IDescriptor problemDescriptor, string description) :
base(problemDescriptor.FullName + ": " + description) {
// Note that problemDescriptor may be partially uninitialized, so we
// don't want to expose it directly to the user. So, we only provide
// the name and the original proto.
name = problemDescriptor.FullName;
proto = problemDescriptor.Proto;
this.description = description;
}
internal DescriptorValidationException(IDescriptor problemDescriptor, string description, Exception cause) :
base(problemDescriptor.FullName + ": " + description, cause) {
name = problemDescriptor.FullName;
proto = problemDescriptor.Proto;
this.description = description;
}
}
}
csharp/ProtocolBuffers/Descriptors/EnumDescriptor.cs
View file @ 3351bb63

using System;
using System.Collections.Generic;
using Google.ProtocolBuffers.DescriptorProtos;
namespace Google.ProtocolBuffers.Descriptors {
public class EnumDescriptor : IndexedDescriptorBase<EnumDescriptorProto, EnumOptions> {
internal EnumDescriptor(EnumDescriptorProto proto, EnumOptions options, FileDescriptor file, int index)
: base(proto, file, index) {
private readonly MessageDescriptor containingType;
private readonly IList<EnumValueDescriptor> values;
internal EnumDescriptor(EnumDescriptorProto proto, FileDescriptor file, MessageDescriptor parent, int index)
: base(proto, file, ComputeFullName(file, parent, proto.Name), index) {
containingType = parent;
if (proto.ValueCount == 0) {
// We cannot allow enums with no values because this would mean there
// would be no valid default value for fields of this type.
throw new DescriptorValidationException(this, "Enums must contain at least one value.");
}
values = DescriptorUtil.ConvertAndMakeReadOnly(proto.ValueList,
(value, i) => new EnumValueDescriptor(value, file, this, i));
File.DescriptorPool.AddSymbol(this);
}
/// <value>
/// If this is a nested type, get the outer descriptor, otherwise null.
/// </value>
public MessageDescriptor ContainingType {
get { return containingType; }
}
/// <value>
/// An unmodifiable list of defined value descriptors for this enum.
/// </value>
public IList<EnumValueDescriptor> Values {
get { return values; }
}
/// <summary>
/// Finds an enum value by number. If multiple enum values have the
/// same number, this returns the first defined value with that number.
/// </summary>
/// <param name="number"></param>
/// <returns></returns>
internal EnumValueDescriptor FindValueByNumber(int number) {
return File.DescriptorPool.FindEnumValueByNumber(this, number);
}
internal EnumValueDescriptor FindValueByNumber(int rawValue) {
throw new System.NotImplementedException();
/// <summary>
/// Finds an enum value by name.
/// </summary>
/// <param name="name">The unqualified name of the value (e.g. "FOO").</param>
/// <returns>The value's descriptor, or null if not found.</returns>
internal EnumValueDescriptor FindValueByName(string name) {
return File.DescriptorPool.FindSymbol<EnumValueDescriptor>(FullName + "." + name);
}
}
}
csharp/ProtocolBuffers/Descriptors/EnumValueDescriptor.cs
View file @ 3351bb63
......@@ -6,15 +6,16 @@ namespace Google.ProtocolBuffers.Descriptors {
private readonly EnumDescriptor enumDescriptor;
internal EnumValueDescriptor(EnumValueDescriptorProto proto,
FileDescriptor file,
EnumDescriptor parent,
int index) : base (proto, file, index) {
internal EnumValueDescriptor(EnumValueDescriptorProto proto, FileDescriptor file,
EnumDescriptor parent, int index)
: base (proto, file, parent.FullName + "." + proto.Name, index) {
enumDescriptor = parent;
file.DescriptorPool.AddSymbol(this);
file.DescriptorPool.AddEnumValueByNumber(this);
}
public int Number {
get { throw new NotImplementedException(); }
get { return Proto.Number; }
}
public EnumDescriptor EnumDescriptor {
......
csharp/ProtocolBuffers/Descriptors/FieldDescriptor.cs
View file @ 3351bb63
......@@ -5,43 +5,215 @@ using Google.ProtocolBuffers.Collections;
using Google.ProtocolBuffers.DescriptorProtos;
namespace Google.ProtocolBuffers.Descriptors {
public class FieldDescriptor : IndexedDescriptorBase<FieldDescriptorProto, FieldOptions> {
public class FieldDescriptor : IndexedDescriptorBase<FieldDescriptorProto, FieldOptions>, IComparable<FieldDescriptor> {
private readonly EnumDescriptor enumType;
private readonly MessageDescriptor parent;
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, index) {
enumType = null;
this.parent = parent;
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);
//type = proto.Type;
}
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;
set;
get { return Proto.Label == FieldDescriptorProto.Types.Label.LABEL_REQUIRED; }
}
public bool IsOptional {
get { return Proto.Label == FieldDescriptorProto.Types.Label.LABEL_OPTIONAL; }
}
public MappedType MappedType { get; set; }
public bool IsRepeated {
get { return Proto.Label == FieldDescriptorProto.Types.Label.LABEL_REPEATED; }
}
public bool IsRepeated { get; set; }
/// <valule>
/// Indicates whether or not the field had an explicitly-defined default value.
/// </value>
public bool HasDefaultValue {
get { return Proto.HasDefaultValue; }
}
public FieldType FieldType { get; set; }
public int FieldNumber { get; set; }
/// <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 list. 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;
}
}
public bool IsExtension { get; set; }
/// <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 parent; }
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 bool IsOptional { get; set; }
public MappedType MappedType {
get { return mappedType; }
}
public MessageDescriptor MessageType { get; set; }
public FieldType FieldType {
get { return fieldType; }
}
public MessageDescriptor ExtensionScope { get; set; }
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.
......@@ -53,15 +225,18 @@ namespace Google.ProtocolBuffers.Descriptors {
}
return enumType;
}
}
}
/// <summary>
/// The default value for this field. For repeated fields
/// this will always be an empty list. For message fields it will
/// always be null. For singular values, it will depend on the descriptor.
/// For embedded message and group fields, returns the field's type.
/// </summary>
public object DefaultValue {
get { throw new NotImplementedException(); }
public MessageDescriptor MessageType {
get {
if (MappedType != MappedType.Message) {
throw new InvalidOperationException("MessageType is only valid for enum fields.");
}
return messageType;
}
}
/// <summary>
......@@ -70,6 +245,7 @@ namespace Google.ProtocolBuffers.Descriptors {
/// </summary>
public static readonly IDictionary<FieldType, MappedType> FieldTypeToWireFormatMap = MapFieldTypes();
private static IDictionary<FieldType, MappedType> MapFieldTypes() {
var map = new Dictionary<FieldType, MappedType>();
foreach (FieldInfo field in typeof(FieldType).GetFields(BindingFlags.Static | BindingFlags.Public)) {
......@@ -79,5 +255,161 @@ namespace Google.ProtocolBuffers.Descriptors {
}
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 {
// TODO(jonskeet): Check signage for Int32 and Int64.
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:
defaultValue = bool.Parse(Proto.DefaultValue); // TODO(jonskeet): Check this will work
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) {
// FIXME(jonskeet): Find out the correct list type and use that instead.
defaultValue = new List<object>();
} 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.");
}
}
}
}
}
csharp/ProtocolBuffers/Descriptors/FileDescriptor.cs
View file @ 3351bb63
using System;
using System.Collections.ObjectModel;
using Google.ProtocolBuffers.DescriptorProtos;
using System.Collections.Generic;
using Google.ProtocolBuffers.Collections;
namespace Google.ProtocolBuffers.Descriptors {
public class FileDescriptor : DescriptorBase<FileDescriptorProto, FileOptions> {
/// <summary>
/// Describes a .proto file, including everything defined within.
/// IDescriptor is implemented such that the File property returns this descriptor,
/// and the FullName is the same as the Name.
/// </summary>
public class FileDescriptor : IDescriptor<FileDescriptorProto> {
private readonly FileDescriptorProto proto;
private readonly IList<MessageDescriptor> messageTypes;
private readonly IList<EnumDescriptor> enumTypes;
private readonly IList<ServiceDescriptor> services;
private readonly IList<FieldDescriptor> extensions;
private readonly IList<FileDescriptor> dependencies;
private readonly DescriptorPool pool;
private FileDescriptor(FileDescriptorProto proto, FileDescriptor[] dependencies, DescriptorPool pool) {
this.pool = pool;
this.proto = proto;
this.dependencies = new ReadOnlyCollection<FileDescriptor>((FileDescriptor[]) dependencies.Clone());
pool.AddPackage(Package, this);
messageTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.MessageTypeList,
(message, index) => new MessageDescriptor(message, this, null, index));
enumTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.EnumTypeList,
(enumType, index) => new EnumDescriptor(enumType, this, null, index));
services = DescriptorUtil.ConvertAndMakeReadOnly(proto.ServiceList,
(service, index) => new ServiceDescriptor(service, this, index));
extensions = DescriptorUtil.ConvertAndMakeReadOnly(proto.ExtensionList,
(field, index) => new FieldDescriptor(field, this, null, index, true));
}
/// <value>
/// The descriptor in its protocol message representation.
/// </value>
public FileDescriptorProto Proto {
get { return proto; }
}
public FileDescriptor(FileDescriptorProto proto, FileDescriptor file) : base(proto, file) {
/// <value>
/// The <see cref="FileOptions" /> defined in <c>descriptor.proto</c>.
/// </value>
public FileOptions Options {
get { return proto.Options; }
}
/// <value>
/// The file name.
/// </value>
public string Name {
get { return proto.Name; }
}
/// <summary>
......@@ -19,7 +66,7 @@ namespace Google.ProtocolBuffers.Descriptors {
/// be equivalent to the .NET namespace of the generated classes.
/// </summary>
public string Package {
get { return Proto.Package; }
get { return proto.Package; }
}
/// <value>
......@@ -57,10 +104,110 @@ namespace Google.ProtocolBuffers.Descriptors {
get { return dependencies; }
}
public static FileDescriptor BuildFrom(FileDescriptorProto proto,
FileDescriptor[] dependencies) {
throw new NotImplementedException();
/// <value>
/// Implementation of IDescriptor.FullName - just returns the same as Name.
/// </value>
string IDescriptor.FullName {
get { return Name; }
}
/// <value>
/// Implementation of IDescriptor.File - just returns this descriptor.
/// </value>
FileDescriptor IDescriptor.File {
get { return this; }
}
/// <value>
/// Protocol buffer describing this descriptor.
/// </value>
IMessage IDescriptor.Proto {
get { return Proto; }
}
/// <value>
/// Pool containing symbol descriptors.
/// </value>
internal DescriptorPool DescriptorPool {
get { return pool; }
}
/// <summary>
/// Finds a type (message, enum, service or extension) in the file by name. Does not find nested types.
/// </summary>
/// <param name="name">The unqualified type name to look for.</param>
/// <typeparam name="T">The type of descriptor to look for (or ITypeDescriptor for any)</typeparam>
/// <returns>The type's descriptor, or null if not found.</returns>
public T FindTypeByName<T>(String name)
where T : class, IDescriptor {
// Don't allow looking up nested types. This will make optimization
// easier later.
if (name.IndexOf('.') != -1) {
return null;
}
if (Package.Length > 0) {
name = Package + "." + name;
}
T result = pool.FindSymbol<T>(name);
if (result != null && result.File == this) {
return result;
}
return null;
}
/// <summary>
/// Builds a FileDescriptor from its protocol buffer representation.
/// </summary>
/// <param name="proto">The protocol message form of the FileDescriptor.</param>
/// <param name="dependencies">FileDescriptors corresponding to all of the
/// file's dependencies, in the exact order listed in the .proto file</param>
/// <exception cref="DescriptorValidationException">If <paramref name="proto"/> is not
/// a valid descriptor. This can occur for a number of reasons, such as a field
/// having an undefined type or because two messages were defined with the same name.</exception>
public static FileDescriptor BuildFrom(FileDescriptorProto proto, FileDescriptor[] dependencies) {
// Building decsriptors involves two steps: translating and linking.
// In the translation step (implemented by FileDescriptor's
// constructor), we build an object tree mirroring the
// FileDescriptorProto's tree and put all of the descriptors into the
// DescriptorPool's lookup tables. In the linking step, we look up all
// type references in the DescriptorPool, so that, for example, a
// FieldDescriptor for an embedded message contains a pointer directly
// to the Descriptor for that message's type. We also detect undefined
// types in the linking step.
DescriptorPool pool = new DescriptorPool(dependencies);
FileDescriptor result = new FileDescriptor(proto, dependencies, pool);
if (dependencies.Length != proto.DependencyCount) {
throw new DescriptorValidationException(result,
"Dependencies passed to FileDescriptor.BuildFrom() don't match " +
"those listed in the FileDescriptorProto.");
}
for (int i = 0; i < proto.DependencyCount; i++) {
if (dependencies[i].Name != proto.DependencyList[i]) {
throw new DescriptorValidationException(result,
"Dependencies passed to FileDescriptor.BuildFrom() don't match " +
"those listed in the FileDescriptorProto.");
}
}
result.CrossLink();
return result;
}
private void CrossLink() {
foreach (MessageDescriptor message in messageTypes) {
message.CrossLink();
}
foreach (ServiceDescriptor service in services) {
service.CrossLink();
}
foreach (FieldDescriptor extension in extensions) {
extension.CrossLink();
}
}
/// <summary>
/// This method is to be called by generated code only. It is equivalent
/// to BuilderFrom except that the FileDescriptorProto is encoded in
......
csharp/ProtocolBuffers/Descriptors/IDescriptor.cs 0 → 100644
View file @ 3351bb63
using System;
using System.Collections.Generic;
using System.Text;
namespace Google.ProtocolBuffers.Descriptors {
/// <summary>
/// The non-generic form of the IDescriptor interface. Useful for describing a general
/// descriptor.
/// </summary>
public interface IDescriptor {
string Name { get; }
string FullName { get; }
FileDescriptor File { get; }
IMessage Proto { get; }
}
/// <summary>
/// Strongly-typed form of the IDescriptor interface.
/// </summary>
/// <typeparam name="TProto">Protocol buffer type underlying this descriptor type</typeparam>
public interface IDescriptor<TProto> : IDescriptor where TProto : IMessage {
new TProto Proto { get; }
}
}
csharp/ProtocolBuffers/Descriptors/IndexedDescriptorBase.cs
View file @ 3351bb63
......@@ -13,8 +13,8 @@ namespace Google.ProtocolBuffers.Descriptors {
private readonly int index;
protected IndexedDescriptorBase(TProto proto, FileDescriptor file, int index)
: base(proto, file) {
protected IndexedDescriptorBase(TProto proto, FileDescriptor file, string fullName, int index)
: base(proto, file, fullName) {
this.index = index;
}
......
csharp/ProtocolBuffers/Descriptors/MessageDescriptor.cs
View file @ 3351bb63

using System.Collections.Generic;
using System.Collections.Generic;
using Google.ProtocolBuffers.DescriptorProtos;
namespace Google.ProtocolBuffers.Descriptors {
public class MessageDescriptor : DescriptorBase<DescriptorProto, MessageOptions> {
public IList<FieldDescriptor> Fields;
internal MessageDescriptor(DescriptorProto proto, FileDescriptor file) : base(proto, file) {
/// <summary>
/// Describes a message type.
/// </summary>
public class MessageDescriptor : IndexedDescriptorBase<DescriptorProto, MessageOptions> {
private readonly MessageDescriptor containingType;
private readonly IList<MessageDescriptor> nestedTypes;
private readonly IList<EnumDescriptor> enumTypes;
private readonly IList<FieldDescriptor> fields;
private readonly IList<FieldDescriptor> extensions;
internal MessageDescriptor(DescriptorProto proto, FileDescriptor file, MessageDescriptor parent, int typeIndex)
: base(proto, file, ComputeFullName(file, parent, proto.Name), typeIndex) {
containingType = parent;
nestedTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.NestedTypeList,
(type, index) => new MessageDescriptor(type, file, null, index));
enumTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.EnumTypeList,
(type, index) => new EnumDescriptor(type, file, null, index));
fields = DescriptorUtil.ConvertAndMakeReadOnly(proto.FieldList,
(field, index) => new FieldDescriptor(field, file, null, index, false));
extensions = DescriptorUtil.ConvertAndMakeReadOnly(proto.ExtensionList,
(field, index) => new FieldDescriptor(field, file, null, index, true));
file.DescriptorPool.AddSymbol(this);
}
internal bool IsExtensionNumber(int fieldNumber) {
throw new System.NotImplementedException();
/// <value>
/// An unmodifiable list of this message type's fields.
/// </value>
public IList<FieldDescriptor> Fields {
get { return fields; }
}
internal FieldDescriptor FindFieldByNumber(int fieldNumber) {
throw new System.NotImplementedException();
/// <value>
/// An unmodifiable list of this message type's extensions.
/// </value>
public IList<FieldDescriptor> Extensions {
get { return extensions; }
}
/// <value>
/// List of message types nested within this one.
/// An unmodifiable list of this message type's nested types.
/// </value>
public IList<MessageDescriptor> NestedTypes {
get { throw new System.NotImplementedException(); }
get { return nestedTypes; }
}
/// <value>
/// An unmodifiable list of this message type's enum types.
/// </value>
public IList<EnumDescriptor> EnumTypes {
get { return enumTypes; }
}
/// <summary>
/// Determines if the given field number is an extension.
/// </summary>
public bool IsExtensionNumber(int number) {
foreach (DescriptorProto.Types.ExtensionRange range in Proto.ExtensionRangeList) {
if (range.Start <= number && number < range.End) {
return true;
}
}
return false;
}
/// <summary>
/// Finds a field by field number.
/// </summary>
/// <param name="number">The field number within this message type.</param>
/// <returns>The field's descriptor, or null if not found.</returns>
public FieldDescriptor FindFieldByNumber(int number) {
return File.DescriptorPool.FindFieldByNumber(this, number);
}
/// <summary>
/// Finds a nested descriptor by name. The is valid for fields, nested
/// message types and enums.
/// </summary>
/// <param name="name">The unqualified name of the descriptor, e.g. "Foo"</param>
/// <returns>The descriptor, or null if not found.</returns>
public T FindDescriptor<T>(string name)
where T : class, IDescriptor {
return File.DescriptorPool.FindSymbol<T>(FullName + "." + name);
}
/// <summary>
/// Looks up and cross-links all fields, nested types, and extensions.
/// </summary>
internal void CrossLink() {
foreach (MessageDescriptor message in nestedTypes) {
message.CrossLink();
}
foreach (FieldDescriptor field in fields) {
field.CrossLink();
}
foreach (FieldDescriptor extension in extensions) {
extension.CrossLink();
}
}
}
}
csharp/ProtocolBuffers/Descriptors/MethodDescriptor.cs 0 → 100644
View file @ 3351bb63
using Google.ProtocolBuffers.DescriptorProtos;
namespace Google.ProtocolBuffers.Descriptors {
/// <summary>
/// Describes a single method in a service.
/// </summary>
public class MethodDescriptor : IndexedDescriptorBase<MethodDescriptorProto, MethodOptions> {
private readonly ServiceDescriptor service;
private MessageDescriptor inputType;
private MessageDescriptor outputType;
/// <value>
/// The service this method belongs to.
/// </value>
public ServiceDescriptor Service {
get { return service; }
}
/// <value>
/// The method's input type.
/// </value>
public MessageDescriptor InputType {
get { return inputType; }
}
/// <value>
/// The method's input type.
/// </value>
public MessageDescriptor OutputType {
get { return inputType; }
}
internal MethodDescriptor(MethodDescriptorProto proto, FileDescriptor file,
ServiceDescriptor parent, int index)
: base(proto, file, parent.FullName + "." + proto.Name, index) {
service = parent;
file.DescriptorPool.AddSymbol(this);
}
internal void CrossLink() {
IDescriptor lookup = File.DescriptorPool.LookupSymbol(Proto.InputType, this);
if (!(lookup is MessageDescriptor)) {
throw new DescriptorValidationException(this, "\"" + Proto.InputType + "\" is not a message type.");
}
inputType = (MessageDescriptor) lookup;
lookup = File.DescriptorPool.LookupSymbol(Proto.OutputType, this);
if (!(lookup is MessageDescriptor)) {
throw new DescriptorValidationException(this, "\"" + Proto.OutputType + "\" is not a message type.");
}
outputType = (MessageDescriptor) lookup;
}
}
}
csharp/ProtocolBuffers/Descriptors/PackageDescriptor.cs 0 → 100644
View file @ 3351bb63
using System;
using System.Collections.Generic;
using System.Text;
namespace Google.ProtocolBuffers.Descriptors {
/*
* Represents a package in the symbol table. We use PackageDescriptors
* just as placeholders so that someone cannot define, say, a message type
* that has the same name as an existing package.
*/
/// <summary>
/// Represents a package in the symbol table. We use PackageDescriptors
/// just as placeholders so that someone cannot define, say, a message type
/// that has the same name as an existing package.
/// </summary>
internal class PackageDescriptor : IDescriptor<IMessage> {
private readonly string name;
private readonly string fullName;
private readonly FileDescriptor file;
internal PackageDescriptor(string name, string fullName, FileDescriptor file) {
this.file = file;
this.fullName = fullName;
this.name = name;
}
public IMessage Proto {
get { return file.Proto; }
}
public string Name {
get { return name; }
}
public string FullName {
get { return fullName; }
}
public FileDescriptor File {
get { return file; }
}
}
}
csharp/ProtocolBuffers/Descriptors/ServiceDescriptor.cs
View file @ 3351bb63
......@@ -4,9 +4,34 @@ using System.Text;
using Google.ProtocolBuffers.DescriptorProtos;
namespace Google.ProtocolBuffers.Descriptors {
/// <summary>
/// Describes a service type.
/// </summary>
public class ServiceDescriptor : IndexedDescriptorBase<ServiceDescriptorProto, ServiceOptions> {
private readonly IList<MethodDescriptor> methods;
public ServiceDescriptor(ServiceDescriptorProto proto, FileDescriptor file, int index)
: base(proto, file, index) {
: base(proto, file, ComputeFullName(file, null, proto.Name), index) {
methods = DescriptorUtil.ConvertAndMakeReadOnly(proto.MethodList,
(method, i) => new MethodDescriptor(method, file, this, i));
file.DescriptorPool.AddSymbol(this);
}
/// <value>
/// An unmodifiable list of methods in this service.
/// </value>
public IList<MethodDescriptor> Methods {
get { return methods; }
}
internal void CrossLink() {
foreach (MethodDescriptor method in methods) {
method.CrossLink();
}
}
}
}
csharp/ProtocolBuffers/ProtocolBuffers.csproj
View file @ 3351bb63
......@@ -52,6 +52,8 @@
<Compile Include="DescriptorProtos\PartialClasses.cs" />
<Compile Include="Descriptors\DescriptorBase.cs" />
<Compile Include="Descriptors\DescriptorPool.cs" />
<Compile Include="Descriptors\DescriptorUtil.cs" />
<Compile Include="Descriptors\DescriptorValidationException.cs" />
<Compile Include="Descriptors\EnumDescriptor.cs" />
<Compile Include="Descriptors\EnumDescriptorIndexAttribute.cs" />
<Compile Include="Descriptors\EnumValueDescriptor.cs" />
......@@ -59,9 +61,12 @@
<Compile Include="Descriptors\FieldMappingAttribute.cs" />
<Compile Include="Descriptors\FieldType.cs" />
<Compile Include="Descriptors\FileDescriptor.cs" />
<Compile Include="Descriptors\IDescriptor.cs" />
<Compile Include="Descriptors\IndexedDescriptorBase.cs" />
<Compile Include="Descriptors\MappedType.cs" />
<Compile Include="Descriptors\MessageDescriptor.cs" />
<Compile Include="Descriptors\MethodDescriptor.cs" />
<Compile Include="Descriptors\PackageDescriptor.cs" />
<Compile Include="Descriptors\ServiceDescriptor.cs" />
<Compile Include="ExtensionInfo.cs" />
<Compile Include="ExtensionRegistry.cs" />
......
csharp/ProtocolBuffers/TextFormat.cs
View file @ 3351bb63
......@@ -11,5 +11,25 @@ namespace Google.ProtocolBuffers {
internal static string PrintToString(UnknownFieldSet unknownFieldSet) {
throw new NotImplementedException();
}
internal static object ParseUInt64(string p) {
throw new NotImplementedException();
}
internal static object ParseInt64(string p) {
throw new NotImplementedException();
}
internal static object ParseUInt32(string p) {
throw new NotImplementedException();
}
internal static object ParseInt32(string p) {
throw new NotImplementedException();
}
internal static object UnescapeBytes(string p) {
throw new NotImplementedException();
}
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment