Exemplo n.º 1
0
 /// <summary>
 /// A generic method to serialize primitive Avro types.
 /// </summary>
 /// <typeparam name="S">Type of the C# type to be serialized</typeparam>
 /// <param name="value">The value to be serialized</param>
 /// <param name="tag">The schema type tag</param>
 /// <param name="writer">The writer which should be used to write the given type.</param>
 protected virtual void Write <S>(object value, Schema.Type tag, Writer <S> writer)
 {
     if (!(value is S))
     {
         throw TypeMismatch(value, tag.ToString(), typeof(S).ToString());
     }
     writer((S)value);
 }
Exemplo n.º 2
0
        /// <summary>
        /// A generic method to serialize primitive Avro types.
        /// </summary>
        /// <typeparam name="S">Type of the C# type to be serialized</typeparam>
        /// <param name="value">The value to be serialized</param>
        /// <param name="tag">The schema type tag</param>
        /// <param name="writer">The writer which should be used to write the given type.</param>
        protected void Write <S>(object value, Schema.Type tag, Writer <S> writer)
        {
            if (value == null)
            {
                value = default(S);
            }

            if (!(value is S))
            {
                throw TypeMismatch(value, tag.ToString(), typeof(S).ToString());
            }
            writer((S)value);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Gets the type of the specified type name
        /// </summary>
        /// <param name="name">name of the object to get type of</param>
        /// <param name="schemaType">schema type for the object</param>
        /// <returns>Type</returns>
        public Type GetType(string name, Schema.Type schemaType)
        {
            Type type = FindType(name, true);

            if (schemaType == Schema.Type.Map)
            {
                type = GenericMapType.MakeGenericType(new[] { typeof(string), type });
            }
            else if (schemaType == Schema.Type.Array)
            {
                type = GenericListType.MakeGenericType(new [] { type });
            }

            return(type);
        }
Exemplo n.º 4
0
        /// <summary>
        /// A generic method to serialize primitive Avro types.
        /// </summary>
        /// <typeparam name="S">Type of the C# type to be serialized</typeparam>
        /// <param name="value">The value to be serialized</param>
        /// <param name="tag">The schema type tag</param>
        /// <param name="writer">The writer which should be used to write the given type.</param>
        private static void Write <S>(object value, Schema.Type tag, Writer <S> writer)
        {
            if (value == null)
            {
                value = default(S);
            }

            if (!(value is S))
            {
                throw new AvroTypeMismatchException(
                          $"[{typeof(S)}] required to write against [{tag.ToString()}] schema but found " + value.GetType());
            }

            writer((S)value);
        }
Exemplo n.º 5
0
 protected override bool IsReusable(Schema.Type tag)
 {
     switch (tag)
     {
     case Schema.Type.Double:
     case Schema.Type.Boolean:
     case Schema.Type.Int:
     case Schema.Type.Long:
     case Schema.Type.Float:
     case Schema.Type.Bytes:
     case Schema.Type.String:
     case Schema.Type.Null:
         return(false);
     }
     return(true);
 }
Exemplo n.º 6
0
        /// <summary>
        /// Creates new instance of the given type
        /// </summary>
        /// <param name="name">fully qualified name of the type</param>
        /// <param name="schemaType">type of schema</param>
        /// <returns>new object of the given type</returns>
        public object New(string name, Schema.Type schemaType)
        {
            NameCtorKey key = new NameCtorKey(name, schemaType);

            CtorDelegate ctor;

            lock (ctors)
            {
                if (!ctors.TryGetValue(key, out ctor))
                {
                    Type type = GetType(name, schemaType);
                    ctor = GetConstructor(name, schemaType, type);

                    ctors.Add(key, ctor);
                }
            }
            return(ctor());
        }
Exemplo n.º 7
0
        /// <summary>
        /// Gets the default constructor for the specified type
        /// </summary>
        /// <param name="name">name of object for the type</param>
        /// <param name="schemaType">schema type for the object</param>
        /// <param name="type">type of the object</param>
        /// <returns>Default constructor for the type</returns>
        public CtorDelegate GetConstructor(string name, Schema.Type schemaType, Type type)
        {
            //ConstructorInfo ctorInfo = type.GetConstructor(Type.EmptyTypes);
            //if (ctorInfo == null)
            //    throw new AvroException("Class " + name + " has no default constructor");

            //DynamicMethod dynMethod = new DynamicMethod("DM$OBJ_FACTORY_" + name, typeof(object), null, type, true);
            //ILGenerator ilGen = dynMethod.GetILGenerator();
            //ilGen.Emit(OpCodes.Nop);
            //ilGen.Emit(OpCodes.Newobj, ctorInfo);
            //ilGen.Emit(OpCodes.Ret);

            //return (CtorDelegate)dynMethod.CreateDelegate(ctorType);

            // https://ayende.com/blog/3167/creating-objects-perf-implications
            // http://bit.ly/2cbySMk

            //return () => Activator.CreateInstance(type);

            return(GetCreator(type));
        }
        private static ObjectCreator.CtorDelegate GetConstructor(string name, Schema.Type schemaType)
        {
            var creator = ObjectCreator.Instance;

            return(creator.GetConstructor(name, schemaType, creator.GetType(name, schemaType)));
        }
Exemplo n.º 9
0
 protected S Read <S>(Schema.Type tag, Schema readerSchema, Reader <S> reader)
 {
     return(reader());
 }
Exemplo n.º 10
0
 public NameCtorKey(string value1, Schema.Type value2)
     : this()
 {
     name = value1;
     type = value2;
 }
Exemplo n.º 11
0
 /// <summary>
 /// Indicates if it's possible to reuse an object of the specified type. Generally
 /// false for immutable objects like int, long, string, etc but may differ between
 /// the Specific and Generic implementations. Used to avoid retrieving the existing
 /// value if it's not reusable.
 /// </summary>
 protected virtual bool IsReusable(Schema.Type tag)
 {
     return(true);
 }