Beispiel #1
0
        public static async Task <bool> ComparePropertyLess(GenericTypes.UEProperty lhs, GenericTypes.UEProperty rhs)
        {
            var offsetL         = lhs.GetOffset();
            var offsetR         = rhs.GetOffset();
            var isBoolPropertyL = lhs.IsA <GenericTypes.UEBoolProperty>();
            var isBoolPropertyR = rhs.IsA <GenericTypes.UEBoolProperty>();

            if (await offsetL == await offsetR &&
                await isBoolPropertyL &&
                await isBoolPropertyR)
            {
                return(lhs.Cast <GenericTypes.UEBoolProperty>() < rhs.Cast <GenericTypes.UEBoolProperty>());
            }

            return(await offsetL < await offsetR);
        }
Beispiel #2
0
        /// <summary>
        /// Checks and generates the prerequisites of the members.
        /// </summary>
        /// <param name="first">The first member in the chain.</param>
        /// <returns>Return Processed Objects</returns>
        private async Task GenerateMemberPrerequisites(GenericTypes.UEProperty first)
        {
            for (GenericTypes.UEProperty prop = first; prop.IsValid(); prop = (await prop.GetNext()).Cast <GenericTypes.UEProperty>())
            {
                var info = await prop.GetInfo();

                switch (info.Type)
                {
                case GenericTypes.UEProperty.PropertyType.Primitive:
                    if (await prop.IsA <GenericTypes.UEByteProperty>())
                    {
                        var byteProperty = prop.Cast <GenericTypes.UEByteProperty>();
                        if (await byteProperty.IsEnum())
                        {
                            AddDependency(await(await byteProperty.GetEnum()).GetPackageObject());
                        }
                    }
                    else if (await prop.IsA <GenericTypes.UEEnumProperty>())
                    {
                        var enumProperty = prop.Cast <GenericTypes.UEEnumProperty>();
                        AddDependency(await(await enumProperty.GetEnum()).GetPackageObject());
                    }
                    break;

                case GenericTypes.UEProperty.PropertyType.CustomStruct:
                    await GeneratePrerequisites(await prop.Cast <GenericTypes.UEStructProperty>().GetStruct());

                    break;

                case GenericTypes.UEProperty.PropertyType.Container:
                    var innerProperties = new List <GenericTypes.UEProperty>();

                    if (await prop.IsA <GenericTypes.UEArrayProperty>())
                    {
                        innerProperties.Add(await prop.Cast <GenericTypes.UEArrayProperty>().GetInner());
                    }
                    else if (await prop.IsA <GenericTypes.UEMapProperty>())
                    {
                        var mapProp = prop.Cast <GenericTypes.UEMapProperty>();
                        innerProperties.Add(await mapProp.GetKeyProperty());
                        innerProperties.Add(await mapProp.GetValueProperty());
                    }


                    foreach (var innerProp in innerProperties.Where(p => p.GetInfo().Result.Type == GenericTypes.UEProperty.PropertyType.CustomStruct))
                    {
                        await GeneratePrerequisites(await innerProp.Cast <GenericTypes.UEStructProperty>().GetStruct());
                    }

                    break;

                // Not Need
                case GenericTypes.UEProperty.PropertyType.PredefinedStruct:
                case GenericTypes.UEProperty.PropertyType.Unknown:
                    break;

                default:
                    if (await prop.IsA <GenericTypes.UEFunction>())
                    {
                        var function = prop.Cast <GenericTypes.UEFunction>();
                        await GenerateMemberPrerequisites((await function.GetChildren()).Cast <GenericTypes.UEProperty>());
                    }
                    break;
                }
            }
        }