コード例 #1
0
ファイル: GValue.cs プロジェクト: bencoster/net-vips
        /// <summary>
        /// Map a GType to the name of the C# type we use to represent it.
        /// </summary>
        /// <param name="gtype">The GType to map.</param>
        /// <returns>The C# type we use to represent it.</returns>
        public static string GTypeToCSharp(IntPtr gtype)
        {
            var fundamental = GType.Fundamental(gtype);

            if (GTypeToCSharpDict.ContainsKey(gtype))
            {
                return(GTypeToCSharpDict[gtype]);
            }

            if (GTypeToCSharpDict.ContainsKey(fundamental))
            {
                return(GTypeToCSharpDict[fundamental]);
            }

            return("object");
        }
コード例 #2
0
ファイル: GValue.cs プロジェクト: kleisauke/net-vips
        /// <summary>
        /// Set a GValue.
        /// </summary>
        /// <remarks>
        /// The value is converted to the type of the GValue, if possible, and
        /// assigned.
        /// </remarks>
        /// <param name="value">Value to be set.</param>
        public void Set(object value)
        {
            // logger.Debug($"Set: value = {value}");
            var gtype       = GetTypeOf();
            var fundamental = GType.Fundamental(gtype);

            if (gtype == GBoolType)
            {
                Internal.GValue.SetBoolean(ref Struct, Convert.ToBoolean(value));
            }
            else if (gtype == GIntType)
            {
                Internal.GValue.SetInt(ref Struct, Convert.ToInt32(value));
            }
            else if (gtype == GUint64Type)
            {
                Internal.GValue.SetUint64(ref Struct, Convert.ToUInt64(value));
            }
            else if (gtype == GDoubleType)
            {
                Internal.GValue.SetDouble(ref Struct, Convert.ToDouble(value));
            }
            else if (fundamental == GEnumType)
            {
                Internal.GValue.SetEnum(ref Struct, Convert.ToInt32(value));
            }
            else if (fundamental == GFlagsType)
            {
                Internal.GValue.SetFlags(ref Struct, Convert.ToUInt32(value));
            }
            else if (gtype == GStrType)
            {
                var bytes = Encoding.UTF8.GetBytes(Convert.ToString(value) + char.MinValue); // Ensure null-terminated string
                Internal.GValue.SetString(ref Struct, bytes);
            }
            else if (gtype == RefStrType)
            {
                var bytes = Encoding.UTF8.GetBytes(Convert.ToString(value) + char.MinValue); // Ensure null-terminated string
                VipsValue.SetRefString(ref Struct, bytes);
            }
            else if (fundamental == GObjectType && value is GObject gObject)
            {
                AddMemoryPressure(gObject.MemoryPressure);
                Internal.GValue.SetObject(ref Struct, gObject);
            }
            else if (gtype == ArrayIntType)
            {
                if (!(value is IEnumerable))
                {
                    value = new[] { value };
                }

                int[] integers;
                switch (value)
                {
                case int[] ints:
                    integers = ints;
                    break;

                case double[] doubles:
                    integers = Array.ConvertAll(doubles, Convert.ToInt32);
                    break;

                case object[] objects:
                    integers = Array.ConvertAll(objects, Convert.ToInt32);
                    break;

                default:
                    throw new Exception(
                              $"unsupported value type {value.GetType()} for gtype {NetVips.TypeName(gtype)}");
                }

                VipsValue.SetArrayInt(ref Struct, integers, integers.Length);
            }
            else if (gtype == ArrayDoubleType)
            {
                if (!(value is IEnumerable))
                {
                    value = new[] { value };
                }

                double[] doubles;
                switch (value)
                {
                case double[] dbls:
                    doubles = dbls;
                    break;

                case int[] ints:
                    doubles = Array.ConvertAll(ints, Convert.ToDouble);
                    break;

                case object[] objects:
                    doubles = Array.ConvertAll(objects, Convert.ToDouble);
                    break;

                default:
                    throw new Exception(
                              $"unsupported value type {value.GetType()} for gtype {NetVips.TypeName(gtype)}");
                }

                VipsValue.SetArrayDouble(ref Struct, doubles, doubles.Length);
            }
            else if (gtype == ArrayImageType && value is Image[] images)
            {
                var size = images.Length;
                VipsValue.SetArrayImage(ref Struct, size);

                var ptrArr = VipsValue.GetArrayImage(in Struct, out _);

                for (var i = 0; i < size; i++)
                {
                    ref var image = ref images[i];

                    // the gvalue needs a ref on each of the images
                    Marshal.WriteIntPtr(ptrArr, i * IntPtr.Size, image.ObjectRef());

                    AddMemoryPressure(image.MemoryPressure);
                }
            }
コード例 #3
0
ファイル: NetVips.cs プロジェクト: zhoufan1987/net-vips
 /// <summary>
 /// Extract the fundamental type ID portion.
 /// </summary>
 /// <param name="type">A valid type ID.</param>
 /// <returns>Fundamental type ID.</returns>
 public static IntPtr FundamentalType(IntPtr type)
 {
     return(GType.Fundamental(type));
 }