Пример #1
0
        public Intention(
            decimal lowestPrice,
            decimal maximumPrice,
            int bedroom,
            EState state,
            string city,
            string neighborhood,
            EPropertyType propertyType,
            EPropertySituation propertySituation)
        {
            LowestPrice       = lowestPrice;
            MaximumPrice      = maximumPrice;
            Bedroom           = bedroom;
            State             = state;
            City              = city;
            Neighborhood      = neighborhood;
            PropertyType      = propertyType;
            PropertySituation = propertySituation;

            AddNotifications(new Contract()
                             .Requires()
                             .IsNotNullOrEmpty(City, "Intention.City", "Cidade deve ser preenchido.")
                             .HasMaxLen(City, 50, "Intention.City", "Cidade excedeu o tamanho máximo.")
                             .IsNotNullOrEmpty(Neighborhood, "Intention.Neighborhood", "Bairro deve ser preenchido.")
                             .HasMaxLen(Neighborhood, 50, "Intention.Neighborhood", "Bairro  excedeu o tamanho máximo.")
                             .IsGreaterThan(MaximumPrice, LowestPrice, "Intention.LowestPrice", "Preço minímo não pode ser maior que preço máximo."));
        }
Пример #2
0
 public PropertyDescriptor(string text, EPropertyType type, object propObject, Action <object> changedCallback)
 {
     Text            = text;
     Type            = type;
     PropObject      = propObject;
     ChangedCallback = changedCallback;
 }
Пример #3
0
        /// <summary>
        /// Change properties of other controls based on the selection.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if ((!(sender is ComboBox combo)) ||
                !this.IsLoaded)
            {
                return;
            }

            EPropertyType type = (EPropertyType)combo.SelectedIndex;

            MessageBoxResult result = MessageBox.Show("This may remove property values.\nDo you wish to continue?", "Caution", MessageBoxButton.YesNoCancel);

            if (result == MessageBoxResult.Yes)
            {
                UpdateUI(type);
            }
        }
Пример #4
0
 public CreateIntentionCommand(
     Guid prospectId,
     decimal?rent,
     decimal lowestPrice,
     decimal maximumPrice,
     int bedroom,
     EState state,
     string city,
     string neighborhood,
     EPropertyType propertyType,
     EPropertySituation propertySituation)
 {
     ProspectId        = prospectId;
     Rent              = rent;
     LowestPrice       = lowestPrice;
     MaximumPrice      = maximumPrice;
     Bedroom           = bedroom;
     State             = state;
     City              = city;
     Neighborhood      = neighborhood;
     PropertyType      = propertyType;
     PropertySituation = propertySituation;
 }
 private void AddSt(ILProcessor processor, List <Instruction> instructions,
                    ParameterDefinition param, FieldDefinition field, VariableDefinition var, EPropertyType typeCode)
 {
     if (param != null)
     {
         if (param.IsOut || param.ParameterType.IsByReference)
         {
             // Parameter is ref/out, use the appropriate st opcode
             instructions.Add(CreateStRefOutParam(processor, param, typeCode));
         }
         else
         {
             instructions.Add(processor.Create(OpCodes.Starg, param));
         }
     }
     else if (field != null)
     {
         instructions.Add(processor.Create(OpCodes.Stfld, field));
     }
     else if (var != null)
     {
         instructions.Add(processor.Create(OpCodes.Stloc, var));
     }
 }
        private MethodReference GetToNativeMarshaler(ManagedUnrealMarshalerType marshalerType,
                                                     EPropertyType typeCode, string typePath,
                                                     EPropertyType arg1TypeCode = EPropertyType.Unknown, string arg1TypePath = null,
                                                     EPropertyType arg2TypeCode = EPropertyType.Unknown, string arg2TypePath = null)
        {
            ManagedUnrealMarshalerInfo marshalerInfo = new ManagedUnrealMarshalerInfo(
                typeCode, typePath, arg1TypeCode, arg1TypePath, arg2TypeCode, arg2TypePath, marshalerType);

            MethodReference method;

            if (toNativeMarshalers.TryGetValue(marshalerInfo, out method))
            {
                return(method);
            }

            int paramCount = marshalerToNativeParamCountMin;

            if (!codeSettings.MinimalMarshalingParams || ManagedUnrealTypeInfo.MarshalerRequiresNativePropertyField(typeCode))
            {
                paramCount = marshalerToNativeParamCount;
            }

            Type type = ManagedUnrealTypeInfo.GetTypeFromMarshalerInfo(marshalerInfo);

            if (type != null)
            {
                if (typeCode == EPropertyType.Struct && !type.IsGenericType)
                {
                    // Struct marshaling methods are generated, find the existing type by path
                    TypeDefinition typeDef = typeDef = assembly.MainModule.GetType(type.FullName);

                    foreach (MethodDefinition methodDef in typeDef.Methods)
                    {
                        if (methodDef.Name == "ToNative" && methodDef.IsPublic && methodDef.IsStatic && methodDef.Parameters.Count == paramCount)
                        {
                            method = methodDef;
                            break;
                        }
                    }
                }
                else
                {
                    foreach (System.Reflection.MethodInfo methodInfo in type.GetMethods())
                    {
                        if (methodInfo.Name == "ToNative" && methodInfo.IsPublic && methodInfo.GetParameters().Length == paramCount &&
                            (methodInfo.IsStatic || ManagedUnrealTypeInfo.IsCollectionType(typeCode)))
                        {
                            method = assembly.MainModule.ImportEx(methodInfo);
                            break;
                        }
                    }
                }
            }

            if (method != null)
            {
                toNativeMarshalers.Add(marshalerInfo, method);
            }

            if (method == null)
            {
                throw new RewriteException(typePath, "Failed to get ToNative marshaler");
            }

            return(method);
        }
        private Instruction[] CreateSetDefaultValue(ILProcessor processor, EPropertyType typeCode,
                                                    ParameterDefinition param, FieldDefinition field, VariableDefinition var)
        {
            List <Instruction> instructions = new List <Instruction>();

            switch (typeCode)
            {
            case EPropertyType.Bool:
            case EPropertyType.Int8:
            case EPropertyType.Byte:
            case EPropertyType.Int:
            case EPropertyType.UInt32:
            case EPropertyType.Int16:
            case EPropertyType.UInt16:
            case EPropertyType.Enum:
                AddLdArgIfRefOrOut(processor, instructions, param);
                instructions.Add(processor.Create(OpCodes.Ldc_I4_0));
                AddSt(processor, instructions, param, field, var, typeCode);
                break;

            case EPropertyType.Int64:
            case EPropertyType.UInt64:
                AddLdArgIfRefOrOut(processor, instructions, param);
                instructions.Add(processor.Create(OpCodes.Ldc_I4_0));
                instructions.Add(processor.Create(OpCodes.Conv_I8));
                AddSt(processor, instructions, param, field, var, typeCode);
                break;

            case EPropertyType.Float:
                AddLdArgIfRefOrOut(processor, instructions, param);
                instructions.Add(processor.Create(OpCodes.Ldc_R4, 0.0f));
                AddSt(processor, instructions, param, field, var, typeCode);
                break;

            case EPropertyType.Double:
                AddLdArgIfRefOrOut(processor, instructions, param);
                instructions.Add(processor.Create(OpCodes.Ldc_R8, 0.0));
                AddSt(processor, instructions, param, field, var, typeCode);
                break;

            case EPropertyType.Struct:
                AddLda(processor, instructions, param, field, var);
                AddInitObj(processor, instructions, param, field, var);
                break;

            case EPropertyType.LazyObject:
            case EPropertyType.WeakObject:
            case EPropertyType.SoftClass:
            case EPropertyType.SoftObject:
            case EPropertyType.Class:
                // Assumes these are all struct types
                AddLda(processor, instructions, param, field, var);
                AddInitObj(processor, instructions, param, field, var);
                break;

            default:
                AddLdArgIfRefOrOut(processor, instructions, param);
                instructions.Add(processor.Create(OpCodes.Ldnull));
                AddSt(processor, instructions, param, field, var, typeCode);
                break;
            }
            return(instructions.ToArray());
        }
Пример #8
0
 private IntPtr CreateProperty(IntPtr outer, Type type, string propertyName, EPropertyType propertyType)
 {
     return(CreateProperty(outer, type, propertyName, propertyType, EPropertyType.Unknown, EPropertyType.Unknown));
 }
Пример #9
0
        private void UpdateUI(EPropertyType type)
        {
            switch (type)
            {
            case EPropertyType.CheckBox:
                values.IsEnabled = false;
                PropertyItem.Values.Clear();
                PropertyItem.Values.Add("True");
                PropertyItem.Values.Add("False");
                values.SelectedItem = null;
                value.IsEnabled     = false;
                PropertyItem.Regex  = "[True|False]";
                add.IsEnabled       = false;
                delete.IsEnabled    = false;
                break;

            case EPropertyType.ComboBox:
                if (PropertyItem?.Type.EPropertyType == EPropertyType.CheckBox)
                {
                    PropertyItem.Values.Clear();
                    PropertyItem.Regex = ".*";
                }

                values.IsEnabled = true;
                value.IsEnabled  = true;
                add.IsEnabled    = true;
                delete.IsEnabled = true;

                break;

            case EPropertyType.ComboBoxEdit:
                if (PropertyItem?.Type.EPropertyType == EPropertyType.CheckBox)
                {
                    PropertyItem.Values.Clear();
                    PropertyItem.Regex = ".*";
                }

                values.IsEnabled = true;
                value.IsEnabled  = true;
                add.IsEnabled    = true;
                delete.IsEnabled = true;

                break;

            case EPropertyType.TextBox:
                if (PropertyItem?.Type.EPropertyType == EPropertyType.CheckBox)
                {
                    PropertyItem.Values.Clear();
                    PropertyItem.Regex = ".*";
                }

                if ((PropertyItem?.Type.EPropertyType == EPropertyType.TextBox) &&
                    PropertyItem.Values.Count == 0)
                {
                    add.IsEnabled = true;
                }
                else
                {
                    add.IsEnabled = false;
                }

                values.IsEnabled = true;
                value.IsEnabled  = true;
                delete.IsEnabled = true;

                break;

            default:
                break;
            }
        }
Пример #10
0
        public bool Update(IntPtr address)
        {
            if (Address != address)
            {
                Address             = address;
                Size                = 0;
                ArrayDim            = 0;
                IsEditConst         = false;
                IsBlueprintReadOnly = false;
                GenericArg1Address  = IntPtr.Zero;
                GenericArg1Size     = 0;
                GenericArg1ArrayDim = 0;
                GenericArg2Address  = IntPtr.Zero;
                GenericArg2Size     = 0;
                GenericArg2ArrayDim = 0;
                PropertyType        = EPropertyType.Unknown;

                if (address == IntPtr.Zero)
                {
                    return(true);
                }

                EPropertyType propertyType = NativeReflection.GetPropertyType(address);
                if (propertyType != EPropertyType.Unknown)
                {
                    PropertyType = propertyType;

                    Size     = Native_UProperty.Get_ElementSize(address);
                    ArrayDim = Native_UProperty.Get_ArrayDim(address);

                    IsEditConst         = Native_UProperty.HasAnyPropertyFlags(address, EPropertyFlags.EditConst);
                    IsBlueprintReadOnly = Native_UProperty.HasAnyPropertyFlags(address, EPropertyFlags.BlueprintReadOnly);

                    switch (propertyType)
                    {
                    case EPropertyType.Array:
                        GenericArg1Address = Native_UArrayProperty.Get_Inner(address);
                        if (GenericArg1Address != IntPtr.Zero)
                        {
                            GenericArg1Size     = Native_UProperty.Get_ElementSize(GenericArg1Address);
                            GenericArg1ArrayDim = Native_UProperty.Get_ArrayDim(GenericArg1Address);
                        }
                        break;

                    case EPropertyType.Map:
                        GenericArg1Address = Native_UMapProperty.Get_KeyProp(address);
                        if (GenericArg1Address != IntPtr.Zero)
                        {
                            GenericArg1Size     = Native_UProperty.Get_ElementSize(GenericArg1Address);
                            GenericArg1ArrayDim = Native_UProperty.Get_ArrayDim(GenericArg1Address);
                        }
                        GenericArg2Address = Native_UMapProperty.Get_ValueProp(address);
                        if (GenericArg2Address != IntPtr.Zero)
                        {
                            GenericArg2Size     = Native_UProperty.Get_ElementSize(GenericArg2Address);
                            GenericArg2ArrayDim = Native_UProperty.Get_ArrayDim(GenericArg2Address);
                        }
                        break;

                    case EPropertyType.Set:
                        GenericArg1Address = Native_USetProperty.Get_ElementProp(address);
                        if (GenericArg1Address != IntPtr.Zero)
                        {
                            GenericArg1Size     = Native_UProperty.Get_ElementSize(GenericArg1Address);
                            GenericArg1ArrayDim = Native_UProperty.Get_ArrayDim(GenericArg1Address);
                        }
                        break;
                    }
                }

                return(true);
            }
            return(false);
        }
Пример #11
0
 public UnrealMarshalerTypeNotFoundException(EPropertyType typeCode, string typePath)
     : base("Failed to find type path for marshaler " + typeCode + " " + typePath)
 {
 }
        /// <summary>
        /// Creates a st opcode for a ref/out param taking what is currently on the stack
        /// </summary>
        private Instruction CreateStRefOutParam(ILProcessor processor, ParameterDefinition param, EPropertyType paramTypeCode)
        {
            switch (paramTypeCode)
            {
            case EPropertyType.Enum:
                return(CreateStRefOutParam(processor, null,
                                           GetPrimitiveTypeCode(param.ParameterType.Resolve().GetEnumUnderlyingType())));

            case EPropertyType.Bool:
            case EPropertyType.Int8:
            case EPropertyType.Byte:
                return(processor.Create(OpCodes.Stind_I1));

            case EPropertyType.Int16:
            case EPropertyType.UInt16:
                return(processor.Create(OpCodes.Stind_I2));

            case EPropertyType.Int:
            case EPropertyType.UInt32:
                return(processor.Create(OpCodes.Stind_I4));

            case EPropertyType.Int64:
            case EPropertyType.UInt64:
                return(processor.Create(OpCodes.Stind_I8));

            case EPropertyType.Float:
                return(processor.Create(OpCodes.Stind_R4));

            case EPropertyType.Double:
                return(processor.Create(OpCodes.Stind_R8));

            case EPropertyType.Struct:
                Debug.Assert(!param.ParameterType.IsValueType);    // Should be a ref to a struct
                return(processor.Create(OpCodes.Stobj, param.ParameterType.GetElementType()));

            case EPropertyType.LazyObject:
            case EPropertyType.WeakObject:
            case EPropertyType.SoftClass:
            case EPropertyType.SoftObject:
            case EPropertyType.Class:
                // Assumes these are all struct types
                Debug.Assert(!param.ParameterType.IsValueType);    // Should be a ref to a struct
                return(processor.Create(OpCodes.Stobj, param.ParameterType.GetElementType()));

            case EPropertyType.Delegate:
            case EPropertyType.MulticastDelegate:
                // Delegate/multicast delegates in C# are implemented as classes, use Stind_Ref
                return(processor.Create(OpCodes.Stind_Ref));

            case EPropertyType.InternalManagedFixedSizeArray:
            case EPropertyType.InternalNativeFixedSizeArray:
                throw new NotImplementedException();    // Fixed size arrays not supported as args

            case EPropertyType.Array:
            case EPropertyType.Set:
            case EPropertyType.Map:
                // Assumes this will be always be an object (IList, List, ISet, HashSet, IDictionary, Dictionary)
                return(processor.Create(OpCodes.Stind_Ref));

            default:
                return(processor.Create(OpCodes.Stind_Ref));
            }
        }
 private Instruction[] CreateSetDefaultValue(ILProcessor processor, EPropertyType typeCode, FieldDefinition field)
 {
     return(CreateSetDefaultValue(processor, typeCode, null, field, null));
 }
        internal void RemoveHeader(string stHeaderName, EPropertyType prop = EPropertyType.XHdrProp)
        {
            _Log.DebugFormat("RemoveHader(): Removing '{0}' for mail: {1}", stHeaderName, _mail.Message.Subject);

            try
            {
                MimePart tnefPart = _mail.Message.TnefPart;
                MimeDocument mdMimeDoc = _mail.Message.MimeDocument;
                HeaderList hlHeaderlist = mdMimeDoc.RootPart.Headers;
                _Log.DebugFormat("RemoveHader(): Tnef null: {0}, mimedoc null: {1}, header list: {2}", tnefPart == null, mdMimeDoc == null, hlHeaderlist == null);


                Header hdr = hlHeaderlist.FindFirst(stHeaderName);
                _Log.DebugFormat("RemoveHader(): {0} header found: {1}", stHeaderName, hdr != null);

                if (hdr != null)
                {
                    MimeNode hdrRemoved = hlHeaderlist.RemoveChild(hdr);
                    _Log.DebugFormat("RemoveHader(): Header removed: {0}", hdrRemoved != null);
                }
            }
            catch (Exception x)
            {
                _Log.ErrorFormat("RemoveHader(): Error - {0}", x.ToString());
            }

            _Log.DebugFormat("RemoveHader(): Removed {0} for mail {1}", stHeaderName, _mail.Message.Subject);
        }
        internal void SetProperty(string stPropName, string stPropVal, EPropertyType eProp = EPropertyType.XHdrProp)
        {
            _Log.DebugFormat("SetProperty() Setting property {0} - {1} for mail {2}", stPropName, stPropVal, _mail.Message.Subject);
            try
            {
                MimePart tnefPart = _mail.Message.TnefPart;
                MimeDocument mdMimeDoc = _mail.Message.MimeDocument;
                HeaderList hlHeaderlist = mdMimeDoc.RootPart.Headers;
                _Log.DebugFormat("SetHeader(): Tnef null: {0}, mimedoc null: {1}, header list: {2}", tnefPart == null, mdMimeDoc == null, hlHeaderlist == null);

                Header hdrToInsert = hlHeaderlist.FindFirst(stPropName);
                if (hdrToInsert == null)
                {
                    _Log.DebugFormat("SetProperty(): Header does not exist. Inserting new.");
                    TextHeader nhNewKeywords = new TextHeader(stPropName, stPropVal);
                    MimeNode lhLasterHeader = hlHeaderlist.LastChild;
                    MimeNode hdrNew = hlHeaderlist.InsertBefore(nhNewKeywords, lhLasterHeader);

                    _Log.DebugFormat("SetProperty(): Header inserted: {0}", hdrNew == null);
                }
                else
                {
                    _Log.DebugFormat("SetProperty(): Header exists. Updating value");
                    hdrToInsert.Value = stPropVal;
                }
            }
            catch (Exception x)
            {
                _Log.ErrorFormat("SetProperty(): Error - {0}", x.ToString());
            }
            _Log.DebugFormat("SetProperty() Set property '{0} - {1}' for mail: {2}", stPropName, stPropVal, _mail.Message.Subject);
        }
Пример #16
0
        private IntPtr CreateProperty(IntPtr outer, Type type, string propertyName, EPropertyType propertyType,
                                      EPropertyType innerPropertyType1, EPropertyType innerPropertyType2)
        {
            propertyType = ManagedUnrealTypes.GetPropertyType(type, propertyType);

            IntPtr propertyClass = ManagedUnrealTypes.GetPropertyClass(propertyType);

            if (propertyClass == IntPtr.Zero)
            {
                return(IntPtr.Zero);
            }

            EObjectFlags objectFlags = EObjectFlags.Public | EObjectFlags.Transient | EObjectFlags.MarkAsNative;
            IntPtr       property    = NativeReflection.NewObject(outer, propertyClass, new FName(propertyName), objectFlags);

            Native_UProperty.SetPropertyFlags(property, EPropertyFlags.BlueprintVisible | EPropertyFlags.BlueprintAssignable | EPropertyFlags.Edit);

            // Set type specific information
            switch (propertyType)
            {
            case EPropertyType.Array:
                if (!firstRun)
                {
                    Native_UArrayProperty.Set_Inner(property,
                                                    CreateProperty(property, typeof(int), propertyName, innerPropertyType1));
                }
                else
                {
                    Native_UArrayProperty.Set_Inner(property,
                                                    CreateProperty(property, type.GenericTypeArguments[0], propertyName, innerPropertyType1));
                }
                break;

            case EPropertyType.Set:
                Native_USetProperty.Set_ElementProp(property,
                                                    CreateProperty(property, type.GenericTypeArguments[0], propertyName, innerPropertyType1));
                break;

            case EPropertyType.Map:
                Native_UMapProperty.Set_KeyProp(property,
                                                CreateProperty(property, type.GenericTypeArguments[0], propertyName, innerPropertyType1));
                Native_UMapProperty.Set_ValueProp(property,
                                                  CreateProperty(property, type.GenericTypeArguments[1], propertyName, innerPropertyType2));
                break;

            case EPropertyType.Class:
                Native_UClassProperty.SetMetaClass(property, UClass.GetClass(type.GenericTypeArguments[0]).Address);
                break;

            case EPropertyType.Object:
                var v1 = ManagedUnrealTypes.GetStaticClass(type);
                var v2 = ManagedUnrealTypes.GetStaticClass(typeof(UObject));
                Native_UObjectPropertyBase.SetPropertyClass(property, v1 == IntPtr.Zero ? v2 : v1);
                break;

            case EPropertyType.LazyObject:
            case EPropertyType.WeakObject:
            case EPropertyType.SoftObject:
                Native_UObjectPropertyBase.SetPropertyClass(property, UClass.GetClass(type.GenericTypeArguments[0]).Address);
                break;

            case EPropertyType.SoftClass:
                Native_USoftClassProperty.SetMetaClass(property, UClass.GetClass(type.GenericTypeArguments[0]).Address);
                break;

            case EPropertyType.Enum:
                Native_UEnumProperty.SetEnum(property, ManagedUnrealTypes.GetEnum(type));
                break;

            case EPropertyType.Delegate:
                //Native_UDelegateProperty.Set_SignatureFunction(property, ManagedUnrealTypes.GetSignatureFunction(type));
                break;

            case EPropertyType.MulticastDelegate:
                //Native_UMulticastDelegateProperty.Set_SignatureFunction(property, ManagedUnrealTypes.GetSignatureFunction(type));
                break;
            }

            Native_UField.AddCppProperty(outer, property);

            return(property);
        }
Пример #17
0
 public Property(string name, object val)
 {
     m_name  = name;
     m_type  = EPropertyType.EPropertyType_Object;
     m_value = val;
 }
Пример #18
0
 public Property(string name)
 {
     m_name  = name;
     m_type  = EPropertyType.EPropertyType_Object;
     m_value = null;
 }
 private void EmitSetDefaultValue(ILProcessor processor, EPropertyType typeCode, ParameterDefinition param)
 {
     AppendInstructions(processor, CreateSetDefaultValue(processor, typeCode, param));
 }
Пример #20
0
 public static EPropertyType GetPropertyType(Type type, EPropertyType predefinedType)
 {
     return(predefinedType != EPropertyType.Unknown ? predefinedType : GetPropertyType(type));
 }
 private void EmitSetDefaultValue(ILProcessor processor, EPropertyType typeCode, VariableDefinition var)
 {
     AppendInstructions(processor, CreateSetDefaultValue(processor, typeCode, var));
 }
Пример #22
0
 public USharpPathAttribute(string path, EPropertyType propertyType)
 {
     Path         = path;
     PropertyType = propertyType;
 }
 private Instruction[] CreateSetDefaultValue(ILProcessor processor, EPropertyType typeCode, ParameterDefinition param)
 {
     return(CreateSetDefaultValue(processor, typeCode, param, null, null));
 }
Пример #24
0
 public UnrealTypeNotFoundException(EPropertyType typeCode, string typePath)
     : base("Failed to find path for " + typeCode + " " + typePath)
 {
 }
 private Instruction[] CreateSetDefaultValue(ILProcessor processor, EPropertyType typeCode, VariableDefinition var)
 {
     return(CreateSetDefaultValue(processor, typeCode, null, null, var));
 }
Пример #26
0
        public static IntPtr GetPropertyClass(EPropertyType propertyType)
        {
            switch (propertyType)
            {
            case EPropertyType.Bool: return(Native_UBoolProperty.StaticClass());

            case EPropertyType.Int8: return(Native_UInt8Property.StaticClass());

            case EPropertyType.Int16: return(Native_UInt16Property.StaticClass());

            case EPropertyType.Int: return(Native_UIntProperty.StaticClass());

            case EPropertyType.Int64: return(Native_UInt64Property.StaticClass());

            case EPropertyType.Byte: return(Native_UByteProperty.StaticClass());

            case EPropertyType.UInt16: return(Native_UUInt16Property.StaticClass());

            case EPropertyType.UInt32: return(Native_UUInt32Property.StaticClass());

            case EPropertyType.UInt64: return(Native_UUInt64Property.StaticClass());

            case EPropertyType.Double: return(Native_UDoubleProperty.StaticClass());

            case EPropertyType.Float: return(Native_UFloatProperty.StaticClass());

            case EPropertyType.Enum: return(Native_UEnumProperty.StaticClass());

            case EPropertyType.Interface: return(Native_UInterfaceProperty.StaticClass());

            case EPropertyType.Struct: return(Native_UStructProperty.StaticClass());

            case EPropertyType.Class: return(Native_UClassProperty.StaticClass());

            case EPropertyType.Object: return(Native_UObjectProperty.StaticClass());

            case EPropertyType.LazyObject: return(Native_ULazyObjectProperty.StaticClass());

            case EPropertyType.WeakObject: return(Native_UWeakObjectProperty.StaticClass());

            case EPropertyType.SoftClass: return(Native_USoftClassProperty.StaticClass());

            case EPropertyType.SoftObject: return(Native_USoftObjectProperty.StaticClass());

            case EPropertyType.Delegate: return(Native_UDelegateProperty.StaticClass());

            case EPropertyType.MulticastDelegate: return(Native_UMulticastDelegateProperty.StaticClass());

            case EPropertyType.Array: return(Native_UArrayProperty.StaticClass());

            case EPropertyType.Map: return(Native_UMapProperty.StaticClass());

            case EPropertyType.Set: return(Native_USetProperty.StaticClass());

            case EPropertyType.Str: return(Native_UStrProperty.StaticClass());

            case EPropertyType.Name: return(Native_UNameProperty.StaticClass());

            case EPropertyType.Text: return(Native_UTextProperty.StaticClass());

            default: return(IntPtr.Zero);
            }
        }