public IDomainTree Load(EntityData entityData)
{
var outcome = _validator.Validate(entityData);
if (outcome.IsFailure)
{
throw new DataValidationException(outcome.Message);
}
IDomainTree domainTree = new DomainTree();
var domainAttributesCount = entityData.Attributes.Count;
var attributesBuffer = new string[domainAttributesCount];
entityData.Attributes.CopyTo(attributesBuffer);
domainTree.Attributes = new List <string>(attributesBuffer);
for (var i = 0; i < domainAttributesCount; i++)
{
domainTree.Domain.Add(new List <string>());
}
EvalInputFrom(entityData, domainTree);
return(domainTree);
}
public static IEnumerable <T> ClosestData <T>(this DomainTree <T> tree,
DomainBox searchBox,
bool tightBox = false,
double maxDistance = double.PositiveInfinity,
double tolerance = Tolerance.Distance)
{
if (searchBox == null)
{
return(new List <T>());
}
Func <DomainTree <T>, double> evaluationMethod = (x) => x.DomainBox?.SquareDistance(searchBox) ?? double.PositiveInfinity;
Func <DomainTree <T>, double> worstCaseMethod;
if (tightBox)
{
worstCaseMethod = (x) => x.DomainBox?.FurthestTightSquareDistance(searchBox) ?? double.PositiveInfinity;
}
else
{
worstCaseMethod = (x) => x.DomainBox?.FurthestSquareDistance(searchBox) ?? double.PositiveInfinity;
}
return(ClosestData <DomainTree <T>, T>(tree, evaluationMethod, worstCaseMethod, maxDistance * maxDistance, tolerance * tolerance));
}
public void Setup()
{
if (Directory.Exists("Generated"))
{
Directory.Delete("Generated", true);
}
if (Directory.Exists("HttpAdapter"))
{
Directory.Delete("HttpAdapter", true);
}
if (Directory.Exists("SqlAdapter"))
{
Directory.Delete("SqlAdapter", true);
}
if (Directory.Exists("Application"))
{
Directory.Delete("Application", true);
}
if (Directory.Exists("Domain"))
{
Directory.Delete("Domain", true);
}
if (Directory.Exists("Solution"))
{
Directory.Delete("Solution", true);
}
using (var reader = new StreamReader("Schema.mic"))
{
var content = reader.ReadToEnd();
DomainTree = new DslParser(new MicrowaveLanguageTokenizer(), new MicrowaveLanguageParser()).Parse(content);
}
}
public void Write(DomainTree domainTree)
{
foreach (var domainClass in domainTree.Classes)
{
var controller = _repositoryBuilder.Build(domainClass);
_fileWriter.WriteToFile($"{domainClass.Name}s", controller);
}
new PrivateSetPropertyHackCleaner().ReplaceHackPropertyNames(_basePath);
}
public static IEnumerable <T> ItemsInRange <T>(this DomainTree <T> tree, DomainBox box, double tolerance = Tolerance.Distance)
{
if (box == null)
{
return(new List <T>());
}
Func <DomainTree <T>, bool> isWithinSearch = x => x.DomainBox?.IsInRange(box, tolerance) ?? false;
return(ItemsInRange <DomainTree <T>, T>(tree, isWithinSearch));
}
public static List <List <T> > DomainTreeClusters <T>(this List <T> data, Func <T, DomainBox> toDomainBox, Func <DomainBox, DomainBox, bool> treeEvaluator, Func <T, T, bool> itemEvaluator, int minItemCount = 1)
{
if (data.Count == 0)
{
return(new List <List <T> >());
}
List <T> items = new List <T>(data);
List <bool> check = items.Select(x => false).ToList();
List <DomainBox> domainBoxes = data.Select(x => toDomainBox(x)).ToList();
DomainTree <int> indexTree = Data.Create.DomainTree(domainBoxes.Select((x, i) => Data.Create.DomainTreeLeaf(i, x)));
List <List <T> > result = new List <List <T> >();
List <int> toEvaluate = new List <int>();
int count = -1;
for (int i = 0; i < items.Count; i++)
{
if (check[i])
{
continue;
}
result.Add(new List <T>());
count++;
toEvaluate.Add(i);
check[i] = true;
while (toEvaluate.Count > 0)
{
// Find all the neighbours for each item in toEvaluate, and add them in toEvaluate
foreach (int index in Data.Query.ItemsInRange <DomainTree <int>, int>(indexTree, x => treeEvaluator(x.DomainBox, domainBoxes[toEvaluate[0]])))
{
if (!check[index])
{
if (itemEvaluator(items[toEvaluate[0]], items[index]))
{
toEvaluate.Add(index);
check[index] = true;
}
}
}
// move the checked items from toEvaluate to result
result[count].Add(items[toEvaluate[0]]);
toEvaluate.RemoveAt(0);
}
}
return(result.Where(list => list.Count >= minItemCount).ToList());
}
public void Write(DomainTree domainTree, string basePath)
{
foreach (var domainClass in domainTree.Classes)
{
foreach (var domainEvent in domainClass.Events)
{
var domainEventClass = _classBuilderDirector.BuildInstance(new DomainEventBuilder(domainClass, domainEvent));
_fileWriter.WriteToFile($"{domainClass.Name}s", domainEventClass);
}
var domainClassBuild = _classBuilderDirector.BuildInstance(new DomainClassBuilder(domainClass));
_fileWriter.WriteToFile($"{domainClass.Name}s", domainClassBuild);
var domainClassFirst = _classBuilderDirector.BuildInstance(new DomainClassFirstBuilder(domainClass));
if (!ClassIsAllreadyExisting(domainClass))
{
_fileWriterOneTime.WriteToFile("", domainClassFirst, false);
}
var commands = _commandBuilder.Build(domainClass);
foreach (var command in commands)
{
_fileWriter.WriteToFile($"{domainClass.Name}s/Commands", command);
}
}
var validationResult = _classBuilderDirector.BuildInstance(new ValidationResultBaseClassBuilder(new ValidationResultBaseClass()));
_fileWriter.WriteToFile("Base", validationResult);
var codeNamespace = _classBuilderDirector.BuildInstance(new CreationResultBaseClassBuilder(new CreationResultBaseClass()));
_fileWriter.WriteToFile("Base", codeNamespace);
var domainEventBaseClass = _classBuilderDirector.BuildInstance(new DomainEventBaseClassBuilder(new DomainEventBaseClass()));
_fileWriter.WriteToFile("Base", domainEventBaseClass);
new PrivateSetPropertyHackCleaner().ReplaceHackPropertyNames(basePath);
}
public static DomainTree <T> DomainTree <T>(IEnumerable <DomainTree <T> > dataItems, int treeDegree = 16, int leafSize = 16, int sampleSize = 60)
{
sampleSize = Math.Max(2, sampleSize);
Func <IEnumerable <DomainTree <T> >, Output <List <DomainTree <T> >, List <DomainTree <T> > > > splitMethod = (list) =>
{
return(SplitList((list as List <DomainTree <T> >), sampleSize));
};
Func <IEnumerable <DomainTree <T> >, DomainTree <T> > setChildrenToNode = (children) =>
{
DomainTree <T> tree = new DomainTree <T>()
{
Children = children?.ToList() ?? new List <DomainTree <T> >(),
DomainBox = children?.Select(x => x?.DomainBox).Aggregate((x, y) => x + y)
};
return(tree);
};
return(Node <DomainTree <T>, T>(dataItems, splitMethod, setChildrenToNode, treeDegree, leafSize));
}
public void Write(DomainTree domainTree)
{
foreach (var domainClass in domainTree.Classes)
{
var repo = _repositoryBuilder.Build(domainClass);
_fileWriter.WriteToFile($"{domainClass.Name}s", repo);
}
var dbContext = _eventStoreContextBuilder.Build(domainTree.Classes.ToList());
_fileWriter.WriteToFile("Base", dbContext);
var hangfireContext = _hangfireContextBuilder.Build(domainTree.Classes.ToList());
_fileWriter.WriteToFile("Base", hangfireContext);
var eventStoreRepo = _classBuilderDirector.BuildInstance(new EventStoreRepositoryBuilder(new EventStoreRepository()));
_fileWriter.WriteToFile("Base", eventStoreRepo);
var eventTuple = _classBuilderDirector.BuildInstance(new DefaultClassBuilder(_sqlAdapterNameSpace, new EventTupleClass()));
_fileWriter.WriteToFile("Base", eventTuple);
var eventJobRegistration = _eventJobRegistrationClassBuilder.Build(domainTree.AsyncDomainHooks);
_fileWriter.WriteToFile("Base", eventJobRegistration);
var hangfireQueue = _hangfireQueueBuilder.Build(new HangfireQueueClass());
_fileWriter.WriteToFile("Base", hangfireQueue);
var queueRepo = _queueRepositoryBuilder.Build(new QueueRepositoryClass());
_fileWriter.WriteToFile("Base", queueRepo);
new PrivateSetPropertyHackCleaner().ReplaceHackPropertyNames(_basePath);
}
public static List <T> Values <T>(this DomainTree <T> node)
{
return(node?.Values ?? new List <T>());
}
private static DomainBox Bounds <T>(this DomainTree <T> domainTree)
{
return(domainTree.Children.Select(x => x.DomainBox).Aggregate((x, y) => x + y));
}
public void Write(DomainTree domainTree)
{
foreach (var domainClass in domainTree.Classes)
{
var commandHandler = _commandHandlerBuilder.Build(domainClass);
_fileWriter.WriteToFile($"{domainClass.Name}s", commandHandler);
var iRepository = _repositoryInterfaceBuilder.Build(domainClass);
_fileWriter.WriteToFile($"{domainClass.Name}s", iRepository);
foreach (var loadMethod in domainClass.LoadMethods)
{
var apiCommand = _apiCommandBuilder.Build(loadMethod, domainClass);
_fileWriter.WriteToFile($"{domainClass.Name}s", apiCommand);
}
foreach (var hook in domainClass.ChildHookMethods)
{
var createdHook = _synchronousHookBuilder.BuildOnChildHook(hook, domainClass.Properties, domainClass.ListProperties);
_fileWriter.WriteToFile($"{hook.ContainingClassName}s/Hooks/", createdHook);
}
}
foreach (var hook in domainTree.SynchronousDomainHooks)
{
var createdHook = _synchronousHookBuilder.Build(hook);
_fileWriter.WriteToFile($"{hook.ClassType}s/Hooks/", createdHook);
var formattableString = $"{_applicationBasePathRealClasses}{hook.ClassType}s/Hooks/{hook.Name}Hook.cs";
if (!File.Exists(formattableString))
{
var buildReplacementClass = _synchronousHookBuilder.BuildReplacementClass(hook);
_fileWriterRealClasses.WriteToFile($"{hook.ClassType}s/Hooks", buildReplacementClass, false);
}
}
foreach (var hook in domainTree.AsyncDomainHooks)
{
var createdHookEventHandler = _asyncHookCreateEventHandlerBuilder.Build(hook);
_fileWriter.WriteToFile($"{hook.ClassType}s/AsyncHooks/", createdHookEventHandler);
var formattableString = $"{_applicationBasePathRealClasses}{hook.ClassType}s/AsyncHooks/{_nameBuilderUtil.AsyncEventHookName(hook)}.cs";
if (!File.Exists(formattableString))
{
var buildReplacementClass = _classBuilderDirector.BuildInstance(new AsyncHookBuilder(hook));
_fileWriterRealClasses.WriteToFile($"{hook.ClassType}s/AsyncHooks", buildReplacementClass, false);
}
}
var hookResult = _hookResultBuilder.Build(new HookResultBaseClass());
_fileWriter.WriteToFile("Base", hookResult);
var hookBase = _hookBaseClassBuilder.Build(new DomainHookBaseClass());
_fileWriter.WriteToFile("Base", hookBase);
var eventStoreRepoInterface = _eventStoreRepositoryInterfaceBuilder.Build(new EventStoreRepositoryInterface());
_fileWriter.WriteToFile("Base", eventStoreRepoInterface);
var eventStore = _eventStoreBuilder.Build(new EventStore());
_fileWriter.WriteToFile("Base", eventStore);
var eventStoreInterface = _eventStoreInterfaceBuilder.Build(new EventStoreInterface());
_fileWriter.WriteToFile("Base", eventStoreInterface);
var hangfireQueue = _hangfireQueueInterfaceBuilder.Build(new HangfireQueueInterface());
_fileWriter.WriteToFile("Base", hangfireQueue);
var jobAndEventClass = _eventAndJobClassBuilder.Build(new EventAndJobClass());
_fileWriter.WriteToFile("Base", jobAndEventClass);
var queueRepo = _queueRepositoryInterfaceBuilder.Build(new QueueRepositoryInterface());
_fileWriter.WriteToFile("Base", queueRepo);
new PrivateSetPropertyHackCleaner().ReplaceHackPropertyNames(_basePath);
}
public static List <DomainTree <T> > Children <T>(this DomainTree <T> node)
{
return(node?.Children ?? new List <DomainTree <T> >());
}
