/// <summary>
/// Constructor for Message class
/// </summary>
/// <param name="name">name property</param>
/// <param name="doc">doc property</param>
/// <param name="request">list of parameters</param>
/// <param name="response">response property</param>
/// <param name="error">error union schema</param>
public Message(string name, string doc, RecordSchema request, Schema response, UnionSchema error, bool?oneway)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name", "name cannot be null.");
}
this.Request = request;
this.Response = response;
this.Error = error;
this.Name = name;
this.Doc = doc;
this.Oneway = oneway;
if (error != null && error.CanRead(Schema.Parse("string")))
{
this.SupportedErrors = error;
}
else
{
this.SupportedErrors = (UnionSchema)Schema.Parse("[\"string\"]");
if (error != null)
{
for (int i = 0; i < error.Schemas.Count; ++i)
{
this.SupportedErrors.Schemas.Add(error.Schemas[i]);
}
}
}
}
/// <summary>
/// Gets the schema of a union with null
/// </summary>
/// <param name="schema">union schema</param>
/// <returns>schema that is nullible</returns>
public static Schema getNullableType(UnionSchema schema)
{
Schema ret = null;
if (schema.Count == 2)
{
bool nullable = false;
foreach (Schema childSchema in schema.Schemas)
{
if (childSchema.Tag == Schema.Type.Null)
{
nullable = true;
}
else
{
ret = childSchema;
}
}
if (!nullable)
{
ret = null;
}
}
return(ret);
}
/// <summary>
/// Parses the messages section of a protocol definition
/// </summary>
/// <param name="jmessage">messages JSON object</param>
/// <param name="names">list of parsed names</param>
/// <param name="encspace">enclosing namespace</param>
/// <returns></returns>
internal static Message Parse(JProperty jmessage, SchemaNames names, string encspace)
{
string name = jmessage.Name;
string doc = JsonHelper.GetOptionalString(jmessage.Value, "doc");
bool? oneway = JsonHelper.GetOptionalBoolean(jmessage.Value, "one-way");
PropertyMap props = Schema.GetProperties(jmessage.Value);
RecordSchema schema = RecordSchema.NewInstance(Schema.Type.Record, jmessage.Value as JObject, props, names, encspace);
JToken jresponse = jmessage.Value["response"];
var response = Schema.ParseJson(jresponse, names, encspace);
JToken jerrors = jmessage.Value["errors"];
UnionSchema uerrorSchema = null;
if (null != jerrors)
{
Schema errorSchema = Schema.ParseJson(jerrors, names, encspace);
if (!(errorSchema is UnionSchema))
{
throw new AvroException("");
}
uerrorSchema = errorSchema as UnionSchema;
}
return(new Message(name, doc, schema, response, uerrorSchema, oneway));
}
public Message(string name, string doc, IList<Parameter> request, Schema response, UnionSchema error)
{
if (string.IsNullOrEmpty(name)) throw new ArgumentNullException("name", "name cannot be null.");
this.Request = request;
this.Response = response;
this.Error = error;
this.Name = name;
this.Doc = doc;
}
/// <summary>
/// Constructor for Message class
/// </summary>
/// <param name="name">name property</param>
/// <param name="doc">doc property</param>
/// <param name="request">list of parameters</param>
/// <param name="response">response property</param>
/// <param name="error">error union schema</param>
public Message(string name, string doc, RecordSchema request, Schema response, UnionSchema error, bool? oneway)
{
if (string.IsNullOrEmpty(name)) throw new ArgumentNullException("name", "name cannot be null.");
this.Request = request;
this.Response = response;
this.Error = error;
this.Name = name;
this.Doc = doc;
this.Oneway = oneway;
}
private static AvroSchema ParseUnionSchema(JToken jToken, IDictionary <string, NamedSchema> namedTypes, Stack <string> enclosingNamespace)
{
var jArray = jToken as JArray;
var unionSchema = new UnionSchema();
foreach (var item in jArray)
{
var schema = ParseSchema(item, namedTypes, enclosingNamespace);
unionSchema.Add(schema);
}
return(unionSchema);
}
/// <summary>
/// Gets the schema of a union with null.
/// </summary>
/// <param name="schema">union schema.</param>
/// <returns>
/// schema that is nullable.
/// </returns>
/// <exception cref="ArgumentNullException">schema - UnionSchema can not be null.</exception>
public static Schema GetNullableType(UnionSchema schema)
{
if (schema == null)
{
throw new ArgumentNullException(nameof(schema), "UnionSchema can not be null");
}
if (schema.Count == 2 && !schema.Schemas.All(x => x.Tag != Schema.Type.Null))
{
return(schema.Schemas.FirstOrDefault(x => x.Tag != Schema.Type.Null));
}
return(null);
}
private static void WriteUnion(TextWriter writer, UnionSchema schema, WriterMode mode, string parentNamespace, ISet <string> namedSchemas, bool stripNs)
{
var i = 0;
switch (mode)
{
case WriterMode.Canonical:
writer.Write(@"[");
foreach (var item in schema)
{
if (i++ > 0)
{
writer.Write(",");
}
Write(writer, item, mode, parentNamespace, namedSchemas, stripNs);
}
writer.Write(@"]");
break;
case WriterMode.Full:
writer.Write(@"[");
foreach (var item in schema)
{
if (i++ > 0)
{
writer.Write(", ");
}
Write(writer, item, mode, parentNamespace, namedSchemas, stripNs);
}
writer.Write(@"]");
break;
default:
writer.Write(@"[");
foreach (var item in schema)
{
if (i++ > 0)
{
writer.Write(", ");
}
Write(writer, item, mode, parentNamespace, namedSchemas, stripNs);
}
writer.Write(@"]");
break;
}
}
/// <summary>
/// Compares two union schema objects
/// </summary>
/// <param name="obj">union schema object to compare against this schema</param>
/// <returns>true if objects are equal, false otherwise</returns>
public override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
if (obj != null && obj is UnionSchema)
{
UnionSchema that = obj as UnionSchema;
if (that.Count == Count)
{
for (int i = 0; i < Count; i++)
{
if (!that[i].Equals(this[i]))
{
return(false);
}
}
return(areEqual(that.Props, this.Props));
}
}
return(false);
}
/// <summary>
/// Gets the schema of a union with null
/// </summary>
/// <param name="schema">union schema</param>
/// <returns>schema that is nullible</returns>
public static Schema getNullableType(UnionSchema schema)
{
Schema ret = null;
if (schema.Count == 2)
{
bool nullable = false;
foreach (Schema childSchema in schema.Schemas)
{
if (childSchema.Tag == Schema.Type.Null)
nullable = true;
else
ret = childSchema;
}
if (!nullable)
ret = null;
}
return ret;
}
/// <summary>
/// Static class to return new instance of schema object
/// </summary>
/// <param name="jtok">JSON object</param>
/// <param name="names">list of named schemas already read</param>
/// <param name="encspace">enclosing namespace of the schema</param>
/// <returns>new Schema object</returns>
internal static Schema ParseJson(JToken jtok, SchemaNames names, string encspace)
{
if (null == jtok)
{
throw new ArgumentNullException("j", "j cannot be null.");
}
if (jtok.Type == JTokenType.String) // primitive schema with no 'type' property or primitive or named type of a record field
{
string value = (string)jtok;
PrimitiveSchema ps = PrimitiveSchema.NewInstance(value);
if (null != ps)
{
return(ps);
}
NamedSchema schema = null;
if (names.TryGetValue(value, null, encspace, out schema))
{
return(schema);
}
throw new SchemaParseException($"Undefined name: {value} at '{jtok.Path}'");
}
if (jtok is JArray) // union schema with no 'type' property or union type for a record field
{
return(UnionSchema.NewInstance(jtok as JArray, null, names, encspace));
}
if (jtok is JObject) // JSON object with open/close parenthesis, it must have a 'type' property
{
JObject jo = jtok as JObject;
JToken jtype = jo["type"];
if (null == jtype)
{
throw new SchemaParseException($"Property type is required at '{jtok.Path}'");
}
var props = Schema.GetProperties(jtok);
if (jtype.Type == JTokenType.String)
{
string type = (string)jtype;
if (type.Equals("array", StringComparison.Ordinal))
{
return(ArraySchema.NewInstance(jtok, props, names, encspace));
}
if (type.Equals("map", StringComparison.Ordinal))
{
return(MapSchema.NewInstance(jtok, props, names, encspace));
}
if (null != jo["logicalType"]) // logical type based on a primitive
{
return(LogicalSchema.NewInstance(jtok, props, names, encspace));
}
Schema schema = PrimitiveSchema.NewInstance((string)type, props);
if (null != schema)
{
return(schema);
}
return(NamedSchema.NewInstance(jo, props, names, encspace));
}
else if (jtype.Type == JTokenType.Array)
{
return(UnionSchema.NewInstance(jtype as JArray, props, names, encspace));
}
else if (jtype.Type == JTokenType.Object && null != jo["logicalType"]) // logical type based on a complex type
{
return(LogicalSchema.NewInstance(jtok, props, names, encspace));
}
}
throw new AvroTypeException($"Invalid JSON for schema: {jtok} at '{jtok.Path}'");
}
private static StringBuilder Build(IDictionary <string, string> env, Schema s, StringBuilder o)
{
bool firstTime = true;
Schema.Type st = s.Tag;
switch (st)
{
case Schema.Type.Union:
UnionSchema us = s as UnionSchema;
o.Append('[');
foreach (Schema b in us.Schemas)
{
if (!firstTime)
{
o.Append(',');
}
else
{
firstTime = false;
}
Build(env, b, o);
}
return(o.Append(']'));
case Schema.Type.Array:
case Schema.Type.Map:
o.Append("{\"type\":\"").Append(Schema.GetTypeString(s.Tag)).Append('\"');
if (st == Schema.Type.Array)
{
ArraySchema arraySchema = s as ArraySchema;
Build(env, arraySchema.ItemSchema, o.Append(",\"items\":"));
}
else
{
MapSchema mapSchema = s as MapSchema;
Build(env, mapSchema.ValueSchema, o.Append(",\"values\":"));
}
return(o.Append('}'));
case Schema.Type.Enumeration:
case Schema.Type.Fixed:
case Schema.Type.Record:
NamedSchema namedSchema = s as NamedSchema;
var name = namedSchema.Fullname;
if (env.ContainsKey(name))
{
return(o.Append(env[name]));
}
var qname = "\"" + name + "\"";
env.Add(name, qname);
o.Append("{\"name\":").Append(qname);
o.Append(",\"type\":\"").Append(Schema.GetTypeString(s.Tag)).Append('\"');
if (st == Schema.Type.Enumeration)
{
EnumSchema enumSchema = s as EnumSchema;
o.Append(",\"symbols\":[");
foreach (var enumSymbol in enumSchema.Symbols)
{
if (!firstTime)
{
o.Append(',');
}
else
{
firstTime = false;
}
o.Append('\"').Append(enumSymbol).Append('\"');
}
o.Append(']');
}
else if (st == Schema.Type.Fixed)
{
FixedSchema fixedSchema = s as FixedSchema;
o.Append(",\"size\":")
.Append(fixedSchema.Size.ToString(CultureInfo.InvariantCulture));
}
else // st == Schema.Type.Record
{
RecordSchema recordSchema = s as RecordSchema;
o.Append(",\"fields\":[");
foreach (var field in recordSchema.Fields)
{
if (!firstTime)
{
o.Append(',');
}
else
{
firstTime = false;
}
o.Append("{\"name\":\"").Append(field.Name).Append('\"');
Build(env, field.Schema, o.Append(",\"type\":")).Append('}');
}
o.Append(']');
}
return(o.Append('}'));
default: //boolean, bytes, double, float, int, long, null, string
return(o.Append('\"').Append(s.Name).Append('\"'));
}
}
public static Schema getNullableType(UnionSchema schema)
{
return(GetNullableType(schema));
}
/// <summary>
/// Constructor for Message class
/// </summary>
/// <param name="name">name property</param>
/// <param name="doc">doc property</param>
/// <param name="request">list of parameters</param>
/// <param name="response">response property</param>
/// <param name="error">error union schema</param>
public Message(string name, string doc, RecordSchema request, Schema response, UnionSchema error, bool?oneway)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name", "name cannot be null.");
}
this.Request = request;
this.Response = response;
this.Error = error;
this.Name = name;
this.Doc = doc;
this.Oneway = oneway;
}
/// <summary>
/// Constructor for Message class
/// </summary>
/// <param name="name">name property</param>
/// <param name="doc">doc property</param>
/// <param name="request">list of parameters</param>
/// <param name="response">response property</param>
/// <param name="error">error union schema</param>
public Message(string name, string doc, RecordSchema request, Schema response, UnionSchema error, bool? oneway)
{
if (string.IsNullOrEmpty(name)) throw new ArgumentNullException("name", "name cannot be null.");
this.Request = request;
this.Response = response;
this.Error = error;
this.Name = name;
this.Doc = doc;
this.Oneway = oneway;
if (error != null && error.CanRead(Schema.Parse("string")))
{
this.SupportedErrors = error;
}
else
{
this.SupportedErrors = (UnionSchema) Schema.Parse("[\"string\"]");
if (error != null)
{
for (int i = 0; i < error.Schemas.Count; ++i)
{
this.SupportedErrors.Schemas.Add(error.Schemas[i]);
}
}
}
}