private static void Main(string[] args)
{
try
{
Arguments arguments = Arguments.ProcessArguments(args, new FileSystemService( ));
Trace.TraceInformation("Beginning documentation generation run at {0}".Inject(DateTime.Now.ToShortTimeString( )));
var parser = new XmlDocParser(arguments.XmlDocs, arguments.TargetType)
{
TargetAssembly = arguments.TargetAssembly
};
IEnumerable <XDocument> cleanedDocs = parser.Parse( );
var writer = new BatchWriter(cleanedDocs);
writer.Write(arguments.OutputDirectory);
Trace.TraceInformation("Finished documentation generation run at {0}".Inject(DateTime.Now.ToShortTimeString( )));
}
catch (ArgumentException e)
{
Console.WriteLine(e.Message);
}
catch (Exception e)
{
Trace.TraceInformation("Documentation generation run failed at {0}".Inject(DateTime.Now.ToShortTimeString( )));
Trace.TraceError(e.Message);
throw;
}
//finally
//{
// Console.ReadLine();
//}
}
public void EndBatch()
{
if (IsBatching)
{
IsBatching = false;
long pos = BatchStream.Position;
BatchStream.Seek(BatchSizeOff, SeekOrigin.Begin);
BatchWriter.Write((uint)pos);
BatchStream.Seek(BatchCmdOff, SeekOrigin.Begin);
BatchWriter.Write(BatchCmdCount);
BatchStream.Seek(pos, SeekOrigin.Begin);
}
}
public void Should_throw_when_name_attribute_is_missing()
{
var docs = new List <XDocument> {
new XDocument(new XElement("member"))
};
sut = new BatchWriter(docs)
{
FileSystemService = FileSystem
};
using (Record)
{
Expect
.Call(FileSystem.DoesDirectoryExist(OutputDirectory))
.Return(false);
}
using (PlayBack)
{
sut.Write(OutputDirectory);
}
}
public void AddCommand(RunnerCommand cmd, params object[] args)
{
if (IsBatching)
{
switch (cmd)
{
case RunnerCommand.Ping:
{
BatchCmdCount++;
BatchWriter.Write((int)RunnerCommand.Ping);
BatchWriter.Write((uint)args[0]); // sendID
BatchWriter.Write((int)args[1]); // flags
break;
}
case RunnerCommand.GetUpdate:
{
BatchCmdCount++;
BatchWriter.Write((int)RunnerCommand.GetUpdate);
BatchWriter.Write((int)args[0]); // flags
break;
}
case RunnerCommand.GetInstanceData:
{
BatchCmdCount++;
BatchWriter.Write((int)RunnerCommand.GetInstanceData);
BatchWriter.Write(AllInstances.Count);
for (int i = 0; i < AllInstances.Count; i++)
{
BatchWriter.Write(AllInstances[i].ID);
}
break;
}
}
}
}
public static void Write(OutputModel outputModel, DatabasePlan databasePlan, PartitionPlan partitionPlan)
{
var s = $@"
namespace {databasePlan.Namespace};
public class {partitionPlan.ClassName} : Cosmogenesis.Core.DbPartitionBase
{{
protected virtual {databasePlan.Namespace}.{databasePlan.DbClassName} {databasePlan.DbClassName} {{ get; }} = default!;
{PkClass(partitionPlan)}
/// <summary>Mocking constructor</summary>
protected {partitionPlan.ClassName}() {{ }}
internal protected {partitionPlan.ClassName}(
{new[] { ConstructorClassParameter(databasePlan), ConstructorKeyParameter(partitionPlan) }.Where(x => !string.IsNullOrEmpty(x)).JoinNonEmpty()})
: base(
db: {databasePlan.DbClassNameArgument},
partitionKey: {partitionPlan.GetPkPlan.FullMethodName}({partitionPlan.GetPkPlan.DocumentToParametersMapping("pkData")}),
serializer: {databasePlan.Namespace}.{databasePlan.SerializerClassName}.Instance)
{{
this.{databasePlan.DbClassName} = {databasePlan.DbClassNameArgument} ?? throw new System.ArgumentNullException(nameof({databasePlan.DbClassNameArgument}));
{PkClassSetter(partitionPlan)}
}}
{databasePlan.Namespace}.{partitionPlan.QueryBuilderClassName}? queryBuilder;
/// <summary>
/// Methods to build queries for later execution.
/// </summary>
public virtual {databasePlan.Namespace}.{partitionPlan.QueryBuilderClassName} QueryBuilder => this.queryBuilder ??= new(
{databasePlan.DbClassNameArgument}: this.{databasePlan.DbClassName},
partitionKey: this.PartitionKey);
{databasePlan.Namespace}.{partitionPlan.QueryClassName}? query;
/// <summary>
/// Methods to execute queries.
/// </summary>
public virtual {databasePlan.Namespace}.{partitionPlan.QueryClassName} Query => this.query ??= new(
{databasePlan.DbClassNameArgument}: this.{databasePlan.DbClassName},
{partitionPlan.QueryBuilderClassNameArgument}: this.QueryBuilder);
/// <summary>
/// A batch of operations to be executed atomically (or not at all) within a {partitionPlan.Name} in the {databasePlan.Name} database.
/// </summary>
public virtual {databasePlan.Namespace}.{partitionPlan.BatchClassName} CreateBatch() => new(
transactionalBatch: this.CreateBatchForPartition(),
partitionKey: this.PartitionKeyString,
validateStateBeforeSave: this.{databasePlan.DbClassName}.ValidateStateBeforeSave,
{partitionPlan.ClassNameArgument}: this);
{databasePlan.Namespace}.{partitionPlan.ReadClassName}? read;
/// <summary>
/// Methods to read documents.
/// </summary>
public virtual {databasePlan.Namespace}.{partitionPlan.ReadClassName} Read => this.read ??= new(
{databasePlan.DbClassNameArgument}: this.{databasePlan.DbClassName},
partitionKey: this.PartitionKey);
{databasePlan.Namespace}.{partitionPlan.ReadOrThrowClassName}? readOrThrow;
/// <summary>
/// Methods to read documents, or throw DbConflictException is they are not found.
/// </summary>
public virtual {databasePlan.Namespace}.{partitionPlan.ReadOrThrowClassName} ReadOrThrow => this.readOrThrow ??= new(
{databasePlan.DbClassNameArgument}: this.{databasePlan.DbClassName},
partitionKey: this.PartitionKey);
{databasePlan.Namespace}.{partitionPlan.CreateClassName}? create;
/// <summary>
/// Methods to create documents.
/// </summary>
public virtual {databasePlan.Namespace}.{partitionPlan.CreateClassName} Create => this.create ??= new(this);
{databasePlan.Namespace}.{partitionPlan.ReadOrCreateClassName}? readOrCreate;
/// <summary>
/// Methods to read documents, or create them if they did not yet exist.
/// </summary>
public virtual {databasePlan.Namespace}.{partitionPlan.ReadOrCreateClassName} ReadOrCreate => this.readOrCreate ??= new(this);
{ReadMany(databasePlan, partitionPlan)}
{CreateOrReplace(databasePlan, partitionPlan)}
{string.Concat(partitionPlan.Documents.Select(x => Create(partitionPlan, x)))}
{string.Concat(partitionPlan.Documents.Select(x => CreateOrReplace(partitionPlan, x)))}
{string.Concat(partitionPlan.Documents.Select(x => ReadOrCreate(partitionPlan, x)))}
{string.Concat(partitionPlan.Documents.Select(ReplaceIfMutable))}
{string.Concat(partitionPlan.Documents.Select(DeleteIfTransient))}
}}
";
outputModel.Context.AddSource($"partition_{partitionPlan.ClassName}.cs", s);
BatchWriter.Write(outputModel, databasePlan, partitionPlan);
CreateWriter.Write(outputModel, databasePlan, partitionPlan);
ReadOrCreateWriter.Write(outputModel, databasePlan, partitionPlan);
CreateOrReplaceWriter.Write(outputModel, databasePlan, partitionPlan);
ReadWriter.Write(outputModel, databasePlan, partitionPlan);
ReadOrThrowWriter.Write(outputModel, databasePlan, partitionPlan);
ReadManyWriter.Write(outputModel, databasePlan, partitionPlan);
QueryBuilderWriter.Write(outputModel, databasePlan, partitionPlan);
QueryWriter.Write(outputModel, databasePlan, partitionPlan);
}
