NamedSchema.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Text;
using Newtonsoft.Json.Linq;


namespace Avro
{
    public abstract class NamedSchema : Schema
    {
        public SchemaName SchemaName { get; private set; }

        public override string Name
        {
            get { return SchemaName.Name; }
        }

        public string Namespace
        {
            get { return SchemaName.Namespace; }
        }

        public string Fullname
        {
            get { return SchemaName.Fullname; }
        }

        private readonly IList<SchemaName> aliases;

        internal static NamedSchema NewInstance(JObject jo, PropertyMap props, SchemaNames names, string encspace)
        {
            string type = JsonHelper.GetRequiredString(jo, "type");
            switch (type)
            {
                case "fixed":
                    return FixedSchema.NewInstance(jo, props, names, encspace);
                case "enum":
                    return EnumSchema.NewInstance(jo, props, names, encspace);
                case "record":
                    return RecordSchema.NewInstance(Type.Record, jo, props, names, encspace);
                case "error":
                    return RecordSchema.NewInstance(Type.Error, jo, props, names, encspace);
                default:
                    NamedSchema result;
                    if (names.TryGetValue(type, null, encspace, out result))
                        return result;
                    return null;
            }
        }

        protected NamedSchema(Type type, SchemaName name, IList<SchemaName> aliases, PropertyMap props, SchemaNames names)
                                : base(type, props)
        {
            this.SchemaName = name;
            this.aliases = aliases;
            if (null != name.Name)  // Added this check for anonymous records inside Message 
                if (!names.Add(name, this))
                    throw new AvroException("Duplicate schema name " + name.Fullname);
        }

        protected static SchemaName GetName(JToken jtok, string encspace)
        {
            String n = JsonHelper.GetOptionalString(jtok, "name");      // Changed this to optional string for anonymous records in messages 
            String ns = JsonHelper.GetOptionalString(jtok, "namespace");
            return new SchemaName(n, ns, encspace);
        }

        protected static IList<SchemaName> GetAliases(JToken jtok, string space, string encspace)
        {
            JToken jaliases = jtok["aliases"];
            if (null == jaliases)
                return null;

            if (jaliases.Type != JTokenType.Array)
                throw new SchemaParseException("Aliases must be of format JSON array of strings");

            var aliases = new List<SchemaName>();
            foreach (JToken jalias in jaliases)
            {
                if (jalias.Type != JTokenType.String)
                    throw new SchemaParseException("Aliases must be of format JSON array of strings");

                aliases.Add(new SchemaName((string)jalias, space, encspace));
            }
            return aliases;
        }

        protected bool InAliases(SchemaName name)
        {
            if (null != aliases)
            {
                foreach (SchemaName alias in aliases)
                    if (name.Equals(alias)) return true;
            }
            return false;
        }

        protected internal override void WriteJson(Newtonsoft.Json.JsonTextWriter writer, SchemaNames names, string encspace)
        {
            if (!names.Add(this))
            {
                // schema is already in the list, write name only
                SchemaName schemaName = this.SchemaName;
                string name;
                if (schemaName.Namespace != encspace)
                    name = schemaName.Namespace + "." + schemaName.Name;  // we need to add the qualifying namespace of the target schema if it's not the same as current namespace
                else
                    name = schemaName.Name;
                writer.WriteValue(name);
            }
            else
                // schema is not in the list, write full schema definition
                base.WriteJson(writer, names, encspace);
        }

        protected internal override void WriteJsonFields(Newtonsoft.Json.JsonTextWriter writer, SchemaNames names, string encspace)
        {
            this.SchemaName.WriteJson(writer, names, encspace);

            if (null != aliases)
            {
                writer.WritePropertyName("aliases");
                writer.WriteStartArray();
                foreach (SchemaName name in aliases)
                {
                    string fullname = (null != name.Space) ? name.Space + "." + name.Name : name.Name;
                    writer.WriteValue(fullname);
                }
                writer.WriteEndArray();
            }
        }
    }
}