public override void Load(XElement node, bool requireName = true) { base.Load(node, requireName); if (!node.Elements().Any()) { throw new ArgumentException("List had no elements."); } if (node.Elements().Any() && ObjectGen.LoadField( node.Elements().First(), false, out SingleTypeGen)) { singleType = true; isNoggSingle = SingleTypeGen as NoggType != null; } else { throw new NotImplementedException(); } if (this.Derivative) { throw new NotImplementedException(); } }
public override async Task Load(XElement node, bool requireName = true) { await base.Load(node, requireName); var keyNode = node.Element(XName.Get("Key", LoquiGenerator.Namespace)); if (keyNode == null) { throw new ArgumentException("Dict had no key element."); } var keyTypeGen = await ObjectGen.LoadField( keyNode.Elements().FirstOrDefault(), requireName : false, setDefaults : false); if (keyTypeGen.Succeeded) { KeyTypeGen = keyTypeGen.Value; KeyIsLoqui = keyTypeGen.Value as LoquiType != null; } else { throw new NotImplementedException(); } var valNode = node.Element(XName.Get("Value", LoquiGenerator.Namespace)); if (valNode == null) { throw new ArgumentException("Dict had no value element."); } var valueTypeGen = await ObjectGen.LoadField( valNode.Elements().FirstOrDefault(), requireName : false, setDefaults : false); if (valueTypeGen.Succeeded) { ValueTypeGen = valueTypeGen.Value; ValueIsLoqui = valueTypeGen.Value is LoquiType; } else { throw new NotImplementedException(); } if (keyTypeGen.Value is ContainerType || keyTypeGen.Value is DictType) { throw new NotImplementedException(); } if (valueTypeGen.Value is ContainerType || valueTypeGen.Value is DictType) { throw new NotImplementedException(); } }
private void Awake() { buildingLots = new List <BuildingLot>(); baseBuildingLots = new List <GameObject>(); roadGen = GetComponent <RoadGen>(); objectGen = GetComponent <ObjectGen>(); trafficController = GetComponentInChildren <AITrafficController>(); }
public override async Task Load(XElement node, bool requireName = true) { var fieldsNode = node.Element(XName.Get(Constants.FIELDS, LoquiGenerator.Namespace)); if (fieldsNode != null) { foreach (var fieldNode in fieldsNode.Elements()) { var typeGen = await ObjectGen.LoadField(fieldNode, requireName : true); if (typeGen.Succeeded) { SubFields.Add(typeGen.Value); } } } }
public override void Load(XElement node, bool requireName = true) { base.Load(node, requireName); var keyNode = node.Element(XName.Get("Key", NoggolloquyGenerator.Namespace)); if (keyNode == null) { throw new ArgumentException("Dict had no key element."); } if (ObjectGen.LoadField( keyNode.Elements().FirstOrDefault(), false, out KeyTypeGen)) { KeyIsNogg = KeyTypeGen as NoggType != null; } else { throw new NotImplementedException(); } var valNode = node.Element(XName.Get("Value", NoggolloquyGenerator.Namespace)); if (valNode == null) { throw new ArgumentException("Dict had no value element."); } if (ObjectGen.LoadField( valNode.Elements().FirstOrDefault(), false, out ValueTypeGen)) { ValueIsNogg = ValueTypeGen as NoggType != null; } else { throw new NotImplementedException(); } }
public override async Task GenerateForClass(StructuredStringBuilder sb) { sb.AppendLine($"[DebuggerBrowsable(DebuggerBrowsableState.Never)]"); sb.AppendLine($"private readonly {DictInterface(getter: false)} _{Name} = new {GetActualItemClass(getter: false)};"); Comments?.Apply(sb, LoquiInterfaceType.Direct); sb.AppendLine($"public {DictInterface(getter: false)} {Name} => _{Name};"); var member = $"_{Name}"; using (sb.Region("Interface Members")) { if (!ReadOnly) { sb.AppendLine($"[DebuggerBrowsable(DebuggerBrowsableState.Never)]"); sb.AppendLine($"{DictInterface(getter: false)} {ObjectGen.Interface(internalInterface: false)}.{Name} => {member};"); } sb.AppendLine($"[DebuggerBrowsable(DebuggerBrowsableState.Never)]"); sb.AppendLine($"{DictInterface(getter: true)} {ObjectGen.Interface(getter: true, internalInterface: false)}.{Name} => {member};"); } }
public override void Load(XElement node, bool requireName = true) { base.Load(node, requireName); var keyedValNode = node.Element(XName.Get("KeyedValue", NoggolloquyGenerator.Namespace)); if (keyedValNode == null) { throw new ArgumentException("Dict had no keyed value element."); } TypeGeneration valType; if (ObjectGen.LoadField( keyedValNode.Elements().FirstOrDefault(), false, out valType) && valType is NoggType) { this.ValueTypeGen = valType as NoggType; } else { throw new NotImplementedException(); } var keyAccessorAttr = keyedValNode.Attribute(XName.Get("keyAccessor")); if (keyAccessorAttr == null) { throw new ArgumentException("Dict had no key accessor attribute."); } this.KeyAccessorString = keyAccessorAttr.Value; this.KeyTypeGen = this.ValueTypeGen.RefGen.Obj.Fields.First((f) => f.Name.Equals(keyAccessorAttr.Value)); if (this.KeyTypeGen == null) { throw new ArgumentException($"Dict had a key accessor attribute that didn't correspond to a field: {keyAccessorAttr.Value}"); } }
public override async Task Resolve() { await base.Resolve(); var protoID = ProtocolID ?? ObjectGen.ProtoGen.Protocol.Namespace; if (!ObjectGen.ProtoGen.Gen.TryGetProtocol(new ProtocolKey(protoID), out var protoGen)) { throw new ArgumentException($"Protocol did not exist {protoID}."); } if (!protoGen.FieldBatchesByName.TryGetValue(BatchName, out var batch)) { throw new ArgumentException($"Field batch did not exist {BatchName} in protocol {protoGen.Protocol.Namespace}"); } var index = ObjectGen.IterateFields().ToList().IndexOf(this); if (index == -1) { throw new ArgumentException("Could not find self in object's field list."); } foreach (var generic in batch.Generics) { ObjectGen.Generics[generic.Key] = generic.Value; } foreach (var field in batch.Fields) { var typeGen = await ObjectGen.LoadField(field.Node, requireName : true); if (typeGen.Succeeded) { ObjectGen.Fields.Insert(index++, typeGen.Value); await typeGen.Value.Resolve(); } } if (!ObjectGen.Fields.Remove(this)) { throw new ArgumentException("Could not remove self from object's field list."); } }
public override async Task Load(XElement node, bool requireName = true) { await base.Load(node, requireName); var fieldsNode = node.Elements().FirstOrDefault(f => f.Name.LocalName.Equals("Fields")); if (fieldsNode != null) { node = fieldsNode; } if (!node.Elements().Any()) { throw new ArgumentException("Wrapper had no elements."); } if (node.Elements().Any()) { var typeGen = await ObjectGen.LoadField( node.Elements().First(), requireName : false, setDefaults : false); if (typeGen.Succeeded) { SubTypeGeneration = typeGen.Value; isLoquiSingle = SubTypeGeneration as LoquiType != null; } else { throw new NotImplementedException(); } SubTypeGeneration.Parent = this; } else { throw new NotImplementedException(); } }
public override async Task GenerateForClass(StructuredStringBuilder sb) { sb.AppendLine($"private readonly Dictionary<{TypeTuple(getter: false)}> _{Name} = new Dictionary<{TypeTuple(getter: false)}>();"); Comments?.Apply(sb, LoquiInterfaceType.Direct); sb.AppendLine($"public IDictionary<{TypeTuple(getter: false)}> {Name} => _{Name};"); var member = "_" + Name; using (new Region(sb, "Interface Members")) { if (!ReadOnly) { sb.AppendLine($"IDictionary{(ReadOnly ? "Getter" : string.Empty)}<{TypeTuple(getter: false)}> {ObjectGen.Interface()}.{Name} => {member};"); } if (ValueIsLoqui) { sb.AppendLine($"IReadOnlyDictionary<{TypeTuple(getter: true)}> {ObjectGen.Interface(getter: true)}.{Name} => {member}.Covariant<{TypeTuple(getter: false)}, {ValueTypeGen.TypeName(getter: true)}>();"); } else { sb.AppendLine($"IReadOnlyDictionary<{TypeTuple(getter: true)}> {ObjectGen.Interface(getter: true)}.{Name} => {member};"); } } }
public override async Task GenerateForClass(StructuredStringBuilder sb) { if (!IntegrateField) { return; } if (Nullable) { if (CanBeNullable(false)) { if (!TrueReadOnly) { sb.AppendLine($"[DebuggerBrowsable(DebuggerBrowsableState.Never)]"); sb.AppendLine($"protected {TypeName(getter: false)}? _{Name};"); Comments?.Apply(sb, LoquiInterfaceType.Direct); sb.AppendLine($"public {OverrideStr}{TypeName(getter: false)}? {Name}"); using (sb.CurlyBrace()) { sb.AppendLine($"get => this._{ Name};"); sb.AppendLine($"{SetPermissionStr}set => this._{Name} = value;"); } sb.AppendLine($"[DebuggerBrowsable(DebuggerBrowsableState.Never)]"); if (CanBeNullable(getter: true)) { sb.AppendLine($"{TypeName(getter: true)}? {ObjectGen.Interface(getter: true, InternalGetInterface)}.{Name} => this.{Name};"); } else { sb.AppendLine($"{TypeName(getter: true)} {ObjectGen.Interface(getter: true, InternalGetInterface)}.{Name} => this.{Name};"); sb.AppendLine($"bool {ObjectGen.Interface(getter: true, InternalGetInterface)}.{Name}_IsSet => this.{Name} != null;"); } } else { Comments?.Apply(sb, LoquiInterfaceType.Direct); sb.AppendLine($"public readonly {TypeName(getter: false)}? {Name};"); sb.AppendLine($"[DebuggerBrowsable(DebuggerBrowsableState.Never)]"); } } else { throw new NotImplementedException(); } } else { sb.AppendLine($"[DebuggerBrowsable(DebuggerBrowsableState.Never)]"); sb.AppendLine($"private {TypeName(getter: false)} _{Name}{(IsNullable ? string.Empty : $" = {GetNewForNonNullable()}")};"); Comments?.Apply(sb, LoquiInterfaceType.Direct); if (Singleton) { sb.AppendLine($"public {OverrideStr}{TypeName(getter: false)} {Name} => {ProtectedName};"); } else { sb.AppendLine($"public {OverrideStr}{TypeName(getter: false)} {Name}"); using (sb.CurlyBrace()) { sb.AppendLine($"get => {ProtectedName};"); sb.AppendLine($"{SetPermissionStr}set => this._{Name} = value;"); } } if (TypeName(getter: true) != TypeName(getter: false)) { sb.AppendLine($"[DebuggerBrowsable(DebuggerBrowsableState.Never)]"); sb.AppendLine($"{TypeName(getter: true)} {ObjectGen.Interface(getter: true, InternalGetInterface)}.{Name} => this.{Name};"); } } }
public static int Main(string[] args) { var outputDir = ""; var assemblyName = ""; var gapiDir = ""; var abiCsUsings = ""; var abiCsFile = ""; var abiCFile = ""; var glueFilename = ""; var glueIncludes = ""; var glueLibName = ""; var schemaUri = ""; var showHelp = false; var inputFilePaths = new List <string>(); var includedFilePaths = new List <string>(); var options = new OptionSet { { "generate=", "Generate the C# code for this GAPI XML file.", v => { inputFilePaths.Add(v); } }, { "I|include=", "GAPI XML file that contain symbols used in the main GAPI XML file.", v => { includedFilePaths.Add(v); } }, { "outdir=", "Directory where the C# files will be generated.", v => { outputDir = v; } }, { "assembly-name=", "Name of the assembly for which the code is generated.", v => { assemblyName = v; } }, { "gapidir=", "GAPI XML data folder.", v => { gapiDir = v; } }, { "abi-cs-filename=", "Filename for the generated C# ABI checker.", v => { abiCsFile = v; } }, { "abi-cs-usings=", "Namespaces to use in the C# ABI checker.", v => { abiCsUsings = v; } }, { "abi-c-filename=", "Filename for the generated C ABI checker.", v => { abiCFile = v; } }, { "glue-filename=", "Filename for the generated C glue code.", v => { glueFilename = v; } }, { "glue-includes=", "Content of #include directive to add in the generated C glue code.", v => { glueIncludes = v; } }, { "gluelib-name=", "Name of the C library into which the C glue code will be compiled. Used to generated correct DllImport attributes.", v => { glueLibName = v; } }, { "schema=", "Validate all GAPI XML files against this XSD schema.", v => { schemaUri = v; } }, { "h|help", "Show this message and exit", v => showHelp = v != null } }; List <string> extra; try { extra = options.Parse(args); } catch (OptionException e) { Console.WriteLine($"gapi-codegen: {e.Message}"); Console.WriteLine("Try `gapi-codegen --help` for more information."); return(64); } if (showHelp) { ShowHelp(options); return(0); } if (extra.Exists(v => v.StartsWith("--customdir"))) { Console.WriteLine("Using .custom files is not supported anymore, use partial classes instead."); return(64); } if (inputFilePaths.Count == 0) { Console.WriteLine("You need to specify a file to process using the --generate option."); Console.WriteLine("Try `gapi-codegen --help` for more information."); return(64); } if (!string.IsNullOrEmpty(schemaUri) && !File.Exists(schemaUri)) { Console.WriteLine( $"WARNING: Could not find schema file at '{schemaUri}', no validation will be done."); schemaUri = null; } var parser = new Parser(); var symbolTable = SymbolTable.Table; foreach (var filePath in includedFilePaths) { Log.Info($"Parsing included gapi: {filePath}"); var generatables = parser.Parse(filePath, schemaUri, gapiDir); symbolTable.AddTypes(generatables); } var gens = new List <IGeneratable>(); foreach (var filename in inputFilePaths) { Log.Info($"Parsing included gapi: {filename}"); var generatables = parser.Parse(filename, schemaUri, gapiDir); symbolTable.AddTypes(generatables); gens.AddRange(generatables); } // Now that everything is loaded, validate all the to-be- // generated generatables and then remove the invalid ones. var invalids = gens.Where(generatable => !generatable.Validate()).ToArray(); foreach (var generatable in invalids) { gens.Remove(generatable); } GenerationInfo generationInfo = null; if (outputDir != "" || assemblyName != "" || glueFilename != "" || glueIncludes != "" || glueLibName != "") { generationInfo = new GenerationInfo(outputDir, assemblyName, glueFilename, glueIncludes, glueLibName, abiCFile, abiCsFile, abiCsUsings); } foreach (var generatable in gens) { if (generationInfo == null) { generatable.Generate(); } else { generatable.Generate(generationInfo); } } ObjectGen.GenerateMappers(); generationInfo?.CloseWriters(); Statistics.Report(); return(0); }
public override async Task GenerateForClass(StructuredStringBuilder sb) { void GenerateTypicalNullableMembers(bool notifying) { Comments?.Apply(sb, LoquiInterfaceType.Direct); sb.AppendLine($"public {OverrideStr}{TypeName(getter: false)}{NullChar} {Name} {{ get; {(ReadOnly ? "protected " : string.Empty)}set; }}{(HasDefault ? $" = {DefaultValueMemberName};" : null)}"); sb.AppendLine($"[DebuggerBrowsable(DebuggerBrowsableState.Never)]"); sb.AppendLine($"{TypeName(getter: true)}{NullChar} {ObjectGen.Interface(getter: true, internalInterface: InternalGetInterface)}.{Name} => this.{Name};"); } if (HasDefault) { Comments?.Apply(sb, LoquiInterfaceType.Direct); sb.AppendLine($"public readonly static {TypeName(getter: false)} {DefaultValueMemberName} = {DefaultValue};"); } if (Nullable) { if (!TrueReadOnly) { GenerateTypicalNullableMembers(false); } else { Comments?.Apply(sb, LoquiInterfaceType.Direct); sb.AppendLine($"public readonly {TypeName(getter: false)} {Name};"); sb.AppendLine($"{TypeName(getter: false)} {ObjectGen.Interface(getter: true, internalInterface: InternalGetInterface)}.{Name} => this.{Name};"); } } else { var subFg = new StructuredStringBuilder(); WrapSetAccessor(subFg, linePrefix: $"{SetPermissionStr}set", toDo: subGen => { if (subGen.Count == 0) { return; } subGen.AppendLine($"this._{Name} = value;"); }); if (subFg.Count > 1) { sb.AppendLine($"[DebuggerBrowsable(DebuggerBrowsableState.Never)]"); sb.AppendLine($"private {TypeName(getter: false)} _{Name};"); Comments?.Apply(sb, LoquiInterfaceType.Direct); sb.AppendLine($"public {OverrideStr}{TypeName(getter: false)} {Name}"); using (sb.CurlyBrace()) { sb.AppendLine($"get => this._{Name};"); sb.AppendLines(subFg); } } else if (subFg.Count == 1) { Comments?.Apply(sb, LoquiInterfaceType.Direct); sb.AppendLine($"public {OverrideStr}{TypeName(getter: false)} {Name} {{ get; {subFg[0]}; }} = {(HasDefault ? DefaultValueMemberName : GetDefault(getter: false))};"); } else { throw new ArgumentException(); } if (!InternalGetInterface && TypeName(getter: true) != TypeName(getter: false)) { sb.AppendLine($"{TypeName(getter: true)} {ObjectGen.Interface(getter: true, internalInterface: InternalGetInterface)}.{Name} => this.{Name};"); } } if (InternalSetInterface) { sb.AppendLine($"[DebuggerBrowsable(DebuggerBrowsableState.Never)]"); sb.AppendLine($"{TypeName(getter: false)}{NullChar} {ObjectGen.Interface(getter: false, internalInterface: true)}.{Name}"); using (sb.CurlyBrace()) { sb.AppendLine($"get => this.{Name};"); sb.AppendLine($"set => this.{Name} = {GetValueSetString("value")};"); } } if (InternalGetInterface) { if (Nullable) { if (CanBeNullable(getter: true)) { sb.AppendLine($"{TypeName(getter: false)}? {ObjectGen.Interface(getter: true, internalInterface: true)}.{Name} => this.{Name}"); } else { sb.AppendLine($"{TypeName(getter: false)} {ObjectGen.Interface(getter: true, internalInterface: true)}.{Name} => this.{Name}"); sb.AppendLine($"bool {ObjectGen.Interface(getter: true, internalInterface: true)}.{Name}_IsSet => this.{Name} != null"); } } else { sb.AppendLine($"{TypeName(getter: false)} {ObjectGen.Interface(getter: true, internalInterface: true)}.{Name} => this.{Name}"); } } }
public void GenerateInterfaceMembers(StructuredStringBuilder sb, string member) { using (sb.Region("Interface Members")) { sb.AppendLine($"[DebuggerBrowsable(DebuggerBrowsableState.Never)]"); sb.AppendLine($"{ListTypeName(getter: true, internalInterface: true)}{NullChar} {ObjectGen.Interface(getter: true, internalInterface: InternalGetInterface)}.{Name} => {member};"); } }
public override async Task Load(XElement node, bool requireName = true) { await base.Load(node, requireName); var keyedValNode = node.Element(XName.Get(Constants.KEYED_VALUE, LoquiGenerator.Namespace)); if (keyedValNode == null) { throw new ArgumentException("Dict had no keyed value element."); } var valType = await ObjectGen.LoadField( keyedValNode.Elements().FirstOrDefault(), requireName : false, setDefaults : false); if (valType.Succeeded && valType.Value is LoquiType) { ValueTypeGen = valType.Value as LoquiType; } else { throw new NotImplementedException(); } var keyAccessorAttr = keyedValNode.Attribute(XName.Get(Constants.KEY_ACCESSOR)); if (keyAccessorAttr == null) { throw new ArgumentException("Dict had no key accessor attribute."); } KeyAccessorString = keyAccessorAttr.Value; if (ValueTypeGen.GenericDef == null) { await ValueTypeGen.TargetObjectGeneration.LoadingCompleteTask.Task; KeyTypeGen = ValueTypeGen.TargetObjectGeneration.IterateFields(includeBaseClass: true).FirstOrDefault((f) => f.Name.Equals(keyAccessorAttr.Value)); if (KeyTypeGen == null) { throw new ArgumentException($"Dict had a key accessor attribute that didn't correspond to a field: {keyAccessorAttr.Value}"); } } else { if (!keyedValNode.TryGetAttribute <string>(Constants.KEY_TYPE, out var keyTypeName)) { throw new ArgumentException("Cannot have a generic keyed reference without manually specifying keyType"); } if (!ObjectGen.ProtoGen.Gen.TryGetTypeGeneration(keyTypeName, out var keyTypeGen)) { throw new ArgumentException($"Generic keyed type specification did not link to a known field type: {keyTypeName}"); } KeyTypeGen = keyTypeGen; } await base.Resolve(); if (KeyTypeGen is ContainerType || KeyTypeGen is DictType) { throw new NotImplementedException(); } }