public override async Task Load()
{
BaseClassStr = Node.GetAttribute("baseClass");
_abstract = Node.GetAttribute <bool>("abstract", false);
_nullableDefault = Node.GetAttribute <bool>("nullableDefault", ProtoGen.NullableDefault);
if (NeedsReflectionGeneration)
{
Interfaces.Add(LoquiInterfaceDefinitionType.ISetter, nameof(ILoquiReflectionSetter));
}
if (ObjectNamedKey.TryFactory(BaseClassStr, ProtoGen.Protocol, out var baseClassObjKey))
{
if (!gen.ObjectGenerationsByObjectNameKey.TryGetValue(baseClassObjKey, out ObjectGeneration baseObj) ||
!(baseObj is ClassGeneration))
{
throw new ArgumentException($"Could not resolve base class object: {BaseClassStr}");
}
else
{
ClassGeneration baseClass = baseObj as ClassGeneration;
BaseClass = baseClass;
baseClass._derivativeClasses.Add(this);
}
}
#if NETSTANDARD2_0
WiredBaseClassTCS.TrySetResult(true);
#else
WiredBaseClassTCS.TrySetResult();
#endif
await base.Load();
}
public static async Task <Case> HasMajorRecords(LoquiType loqui, bool includeBaseClass, GenericSpecification specifications = null, bool includeSelf = true)
{
if (loqui.TargetObjectGeneration != null)
{
if (includeSelf && await loqui.TargetObjectGeneration.IsMajorRecord())
{
return(Case.Yes);
}
return(await MajorRecordModule.HasMajorRecordsInTree(loqui.TargetObjectGeneration, includeBaseClass, loqui.GenericSpecification));
}
else if (specifications != null)
{
foreach (var target in specifications.Specifications.Values)
{
if (!ObjectNamedKey.TryFactory(target, out var key))
{
continue;
}
var specObj = loqui.ObjectGen.ProtoGen.Gen.ObjectGenerationsByObjectNameKey[key];
if (await specObj.IsMajorRecord())
{
return(Case.Yes);
}
return(await MajorRecordModule.HasMajorRecordsInTree(specObj, includeBaseClass));
}
}
else if (loqui.RefType == LoquiType.LoquiRefType.Interface)
{
// ToDo
// Quick hack. Real solution should use reflection to investigate the interface
return(includeSelf ? Case.Yes : Case.No);
}
return(Case.Maybe);
}
public void BasicEquals()
{
var lhs = new ObjectNamedKey(
new ProtocolKey("Test"),
"Object");
var rhs = new ObjectNamedKey(
new ProtocolKey("Test"),
"Object");
Assert.Equal(lhs, rhs);
}
public static async IAsyncEnumerable <ObjectGeneration> IterateMajorRecords(LoquiType loqui, bool includeBaseClass, GenericSpecification specifications = null)
{
if (specifications?.Specifications.Count > 0)
{
foreach (var target in specifications.Specifications.Values)
{
if (!ObjectNamedKey.TryFactory(target, out var key))
{
continue;
}
var specObj = loqui.ObjectGen.ProtoGen.Gen.ObjectGenerationsByObjectNameKey[key];
if (await specObj.IsMajorRecord())
{
yield return(specObj);
}
await foreach (var item in IterateMajorRecords(specObj, includeBaseClass, includeSelf: true, loqui.GenericSpecification))
{
yield return(item);
}
}
}
else if (loqui.TargetObjectGeneration != null)
{
if (await loqui.TargetObjectGeneration.IsMajorRecord())
{
yield return(loqui.TargetObjectGeneration);
}
await foreach (var item in IterateMajorRecords(loqui.TargetObjectGeneration, includeBaseClass, includeSelf: true, loqui.GenericSpecification))
{
yield return(item);
}
}
else if (loqui.RefType == LoquiType.LoquiRefType.Interface)
{
// Must be a link interface
if (!LinkInterfaceModule.ObjectMappings[loqui.ObjectGen.ProtoGen.Protocol].TryGetValue(loqui.SetterInterface, out var mappings))
{
throw new ArgumentException();
}
foreach (var obj in mappings)
{
yield return(obj);
}
}
else
{
throw new ArgumentException();
}
}
public override Task Load(XElement node, bool requireName = true)
{
XElement convert = new XElement(XName.Get("Ref", LoquiGenerator.Namespace));
convert.Add(node.Attribute("name"));
var dir = new XElement(XName.Get("Direct", LoquiGenerator.Namespace));
dir.Add(new XAttribute("refName", "Group"));
convert.Add(dir);
var gen = new XElement(XName.Get("GenericSpecification", LoquiGenerator.Namespace));
var nameKey = ObjectNamedKey.Factory(node.GetAttribute("refName"), this.ObjectGen.ProtoGen.Protocol);
gen.Add(new XAttribute("Definition", nameKey.ToString()));
gen.Add(new XAttribute("TypeToSpecify", "T"));
dir.Add(gen);
this.ThisConstruction = true;
this.CustomData[Plugins.Internals.Constants.EdidLinked] = node.GetAttribute <bool>(Plugins.Internals.Constants.EdidLinked, false);
return(base.Load(convert, requireName));
}
public static async Task <Case> HasLinks(LoquiType loqui, bool includeBaseClass, GenericSpecification specifications = null)
{
if (loqui.TargetObjectGeneration != null)
{
return(await HasLinks(loqui.TargetObjectGeneration, includeBaseClass, loqui.GenericSpecification));
}
else if (specifications != null)
{
foreach (var target in specifications.Specifications.Values)
{
if (!ObjectNamedKey.TryFactory(target, out var key))
{
continue;
}
var specObj = loqui.ObjectGen.ProtoGen.Gen.ObjectGenerationsByObjectNameKey[key];
return(await HasLinks(specObj, includeBaseClass));
}
return(Case.Maybe);
}
else
{
return(Case.Maybe);
}
}
public void Resolve(ObjectGeneration obj)
{
if (!Wheres.Any())
{
return;
}
if (!Loqui)
{
var loquiElem = Wheres.FirstOrDefault((i) =>
i.Equals(nameof(ILoquiObjectGetter)) ||
i.Equals(nameof(ILoquiObject)));
Loqui = loquiElem != null;
}
if (!ObjectNamedKey.TryFactory(Wheres.First(), obj.ProtoGen.Protocol, out var objGenKey))
{
return;
}
if (!obj.ProtoGen.Gen.ObjectGenerationsByObjectNameKey.TryGetValue(objGenKey, out var baseObjGen))
{
return;
}
BaseObjectGeneration = baseObjGen;
Loqui = true;
}
public void TryFactory_ExtraFull()
{
Assert.True(ObjectNamedKey.TryFactory($"{LargeProtocol.Namespace}.{ObjectName}", FallbackProtocol, out var key));
Assert.Equal(key.ProtocolKey, LargeProtocol);
Assert.Equal(key.Name, ObjectName);
}
public void TryFactory_OnlyName()
{
Assert.True(ObjectNamedKey.TryFactory(ObjectName, FallbackProtocol, out var key));
Assert.Equal(key.ProtocolKey, FallbackProtocol);
Assert.Equal(key.Name, ObjectName);
}
public void TryFactory_Null()
{
Assert.False(ObjectNamedKey.TryFactory(null, FallbackProtocol, out var key));
}
public void TryFactory_Empty()
{
Assert.False(ObjectNamedKey.TryFactory(string.Empty, FallbackProtocol, out var key));
}
