private static void ReadExpertClassSpecifications(TreeEventEntity entity, ReadConversionCollector collector, TreeEvent treeEvent)
{
var specifications = entity.ExpertClassEstimationEntities.OrderBy(e => e.Order).Select(e => e.Read(collector));
foreach (var specification in specifications)
{
treeEvent.ClassesProbabilitySpecification.Add(specification);
}
}
private static void AddExpertClassEstimations(TreeEventEntity entity, TreeEvent model, PersistenceRegistry registry)
{
for (var index = 0; index < model.ClassesProbabilitySpecification.Count; index++)
{
var expertClassEstimationEntity = model.ClassesProbabilitySpecification[index].Create(registry);
expertClassEstimationEntity.TreeEventEntity = entity;
expertClassEstimationEntity.Order = index;
entity.ExpertClassEstimationEntities.Add(expertClassEstimationEntity);
}
}
private static void AddFragilityCurveElements(TreeEventEntity entity, TreeEvent model, PersistenceRegistry registry)
{
if (model.FixedFragilityCurve != null)
{
for (var index = 0; index < model.FixedFragilityCurve.Count; index++)
{
var fragilityCurveElement = model.FixedFragilityCurve[index];
var curveElementEntity = new TreeEventFragilityCurveElementEntity
{
FragilityCurveElementEntity = fragilityCurveElement.Create(registry),
TreeEventEntity = entity,
Order = index
};
entity.TreeEventFragilityCurveElementEntities.Add(curveElementEntity);
}
}
}
internal static TreeEvent Read(this TreeEventEntity entity, ReadConversionCollector collector)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
if (collector.Contains(entity))
{
return(collector.Get(entity));
}
var treeEvent = new TreeEvent
{
Name = entity.Name,
Details = entity.Details,
FixedProbability = entity.FixedProbability == null
? Probability.NaN
: (Probability)(double)entity.FixedProbability,
ProbabilitySpecificationType = (ProbabilitySpecificationType)entity.ProbabilitySpecificationType,
Summary = entity.Summary,
Information = entity.Information,
Discussion = entity.Discussion
// TODO: Add PassPhrase
};
ReadFragilityCurve(treeEvent, entity.TreeEventFragilityCurveElementEntities, collector);
if (entity.TreeEventEntity3 != null)
{
treeEvent.FailingEvent = entity.TreeEventEntity3.Read(collector);
}
if (entity.TreeEventEntity2 != null)
{
treeEvent.PassingEvent = entity.TreeEventEntity2.Read(collector);
}
ReadExpertClassSpecifications(entity, collector, treeEvent);
collector.Collect(entity, treeEvent);
return(treeEvent);
}
internal static TreeEventEntity Create(this TreeEvent model, PersistenceRegistry registry)
{
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
if (registry.Contains(model))
{
return(registry.Get(model));
}
var entity = new TreeEventEntity
{
Name = model.Name.DeepClone(),
Details = model.Details.DeepClone(),
Summary = model.Summary.DeepClone(),
FixedProbability = ((double)model.FixedProbability).ToNaNAsNull(),
ProbabilitySpecificationType = Convert.ToByte(model.ProbabilitySpecificationType),
Information = model.Information.DeepClone(),
Discussion = model.Discussion.DeepClone(),
// Add passphrase
};
AddExpertClassEstimations(entity, model, registry);
AddFragilityCurveElements(entity, model, registry);
if (model.FailingEvent != null)
{
entity.TreeEventEntity3 = model.FailingEvent.Create(registry);
}
if (model.PassingEvent != null)
{
entity.TreeEventEntity2 = model.PassingEvent.Create(registry);
}
registry.Register(model, entity);
return(entity);
}
internal bool Contains(TreeEventEntity entity)
{
return(Contains(treeEvents, entity));
}
internal void Collect(TreeEventEntity entity, TreeEvent model)
{
Collect(treeEvents, entity, model);
}
internal TreeEvent Get(TreeEventEntity entity)
{
return(Get(treeEvents, entity));
}
internal void Register(TreeEvent model, TreeEventEntity entity)
{
Register(treeEvents, model, entity);
}
