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