IEnumeration IDeclarationContext.FindEnumWithItem(string Name) { var foundEnumIt = Enums.FirstOrDefault(_enum => _enum.FindItemByName(Name) != null); if (foundEnumIt != null) { return(foundEnumIt); } foreach (var it in Namespaces) { var foundEnum = it.FindEnumWithItem(Name); if (foundEnum != null) { return(foundEnum); } } foreach (var it in Classes) { var foundEnum = it.FindEnumWithItem(Name); if (foundEnum != null) { return(foundEnum); } } return(null); }
public Enumeration FindEnum(string name, bool createDecl = false) { var entries = name.Split(new string[] { "::" }, StringSplitOptions.RemoveEmptyEntries).ToList(); if (entries.Count <= 1) { var @enum = Enums.FirstOrDefault(e => e.Name.Equals(name)); if (@enum == null && createDecl) { @enum = new Enumeration() { Name = name, Namespace = this }; Declarations.Add(@enum); } return(@enum); } var enumName = entries[entries.Count - 1]; var namespaces = entries.Take(entries.Count - 1); var @namespace = FindNamespace(namespaces); if (@namespace == null) { return(null); } return(@namespace.FindEnum(enumName, createDecl)); }
public Enumeration FindEnumWithItem(string name) { return(Enums.FirstOrDefault(e => e.ItemsByName.ContainsKey(name)) ?? (from declContext in Namespaces.Union <DeclarationContext>(Classes) let @enum = declContext.FindEnumWithItem(name) where @enum != null select @enum).FirstOrDefault()); }
IEnumeration IDeclarationContext.FindEnum(string Name, bool Create) { var entries = Name.Split(new[] { "::" }, StringSplitOptions.None); if (entries.Length == 1) { var foundEnum = Enums.FirstOrDefault((e) => e.Name == Name); if (foundEnum != null) { return(foundEnum); } if (!Create) { return(null); } var _enum = new Enumeration(); _enum.Name = Name; _enum.Namespace = this; Enums.Add(_enum); return(_enum); } var enumName = entries[entries.Length - 1]; var namespaces = new string[entries.Length - 1]; for (int i = 0; i < namespaces.Length; i++) { namespaces[i] = entries[i]; } var _namespace = FindNamespace(namespaces); if (_namespace == null) { return(null); } return(_namespace.FindEnum(enumName, Create)); }
private void WaitMessage() { while (true) { using (_pipe = new NamedPipeClientStream(".", PipeName, PipeDirection.InOut)) { //I do not know how abort Connect method try { _pipe.Connect(1000); using (var reader = new StreamReader(_pipe)) { string message = reader.ReadToEnd(); string enumString = Enums.FirstOrDefault(message.StartsWith); if (!string.IsNullOrEmpty(enumString)) { message = message.Substring(enumString.Length); SpecificMessageRecived((SpecificMessageId)Enum.Parse(typeof(SpecificMessageId), enumString), message); } else { MessageRecived(message); } } } catch (TimeoutException) { Debug.WriteLine("Pipe client timeout exception"); } } if (_aborted) { _pipe = null; _aborted = false; Aborted(); break; } } }
public Enumeration FindEnum(IntPtr ptr) { return(Enums.FirstOrDefault(f => f.OriginalPtr == ptr)); }
public IEnumerable <Card> FilterCards(CardSearchFilters filters) { if (filters == null) { UnityEngine.Debug.LogWarning("FilterCards::NullFilters"); yield break; } foreach (Card card in Cards.Values) { if (!string.IsNullOrEmpty(filters.Name) && !filters.Name.ToLower().Split(' ').All(card.Name.ToLower().Contains)) { continue; } if (!string.IsNullOrEmpty(filters.Id) && !card.Id.ToLower().Contains(filters.Id.ToLower())) { continue; } if (!string.IsNullOrEmpty(filters.SetCode) && !card.SetCode.ToLower().Contains(filters.SetCode.ToLower())) { continue; } bool propsMatch = true; foreach (KeyValuePair <string, string> entry in filters.StringProperties) { if (!card.GetPropertyValueString(entry.Key).ToLower().Contains(entry.Value.ToLower())) { propsMatch = false; } } foreach (KeyValuePair <string, int> entry in filters.IntMinProperties) { if (card.GetPropertyValueInt(entry.Key) < entry.Value) { propsMatch = false; } } foreach (KeyValuePair <string, int> entry in filters.IntMaxProperties) { if (card.GetPropertyValueInt(entry.Key) > entry.Value) { propsMatch = false; } } foreach (KeyValuePair <string, int> entry in filters.EnumProperties) { EnumDef enumDef = Enums.FirstOrDefault(def => def.Property.Equals(entry.Key)); if (enumDef == null) { propsMatch = false; continue; } if ((card.GetPropertyValueEnum(entry.Key) & entry.Value) == 0) { propsMatch = propsMatch && (entry.Value == (1 << enumDef.Values.Count)) && CardProperties.FirstOrDefault(prop => prop.Name.Equals(entry.Key)).Empty.Equals(card.GetPropertyValueString(entry.Key)); } } if (propsMatch) { yield return(card); } } }
/// <summary> /// 查找枚举对象 /// </summary> /// <param name="func"></param> /// <returns></returns> public static EnumConfig Find(Func <EnumConfig, bool> func) { return(Enums.FirstOrDefault(func)); }
/// <summary> /// 取得枚举对象 /// </summary> /// <param name="name"></param> /// <returns></returns> public static EnumConfig GetEnum(string name) { return(Enums.FirstOrDefault(p => p.Name == name)); }
/********* ** Public Methods *********/ /// <summary>Constructs an instance.</summary> /// <param name="specificationDocument">The <see cref="XDocument"/> with the vulkan specification loaded.</param> public VulkanSpecification(XDocument specificationDocument) { var registry = specificationDocument.Element("registry"); var types = registry !.Elements("types"); // typedefs var typedefs = types.Elements("type") .Where(element => element.Value.StartsWith("typedef") && (element.HasAttributeWithValue("category", "bitmask") || element.HasAttributeWithValue("category", "basetype"))) .Select(typedefElement => new TypedefInfo(typedefElement)) .ToList(); // remove typedefs that have a C# type manually created for them var definedBaseTypes = new List <string> { "VkBool32", "VkDeviceSize", "VkDeviceAddress" }; typedefs.RemoveAll(typedef => definedBaseTypes.Contains(typedef.Name)); // enum aliases var enumAliases = types.Elements("type") .Where(element => element.Attribute("alias") != null && (element.HasAttributeWithValue("category", "enum") || element.HasAttributeWithValue("category", "bitmask"))) .ToDictionary(element => element.Attribute("name") !.Value, element => element.Attribute("alias") !.Value); var typeConverter = new TypeConverter(typedefs, enumAliases); // extensions var supportedPlatforms = new[] { "win32", "macos", "xlib", "android" }; var allExtensions = registry.Element("extensions") !.Elements("extension") .Select(extensionElement => new ExtensionInfo(extensionElement, typeConverter)) .Where(extensionInfo => extensionInfo.Supported != "disabled") .ToList(); var supportedExtensions = allExtensions .Where(extensionInfo => extensionInfo.Platform == null || supportedPlatforms.Contains(extensionInfo.Platform)) .ToList(); // constants Constants = registry.Elements("enums").Single(element => element.Attribute("name") !.Value == "API Constants").Elements("enum") .Select(constantElement => new ConstantInfo(constantElement)) // ensure the constant isn't added by an unsupported extension .Where(constantInfo => !allExtensions.Any(extensionInfo => extensionInfo.Constants.Select(extensionConstantInfo => extensionConstantInfo.Name).Contains(constantInfo.Name)) || supportedExtensions.Any(extensionInfo => extensionInfo.Constants.Select(extensionConstantInfo => extensionConstantInfo.Name).Contains(constantInfo.Name))) .ToList(); // enums Enums = registry.Elements("enums").Where(element => element.Attribute("name") !.Value != "API Constants") .Select(enumsElement => new EnumInfo(enumsElement, typeConverter)) // ensure the enum isn't added by an unsupported extension .Where(enumInfo => !allExtensions.SelectMany(extensionInfo => extensionInfo.TypeNames).Contains(enumInfo.Name) || // ensure the enum isn't added by an unsupported extension supportedExtensions.SelectMany(extensionInfo => extensionInfo.TypeNames).Contains(enumInfo.Name)) .ToList(); // methods Commands = registry.Element("commands") !.Elements("command") .Select(commandElement => new CommandInfo(commandElement, typeConverter)) // ensure the function isn't added by an unsupported extension .Where(commandInfo => !allExtensions.SelectMany(extensionInfo => extensionInfo.CommandNames).Contains(commandInfo.Name) || supportedExtensions.SelectMany(extensionInfo => extensionInfo.CommandNames).Contains(commandInfo.Name)) .ToList(); foreach (var commandInfo in Commands) // set the parameters of aliased commands, this is used for overload creation { if (commandInfo.Alias != null) { commandInfo.Parameters.AddRange(Commands.Single(cInfo => cInfo.Name == commandInfo.Alias).Parameters); } } // delegates Delegates = types.Elements("type").Where(element => element.HasAttributeWithValue("category", "funcpointer")) .Select(delegateElement => new DelegateInfo(delegateElement, typeConverter)) .ToList(); // handles Handles = types.Elements("type").Where(element => element.HasAttributeWithValue("category", "handle")) .Select(handleElement => new HandleInfo(handleElement)) // ensure the handle isn't added by an unsupported extension .Where(handleInfo => !allExtensions.SelectMany(extensionInfo => extensionInfo.TypeNames).Contains(handleInfo.Name) || supportedExtensions.SelectMany(extensionInfo => extensionInfo.TypeNames).Contains(handleInfo.Name)) .ToList(); // structures Structures = types.Elements("type").Where(element => element.HasAttributeWithValue("category", "struct") || element.HasAttributeWithValue("category", "union")) .Select(structureElement => new StructureInfo(structureElement, typeConverter)) // ensure the structure isn't added by an unsupported extension .Where(structureInfo => !allExtensions.SelectMany(extensionInfo => extensionInfo.TypeNames).Contains(structureInfo.Name) || supportedExtensions.SelectMany(extensionInfo => extensionInfo.TypeNames).Contains(structureInfo.Name)) .ToList(); // add enums fields that are added in >1.0 Vulkan var featureElements = registry.Elements("feature").Where(featureElement => featureElement.Attribute("number")?.Value != "1.0"); // skip v1.0 as that doesn't add extensions foreach (var enumElement in featureElements.SelectMany(featureElement => featureElement.Elements("require")).SelectMany(requireElement => requireElement.Elements("enum"))) { var extensionNumberString = enumElement.Attribute("extnumber")?.Value; int?extensionNumber = null; if (extensionNumberString != null) { extensionNumber = int.Parse(extensionNumberString); } // ensure enum element isn't a constant (these can be ignored as they're already defined, in the spec it's just mentioning what version they got added which we don't care about) if (enumElement.Attribute("extends") == null) { continue; } var coreEnumExtension = new ExtensionEnumFieldInfo(extensionNumber, enumElement, typeConverter); var enumBeingExtended = Enums.Single(enumInfo => enumInfo.Name == coreEnumExtension.ExtendedType); enumBeingExtended.Values.Add(new EnumFieldInfo(enumBeingExtended.Name, coreEnumExtension.Name, coreEnumExtension.Value, coreEnumExtension.BitPosition, coreEnumExtension.Alias)); } // fix extension constants, in some cases extension constants are defined in the main header constants (if multiple extensions add that constant), this means neither a value nor alias // is defined on the constant were the extension defines the constant, we'll just remove these constants from the extensions foreach (var extensionInfo in supportedExtensions) { for (int i = 0; i < extensionInfo.Constants.Count; i++) { var constantInfo = extensionInfo.Constants[i]; if (constantInfo.Alias == null && constantInfo.Value == null) { var definedConstant = Constants.Single(cInfo => cInfo.Name == constantInfo.Name); definedConstant.Extensions.Add(extensionInfo.Name); extensionInfo.Constants.RemoveAt(i--); } } } // add everything added by extensions foreach (var extension in supportedExtensions) { // add constants and keep note that they were added by this extension (for documentation reasons) foreach (var constant in extension.Constants) { constant.Extensions.Add(extension.Name); Constants.Add(constant); } // add enum fields and keep note that they were added by this extension (for documentation reasons) foreach (var enumValue in extension.EnumExtensions) { var enumBeingExtended = Enums.Single(enumInfo => enumInfo.Name == enumValue.ExtendedType); enumBeingExtended.Values.Add(new EnumFieldInfo(enumBeingExtended.Name, enumValue.Name, enumValue.Value, enumValue.BitPosition, enumValue.Alias) { Extension = extension.Name }); } // keep note of which handles, enums, and structures this extension added (for documentation reasons) foreach (var typeName in extension.TypeNames) { var handleInfo = Handles.FirstOrDefault(handleInfo => handleInfo.Name == typeName); var enumInfo = Enums.FirstOrDefault(enumInfo => enumInfo.Name == typeName); var structureInfo = Structures.FirstOrDefault(structureInfo => structureInfo.Name == typeName); if (handleInfo != null) { handleInfo.Extension = extension.Name; } else if (enumInfo != null) { enumInfo.Extension = extension.Name; } else if (structureInfo != null) { structureInfo.Extension = extension.Name; } } // keep note of which functions this extension added (for documentation reasons) foreach (var commandName in extension.CommandNames) { var command = Commands.Single(commandInfo => commandInfo.Name == commandName); command.Extension = extension.Name; } } }
IEnumeration IDeclarationContext.FindEnum(IntPtr OriginalPtr) { return(Enums.FirstOrDefault(enumeration => enumeration.OriginalPtr == OriginalPtr)); }