private static SKONObject ParseWithMetadata(string skon, out SKONMetadata meta)
{
return(SKON.Parse(metadataString + skon, out meta));
}
/// <summary>
/// Writes a SKEMAObject.
/// </summary>
/// <param name="obj">The object to write.</param>
/// <returns>A string to write into a file.</returns>
public static string Write(SKEMAObject obj, SKONMetadata metadata = default(SKONMetadata))
{
if (obj.Type != SKEMAType.MAP)
{
throw new ArgumentException("SKEMAObject to write must be of type map!");
}
// We might want to do something here?
metadata.LanguageVersion = LanguageVersion;
StringBuilder sb = new StringBuilder();
sb.Append($"{SKON.Metadelimit}Version: {metadata.LanguageVersion}{SKON.Metadelimit}\n");
sb.Append($"{SKON.Metadelimit}DocumentVersion: \"{metadata.DocuemntVersion}\"{SKON.Metadelimit}\n");
if (metadata.SKEMA != null && metadata.SKEMA.Length > 0)
{
sb.Append($"{SKON.Metadelimit}SKEMA: \"{metadata.SKEMA}\"{SKON.Metadelimit}\n");
}
List <LinkedList <SKEMAObject> > sccs = new ReferenceSolver().FindStronglyConnectedComponents(obj, (v) =>
{
List <SKEMAObject> successors = new List <SKEMAObject>();
switch (v.Type)
{
case SKEMAType.REFERENCE:
if (v.ReferenceSKEMA.Type == SKEMAType.REFERENCE || v.ReferenceSKEMA.Type == SKEMAType.ARRAY || v.ReferenceSKEMA.Type == SKEMAType.MAP)
{
successors.Add(v.ReferenceSKEMA);
}
break;
case SKEMAType.ANY:
case SKEMAType.STRING:
case SKEMAType.INTEGER:
case SKEMAType.FLOAT:
case SKEMAType.BOOLEAN:
case SKEMAType.DATETIME:
break;
case SKEMAType.MAP:
foreach (string key in v.Keys)
{
SKEMAObject w = v[key];
if (w.Type == SKEMAType.REFERENCE || w.Type == SKEMAType.ARRAY || w.Type == SKEMAType.MAP)
{
successors.Add(w);
}
}
break;
case SKEMAType.ARRAY:
if (v.ArrayElementSKEMA.Type == SKEMAType.REFERENCE || v.ArrayElementSKEMA.Type == SKEMAType.ARRAY || v.ArrayElementSKEMA.Type == SKEMAType.MAP)
{
successors.Add(v.ArrayElementSKEMA);
}
break;
default:
break;
}
//Console.WriteLine($"Found {successors.Count} successsors!");
foreach (var s in successors)
{
//Console.WriteLine(s.Type);
}
return(successors);
});
if (sccs.Count > 1)
{
List <LinkedList <SKEMAObject> > badSccs = new List <LinkedList <SKEMAObject> >();
foreach (var scc in sccs)
{
//Console.WriteLine($"Component (Length {scc.Count}):");
if (scc.Count == 1 && scc.First.Value.Type != SKEMAType.REFERENCE)
{
// This strongly connected component can't be bad
continue;
}
bool containsDefiniton = false;
foreach (SKEMAObject element in scc)
{
//Console.WriteLine(element.Type);
if (element.Type == SKEMAType.REFERENCE && element.ReferenceSKEMA != null)
{
containsDefiniton = true;
//Console.WriteLine("Component Contains Definition!");
break;
}
}
if (containsDefiniton == false)
{
badSccs.Add(scc);
}
}
if (badSccs.Count > 0)
{
throw new CouldNotSolveReferencesException(badSccs);
}
}
List <SKEMAObject> references = FindReferences(obj);
foreach (SKEMAObject reference in references)
{
sb.Append("define " + reference.Reference + ": " + WriteObject(reference.ReferenceSKEMA, 0) + ",\n");
}
foreach (string key in obj.Keys)
{
sb.Append(key + ": " + WriteObject(obj[key], 0) + ",\n");
}
return(sb.ToString());
}
