public Simulation MapFrom(SimulationMetaData simulationMetaData)
{
var simulation = simulationFrom(simulationMetaData.SimulationMode);
simulationMetaData.BuildingBlocks.Each(bb => simulation.AddUsedBuildingBlock(mapFrom(bb)));
//no lazy load need for the simulation properties
simulation.Properties = _serializationManager.Deserialize <SimulationProperties>(simulationMetaData.Properties.Data);
simulationMetaData.UsedObservedData.Each(o => simulation.AddUsedObservedData(mapFrom(o)));
return(simulation);
}
private DataRepository dataRepositoryFor(Simulation simulation)
{
var dataRepositoryMetaData = _dataRepositoryQuery.ResultFor(simulation.Id);
if (dataRepositoryMetaData == null)
{
return(new NullDataRepository());
}
return(_serializationManager.Deserialize <DataRepository>(dataRepositoryMetaData.Content.Data));
}
public void LoadContentFor(SensitivityAnalysis sensitivityAnalysis)
{
var content = _sensitivityAnalysisMetaDataContentQuery.ResultFor(sensitivityAnalysis.Id);
if (content?.Data == null)
{
return;
}
_compressedSerializationManager.Deserialize(sensitivityAnalysis, content.Data);
}
public void LoadContentFor(ParameterIdentification parameterIdentification)
{
var content = _parameterIdentificationMetaDataContentQuery.ResultFor(parameterIdentification.Id);
if (content == null)
{
return;
}
_compressedSerializationManager.Deserialize(parameterIdentification, content.Data);
}
public void LoadContentFor(ISimulationComparison simulationComparison)
{
var content = _simulationComparisonMetaDataContentQuery.ResultFor(simulationComparison.Id);
if (content == null)
{
return;
}
_compressedSerializationManager.Deserialize(simulationComparison, content.Data);
}
public void LoadContentFor <T>(T objectToLoad) where T : IObjectBase
{
var content = _buildingBlockMetaDataContentQuery.ResultFor(objectToLoad.Id);
if (content == null)
{
return;
}
_serializationManager.Deserialize(objectToLoad, content.Data);
}
public void LoadAnalysesFor(PopulationSimulation populationSimulation)
{
var simulationAnalysesMetaData = _simulationAnalysesQuery.ResultFor(populationSimulation.Id);
PopulationSimulationPKAnalyses pkAnalyses = new NullPopulationSimulationPKAnalyses();
if (simulationAnalysesMetaData != null)
{
pkAnalyses = _serializationManager.Deserialize <PopulationSimulationPKAnalyses>(simulationAnalysesMetaData.Content.Data);
}
populationSimulation.PKAnalyses = pkAnalyses;
}
public IPKSimProject MapFrom(ProjectMetaData projectMetaData)
{
var project = new PKSimProject
{
Name = projectMetaData.Name,
Description = projectMetaData.Description
};
//Observed data needs to be loaded first into project
projectMetaData.AllObservedData.Each(x => project.AddObservedData(mapFrom(x)));
projectMetaData.BuildingBlocks.Each(x => project.AddBuildingBlock(mapFrom(x)));
//we need a shared context for all object referencing observed data and simulations
using (var context = _serializationContextFactory.Create(project.AllObservedData, project.All <ISimulation>()))
{
var localContext = context;
projectMetaData.ParameterIdentifications.Each(x => project.AddParameterIdentification(mapFrom(x, localContext)));
projectMetaData.SensitivityAnalyses.Each(x => project.AddSensitivityAnalysis(mapFrom(x, localContext)));
}
projectMetaData.SimulationComparisons.Each(x => project.AddSimulationComparison(mapFrom(x)));
//Once reference to dynamic meta data was added, deserialize the project itself
_serializationManager.Deserialize(project, projectMetaData.Content.Data);
//if the project DB Version is the same as the current project, the project did not change
if (projectMetaData.Version == ProjectVersions.Current)
{
project.HasChanged = false;
}
return(project);
}
public void LoadContentFor(SensitivityAnalysis sensitivityAnalysis)
{
var content = _sensitivityAnalysisMetaDataContentQuery.ResultFor(sensitivityAnalysis.Id);
if (content?.Data == null)
{
return;
}
using (var context = _serializationContextFactory.Create(externalReferences: _projectRetriever.CurrentProject.All <ISimulation>()))
{
_compressedSerializationManager.Deserialize(sensitivityAnalysis, content.Data, context);
}
}
public void LoadContentFor(ParameterIdentification parameterIdentification)
{
var content = _parameterIdentificationMetaDataContentQuery.ResultFor(parameterIdentification.Id);
if (content == null)
{
return;
}
using (var context = _serializationContextFactory.Create(externalReferences: _projectRetriever.CurrentProject.All <ISimulation>()))
{
_compressedSerializationManager.Deserialize(parameterIdentification, content.Data, context);
}
}
public TObject Deserialize <TObject>(byte[] serializationByte)
{
return(_serializationManager.Deserialize <TObject>(serializationByte));
}
public IWorkspaceLayout MapFrom(WorkspaceLayoutMetaData workspaceLayoutMetaData)
{
return(_serializationManager.Deserialize <IWorkspaceLayout>(workspaceLayoutMetaData.Content.Data));
}
private ISimulationAnalysis mapFrom(SimulationChartMetaData chart)
{
return(_serializationManager.Deserialize <ISimulationAnalysis>(chart.Content.Data));
}
