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));
}
