Class for fixed schemas
Inheritance: NamedSchema
        private static AvroSchema ParseFixedSchema(JToken jToken, IDictionary <string, NamedSchema> namedTypes, Stack <string> enclosingNamespace)
        {
            var keys = new HashSet <string>()
            {
                "type", "size", "name"
            };
            var optionalKeys = new HashSet <string>()
            {
                "namespace"
            };

            JsonUtil.AssertKeys(jToken, keys, optionalKeys, out var tags);

            JsonUtil.AssertValue(jToken, "type", "fixed");
            var size = JsonUtil.GetValue <int>(jToken, "size");
            var name = JsonUtil.GetValue <string>(jToken, "name");

            JsonUtil.TryGetValue <string>(jToken, "namespace", out var ns);
            var fixedSchema = new FixedSchema(name, ns, size);

            if (string.IsNullOrEmpty(fixedSchema.Namespace))
            {
                fixedSchema.Namespace = enclosingNamespace.Peek();
            }
            fixedSchema.AddTags(tags);
            namedTypes.Add(fixedSchema.FullName, fixedSchema);
            return(fixedSchema);
        }
Esempio n. 2
0
        /// <summary>
        /// Creates a class declaration for fixed schema
        /// </summary>
        /// <param name="schema">fixed schema</param>
        /// <param name="ns">namespace object</param>
        protected virtual void processFixed(Schema schema)
        {
            FixedSchema fixedSchema = schema as FixedSchema;

            if (null == fixedSchema)
            {
                throw new CodeGenException("Unable to cast schema into a fixed");
            }

            CodeTypeDeclaration ctd = new CodeTypeDeclaration();

            ctd.Name       = CodeGenUtil.Instance.Mangle(fixedSchema.Name);
            ctd.IsClass    = true;
            ctd.IsPartial  = true;
            ctd.Attributes = MemberAttributes.Public;
            ctd.BaseTypes.Add("SpecificFixed");

            if (fixedSchema.Documentation != null)
            {
                ctd.Comments.Add(createDocComment(fixedSchema.Documentation));
            }

            // create static schema field
            createSchemaField(schema, ctd, true);

            // Add Size field
            string sizefname = "fixedSize";
            var    ctrfield  = new CodeTypeReference(typeof(uint));
            var    codeField = new CodeMemberField(ctrfield, sizefname);

            codeField.Attributes     = MemberAttributes.Private | MemberAttributes.Static;
            codeField.InitExpression = new CodePrimitiveExpression(fixedSchema.Size);
            ctd.Members.Add(codeField);

            // Add Size property
            var property = new CodeMemberProperty();

            property.Attributes = MemberAttributes.Public | MemberAttributes.Static;
            property.Name       = "FixedSize";
            property.Type       = ctrfield;
            property.GetStatements.Add(new CodeMethodReturnStatement(new CodeTypeReferenceExpression(schema.Name + "." + sizefname)));
            ctd.Members.Add(property);

            // create constructor to initiate base class SpecificFixed
            CodeConstructor cc = new CodeConstructor();

            cc.Attributes = MemberAttributes.Public;
            cc.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(sizefname));
            ctd.Members.Add(cc);

            string nspace = fixedSchema.Namespace;

            if (string.IsNullOrEmpty(nspace))
            {
                throw new CodeGenException("Namespace required for enum schema " + fixedSchema.Name);
            }
            CodeNamespace codens = addNamespace(nspace);

            codens.Types.Add(ctd);
        }
Esempio n. 3
0
        /// <summary>
        /// Static function to return a new instance of the named schema
        /// </summary>
        /// <param name="jo">JSON object of the named schema</param>
        /// <param name="names">list of named schemas already read</param>
        /// <param name="encspace">enclosing namespace of the named schema</param>
        /// <returns></returns>
        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);
            }
        }
Esempio n. 4
0
        /// <summary>
        /// Compares two fixed schemas
        /// </summary>
        /// <param name="obj">fixed schema to compare against this schema</param>
        /// <returns>true if two schemas are the same, false otherwise</returns>
        public override bool Equals(object obj)
        {
            if (obj == this)
            {
                return(true);
            }

            if (obj != null && obj is FixedSchema)
            {
                FixedSchema that = obj as FixedSchema;
                return(SchemaName.Equals(that.SchemaName) && Size == that.Size && areEqual(that.Props, this.Props));
            }
            return(false);
        }
Esempio n. 5
0
        /// <summary>
        /// Checks if this schema can read data written by the given schema. Used for decoding data.
        /// </summary>
        /// <param name="writerSchema">writer schema</param>
        /// <returns>true if this and writer schema are compatible based on the AVRO specification, false otherwise</returns>
        public override bool CanRead(Schema writerSchema)
        {
            if (writerSchema.Tag != Tag)
            {
                return(false);
            }
            FixedSchema that = writerSchema as FixedSchema;

            if (that.Size != Size)
            {
                return(false);
            }
            if (that.SchemaName.Equals(SchemaName))
            {
                return(true);
            }
            else
            {
                return(InAliases(that.SchemaName));
            }
        }
Esempio n. 6
0
        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('\"'));
            }
        }
Esempio n. 7
0
        private static void WriteFixed(TextWriter writer, FixedSchema schema, string parentNamespace, WriterMode mode, bool stripNs)
        {
            var ns = parentNamespace;

            if (!string.IsNullOrEmpty(schema.Namespace))
            {
                ns = schema.Namespace;
            }
            if (stripNs && ns == parentNamespace)
            {
                ns = null;
            }
            switch (mode)
            {
            case WriterMode.Canonical:
                writer.Write(@"{""name"":""");
                writer.Write(schema.FullName);
                writer.Write(@"""");
                writer.Write(@",""type"":""fixed""");
                writer.Write(@",""size"":");
                writer.Write(schema.Size);
                writer.Write(@"}");
                break;

            case WriterMode.Full:
                writer.Write(@"{ ""type"": ""fixed""");
                writer.Write(@", ""name"": """);
                writer.Write(schema.Name);
                writer.Write(@"""");
                writer.Write(@", ""namespace"": """);
                writer.Write(schema.Namespace);
                writer.Write(@"""");
                writer.Write(@", ""size"": ");
                writer.Write(schema.Size);
                writer.Write(@", ""aliases"": [");
                writer.Write(string.Join(", ", schema.Aliases.Select(r => $"\"{r}\"")));
                writer.Write(@"]");
                writer.Write(@" }");
                break;

            default:
                writer.Write(@"{ ""type"": ""fixed""");
                writer.Write(@", ""name"": """);
                writer.Write(schema.Name);
                writer.Write(@"""");
                if (!string.IsNullOrEmpty(ns))
                {
                    writer.Write(@", ""namespace"": """);
                    writer.Write(ns);
                    writer.Write(@"""");
                }
                writer.Write(@", ""size"": ");
                writer.Write(schema.Size);
                if (schema.Aliases.Count() > 0)
                {
                    writer.Write(@", ""aliases"": [");
                    writer.Write(string.Join(", ", schema.Aliases.Select(r => $"\"{r}\"")));
                    writer.Write(@"]");
                }
                writer.Write(@" }");
                break;
            }
        }