public object GetFieldValue(FieldDescriptorProto field_desc)
{
lastError.Clear();
object ret;
if (fieldData.TryGetValue(field_desc.number, out ret))
{
if (ret is List <object> )
{
lastError.AddLast(string.Format("field {0} is repeated", field_desc.number));
return(null);
}
return(ret);
}
FieldDescriptorProto field;
if (msgDescriptor.FieldIdIndex.TryGetValue(field_desc.number, out field))
{
return(defaultValue(field));
}
return(null);
}
private static string GenerateInitialString(FieldDescriptorProto fieldDescriptorProto, string tempString)
{
string rightVariableString;
if (fieldDescriptorProto.Type.Equals(FieldDescriptorProto.Types.Type.TYPE_MESSAGE))
{
rightVariableString = $"new {tempString}()";
}
else if (fieldDescriptorProto.Type.Equals(FieldDescriptorProto.Types.Type.TYPE_BYTES))
{
rightVariableString = $"new byte[0]";
}
else if (fieldDescriptorProto.Type.Equals(FieldDescriptorProto.Types.Type.TYPE_ENUM))
{
rightVariableString = $"({tempString})0";
}
else if (fieldDescriptorProto.Type.Equals(FieldDescriptorProto.Types.Type.TYPE_STRING))
{
rightVariableString = $"\"\"";
}
else if (fieldDescriptorProto.Type.Equals(FieldDescriptorProto.Types.Type.TYPE_BOOL))
{
rightVariableString = $"false";
}
else
{
rightVariableString = $"0";
}
return(rightVariableString);
}
/// <summary>
/// 转储数据
/// </summary>
/// <param name="writer">写出目标</param>
/// <returns>全部成功返回true，部分失败或全失败返回false，这时候可以通过LastError获取失败信息</returns>
public bool Serialize(ProtoWriter writer)
{
buildIndex();
lastError.Clear();
foreach (var field in fieldData)
{
FieldDescriptorProto field_desc = null;
// 不认识的值，直接忽略
if (false == msgDescriptor.FieldIdIndex.TryGetValue(field.Key, out field_desc))
{
continue;
}
if (field_desc.label == FieldDescriptorProto.Label.LABEL_REPEATED)
{
foreach (var obj in (List <object>)field.Value)
{
write_object(writer, obj, field_desc);
}
}
else
{
write_object(writer, field.Value, field_desc);
}
}
return(0 == lastError.Count);
}
private static bool UseArray(FieldDescriptorProto field)
{
//LiYu 不再使用数组 统统有List,方便操作
bool v = true;
if (v)
{
return(false);
}
switch (field.type)
{
case FieldDescriptorProto.Type.TypeBool:
case FieldDescriptorProto.Type.TypeDouble:
case FieldDescriptorProto.Type.TypeFixed32:
case FieldDescriptorProto.Type.TypeFixed64:
case FieldDescriptorProto.Type.TypeFloat:
case FieldDescriptorProto.Type.TypeInt32:
case FieldDescriptorProto.Type.TypeInt64:
case FieldDescriptorProto.Type.TypeSfixed32:
case FieldDescriptorProto.Type.TypeSfixed64:
case FieldDescriptorProto.Type.TypeSint32:
case FieldDescriptorProto.Type.TypeSint64:
case FieldDescriptorProto.Type.TypeUint32:
case FieldDescriptorProto.Type.TypeUint64:
return(true);
default:
return(false);
}
}
public static WireType ToWireType(this FieldDescriptorProto proto)
{
switch (proto.type)
{
case FieldDescriptorProto.Type.TypeBool:
case FieldDescriptorProto.Type.TypeEnum:
case FieldDescriptorProto.Type.TypeInt32:
case FieldDescriptorProto.Type.TypeUint32:
case FieldDescriptorProto.Type.TypeSint32:
case FieldDescriptorProto.Type.TypeInt64:
case FieldDescriptorProto.Type.TypeUint64:
case FieldDescriptorProto.Type.TypeSint64:
return(WireType.Varint);
case FieldDescriptorProto.Type.TypeString:
case FieldDescriptorProto.Type.TypeBytes:
case FieldDescriptorProto.Type.TypeMessage:
return(WireType.LengthDelimited);
case FieldDescriptorProto.Type.TypeFloat:
case FieldDescriptorProto.Type.TypeFixed32:
return(WireType.Bit32);
case FieldDescriptorProto.Type.TypeDouble:
case FieldDescriptorProto.Type.TypeFixed64:
return(WireType.Bit64);
default: throw new NotSupportedException("Deprecated features not supported.");
}
}
internal FieldDescriptor(FieldDescriptorProto proto, FileDescriptor file,
MessageDescriptor parent, int index, string propertyName, Extension extension)
: base(file, file.ComputeFullName(parent, proto.Name), index)
{
Proto = proto;
if (proto.Type != 0)
{
fieldType = GetFieldTypeFromProtoType(proto.Type);
}
if (FieldNumber <= 0)
{
throw new DescriptorValidationException(this, "Field numbers must be positive integers.");
}
ContainingType = parent;
if (proto.HasOneofIndex)
{
if (proto.OneofIndex < 0 || proto.OneofIndex >= parent.Proto.OneofDecl.Count)
{
throw new DescriptorValidationException(this,
$"FieldDescriptorProto.oneof_index is out of range for type {parent.Name}");
}
ContainingOneof = parent.Oneofs[proto.OneofIndex];
}
file.DescriptorPool.AddSymbol(this);
// We can't create the accessor until we've cross-linked, unfortunately, as we
// may not know whether the type of the field is a map or not. Remember the property name
// for later.
// We could trust the generated code and check whether the type of the property is
// a MapField, but that feels a tad nasty.
this.propertyName = propertyName;
Extension = extension;
JsonName = Proto.JsonName == "" ? JsonFormatter.ToJsonName(Proto.Name) : Proto.JsonName;
}
/// <summary>
/// Write an extension
/// </summary>
protected override void WriteExtension(GeneratorContext ctx, FieldDescriptorProto field)
{
var type = GetTypeName(ctx, field, out string dataFormat, out bool isMap);
if (isMap)
{
ctx.WriteLine("#error map extensions not yet implemented");
}
else if (field.label == FieldDescriptorProto.Label.LabelRepeated)
{
ctx.WriteLine("#error repeated extensions not yet implemented");
}
else
{
var msg = ctx.TryFind <DescriptorProto>(field.Extendee);
var extendee = MakeRelativeName(field, msg, ctx.NameNormalizer);
var @this = field.Parent is FileDescriptorProto ? "this " : "";
string name = field.Name;
var tw = ctx.WriteLine($"{GetAccess(GetAccess(field))} static {type} Get{name}({@this}{extendee} obj)")
.Write($"=> obj == null ? default({type}) : global::ProtoBuf.Extensible.GetValue<{type}>(obj, {field.Number}");
if (!string.IsNullOrEmpty(dataFormat))
{
tw.Write($", global::ProtoBuf.DataFormat.{dataFormat}");
}
tw.WriteLine(");");
ctx.WriteLine();
// GetValue<TValue>(IExtensible instance, int tag, DataFormat format)
}
}
static bool ExtractType(IExtensible data, FieldDescriptorProto field, out string value)
{
switch (field.type)
{
case FieldDescriptorProto.Type.TYPE_INT32:
case FieldDescriptorProto.Type.TYPE_UINT32:
case FieldDescriptorProto.Type.TYPE_FIXED32:
if (Extensible.TryGetValue(data, field.number, out uint int32))
{
value = Convert.ToString(int32);
return(true);
}
break;
case FieldDescriptorProto.Type.TYPE_INT64:
case FieldDescriptorProto.Type.TYPE_UINT64:
case FieldDescriptorProto.Type.TYPE_FIXED64:
if (Extensible.TryGetValue(data, field.number, out ulong int64))
{
value = Convert.ToString(int64);
return(true);
}
break;
case FieldDescriptorProto.Type.TYPE_SINT32:
case FieldDescriptorProto.Type.TYPE_SFIXED32:
if (Extensible.TryGetValue(data, field.number, out int sint32))
{
value = Convert.ToString(sint32);
return(true);
}
break;
case FieldDescriptorProto.Type.TYPE_SINT64:
case FieldDescriptorProto.Type.TYPE_SFIXED64:
if (Extensible.TryGetValue(data, field.number, out long sint64))
{
value = Convert.ToString(sint64);
return(true);
}
break;
case FieldDescriptorProto.Type.TYPE_STRING:
if (Extensible.TryGetValue(data, field.number, out string str))
{
value = $"\"{str}\"";
return(true);
}
break;
case FieldDescriptorProto.Type.TYPE_BOOL:
if (Extensible.TryGetValue(data, field.number, out bool boolean))
{
value = boolean ? "true" : "false";
return(true);
}
break;
case FieldDescriptorProto.Type.TYPE_BYTES:
if (Extensible.TryGetValue(data, field.number, out byte[] bytes))
private void ItemToLuaTableKVP(ref StringBuilder sb, FieldDescriptorProto infoAttr)
{
var itemType = ProtoTypeCSharType(infoAttr);
var itemName = infoAttr.Name;
sb.Append("\t\t\t");
sb.Append(LUA_API);
sb.Append(".lua_pushstring(L, \"");
sb.Append(itemName);
sb.Append("\");\r\n");
//TypeToPushCode(ref sb, itemType, itemName);
sb.Append("\t\t\t");
var code = PushByType(itemType, "msg." + itemName,
infoAttr.type == FieldDescriptorProto.Type.TypeGroup || infoAttr.label == FieldDescriptorProto.Label.LabelRepeated);
if (string.IsNullOrEmpty(code))
{
sb.Append(LUA_API);
sb.Append(".lua_pushnil(L);\r\n");
}
else
{
sb.Append(code);
}
sb.Append("\t\t\t");
sb.Append(LUA_API);
sb.Append(".xlua_psettable(L, -3);\r\n");
}
private string BuildDescriptorDeclaration(FileDescriptorProto source, FieldDescriptorProto field,
bool emitFieldLabel = true)
{
PushDescriptorName(field);
var type = ResolveType(field);
var options = new Dictionary <string, string>();
if (!string.IsNullOrEmpty(field.default_value))
{
var defaultValue = field.default_value;
if (field.type == FieldDescriptorProto.Type.TYPE_STRING)
{
defaultValue = $"\"{defaultValue}\"";
}
options.Add("default", defaultValue);
}
else if (field.type == FieldDescriptorProto.Type.TYPE_ENUM &&
field.label != FieldDescriptorProto.Label.LABEL_REPEATED)
{
var lookup = _protobufTypeMap[field.type_name];
if (lookup.Source is EnumDescriptorProto enumDescriptor && enumDescriptor.value.Count > 0)
{
options.Add("default", enumDescriptor.value[0].name);
}
}
var fieldOptions = DumpOptions(source, field.options);
foreach (var(key, value) in fieldOptions)
{
options[key] = value;
}
var parameters = string.Empty;
if (options.Count > 0)
{
parameters = $" [{string.Join(", ", options.Select(kvp => $"{kvp.Key} = {kvp.Value}"))}]";
}
PopDescriptorName();
var descriptorDeclarationBuilder = new StringBuilder();
if (emitFieldLabel)
{
descriptorDeclarationBuilder.Append(GetLabel(field.label));
descriptorDeclarationBuilder.Append(" ");
}
descriptorDeclarationBuilder.Append($"{type} {field.name} = {field.number}{parameters};");
return(descriptorDeclarationBuilder.ToString());
}
private string ResolveType(FieldDescriptorProto field)
{
if (field.type == FieldDescriptorProto.Type.TYPE_ENUM || field.type == FieldDescriptorProto.Type.TYPE_MESSAGE)
{
return(field.type_name);
}
return(GetType(field.type));
}
/// <summary>
/// If the field is an enum, add an Attribute to tell JsonConvert.SerializeObject() to write the enum name, not the int value.
/// </summary>
/// <param name="ctx"></param>
/// <param name="obj"></param>
/// <param name="state"></param>
/// <param name="oneOfs"></param>
protected override void WriteField(GeneratorContext ctx, FieldDescriptorProto obj, ref object state, OneOfStub[] oneOfs)
{
if (obj.type == FieldDescriptorProto.Type.TypeEnum && obj.label != FieldDescriptorProto.Label.LabelRepeated)
{
ctx.WriteLine("[Newtonsoft.Json.JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]");
}
base.WriteField(ctx, obj, ref state, oneOfs);
}
/// <summary>
/// Write a field
/// </summary>
protected override void WriteField(GeneratorContext ctx, FieldDescriptorProto obj, ref object state, OneOfStub[] oneOfs)
{
//var name = ctx.NameNormalizer.GetName(obj);
var tw = ctx.Output;
bool isOptional = obj.label == FieldDescriptorProto.Label.LabelOptional;
bool isRepeated = obj.label == FieldDescriptorProto.Label.LabelRepeated;
OneOfStub oneOf = obj.ShouldSerializeOneofIndex() ? oneOfs?[obj.OneofIndex] : null;
if (oneOf != null && oneOf.CountTotal == 1)
{
oneOf = null; // not really a one-of, then!
}
bool explicitValues = isOptional && oneOf == null && ctx.Syntax == FileDescriptorProto.SyntaxProto2 &&
obj.type != FieldDescriptorProto.Type.TypeMessage &&
obj.type != FieldDescriptorProto.Type.TypeGroup;
string defaultValue = null;
bool suppressDefaultAttribute = !isOptional;
var typeName = GetTypeName(ctx, obj, out var dataFormat, out var isMap);
defaultValue = GetDefaltValue(ctx, obj, typeName);
if (isRepeated)
{
var mapMsgType = isMap ? ctx.TryFind <DescriptorProto>(obj.TypeName) : null;
if (mapMsgType != null)
{
var keyTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 1),
out var keyDataFormat, out var _);
var valueTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 2),
out var valueDataFormat, out var _);
ctx.WriteLine($"{GetAccess(GetAccess(obj))} System.Collections.Generic.Dictionary<{keyTypeName}, {valueTypeName}> {Escape(obj.Name)} = new System.Collections.Generic.Dictionary<{keyTypeName}, {valueTypeName}>();");
}
// else if (UseArray(obj))
// {
// ctx.WriteLine($"{GetAccess(GetAccess(obj))} {typeName}[] {Escape(name)} ;");
// }
else
{
ctx.WriteLine($"{GetAccess(GetAccess(obj))} System.Collections.Generic.List<{typeName}> {Escape(obj.Name)} = new System.Collections.Generic.List<{typeName}>();");
}
}
else
{
if (!string.IsNullOrEmpty(defaultValue))
{
ctx.WriteLine($"{GetAccess(GetAccess(obj))} {typeName} {obj.Name} = {defaultValue};");
}
else
{
ctx.WriteLine($"{GetAccess(GetAccess(obj))} {typeName} {obj.Name} ;");
}
}
}
private string pickMsgName(FieldDescriptorProto desc)
{
string msg_name = desc.type_name;
if (msg_name.Length > 0 && '.' == msg_name[0])
{
msg_name = msg_name.Substring(1);
}
return(msg_name);
}
protected void WriteFileRead(GeneratorContext ctx, FieldDescriptorProto obj, OneOfStub[] oneOfs)
{
bool isRepeated = obj.label == FieldDescriptorProto.Label.LabelRepeated;
var typeName = GetTypeName(ctx, obj, out var dataFormat, out var isMap);
Google.Protobuf.WireFormat.WireType ttwtype = ProtoTool.ILHelper.GetWireType(obj.type);
uint ttag = Google.Protobuf.WireFormat.MakeTag(obj.Number, ttwtype);
ctx.WriteLine($"case {ttag}:").Indent();
ReaderString(ctx, obj);
ctx.WriteLine("break;").Outdent();
}
private string BuildDescriptorDeclaration(FieldDescriptorProto field, bool emitFieldLabel = true)
{
PushDescriptorName(field);
string type = ResolveType(field);
Dictionary <string, string> options = new Dictionary <string, string>();
if (!String.IsNullOrEmpty(field.default_value))
{
string default_value = field.default_value;
if (field.type == FieldDescriptorProto.Type.TYPE_STRING)
{
default_value = String.Format("\"{0}\"", default_value);
}
options.Add("default", default_value);
}
else if (field.type == FieldDescriptorProto.Type.TYPE_ENUM && field.label != FieldDescriptorProto.Label.LABEL_REPEATED)
{
options.Add("default", ResolveOrDeferEnumDefaultValue(type));
}
Dictionary <string, string> fieldOptions = DumpOptions(field.options);
foreach (var pair in fieldOptions)
{
options[pair.Key] = pair.Value;
}
string parameters = String.Empty;
if (options.Count > 0)
{
parameters = " [" + String.Join(", ", options.Select(kvp => String.Format("{0} = {1}", kvp.Key, kvp.Value))) + "]";
}
PopDescriptorName();
var descriptorDeclarationBuilder = new StringBuilder();
if (emitFieldLabel)
{
descriptorDeclarationBuilder.Append(GetLabel(field.label));
descriptorDeclarationBuilder.Append(" ");
}
descriptorDeclarationBuilder.AppendFormat("{0} {1} = {2}{3};", type.TrimStart('.'), field.name, field.number, parameters);
return(descriptorDeclarationBuilder.ToString());
}
/// <summary>
/// 创见一个动态Message，和当前的Message共享同一个类型描述集
/// </summary>
/// <param name="desc">field描述</param>
/// <returns>新创建的Message，如果创建失败返回null</returns>
public DynamicMessage CreateMessage(FieldDescriptorProto desc)
{
if (null == desc)
{
lastError.Clear();
lastError.AddLast("FieldDescriptorProto can not be null");
return(null);
}
string msg_name = pickMsgName(desc);
return(CreateMessage(msg_name));
}
private string BuildDescriptorDeclaration(FieldDescriptorProto field, ProtoExtensionDefs extensions, bool emitFieldLabel = true)
{
PushDescriptorName(field);
var type = ResolveType(field);
var options = new Dictionary <string, string>();
if (!string.IsNullOrEmpty(field.default_value))
{
var default_value = field.default_value;
if (field.type == FieldDescriptorProto.Type.TYPE_STRING)
{
default_value = $"\"{default_value}\"";
}
options.Add("default", default_value);
}
else if (field.type == FieldDescriptorProto.Type.TYPE_ENUM && field.label != FieldDescriptorProto.Label.LABEL_REPEATED)
{
options.Add("default", ResolveOrDeferEnumDefaultValue(type));
}
var fieldOptions = DumpOptions(field.options, extensions);
foreach (var pair in fieldOptions)
{
options[pair.Key] = pair.Value;
}
var parameters = string.Empty;
if (options.Count > 0)
{
parameters = $" [{string.Join(", ", options.Select(kvp => $"{kvp.Key} = {kvp.Value}"))}]";
}
PopDescriptorName();
var descriptorDeclarationBuilder = new StringBuilder();
if (emitFieldLabel)
{
descriptorDeclarationBuilder.Append(GetLabel(field.label));
descriptorDeclarationBuilder.Append(" ");
}
descriptorDeclarationBuilder.Append($"{type} {field.name} = {field.number}{parameters};");
return(descriptorDeclarationBuilder.ToString());
}
/// <summary>
/// Emit code initializing field values inside a constructor, if one is required
/// </summary>
protected override void WriteInitField(GeneratorContext ctx, FieldDescriptorProto obj, ref object state, OneOfStub[] oneOfs)
{
var name = ctx.NameNormalizer.GetName(obj);
bool isOptional = obj.label == FieldDescriptorProto.Label.LabelOptional;
bool isRepeated = obj.label == FieldDescriptorProto.Label.LabelRepeated;
string dataFormat;
bool isMap;
var typeName = GetTypeName(ctx, obj, out dataFormat, out isMap);
OneOfStub oneOf = obj.ShouldSerializeOneofIndex() ? oneOfs?[obj.OneofIndex] : null;
bool explicitValues = isOptional && oneOf == null && ctx.Syntax == FileDescriptorProto.SyntaxProto2 &&
obj.type != FieldDescriptorProto.Type.TypeMessage &&
obj.type != FieldDescriptorProto.Type.TypeGroup;
string defaultValue = GetDefaultValue(ctx, obj, typeName);
if (isRepeated)
{
var mapMsgType = isMap ? ctx.TryFind <DescriptorProto>(obj.TypeName) : null;
if (mapMsgType != null)
{
string keyDataFormat;
string valueDataFormat;
bool _;
var keyTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 1),
out keyDataFormat, out _);
var valueTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 2),
out valueDataFormat, out _);
ctx.WriteLine($"{Escape(name)} = new global::System.Collections.Generic.Dictionary<{keyTypeName}, {valueTypeName}>();");
}
else if (UseArray(obj))
{
} // nothing needed
else
{
ctx.WriteLine($"{Escape(name)} = new global::System.Collections.Generic.List<{typeName}>();");
}
}
else if (oneOf != null)
{
} // nothing to do
else if (explicitValues)
{
} // nothing to do
else
{
if (!string.IsNullOrWhiteSpace(defaultValue))
{
ctx.WriteLine($"{Escape(name)} = {defaultValue};");
}
}
}
private object defaultValue(FieldDescriptorProto desc)
{
switch (desc.type)
{
case FieldDescriptorProto.Type.TYPE_DOUBLE:
return((double)0.0);
case FieldDescriptorProto.Type.TYPE_FLOAT:
return((float)0.0);
case FieldDescriptorProto.Type.TYPE_INT64:
case FieldDescriptorProto.Type.TYPE_SFIXED64:
case FieldDescriptorProto.Type.TYPE_SINT64:
return((long)0);
case FieldDescriptorProto.Type.TYPE_FIXED64:
case FieldDescriptorProto.Type.TYPE_UINT64:
return((ulong)0);
case FieldDescriptorProto.Type.TYPE_INT32:
case FieldDescriptorProto.Type.TYPE_SINT32:
case FieldDescriptorProto.Type.TYPE_SFIXED32:
return((int)0);
case FieldDescriptorProto.Type.TYPE_FIXED32:
case FieldDescriptorProto.Type.TYPE_UINT32:
return((uint)0);
case FieldDescriptorProto.Type.TYPE_BOOL:
return(false);
case FieldDescriptorProto.Type.TYPE_STRING:
return("");
case FieldDescriptorProto.Type.TYPE_GROUP:
return(null);
case FieldDescriptorProto.Type.TYPE_MESSAGE:
return(null);
case FieldDescriptorProto.Type.TYPE_BYTES:
return(new byte[0]);
case FieldDescriptorProto.Type.TYPE_ENUM:
return((int)0);
default:
return(null);
}
}
/// <summary>
/// 添加字段，如果是repeated会追加的末尾，否则是覆盖
/// </summary>
/// <param name="desc">key的描述信息</param>
/// <param name="obj">值</param>
/// <returns>返回是否成功</returns>
public bool AddField(FieldDescriptorProto desc, object obj)
{
if (null == desc)
{
return(false);
}
if (desc.label == FieldDescriptorProto.Label.LABEL_REPEATED)
{
return(AddFieldList(desc, obj));
}
return(SetFieldValue(desc, obj));
}
/// <summary>
/// 添加List类型数据
/// </summary>
/// <param name="desc">key的描述信息</param>
/// <param name="obj">值</param>
/// <returns>返回是否成功</returns>
public bool AddFieldList(FieldDescriptorProto desc, object obj)
{
if (null == desc)
{
return(false);
}
buildIndex();
lastError.Clear();
if (desc.label != FieldDescriptorProto.Label.LABEL_REPEATED)
{
lastError.AddLast(string.Format("field {0} is repeated, can only use SetFieldValue", desc.name));
return(false);
}
if (!verifyField(desc, ref obj))
{
lastError.AddLast(string.Format("field {0} type error, must match {1}", desc.name, desc.type.ToString()));
return(false);
}
// 对枚举类型特殊处理
if (desc.type == FieldDescriptorProto.Type.TYPE_ENUM && obj is string)
{
EnumValueDescriptorProto enum_desc;
if (!descriptors.EnumValueDescriptors.TryGetValue((string)obj, out enum_desc))
{
lastError.AddLast(string.Format("enum value path {0} not found", obj));
return(false);
}
obj = enum_desc.number;
}
object old_val;
if (fieldData.TryGetValue(desc.number, out old_val))
{
((List <object>)old_val).Add(obj);
}
else
{
fieldData.Add(desc.number, new List <object> {
obj
});
}
return(true);
}
public static ZField From(this FieldDescriptorProto proto, string @namespace)
{
var fieldName = proto.Name.Pascalize();
var index = proto.Number;
var cSharpType = proto.ToSourceType(@namespace);
var options = new ZFieldOptions
{
Deprecated = proto.Options?.Deprecated == true ? true : false
};
var wireType = proto.ToWireType();
var serializationImplementation = proto.ToSerializationImplementation();
return(new ZField(fieldName, index, cSharpType, options, wireType, serializationImplementation));
}
/// <summary>
/// Suggest a normalized identifier
/// </summary>
public virtual string GetName(FieldDescriptorProto definition)
{
var name = definition?.Options?.GetOptions()?.Name;
if (!string.IsNullOrWhiteSpace(name))
{
return(name);
}
var preferred = GetName(definition.Name);
if (definition.label == FieldDescriptorProto.Label.LabelRepeated)
{
preferred = Pluralize(preferred);
}
return(GetName(definition.Parent as DescriptorProto, preferred, definition.Name, true));
}
private void DumpOptionsFieldRecursive(FieldDescriptorProto field, IExtensible options,
IDictionary <string, string> optionsKv, string path)
{
var key = string.IsNullOrEmpty(path) ? $"({field.name})" : $"{path}.{field.name}";
if (IsNamedType(field.type) && !string.IsNullOrEmpty(field.type_name))
{
var fieldData = _protobufTypeMap[field.type_name].Source;
switch (fieldData)
{
case EnumDescriptorProto enumProto:
{
if (Extensible.TryGetValue(options, field.number, out int idx))
{
var value = enumProto.value.Find(x => x.number == idx);
optionsKv.Add(key, value.name);
}
break;
}
case DescriptorProto messageProto:
{
var extension = Extensible.GetValue <ExtensionPlaceholder>(options, field.number);
if (extension != null)
{
foreach (var subField in messageProto.field)
{
DumpOptionsFieldRecursive(subField, extension, optionsKv, key);
}
}
break;
}
}
}
else
{
if (ExtractType(options, field, out var value))
{
optionsKv.Add(key, value);
}
}
}
private string MakeRelativeName(FieldDescriptorProto field, IType target, NameNormalizer normalizer)
{
if (target == null)
{
return(Escape(field.TypeName)); // the only thing we know
}
var declaringType = field.Parent;
if (declaringType is IType type)
{
var name = FindNameFromCommonAncestor(type, target, normalizer);
if (!string.IsNullOrWhiteSpace(name))
{
return(name);
}
}
return(Escape(field.TypeName)); // give up!
}
private static string GenerateOutputString(FieldDescriptorProto fieldDescriptorProto, string tempString)
{
string rightVariableString;
if (fieldDescriptorProto.Type.Equals(FieldDescriptorProto.Types.Type.TYPE_MESSAGE))
{
rightVariableString = $"{tempString}.OutputBaseFromWrapper()";
}
else if (fieldDescriptorProto.Type.Equals(FieldDescriptorProto.Types.Type.TYPE_BYTES))
{
rightVariableString = $"Google.Protobuf.ByteString.CopyFrom({tempString})";
}
else
{
rightVariableString = $"{tempString}";
}
return(rightVariableString);
}
public DynamicMessage GetFieldMessage(FieldDescriptorProto desc)
{
if (desc.type != FieldDescriptorProto.Type.TYPE_MESSAGE)
{
lastError.Clear();
lastError.AddLast(string.Format("field {0}.{1} is not a message", msgDescriptor.Protocol.name, desc.name));
return(null);
}
object ret = GetFieldValue(desc);
if (ret is DynamicMessage)
{
return((DynamicMessage)ret);
}
return(null);
}
public List <object> GetFieldList(FieldDescriptorProto field_desc)
{
lastError.Clear();
object ret;
if (fieldData.TryGetValue(field_desc.number, out ret))
{
if (!(ret is List <object>))
{
lastError.AddLast(string.Format("field {1} is not repeated", field_desc.number));
return(null);
}
return((List <object>)ret);
}
return(new List <object>());
}
private dynamic GetFiledDefaultValue(FieldDescriptorProto field, List <DescriptorProto> messageTypes)
{
switch (field.type)
{
case FieldDescriptorProto.Type.TypeDouble:
case FieldDescriptorProto.Type.TypeFloat:
case FieldDescriptorProto.Type.TypeInt64:
case FieldDescriptorProto.Type.TypeUint64:
case FieldDescriptorProto.Type.TypeInt32:
case FieldDescriptorProto.Type.TypeFixed64:
case FieldDescriptorProto.Type.TypeFixed32:
case FieldDescriptorProto.Type.TypeUint32:
case FieldDescriptorProto.Type.TypeEnum:
case FieldDescriptorProto.Type.TypeSfixed32:
case FieldDescriptorProto.Type.TypeSfixed64:
case FieldDescriptorProto.Type.TypeSint32:
case FieldDescriptorProto.Type.TypeSint64:
return(0);
case FieldDescriptorProto.Type.TypeBool:
return(true);
case FieldDescriptorProto.Type.TypeString:
case FieldDescriptorProto.Type.TypeBytes:
case FieldDescriptorProto.Type.TypeGroup:
return("");
case FieldDescriptorProto.Type.TypeMessage:
var typeName = field.TypeName.Split('.').Last();
var type = messageTypes.FirstOrDefault(p => p.Name == typeName);
if (type != null)
{
return(type.Fields.ToDictionary(p => p.Name, p => GetFiledDefaultValue(p, messageTypes)));
}
else
{
return("");
}
default:
return("");
}
}
/// <summary>Helper: put the buffer into a MemoryStream and create a new instance to deserializing into</summary>
public static FieldDescriptorProto Deserialize(byte[] buffer)
{
FieldDescriptorProto instance = new FieldDescriptorProto();
using (var ms = new MemoryStream(buffer))
Deserialize(ms, instance);
return instance;
}
/// <summary>Helper: Serialize into a MemoryStream and return its byte array</summary>
public static byte[] SerializeToBytes(FieldDescriptorProto instance)
{
using (var ms = new MemoryStream())
{
Serialize(ms, instance);
return ms.ToArray();
}
}
/// <summary>Helper: Serialize with a varint length prefix</summary>
public static void SerializeLengthDelimited(Stream stream, FieldDescriptorProto instance)
{
var data = SerializeToBytes(instance);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, (uint)data.Length);
stream.Write(data, 0, data.Length);
}
/// <summary>Serialize the instance into the stream</summary>
public static void Serialize(Stream stream, FieldDescriptorProto instance)
{
if (instance.Name != null)
{
// Key for field: 1, LengthDelimited
stream.WriteByte(10);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.Name));
}
// Key for field: 3, Varint
stream.WriteByte(24);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt64(stream,(ulong)instance.Number);
// Key for field: 4, Varint
stream.WriteByte(32);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt64(stream,(ulong)instance.label);
// Key for field: 5, Varint
stream.WriteByte(40);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt64(stream,(ulong)instance.type);
if (instance.TypeName != null)
{
// Key for field: 6, LengthDelimited
stream.WriteByte(50);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.TypeName));
}
if (instance.Extendee != null)
{
// Key for field: 2, LengthDelimited
stream.WriteByte(18);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.Extendee));
}
if (instance.DefaultValue != null)
{
// Key for field: 7, LengthDelimited
stream.WriteByte(58);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.DefaultValue));
}
if (instance.Options != null)
{
// Key for field: 8, LengthDelimited
stream.WriteByte(66);
using (var ms8 = new MemoryStream())
{
Google.protobuf.FieldOptions.Serialize(ms8, instance.Options);
// Length delimited byte array
uint ms8Length = (uint)ms8.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, ms8Length);
stream.Write(ms8.GetBuffer(), 0, (int)ms8Length);
}
}
}
/// <summary>Helper: create a new instance to deserializing into</summary>
public static FieldDescriptorProto DeserializeLengthDelimited(Stream stream)
{
FieldDescriptorProto instance = new FieldDescriptorProto();
DeserializeLengthDelimited(stream, instance);
return instance;
}
/// <summary>Helper: create a new instance to deserializing into</summary>
public static FieldDescriptorProto DeserializeLength(Stream stream, int length)
{
FieldDescriptorProto instance = new FieldDescriptorProto();
DeserializeLength(stream, length, instance);
return instance;
}
/// <summary>Serialize the instance into the stream</summary>
public static void Serialize(Stream stream, FieldDescriptorProto instance)
{
var msField = global::SilentOrbit.ProtocolBuffers.ProtocolParser.Stack.Pop();
if (instance.Name != null)
{
// Key for field: 1, LengthDelimited
stream.WriteByte(10);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.Name));
}
// Key for field: 3, Varint
stream.WriteByte(24);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt64(stream,(ulong)instance.Number);
// Key for field: 4, Varint
stream.WriteByte(32);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt64(stream,(ulong)instance.label);
// Key for field: 5, Varint
stream.WriteByte(40);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt64(stream,(ulong)instance.type);
if (instance.TypeName != null)
{
// Key for field: 6, LengthDelimited
stream.WriteByte(50);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.TypeName));
}
if (instance.Extendee != null)
{
// Key for field: 2, LengthDelimited
stream.WriteByte(18);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.Extendee));
}
if (instance.DefaultValue != null)
{
// Key for field: 7, LengthDelimited
stream.WriteByte(58);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.DefaultValue));
}
if (instance.Options != null)
{
// Key for field: 8, LengthDelimited
stream.WriteByte(66);
msField.SetLength(0);
Google.Protobuf.FieldOptions.Serialize(msField, instance.Options);
// Length delimited byte array
uint length8 = (uint)msField.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, length8);
msField.WriteTo(stream);
}
global::SilentOrbit.ProtocolBuffers.ProtocolParser.Stack.Push(msField);
}
/// <summary>Helper: create a new instance to deserializing into</summary>
public static FieldDescriptorProto Deserialize(Stream stream)
{
var instance = new FieldDescriptorProto();
Deserialize(stream, instance);
return instance;
}
