Protocol.cs

Go to the documentation of this file.

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

namespace Avro
{
    public class Protocol
    {
        public string Name { get; set; }

        public string Namespace { get; set; }

        public string Doc { get; set; }

        public IList<Schema> Types { get; set; }

        public IDictionary<string,Message> Messages { get; set; }

        private byte[] md5;
        public byte[] MD5
        {
            get 
            {
                try
                {
                    if (md5 == null)
                        md5 = System.Security.Cryptography.MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(ToString()));
                }
                catch (Exception ex)
                {
                    throw new AvroRuntimeException("MD5 get exception", ex);
                }
                return md5; 
            }
        }

        public Protocol(string name, string space,
                        string doc, IEnumerable<Schema> types,
                        IDictionary<string,Message> messages)
        {
            if (string.IsNullOrEmpty(name)) throw new ArgumentNullException("name", "name cannot be null.");
            if (null == types) throw new ArgumentNullException("types", "types cannot be null.");
            if (null == messages) throw new ArgumentNullException("messages", "messages cannot be null.");

            this.Name = name;
            this.Namespace = space;
            this.Doc = doc;
            this.Types = new List<Schema>(types);
            this.Messages = new Dictionary<string, Message>(messages);
        }

        public static Protocol Parse(string jstring)
        {
            if (string.IsNullOrEmpty(jstring)) throw new ArgumentNullException("json", "json cannot be null.");

            JToken jtok = null;
            try
            {
                jtok = JObject.Parse(jstring);
            }
            catch (Exception ex)
            {
                throw new ProtocolParseException("Invalid JSON format: " + jstring, ex);
            }
            return Parse(jtok);
        }

        private static Protocol Parse(JToken jtok)
        {
            string name = JsonHelper.GetRequiredString(jtok, "protocol");
            string space = JsonHelper.GetOptionalString(jtok, "namespace");
            string doc = JsonHelper.GetOptionalString(jtok, "doc");

            var names = new SchemaNames();

            JToken jtypes = jtok["types"];
            var types = new List<Schema>();
            if (jtypes is JArray)
            {
                foreach (JToken jtype in jtypes)
                {
                    var schema = Schema.ParseJson(jtype, names, space);
                    types.Add(schema);
                }
            }

            var messages = new Dictionary<string,Message>();
            JToken jmessages = jtok["messages"];
            if (null != jmessages)
            {
                foreach (JProperty jmessage in jmessages)
                {
                    var message = Message.Parse(jmessage, names, space);
                    messages.Add(message.Name, message);
                }
            }

            return new Protocol(name, space, doc, types, messages);
        }

        public override string ToString()
        {
            using (System.IO.StringWriter sw = new System.IO.StringWriter())
            {
                using (Newtonsoft.Json.JsonTextWriter writer = new Newtonsoft.Json.JsonTextWriter(sw))
                {
                    #if(DEBUG)
                    writer.Formatting = Newtonsoft.Json.Formatting.Indented;
                    #endif

                    WriteJson(writer, new SchemaNames());
                    writer.Flush();
                    return sw.ToString();
                }
            }
        }

        internal void WriteJson(Newtonsoft.Json.JsonTextWriter writer, SchemaNames names)
        {
            writer.WriteStartObject();

            JsonHelper.writeIfNotNullOrEmpty(writer, "protocol", this.Name);
            JsonHelper.writeIfNotNullOrEmpty(writer, "namespace", this.Namespace);
            JsonHelper.writeIfNotNullOrEmpty(writer, "doc", this.Doc);

            writer.WritePropertyName("types");
            writer.WriteStartArray();

            foreach (Schema type in this.Types)
                type.WriteJson(writer, names, this.Namespace);

            writer.WriteEndArray();

            writer.WritePropertyName("messages");
            writer.WriteStartObject();

            foreach (KeyValuePair<string,Message> message in this.Messages)
            {
                writer.WritePropertyName(message.Key);
                message.Value.writeJson(writer, names, this.Namespace);
            }

            writer.WriteEndObject();
            writer.WriteEndObject();
        }

        public override bool Equals(object obj)
        {
            if (obj == this) return true;
            if (!(obj is Protocol)) return false;

            Protocol that = obj as Protocol;

            return this.Name.Equals(that.Name) && this.Namespace.Equals(that.Namespace) && 
                    TypesEquals(that.Types) && MessagesEquals(that.Messages);
        }

        private bool TypesEquals(IList<Schema> that)
        {
            if (Types.Count != that.Count) return false;
            foreach (Schema schema in Types)
                if (!that.Contains(schema)) return false;
            return true;
        }

        private bool MessagesEquals(IDictionary<string, Message> that)
        {
            if (Messages.Count != that.Count) return false;
            foreach (KeyValuePair<string, Message> pair in Messages) 
            { 
                if (!that.ContainsKey(pair.Key))
                    return false;
                if (!pair.Value.Equals(that[pair.Key]))
                    return false; 
            } 
            return true;
        }

        public override int GetHashCode()
        {
            return Name.GetHashCode() + Namespace.GetHashCode() +
                   GetTypesHashCode() + GetMessagesHashCode();
        }

        private int GetTypesHashCode()
        {
            int hash = Types.Count;
            foreach (Schema schema in Types)
                hash += schema.GetHashCode();
            return hash;
        }

        private int GetMessagesHashCode()
        {
            int hash = Messages.Count;
            foreach (KeyValuePair<string, Message> pair in Messages)
                hash += (pair.Key.GetHashCode() + pair.Value.GetHashCode());
            return hash;
        }
    }
}