protected void Serialize(WriteTarget target)
{
Type type = target.item.GetType();
context = target.item;
int id;
if (type.IsClass)
{
id = GetRefId(target.item);
outputTargets[id] = target;
}
else
{
id = -1;
}
//string creationType = SerializerUtil.GetCreationType(type, context);
TypeSerializer serializer = SerializerUtil.GetTypeSerializer(type);
builder.Length = 0;
writeCalls = 0;
serializer.Serialize(target.item, this);
target.id = id;
target.fieldCount = writeCalls;
target.fields = builder.ToString();
target.version = serializer.GetVersion();
}
public override void Render([NotNull] GlobalContext globalContext, [NotNull, ItemNotNull] IEnumerable <Dependency> dependencies,
Options options, [NotNull] WriteTarget target, bool ignoreCase)
{
using (var sw = GetDotFileName(target).CreateWriter()) {
Render(dependencies, sw, options.InnerMatch, options.MaxExampleLength);
}
}
public override void Render([NotNull] GlobalContext globalContext,
[NotNull, ItemNotNull] IEnumerable <Dependency> dependencies,
Options options, [NotNull] WriteTarget target, bool ignoreCase)
{
using (var sw = GetMasterFileName(globalContext, options, target).CreateWriter(logToConsoleInfo: true)) {
int n = Write(dependencies, sw, !options.NoExampleInfo, options.Matches, options.Excludes);
Log.WriteInfo($"... written {n} dependencies");
}
}
public override void Render([NotNull] GlobalContext globalContext,
[NotNull, ItemNotNull] IEnumerable <Dependency> dependencies, Options options,
[NotNull] WriteTarget target, bool ignoreCase)
{
string message;
{
int badCount = dependencies.Count(d => d.BadCt > 0);
int questionableCount = dependencies.Count(d => d.QuestionableCt > 0);
string badMessage = badCount > 0 ? $"{badCount} violations" : "";
string questionableMessage = questionableCount > 0
? $"{questionableCount} questionable dependencies"
: "";
message = badMessage != ""
? questionableMessage != "" ? badMessage + " and " + questionableMessage : badMessage
: questionableMessage != "" ? questionableMessage : "no violations";
}
if (target.IsConsoleOut)
{
var consoleLogger = new ConsoleLogger();
foreach (var d in GetQuestionableAndBadDependencies(dependencies))
{
consoleLogger.WriteViolation(d, options.SimpleRuleOutput);
}
}
else if (options.XmlOutput)
{
var document = new XDocument(
new XElement("Violations",
GetQuestionableAndBadDependencies(dependencies).Select(dependency =>
new XElement("Violation",
new XElement("Type", dependency.BadCt > 0 ? "Bad" : "Questionable"),
new XElement("UsingItem", dependency.UsingItemAsString),
// NACH VORN GELEGT - OK? (wir haben kein XSD :-) )
//new XElement("UsingNamespace", violation.Dependency.UsingNamespace),
new XElement("UsedItem", dependency.UsedItemAsString),
//new XElement("UsedNamespace", violation.Dependency.UsedNamespace),
new XElement("FileName", dependency.Source)))));
var settings = new XmlWriterSettings {
Encoding = Encoding.UTF8, Indent = true
};
WriteTarget writeTarget = GetXmlFile(target);
Log.WriteInfo($"Writing {message} to {writeTarget}");
using (var xmlWriter = XmlWriter.Create(writeTarget.FullFileName, settings)) {
document.Save(xmlWriter);
}
}
else
{
WriteTarget writeTarget = GetTextFile(target);
Log.WriteInfo($"Writing {message} to {writeTarget }");
using (var sw = writeTarget.CreateWriter()) {
RenderToTextWriter(dependencies, sw, options.SimpleRuleOutput, options.NewLine);
}
}
}
public override void Render([NotNull] GlobalContext globalContext, [NotNull, ItemNotNull] IEnumerable <Dependency> dependencies,
Options options, [NotNull] WriteTarget target, bool ignoreCase)
{
int pathCount;
using (ITargetWriter tw = GetMasterFileName(globalContext, options, target).CreateWriter()) {
tw.WriteLine($"// Written {DateTime.Now} by {typeof(FlatPathWriter).Name} in Archichect {Program.VERSION}");
tw.WriteLine();
pathCount = WritePaths(dependencies, ignoreCase, options.MarkerMatchers, tw, options.ShowItemMarkers);
}
Log.WriteInfo($"... written {pathCount} paths");
}
public bool AddItem <T>(string itemId, T item) where T : class
{
if (item == null)
{
return(false);
}
//todo containment check
WriteTarget target = new WriteTarget(itemId, item);
GetTypeId(item.GetType());
inputItems.Add(target);
return(true);
}
public override void Render([NotNull] GlobalContext globalContext,
[NotNull, ItemNotNull] IEnumerable <Dependency> dependencies, Options options,
[NotNull] WriteTarget target, bool ignoreCase)
{
int violationsCount = dependencies.Count(d => d.NotOkCt > 0);
if (target.IsConsoleOut)
{
var consoleLogger = new ConsoleLogger();
foreach (var d in dependencies.Where(d => d.QuestionableCt > 0 && d.BadCt == 0))
{
consoleLogger.WriteViolation(d, options.SimpleRuleOutput);
}
foreach (var d in dependencies.Where(d => d.BadCt > 0))
{
consoleLogger.WriteViolation(d, options.SimpleRuleOutput);
}
}
else if (options.XmlOutput)
{
var document = new XDocument(
new XElement("Violations",
from dependency in dependencies where dependency.NotOkCt > 0
select new XElement(
"Violation",
new XElement("Type", dependency.BadCt > 0 ? "Bad" : "Questionable"),
new XElement("UsingItem", dependency.UsingItemAsString), // NACH VORN GELEGT - OK? (wir haben kein XSD :-) )
//new XElement("UsingNamespace", violation.Dependency.UsingNamespace),
new XElement("UsedItem", dependency.UsedItemAsString),
//new XElement("UsedNamespace", violation.Dependency.UsedNamespace),
new XElement("FileName", dependency.Source)
))
);
var settings = new XmlWriterSettings {
Encoding = Encoding.UTF8, Indent = true
};
WriteTarget writeTarget = GetXmlFile(target);
Log.WriteInfo($"Writing {violationsCount} violations to {writeTarget}");
using (var xmlWriter = XmlWriter.Create(writeTarget.FullFileName, settings)) {
document.Save(xmlWriter);
}
}
else
{
WriteTarget writeTarget = GetTextFile(target);
Log.WriteInfo($"Writing {violationsCount} violations to {writeTarget }");
using (var sw = writeTarget.CreateWriter()) {
RenderToTextWriter(dependencies, sw, options.SimpleRuleOutput, options.NewLine);
}
}
}
public override void Render([NotNull] GlobalContext globalContext, [NotNull, ItemNotNull] IEnumerable <Dependency> dependencies, Options options, [NotNull] WriteTarget target, bool ignoreCase)
{
WriteTarget masterFile = GetMasterFileName(globalContext, options, target);
using (var sw = masterFile.CreateWriter()) {
bool writeHeader = masterFile.IsConsoleOut;
if (!writeHeader)
{
sw.WriteLine($"// Written {DateTime.Now} by {typeof(ItemWriter).Name} in Archichect {Program.VERSION}");
sw.WriteLine();
}
Write(dependencies, sw, options.ItemMatches, options.ItemExcludes, options.IndegreeMatches, options.IndegreeExcludes,
options.OutdegreeMatches, options.OutdegreeExcludes, options.WriteOnlyIfIndegreeNotZero,
options.WriteOnlyIfOutdegreeNotZero, options.ShowMarkers, ignoreCase);
}
}
protected int GetWriteTargetId(object value)
{
WriteTarget target = null;
if (value.GetType().IsValueType)
{
target = new WriteTarget(value);
target.id = structTargets.Count;
structTargets.Add(target);
return(target.id);
}
int refId = GetRefId(value);
target = outputTargets.Get(refId);
if (target == null)
{
target = new WriteTarget(value);
target.id = refId;
outputTargets.Add(refId, target);
queue.Enqueue(target);
}
return(refId);
}
private static WriteTarget GetCSVTarget(WriteTarget target)
{
return(target.ChangeExtension(".csv"));
}
private static WriteTarget GetHtmlFileName(WriteTarget target)
{
return(target.ChangeExtension(".html"));
}
public virtual void Render([NotNull] GlobalContext globalContext, [NotNull, ItemNotNull] IEnumerable <Dependency> dependencies, string options, [NotNull] WriteTarget target, bool ignoreCase)
{
DoRender(globalContext, dependencies, options, target);
}
protected string DoRender([NotNull] GlobalContext globalContext, [NotNull, ItemNotNull] IEnumerable <Dependency> dependencies, string argsAsString, WriteTarget baseFileName, params OptionAction[] additionalOptions)
{
if (dependencies.Any())
{
int width = -1;
int height = -1;
int minTextHeight = 15;
string htmlFormat = DEFAULT_HTML_FORMAT;
if (baseFileName == null || baseFileName.IsConsoleOut)
{
Option.ThrowArgumentException("Cannot write graphics file to Console.Out", argsAsString);
}
Option.Parse(globalContext, argsAsString, new[] {
WidthOption.Action((args, j) => {
width = Option.ExtractIntOptionValue(args, ref j, "No valid width");
return(j);
}),
HeightOption.Action((args, j) => {
height = Option.ExtractIntOptionValue(args, ref j, "No valid height");
return(j);
}),
MinTextHeightOption.Action((args, j) => {
minTextHeight = Option.ExtractIntOptionValue(args, ref j, "No valid text height");
return(j);
}),
TitleOption.Action((args, j) => {
_title = Option.ExtractRequiredOptionValue(args, ref j, "Missing title");
return(j);
}),
FormatOption.Action((args, j) => {
htmlFormat = Option.ExtractRequiredOptionValue(args, ref j, "Missing HTML format");
return(j);
}),
FormatFileOption.Action((args, j) => {
htmlFormat =
File.ReadAllText(Option.ExtractRequiredOptionValue(args, ref j, "Missing format file name"));
return(j);
})
}.Concat(additionalOptions).ToArray());
StringBuilder htmlForClicks = new StringBuilder();
Bitmap bitMap = Render(dependencies, minTextHeight, ref width, ref height, htmlForClicks,
globalContext.CheckAbort);
string gifFileName = GetGifFileName(baseFileName);
try {
Log.WriteInfo("Writing " + gifFileName);
bitMap.Save(gifFileName, ImageFormat.Gif);
} catch (Exception ex) {
Log.WriteError("Cannot save GIF image to file " + gifFileName +
". Make sure the file can be written (e.g., that directory is created). Internal message: " +
ex.Message);
throw;
}
WriteTarget htmlFile = GetHtmlFileName(baseFileName);
using (var tw = htmlFile.CreateWriter()) {
Log.WriteInfo("Writing " + htmlFile);
string html = string.Format(htmlFormat,
$@"<img src=""{Path.GetFileName(gifFileName)}"" width=""{width}"" height=""{height}"" usemap=""#map""/>
<map name=""map"">
{htmlForClicks}
</map>");
tw.WriteLine(html);
}
return(htmlFile.FullFileName);
}
else
{
Log.WriteWarning("No dependencies to render");
return(null);
}
}
private WriteTarget GetDotFileName(WriteTarget target)
{
return(target.ChangeExtension(".dot"));
}
private static WriteTarget GetTextFile(WriteTarget target)
{
return(GlobalContext.CreateFullFileName(target, null));
}
public override WriteTarget GetMasterFileName([NotNull] GlobalContext globalContext, Options options, WriteTarget baseTarget)
{
return(options.XmlOutput ? GetXmlFile(baseTarget) : GetTextFile(baseTarget));
}
public override void Render([NotNull] GlobalContext globalContext, [NotNull, ItemNotNull] IEnumerable <Dependency> dependencies, string options, [NotNull] WriteTarget target, bool ignoreCase)
{
DoRender(globalContext, dependencies, options, target,
InterfaceSelectorOption.Action((args, j) => {
_interfaceSelector = new Regex(Option.ExtractRequiredOptionValue(args, ref j, "Regex for interface selector missing"));
return(j);
}),
OrderFieldOption.Action((args, j) => {
string orderPattern = Option.ExtractRequiredOptionValue(args, ref j, "order field missing");
_orderSupport = OrderSupport.Create(orderPattern, ignoreCase);
return(j);
}));
}
private static string GetGifFileName(WriteTarget target)
{
return(target.ChangeExtension(".gif").FullFileName);
}
public override WriteTarget GetMasterFileName([NotNull] GlobalContext globalContext, string optionsString, WriteTarget baseTarget)
{
return(GetCSVTarget(baseTarget));
}
public override WriteTarget GetMasterFileName([NotNull] GlobalContext globalContext, Options options, WriteTarget baseTarget)
{
return(GlobalContext.CreateFullFileName(baseTarget, ".txt"));
}
public void PrepareEnvironment()
{
ScriptEnvironment = new EtcScriptLib.Environment();
ScriptEnvironment.AddSystemMacro("target main", (context, arguments) => { CurrentTarget = WriteTarget.Main; return null; });
ScriptEnvironment.AddSystemMacro("target bottom", (context, arguments) => { CurrentTarget = WriteTarget.CommandList; return null; });
ScriptEnvironment.AddSystemMacro("clear", (context, arguments) => { Clear(CurrentTarget); return null; });
ScriptEnvironment.AddSystemMacro("write (s:string)", (context, arguments) => { Output(arguments[0].ToString(), CurrentTarget); return null; });
}
public override void Render([NotNull] GlobalContext globalContext, [NotNull, ItemNotNull] IEnumerable <Dependency> dependencies, string options, [NotNull] WriteTarget target, bool ignoreCase)
{
int? labelWidthOrNull;
bool withNotOkCt;
ItemMatch itemMatchOrNull;
ParseOptions(globalContext, options, ignoreCase, out labelWidthOrNull, out withNotOkCt, out itemMatchOrNull);
using (var sw = target.ChangeExtension(".csv").CreateWriter()) {
Render(dependencies, null /*TODO: InnerMatch?*/, sw, labelWidthOrNull, withNotOkCt);
}
}
private static WriteTarget GetXmlFile(WriteTarget target)
{
return(target.ChangeExtension(".xml"));
}
public WriteTarget GetMasterFileName([NotNull] GlobalContext globalContext, string optionsString, WriteTarget baseTarget)
{
return(GetHtmlFileName(baseTarget));
}
public override WriteTarget GetMasterFileName([NotNull] GlobalContext globalContext, Options options, WriteTarget baseTarget)
{
return(GetDotFileName(baseTarget));
}
public abstract void Render([NotNull] GlobalContext globalContext, [NotNull, ItemNotNull] IEnumerable <Dependency> dependencies, string options, [NotNull] WriteTarget target, bool ignoreCase);
public abstract WriteTarget GetMasterFileName([NotNull] GlobalContext globalContext, string optionsString, WriteTarget baseTarget);
public string WriteToString()
{
RefId = 0;
structTargets.Clear();
outputTargets.Clear();
queue = new Queue <WriteTarget>(inputItems);
while (queue.Count > 0)
{
Serialize(queue.Dequeue());
}
StringBuilder refBuilder = new StringBuilder(outputTargets.Count);
StringBuilder fieldBuilder = new StringBuilder(500);
StringBuilder structBuilder = new StringBuilder(500);
StringBuilder tagBuilder = new StringBuilder(100);
StringBuilder typeBuilder = new StringBuilder(100);
typeBuilder.AppendLine("--types");
foreach (var kvp in typeMap)
{
typeBuilder.AppendLine(kvp.Key.AssemblyQualifiedName);
}
refBuilder.AppendLine("--refs");
fieldBuilder.AppendLine("--fields");
structBuilder.AppendLine("--structs");
tagBuilder.AppendLine("--tags");
foreach (var kvp in outputTargets)
{
WriteTarget target = kvp.Value;
refBuilder.AppendLine(target.GetRefLine(typeMap));
fieldBuilder.AppendLine(target.id.ToString());
fieldBuilder.Append(target.fields);
if (target.tagId != null)
{
tagBuilder.Append(target.tagId);
tagBuilder.Append(" ");
tagBuilder.AppendLine(target.id.ToString());
}
}
for (int i = 0; i < structTargets.Count; i++)
{
Serialize(structTargets[i]);
}
for (int i = 0; i < structTargets.Count; i++)
{
WriteTarget target = structTargets[i];
target.id = i;
structBuilder.AppendLine(target.GetRefLine(typeMap));
structBuilder.Append(target.fields);
}
string output = typeBuilder.ToString()
+ refBuilder.ToString()
+ structBuilder.ToString()
+ fieldBuilder.ToString()
+ tagBuilder.ToString();
#if DEBUG //for debugging to see file output split by line
Regex regex = new Regex("(\r\n|\r|\n)");
string source = regex.Replace(output, "\n");
string[] lines = source.Split('\n');
#endif
return(output);
// File.WriteAllBytes(path + ".gzip", AssetSerializerHelper.Zip(refBuilder.ToString() + fieldBuilder.ToString() + structBuilder.ToString() + tagBuilder.ToString()));
}
public override WriteTarget GetMasterFileName([NotNull] GlobalContext globalContext, string optionsString, WriteTarget baseTarget)
{
return(baseTarget.ChangeExtension(".csv"));
}
public override void Render([NotNull] GlobalContext globalContext, [NotNull, ItemNotNull] IEnumerable <Dependency> dependencies, string options, [NotNull] WriteTarget target, bool ignoreCase)
{
DoRender(globalContext, dependencies, options, target,
BottomRegexOption.Action((args, j) => {
string pattern = Option.ExtractRequiredOptionValue(args, ref j, "Pattern for selection of bottom items missing");
_bottomItemMatch = new ItemMatch(null, pattern, 0, ignoreCase, anyWhereMatcherOk: true);
return(j);
}),
OrderFieldOption.Action((args, j) => {
string orderPattern = Option.ExtractRequiredOptionValue(args, ref j, "order field missing");
_orderSupport = OrderSupport.Create(orderPattern, ignoreCase);
return(j);
}),
NoEmptiesOnBottomOption.Action((args, j) => {
_showOnlyReferencedOnBottom = true;
return(j);
}),
NoEmptiesOnLeftOption.Action((args, j) => {
_showOnlyReferencingOnLeft = true;
return(j);
}));
}
