public EnumDef AddEnum(string name, BaseType t)
{
if (!t.IsInteger())
{
throw new InvalidEnumArgumentException("Underlying enum type must be integral.");
}
var def = new EnumDef {
Name = name,
IsUnion = t == BaseType.UType,
TypeBuilder = this,
};
if (Enums.Add(name, def))
{
throw new Exception("enum already exists!");
}
def.UnderlyingType.BaseType = t;
def.UnderlyingType.EnumDef = def;
if (def.IsUnion)
{
def.Values.Add("NONE", new EnumVal {
Name = "NONE", Value = 0,
});
}
return(def);
}
static bool Crawl(Type type)
{
foreach (var member in type.GetEffectiveProperties())
{
var memberType = GetDefinableType(member.GetPropertyOrFieldType());
if (memberType == null || All.Contains(memberType))
{
continue;
}
if (memberType.IsEnum)
{
if (Enums.Lacks(memberType))
{
Enums.Add(memberType);
}
}
else
{
All.Add(memberType);
return(true);
}
}
return(false);
}
public void Build()
{
foreach (INamedTypeSymbol symbol in GetSymbolsForNativeApi())
{
if (symbol.TypeKind == TypeKind.Enum)
{
Enums.Add(symbol.Name, symbol);
continue;
}
if (IsRefCountedTypeSymbol(symbol))
{
RefCounted.Add(symbol.Name, symbol);
continue;
}
if (IsScopedTypeSymbol(symbol))
{
Scoped.Add(symbol.Name, symbol);
continue;
}
if (symbol.TypeKind != TypeKind.Struct)
{
continue;
}
if (IsSizedStruct(symbol))
{
Sized.Add(symbol.Name, symbol);
continue;
}
Simple.Add(symbol.Name, symbol);
}
}
private void AddEnum(ITypeDefinition enm, StringBuilder key)
{
if (enm.Namespace == "")
{
lock (Enums)
{
foreach (var typeArg in enm.TypeParameters)
{
foreach (var constraint in typeArg.DirectBaseTypes)
{
key.Append(constraint.Name);
}
}
if (Enums.ContainsKey(key.ToString()))
{
return;
}
Enums.Add(key.ToString(), new EnumProperties(enm));
}
}
else
{
AddNamespace(key, enm);
}
}
private void DetectElementsInFile(CodeElements elements)
{
foreach (CodeElement element in elements)
{
if (element is CodeClass)
{
Classes.Add(element as CodeClass);
}
if (element is CodeEnum)
{
Enums.Add(element as CodeEnum);
}
if (element is CodeStruct)
{
Structs.Add(element as CodeStruct);
}
if (element is CodeInterface)
{
Interfaces.Add(element as CodeInterface);
}
DetectElementsInFile(element.Children);
}
}
public Enumeration FindEnum(string name, bool createDecl = false)
{
var entries = name.Split(new string[] { "::" },
StringSplitOptions.RemoveEmptyEntries).ToList();
if (entries.Count <= 1)
{
var @enum = Enums.Find(e => e.Name.Equals(name));
if (@enum == null && createDecl)
{
@enum = new Enumeration()
{
Name = name, Namespace = this
};
Enums.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 override bool VisitEnumDeclaration([NotNull] JavaParser.EnumDeclarationContext context)
{
++EnumCounter;
Enums.Add(context.IDENTIFIER().GetText());
return(true);
}
private void ApplyGlVersion(GlVersion glVersion)
{
foreach (GlEnum glEnum in glVersion.AddedEnums)
{
if (!Enums.Contains(glEnum))
{
Enums.Add(glEnum);
}
}
foreach (GlFunction glFunction in glVersion.AddedFunctions)
{
if (!Functions.Contains(glFunction))
{
Functions.Add(glFunction);
}
}
if (HasProfiles)
{
if (Profile == GlProfile.Core)
{
ApplyCoreProfile(glVersion);
}
else if (Profile == GlProfile.Compatibility)
{
ApplyCompatibilityProfile(glVersion);
}
}
}
public PackageBuilder Enum(string name, Type type, Action <EnumBuilder> configure)
{
var enumBuilder = new EnumBuilder(Context, name, source: type);
configure(enumBuilder);
Enums.Add(enumBuilder);
return(this);
}
public void ImportCodeEnum <TEnum>(string enumName)
where TEnum : struct, IComparable, IFormattable, IConvertible
{
Contract.Requires(!string.IsNullOrEmpty(enumName));
Contract.Requires(Actions.Count == 0, "Why are you importing an Enum after the DB has been loaded?");
var script_enum = MegaloScriptEnum.ForEnum <TEnum>(enumName);
Enums.Add(script_enum);
}
/// <summary>
/// Creates an enum builder
/// </summary>
/// <param name="Name">Name of the enum</param>
/// <param name="EnumBaseType">Base type of the enum (defaults to int)</param>
/// <param name="Attributes">Attributes associated with the type</param>
/// <returns>An EnumBuilder class</returns>
public virtual EnumBuilder CreateEnum(string Name, Type EnumBaseType = null,
TypeAttributes Attributes = TypeAttributes.Public)
{
if (EnumBaseType == null)
{
EnumBaseType = typeof(int);
}
EnumBuilder ReturnValue = new EnumBuilder(this, Name, EnumBaseType, Attributes);
Enums.Add(ReturnValue);
return(ReturnValue);
}
/// <summary>
/// Creates an enum builder
/// </summary>
/// <param name="name">name of the enum</param>
/// <param name="enumBaseType">Base type of the enum (defaults to int)</param>
/// <param name="attributes">Attributes associated with the type</param>
/// <returns>An EnumBuilder class</returns>
public virtual EnumBuilder CreateEnum(string name, Type enumBaseType = null,
TypeAttributes attributes = TypeAttributes.Public)
{
if (enumBaseType == null)
{
enumBaseType = typeof(int);
}
var returnValue = new EnumBuilder(this, name, enumBaseType, attributes);
Enums.Add(returnValue);
return(returnValue);
}
private void ApplyCoreProfile(GlVersion glVersion)
{
foreach (GlEnum glEnum in glVersion.AddedCoreEnums)
{
if (!Enums.Contains(glEnum))
{
Enums.Add(glEnum);
}
}
Enums.RemoveAll(glEnum => glVersion.RemovedCoreEnums.Contains(glEnum));
Functions.RemoveAll(glFunction => glVersion.RemovedCoreFunctions.Contains(glFunction));
}
/// <summary>
/// Reads properties of "Enum" metadata objects
/// </summary>
/// <param name="connection"></param>
/// <param name="conf"></param>
/// <param name="ct"></param>
/// <returns></returns>
private async Task ReadEnumsAsync(DbConnection connection, BracketsFileNode conf, CancellationToken ct)
{
var objectGuids = GetMetadataObjectGuids(conf.GetNode(4, 1, 1, 17));
foreach (var objectGuid in objectGuids)
{
var objectInfo = BracketsFileParser.Parse(await GetStringConfigFileDataAsync(connection, objectGuid, ct));
var obj = ReadMetadataObject <OneSEnum>(objectInfo.GetNode(1, 5, 1), objectGuid);
Enums.Add(obj);
}
}
public void Merge(ProtoCollection proto)
{
foreach (var m in proto.Messages.Values)
{
Messages.Add(m.ProtoName, m);
m.Parent = this;
}
foreach (var e in proto.Enums.Values)
{
Enums.Add(e.ProtoName, e);
e.Parent = this;
}
}
public void Merge(ProtoCollection proto)
{
foreach (var m in proto.Messages.Values)
{
Messages.Add(m.ProtoName, m);
m.Parent = this;
}
foreach (var e in proto.Enums.Values)
{
Enums.Add(e.ProtoName, e);
e.Parent = this;
}
Comments = Comments == null ? proto.Comments : Comments + "\n" + proto.Comments;
}
private void AddEnumType(Type type)
{
if (!type.IsEnum)
{
throw new ArgumentOutOfRangeException(nameof(type));
}
if (Enums.ContainsKey(type.Name))
{
return;
}
Enums.Add(type.Name, Enum.GetNames(type));
}
public void AddEnum(TypeDefinition thingType)
{
if (Enums.All(e => e.FullName != thingType.FullName))
{
var conflictEnum = Enums.SingleOrDefault(e => e.Name == thingType.Name);
if (conflictEnum == null)
{
Enums.Add(thingType);
}
else
{
LogMessages[thingType.Name] = $"Enum [{thingType.Name}] of type [{thingType.FullName}] conflicts with [{conflictEnum.FullName}]";
}
}
}
/// <summary>
/// Handles updating the form to match the selected data model property
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void UpdateForm(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName != "SelectedDataModelProp")
{
return;
}
Operators.Clear();
Enums.Clear();
UserValueIsVisible = false;
EnumValueIsVisible = false;
switch (SelectedDataModelProp.Type)
{
case "Int32":
case "Single":
Operators.AddRange(_int32Operators);
UserValueIsVisible = true;
break;
case "Boolean":
Operators.AddRange(_boolOperators);
Enums.Add("True");
Enums.Add("False");
EnumValueIsVisible = true;
break;
case "String":
Operators.AddRange(_stringOperators);
UserValueIsVisible = true;
break;
default:
Operators.AddRange(_operators);
UserValueIsVisible = true;
break;
}
// Setup Enum selection if needed
if (SelectedDataModelProp.EnumValues != null)
{
Enums.AddRange(SelectedDataModelProp.EnumValues);
EnumValueIsVisible = true;
}
SelectedOperator = Operators.First();
}
/// <summary>
/// Merges another compilation model into this one.
/// </summary>
/// <param name="model">The model to merge from.</param>
public void Merge(CompilationModel model)
{
foreach (var item in model.Enums)
{
Enums.Add(item);
}
foreach (var item in model.Classes)
{
Classes.Add(item);
}
foreach (var item in model.GlobalStatements)
{
GlobalStatements.Add(item);
}
}
private void ApplyCompatibilityProfile(GlVersion glVersion)
{
foreach (GlEnum glEnum in glVersion.AddedCompatibilityEnums)
{
if (!Enums.Contains(glEnum))
{
Enums.Add(glEnum);
}
}
foreach (GlFunction glFunction in glVersion.AddedCompatibilityFunctions)
{
if (!Functions.Contains(glFunction))
{
Functions.Add(glFunction);
}
}
}
public void SetupPropertyInput()
{
Operators.Clear();
Enums.Clear();
switch (SelectedDataModelProp.Type)
{
case "Int32":
case "Single":
Operators.AddRange(_int32Operators);
UserValueIsVisible = true;
break;
case "Boolean":
Operators.AddRange(_boolOperators);
Enums.Add("True");
Enums.Add("False");
EnumValueIsVisible = true;
break;
case "String":
Operators.AddRange(_stringOperators);
UserValueIsVisible = true;
break;
default:
Operators.AddRange(_operators);
UserValueIsVisible = true;
break;
}
// Add Changed operator is the type is event
if (_editorViewModel.ProposedLayer.IsEvent)
{
Operators.Add(new NamedOperator("Changed", "changed"));
// Also add decreased and increased operator on numbers
if (SelectedDataModelProp.Type == "Int32" || SelectedDataModelProp.Type == "Single")
{
Operators.Add(new NamedOperator("Decreased", "decreased"));
Operators.Add(new NamedOperator("Increased", "increased"));
}
}
SetupUserValueInput();
}
private void AddEnum(IType enm, StringBuilder key)
{
lock (Enums)
{
foreach (var typeArg in enm.TypeParameters)
{
foreach (var constraint in typeArg.Constraints)
{
key.Append(constraint.Name);
}
}
if (Enums.ContainsKey(key.ToString()))
{
return;
}
Enums.Add(key.ToString(), new EnumProperties(enm));
}
}
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));
}
public PropertyCtrlViewModel(string name, EnumProperty property)
{
Name = name;
IntSliderShow = Visibility.Collapsed;
FloatSliderShow = Visibility.Collapsed;
ComboBoxShow = Visibility.Visible;
FileManagerShow = Visibility.Collapsed;
TableViewShow = Visibility.Collapsed;
EnumNameStr = Name;
foreach (var el in property.Values)
{
Enums.Add(new ComboBoxItem()
{
Content = el.Key
});
}
if (Enums.Count > 0)
{
SelectEnum = Enums[0];
foreach (var en in Enums)
{
if (en.Content.ToString() == property.ToString())
{
SelectEnum = en;
break;
}
}
}
OnUpdateEnum += (string content) =>
{
property.Set(content);
if (OnUpdateImg != null)
{
OnUpdateImg(this);
}
};
}
public void Add(Types.Enum e)
{
Enums.Add(e); // check duplicate
}
public void AddEnum(IEnumeration value)
{
Enums.Add((Enumeration)value);
}
void LoadTypes(XmlNode root)
{
foreach (XmlNode node in root.ChildNodes)
{
if (node is XmlComment)
{
continue;
}
if (node.Attributes["requires"] != null && node.ChildNodes.Count == 0)
{
}
if (node.Attributes["category"] != null)
{
string cat = node.Attributes["category"].Value;
if (cat == "union" || cat == "struct")
{
string name = node.Attributes["name"].Value;
bool union = cat == "union";
List <Field> fields = new List <Field>();
foreach (XmlNode fNode in node.ChildNodes)
{
if (fNode is XmlComment)
{
continue;
}
if (fNode.Name == "comment")
{
continue;
}
if (fNode.Name == "validity")
{
continue;
}
LoadField(fNode, fields);
}
var s = new Struct(name, fields, union);
Structs.Add(s);
StructMap.Add(name, s);
}
else if (cat == "handle")
{
if (node.Attributes["alias"] != null)
{
continue;
}
string name = node["name"].InnerText;
List <Field> fields = new List <Field>();
var s = new Struct(name, fields, false);
s.Handle = true;
if (node["type"].InnerText == "VK_DEFINE_HANDLE")
{
fields.Add(new Field("native", "IntPtr", false, null));
}
else
{
fields.Add(new Field("native", "ulong", false, null));
}
Structs.Add(s);
StructMap.Add(name, s);
}
else if (cat == "enum")
{
if (node.Attributes["alias"] != null)
{
continue;
}
var eName = node.Attributes["name"].Value;
if (!EnumMap.ContainsKey(eName))
{
var e = new Enum(eName, false);
EnumMap.Add(eName, e);
Enums.Add(e);
AllEnums.Add(eName);
}
}
else if (cat == "bitmask")
{
if (node.Attributes["alias"] != null)
{
continue;
}
var eName = node["name"].InnerText;
if (!EnumMap.ContainsKey(eName))
{
var e = new Enum(eName, true);
EnumMap.Add(eName, e);
Enums.Add(e);
AllEnums.Add(eName);
}
}
}
}
}
/// <summary>
/// Parses an XML string to a new Easy Base System.
/// </summary>
/// <remarks>Generator step 1.</remarks>
/// <param name="xmlString">The XML string.</param>
private void ParseXml(string xmlString)
{
// Read all entity names (singular and plural)
XmlReader reader = XmlReader.Create(new StringReader(xmlString));
XDocument doc = XDocument.Load(reader);
var entityNames = (from entity in doc.Descendants("Entity")
select new
{
NameSingular = entity.Attribute("NameSingular").Value,
NamePlural = entity.Attributes("NamePlural").Count() > 0 ? entity.Attribute("NamePlural").Value : ToPlural(entity.Attribute("NameSingular").Value)
}).ToList();
reader.Close();
reader = XmlReader.Create(new StringReader(xmlString));
// Read Enums
doc = XDocument.Load(reader);
var enums = (from e in doc.Descendants("Enum")
select e).ToList();
// Create all global enums
foreach (var e in enums)
{
string enumName = e.Attribute("Name").Value;
Enums.Add(new GlobalEnum(enumName));
var values = (from v in e.Descendants()
select v).ToList();
// Create all possible values for current enum
foreach (var value in values)
{
Enums[enumName].Values.Add(value.Value);
}
}
reader.Close();
reader = XmlReader.Create(new StringReader(xmlString));
// Read Entities
while (reader.ReadToFollowing("Entity"))
{
string nameSingular = "";
string namePlural = "";
bool isView = false;
List <Field> fields = new List <Field>();
List <UniqueKey> uniqueKeys = new List <UniqueKey>();
List <string> parentNames = new List <string>();
while (reader.MoveToNextAttribute())
{
string attributeName = reader.Name;
switch (attributeName)
{
case "NameSingular":
nameSingular = reader.Value;
if (namePlural == "")
{
namePlural = ToPlural(nameSingular);
}
break;
case "NamePlural":
namePlural = reader.Value;
break;
case "IsView":
isView = (reader.Value.ToLower() == "true");
break;
default:
throw new NotImplementedException("'" + attributeName + "' on entity '" + nameSingular + "' is not a valid entity attribute.");
}
}
if (nameSingular == "")
{
throw new ApplicationException("Entity must have a name.");
}
while (reader.Read() && reader.NodeType != XmlNodeType.Element && reader.NodeType != XmlNodeType.EndElement)
{
;
}
if (reader.NodeType != XmlNodeType.EndElement && !reader.EOF)
{
if (reader.Name == "Fields")
{
while (reader.Read() && reader.NodeType != XmlNodeType.Element && reader.NodeType != XmlNodeType.EndElement)
{
;
}
while (reader.NodeType != XmlNodeType.EndElement && !reader.EOF)
{
Field field;
if (reader.Name == "PrimaryKeyField")
{
string fieldName = "";
string fieldType = "";
bool allowNull = false;
bool isIdentity = false;
string[] enumValues = null;
string globalEnumName = "";
while (reader.MoveToNextAttribute())
{
string attributeName = reader.Name;
switch (attributeName)
{
case "Name":
fieldName = reader.Value;
break;
case "Type":
fieldType = reader.Value;
break;
case "AllowNull":
allowNull = Convert.ToBoolean(reader.Value);
break;
case "IsIdentity":
isIdentity = Convert.ToBoolean(reader.Value);
break;
case "EnumValues":
if (IsGlobalEnum(reader.Value))
{
globalEnumName = reader.Value;
}
else
{
enumValues = reader.Value.Split("/".ToArray());
}
break;
default:
throw new NotImplementedException("'" + attributeName + "' on field '" + fieldName + "' on entity '" + nameSingular + "' is not a valid primary key field attribute.");
}
}
if (fieldName == "")
{
throw new ApplicationException("Primary key field for entity '" + nameSingular + "' must have a name.");
}
if (fieldType == "")
{
throw new ApplicationException("Primary key field '" + fieldName + "' on entity '" + nameSingular + "' must have a type.");
}
field = new PrimaryKeyField(nameSingular, fieldName, fieldType, allowNull, isIdentity);
if (globalEnumName != "")
{
field.GlobalEnumName = globalEnumName;
}
else
{
if (enumValues != null)
{
field.EnumValues = enumValues;
}
}
}
else if (reader.Name == "ForeignKeyField")
{
string fieldName = "";
string fieldType = "";
string targetEntityName = "";
string targetFieldName = "";
bool allowNull = false;
bool isParentConnection = false;
List <int> uniqueKeyGroups = new List <int>();
while (reader.MoveToNextAttribute())
{
string attributeName = reader.Name;
switch (attributeName)
{
case "Name":
fieldName = reader.Value;
break;
case "Type":
fieldType = reader.Value;
break;
case "TargetEntity":
targetEntityName = reader.Value;
break;
case "TargetField":
targetFieldName = reader.Value;
break;
case "AllowNull":
allowNull = Convert.ToBoolean(reader.Value);
break;
case "IsParentConnection":
isParentConnection = Convert.ToBoolean(reader.Value);
break;
case "UniqueKeyGroup":
string[] keyGroups = reader.Value.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
foreach (string sKeyGroup in keyGroups)
{
uniqueKeyGroups.Add(int.Parse(sKeyGroup));
}
break;
default:
throw new NotImplementedException("'" + attributeName + "' on field '" + fieldName + "' on entity '" + nameSingular + "' is not a valid foreign key field attribute.");
}
}
if (fieldName == "")
{
throw new ApplicationException("Foreign key field for entity '" + nameSingular + "' must have a name.");
}
if (fieldType == "")
{
throw new ApplicationException("Foreign key field '" + fieldName + "' on entity '" + nameSingular + "' must have a type.");
}
if (targetEntityName == "")
{
throw new ApplicationException("Foreign key field '" + fieldName + "' on entity '" + nameSingular + "' must have a target entity.");
}
if (targetFieldName == "")
{
throw new ApplicationException("Foreign key field '" + fieldName + "' on entity '" + nameSingular + "' must have a target field.");
}
var tableName = entityNames.Find(a => a.NameSingular == targetEntityName).NamePlural;
field = new ForeignKeyField(nameSingular, fieldName, fieldType, tableName, targetFieldName, allowNull, isParentConnection, uniqueKeyGroups.ToArray());
if (isParentConnection)
{
parentNames.Add(targetEntityName);
}
if (uniqueKeyGroups.Count > 0)
{
foreach (int uniqueKeyGroup in uniqueKeyGroups)
{
AddToUniqueKeys(uniqueKeys, uniqueKeyGroup, field);
}
}
}
else if (reader.Name == "Field")
{
string fieldName = "";
string fieldType = "";
bool allowNull = false;
List <int> uniqueKeyGroups = new List <int>();
string[] enumValues = null;
string globalEnumName = "";
while (reader.MoveToNextAttribute())
{
string attributeName = reader.Name;
switch (attributeName)
{
case "Name":
fieldName = reader.Value;
break;
case "Type":
fieldType = reader.Value;
break;
case "AllowNull":
allowNull = Convert.ToBoolean(reader.Value);
break;
case "UniqueKeyGroup":
string[] keyGroups = reader.Value.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
foreach (string sKeyGroup in keyGroups)
{
uniqueKeyGroups.Add(int.Parse(sKeyGroup));
}
break;
case "EnumValues":
if (IsGlobalEnum(reader.Value))
{
globalEnumName = reader.Value;
}
else
{
enumValues = reader.Value.Split("/".ToArray());
}
break;
default:
throw new NotImplementedException("'" + attributeName + "' on field '" + fieldName + "' on entity '" + nameSingular + "' is not a valid field attribute.");
}
}
if (fieldName == "")
{
throw new ApplicationException("Field on entity '" + nameSingular + "' must have a name.");
}
if (fieldType == "")
{
throw new ApplicationException("Field '" + fieldName + "' entity '" + nameSingular + "' must have a type.");
}
field = new Field(nameSingular, fieldName, fieldType, allowNull, uniqueKeyGroups.ToArray());
if (globalEnumName != "")
{
field.GlobalEnumName = globalEnumName;
}
else
{
if (enumValues != null)
{
field.EnumValues = enumValues;
}
}
if (uniqueKeyGroups.Count > 0)
{
foreach (int uniqueKeyGroup in uniqueKeyGroups)
{
AddToUniqueKeys(uniqueKeys, uniqueKeyGroup, field);
}
}
}
else if (reader.Name == "ViewField")
{
string fieldName = "";
string fieldType = "";
bool allowNull = false;
while (reader.MoveToNextAttribute())
{
string attributeName = reader.Name;
switch (attributeName)
{
case "Name":
fieldName = reader.Value;
break;
case "Type":
fieldType = reader.Value;
break;
case "AllowNull":
allowNull = Convert.ToBoolean(reader.Value);
break;
default:
throw new NotImplementedException("'" + attributeName + "' on field '" + fieldName + "' on entity '" + nameSingular + "' is not a valid field attribute.");
}
}
if (fieldName == "")
{
throw new ApplicationException("Field on entity '" + nameSingular + "' must have a name.");
}
if (fieldType == "")
{
throw new ApplicationException("Field '" + fieldName + "' entity '" + nameSingular + "' must have a type.");
}
field = new ViewField(nameSingular, fieldName, fieldType, allowNull);
}
else
{
throw new ApplicationException("When initiating entity '" + nameSingular + "', tags '<PrimaryKeyField>, <ForeighKeyField>, <Field> or <ViewField>' was expected, but got tag '<" + reader.Name + ">'");
}
fields.Add(field);
while (reader.Read() && reader.NodeType != XmlNodeType.Element && reader.NodeType != XmlNodeType.EndElement)
{
;
}
}
}
else
{
throw new ApplicationException("When initiating entity '" + nameSingular + "', tag '<Fields>' was expected, but got tag '<" + reader.Name + ">'");
}
Entities.Add(new Entity(this, nameSingular, namePlural, isView, fields.ToArray(), uniqueKeys.ToArray(), parentNames.ToArray()));
}
}
// Loopa igenom alla entiteter och sätt barn på alla föräldrar
foreach (Entity entity in Entities)
{
if (entity.HasParents)
{
foreach (string parentName in entity.ParentNames)
{
Entity parent = Entities.Find(e => e.NameSingular == parentName);
parent.ChildNames.Add(entity.NameSingular);
}
}
}
}
public void MapObj(Type o)
{
bool isArray = false, isByRef = false;
string ShortName = FixName(o, ref isArray, ref isByRef);
if (Enums.Contains(ShortName))
{
return;
}
Console.WriteLine(ShortName);
Enums.Add(ShortName);
XmlDocument CDOC = new XmlDocument();
string title = "class";
if (o.IsValueType)
{
title = "struct";
}
if (o.IsInterface)
{
title = "interface";
}
var x1 = NewNode(CDOC, title, FixName(o, ref isArray, ref isByRef));
AddAttribute(x1, "fullName", o.FullName);
AddAttribute(x1, "assembly", o.Assembly.FullName);
AddAttribute(x1, "location", o.Assembly.Location);
IdType(o, x1);
if (o.GetConstructor(Type.EmptyTypes) == null && o.IsAbstract && o.IsSealed)
{
AddAttribute(x1, "static", "1");
}
x1.AppendChild(CDOC.CreateElement("interfaces"));
x1.AppendChild(CDOC.CreateElement("constructors"));
x1.AppendChild(CDOC.CreateElement("fields"));
x1.AppendChild(CDOC.CreateElement("props"));
var xMethods = (CDOC.CreateElement("methods"));
x1.AppendChild(xMethods);
CDOC.AppendChild(x1);
foreach (var i in o.GetInterfaces())
{
var Name = (i.FullName == null ? i.Name : i.FullName);
if (Name != null)
{
bool dum = false;
var x2 = NewNode(CDOC, "interface", FixName(i, ref dum, ref dum));
Type iT = i.GetType();
MapObj(i);
x1.SelectSingleNode("interfaces").AppendChild(x2);
}
}
foreach (var mi in o.GetConstructors())
{
var x2 = (XmlElement)CDOC.CreateElement("constructor");
foreach (var pi in mi.GetParameters())
{
var x3 = NewNode(CDOC, "param", pi.Name);
IdType(pi.ParameterType, x3);
x2.AppendChild(x3);
}
x1.SelectSingleNode("constructors").AppendChild(x2);
}
var pnames = new List <string>();
foreach (FieldInfo fi in o.GetFields())
{
pnames.Add(fi.Name);
var f = NewNode(CDOC, "field", fi.Name);
AddAttribute(f, "value");
Type t = fi.FieldType;
IdType(t, f);
int iType = Convert.ToInt32(f.GetAttribute("type"));
x1.SelectSingleNode("fields").AppendChild(f);
}
foreach (PropertyInfo pi in o.GetProperties())
{
//necessary because adds prop twice if read/write
if (!pnames.Contains(pi.Name))
{
var p = NewNode(CDOC, "prop", pi.Name);
var list = pi.GetIndexParameters();
if (list.Length > 0)
{
AddAttribute(p, "index", GetDataType(list[0].ParameterType).ToString());
}
AddAttribute(p, "value");
AddAttribute(p, "read", pi.CanRead ? "1" : "0");
AddAttribute(p, "write", pi.CanWrite ? "1" : "0");
Type t = pi.PropertyType;
IdType(t, p);
x1.SelectSingleNode("props").AppendChild(p);
pnames.Add(pi.Name);
x1.SelectSingleNode("props").AppendChild(p);
}
}
int staticMethods = 0;
int totalMethods = 0;
if (o.IsInterface)
{
int i = 0;
}
foreach (var mi in o.GetMethods())
{
if (mi.Name.StartsWith("get_") || mi.Name.StartsWith("set_"))
{
continue;
}
if (mi.Name == "GetType")
{
continue;
}
totalMethods++;
XmlElement x2 = null;
XmlElement x3 = null;
foreach (XmlElement x2a in xMethods.SelectNodes("method"))
{
if (x2a.GetAttribute("name") == mi.Name)
{
x2 = x2a; break;
}
}
if (x2 == null)
{
x2 = NewNode(CDOC, "method", mi.Name);
xMethods.AppendChild(x2);
x3 = CDOC.CreateElement("overloads");
x2.AppendChild(x3);
Type t = mi.ReturnType;
IdType(t, x2);
int iType = Convert.ToInt32(x2.GetAttribute("type"));
}
else
{
x3 = (XmlElement)x2.SelectSingleNode("overloads");
}
if (mi.IsStatic)
{
staticMethods++;
AddAttribute(x2, "static", "1");
}
var x4 = CDOC.CreateElement("params");
foreach (var pi in mi.GetParameters())
{
Type t = pi.ParameterType;
var x5 = NewNode(CDOC, "param", pi.Name);
IdType(t, x5);
x4.AppendChild(x5);
}
bool dupe = false;
foreach (XmlElement nowParms in x3.ChildNodes)
{
dupe = (nowParms.InnerXml == x4.InnerXml);
if (dupe)
{
break;
}
}
if (!dupe)
{
x3.AppendChild(x4);
}
}
if (totalMethods == staticMethods && totalMethods != 0)
{ // this should be good cuz can't have non static methods in a static class
AddAttribute(x1, "static", "1");
}
if (ShortName == "System.Data.SqlClient.SqlCommand")
{
Debug.Print("bam");
}
;
Write(CDOC);
}