protected override void Context()
{
_view = A.Fake <ISensitivityAnalysisParameterSelectionView>();
_simulationParametersPresenter = A.Fake <ISimulationParametersPresenter>();
_sensitivityAnalysisParametersPresenter = A.Fake <ISensitivityAnalysisParametersPresenter>();
_simulationRepository = A.Fake <ISimulationRepository>();
_lazyLoadTask = A.Fake <ILazyLoadTask>();
_simulationSelector = A.Fake <ISimulationSelector>();
_sensitivityAnalysisTask = A.Fake <ISensitivityAnalysisTask>();
sut = new SensitivityAnalysisParameterSelectionPresenter(_view, _simulationParametersPresenter, _sensitivityAnalysisParametersPresenter, _simulationRepository, _lazyLoadTask, _simulationSelector, _sensitivityAnalysisTask);
_sensitivityAnalysis = new SensitivityAnalysis {
Simulation = A.Fake <ISimulation>()
};
_simulations = new[] { _sensitivityAnalysis.Simulation };
A.CallTo(() => _simulationRepository.All()).Returns(_simulations);
A.CallTo(() => _simulationSelector.SimulationCanBeUsedForSensitivityAnalysis(_sensitivityAnalysis.Simulation)).Returns(true);
}
protected override void Context()
{
_view = A.Fake <ICreatePopulationAnalysisView>();
_dialogCreator = A.Fake <IDialogCreator>();
_populationAnalysisTemplateTask = A.Fake <IPopulationAnalysisTemplateTask>();
_populationAnalysisChartFactory = A.Fake <IPopulationAnalysisChartFactory>();
_lazyLoadTask = A.Fake <ILazyLoadTask>();
_populationAnalysisTask = A.Fake <IPopulationAnalysisTask>();
_subPresenterManager = SubPresenterHelper.Create <IPopulationAnalysisItemPresenter>();
_parameterSelectionPresenter = _subPresenterManager.CreateFake(TimeProfileItems.ParameterSelection);
_pkParameterSpecificationPresenter = _subPresenterManager.CreateFake(TimeProfileItems.PKParameterSpecification);
_populationAnalysisFieldFactory = A.Fake <IPopulationAnalysisFieldFactory>();
_populationAnalysisChart = new TimeProfileAnalysisChart {
PopulationAnalysis = new PopulationStatisticalAnalysis()
};
A.CallTo(() => _populationAnalysisChartFactory.Create <PopulationStatisticalAnalysis, TimeProfileAnalysisChart>()).Returns(_populationAnalysisChart);
sut = new CreateTimeProfileAnalysisPresenter(_view, _subPresenterManager, _dialogCreator, _populationAnalysisTemplateTask, _populationAnalysisChartFactory, _lazyLoadTask, _populationAnalysisTask, _populationAnalysisFieldFactory);
}
protected override Task Context()
{
_logger = A.Fake <ILogger>();
_workspacePersitor = A.Fake <IWorkspacePersistor>();
_workspace = A.Fake <ICoreWorkspace>();
_simulationExporter = A.Fake <ISimulationExporter>();
_lazyLoadTask = A.Fake <ILazyLoadTask>();
sut = new ExportSimulationRunner(_logger, _workspacePersitor, _workspace, _simulationExporter, _lazyLoadTask);
_project = new PKSimProject {
Name = _projectName
};
_simulation1 = createSimulationWithResults(_simulation1Name);
_simulation2 = createSimulationWithResults(_simulation2Name);
A.CallTo(() => _workspacePersitor.LoadSession(_workspace, _projectFileName)).Invokes(x => { _workspace.Project = _project; });
return(_completed);
}
public InteractiveSimulationRunner(
ISimulationSettingsRetriever simulationSettingsRetriever,
ISimulationRunner simulationRunner,
ICloner cloner,
ISimulationAnalysisCreator simulationAnalysisCreator,
ILazyLoadTask lazyLoadTask)
{
_simulationSettingsRetriever = simulationSettingsRetriever;
_simulationRunner = simulationRunner;
_cloner = cloner;
_simulationAnalysisCreator = simulationAnalysisCreator;
_lazyLoadTask = lazyLoadTask;
_simulationRunOptions = new SimulationRunOptions
{
CheckForNegativeValues = true,
RaiseEvents = true,
RunForAllOutputs = false,
SimModelExportMode = SimModelExportMode.Optimized
};
}
public ExpressionProfileUpdater(
IParameterSetUpdater parameterSetUpdater,
IContainerTask containerTask,
IOntogenyTask ontogenyTask,
ICloner cloner,
IPKSimProjectRetriever projectRetriever,
ILazyLoadTask lazyLoadTask,
IParameterIdUpdater parameterIdUpdater,
IExecutionContext executionContext,
IDiseaseStateImplementationFactory diseaseStateImplementationFactory)
{
_parameterSetUpdater = parameterSetUpdater;
_containerTask = containerTask;
_ontogenyTask = ontogenyTask;
_cloner = cloner;
_projectRetriever = projectRetriever;
_lazyLoadTask = lazyLoadTask;
_parameterIdUpdater = parameterIdUpdater;
_executionContext = executionContext;
_diseaseStateImplementationFactory = diseaseStateImplementationFactory;
}
public MoBiContext(IObjectBaseFactory objectBaseFactory, IMoBiDimensionFactory dimensionFactory, IEventPublisher eventPublisher,
IXmlSerializationService serializationService, IObjectPathFactory objectPathFactory, IWithIdRepository objectBaseRepository,
IHistoryManagerFactory historyManagerFactory, IRegisterTask registerTask, IUnregisterTask unregisterTask,
IClipboardManager clipboardManager, IContainer container, IObjectTypeResolver objectTypeResolver,
ICloneManagerForBuildingBlock cloneManager, IJournalSession journalSession, IFileLocker fileLocker, ILazyLoadTask lazyLoadTask) : base(eventPublisher, journalSession, fileLocker)
{
ObjectBaseFactory = objectBaseFactory;
ObjectRepository = objectBaseRepository;
EventPublisher = eventPublisher;
DimensionFactory = dimensionFactory;
ObjectPathFactory = objectPathFactory;
_serializationService = serializationService;
_container = container;
_objectTypeResolver = objectTypeResolver;
_cloneManager = cloneManager;
_lazyLoadTask = lazyLoadTask;
_historyManagerFactory = historyManagerFactory;
_registerTask = registerTask;
_unregisterTask = unregisterTask;
_clipboardManager = clipboardManager;
}
public ProjectMapper(
SimulationMapper simulationMapper,
SimulationComparisonMapper simulationComparisonMapper,
ParameterIdentificationMapper parameterIdentificationMapper,
QualificationPlanMapper qualificationPlanMapper,
IExecutionContext executionContext,
IClassificationSnapshotTask classificationSnapshotTask,
ILazyLoadTask lazyLoadTask,
ICreationMetaDataFactory creationMetaDataFactory,
ILogger logger)
{
_simulationMapper = simulationMapper;
_simulationComparisonMapper = simulationComparisonMapper;
_parameterIdentificationMapper = parameterIdentificationMapper;
_qualificationPlanMapper = qualificationPlanMapper;
_classificationSnapshotTask = classificationSnapshotTask;
_lazyLoadTask = lazyLoadTask;
_creationMetaDataFactory = creationMetaDataFactory;
_logger = logger;
//required to load the snapshot mapper via execution context to avoid circular references
_snapshotMapper = new Lazy <ISnapshotMapper>(executionContext.Resolve <ISnapshotMapper>);
}
public SensitivityAnalysisParameterSelectionPresenter(
ISensitivityAnalysisParameterSelectionView view,
ISimulationParametersPresenter simulationParametersPresenter,
ISensitivityAnalysisParametersPresenter sensitivityAnalysisParametersPresenter,
ISimulationRepository simulationRepository,
ILazyLoadTask lazyLoadTask,
ISimulationSelector simulationSelector,
ISensitivityAnalysisTask sensitivityAnalysisTask,
IApplicationController applicationController) : base(view)
{
_simulationParametersPresenter = simulationParametersPresenter;
_sensitivityAnalysisParametersPresenter = sensitivityAnalysisParametersPresenter;
_simulationRepository = simulationRepository;
_lazyLoadTask = lazyLoadTask;
_simulationSelector = simulationSelector;
_sensitivityAnalysisTask = sensitivityAnalysisTask;
_applicationController = applicationController;
_subPresenterManager.Add(_simulationParametersPresenter);
_subPresenterManager.Add(_sensitivityAnalysisParametersPresenter);
_view.AddSimulationParametersView(_simulationParametersPresenter.BaseView);
_view.AddSensitivityParametersView(_sensitivityAnalysisParametersPresenter.BaseView);
}
protected override void Context()
{
_dimensionRepository = A.Fake <IDimensionRepository>();
_representationInfoRepository = A.Fake <IRepresentationInfoRepository>();
_lazyLoadTask = A.Fake <ILazyLoadTask>();
_observedCurveDataMapper = A.Fake <IDataRepositoryToObservedCurveDataMapper>();
_statisticalAnalysis = new PopulationStatisticalAnalysis();
_genderField = ChartDataHelperForSpecs.CreateGenderField();
_statisticalAnalysis.Add(_genderField);
_statisticalAnalysis.Add(_outputFieldVenousBloodPlasma);
_statisticalAnalysis.Add(_outputFieldLiverCell);
_predefinedStatisticalAggregation = new PredefinedStatisticalAggregation {
Selected = true
};
_percentileStatisticalAggregation = new PercentileStatisticalAggregation {
Selected = false, Percentile = 50
};
_statisticalAnalysis.AddStatistic(_predefinedStatisticalAggregation);
_statisticalAnalysis.AddStatistic(_percentileStatisticalAggregation);
A.CallTo(() => _representationInfoRepository.DisplayNameFor(_predefinedStatisticalAggregation)).Returns(_singleCurveId);
A.CallTo(() => _representationInfoRepository.DisplayNameFor(_percentileStatisticalAggregation)).Returns(_percentileId);
_statisticalDataCalculator = new StatisticalDataCalculator();
_pivotResultCreator = A.Fake <IPivotResultCreator>();
_mergedDimensionVenousBloodPlasma = DomainHelperForSpecs.ConcentrationDimensionForSpecs();
_mergedDimensionLiverCell = DomainHelperForSpecs.FractionDimensionForSpecs();
A.CallTo(() => _dimensionRepository.MergedDimensionFor(A <IWithDimension> ._))
.WhenArgumentsMatch((IWithDimension context) => Equals((context as NumericFieldContext)?.NumericValueField, _outputFieldVenousBloodPlasma))
.Returns(_mergedDimensionVenousBloodPlasma);
A.CallTo(() => _dimensionRepository.MergedDimensionFor(A <IWithDimension> ._))
.WhenArgumentsMatch((IWithDimension context) => Equals((context as NumericFieldContext)?.NumericValueField, _outputFieldLiverCell))
.Returns(_mergedDimensionLiverCell);
sut = new TimeProfileChartDataCreator(_dimensionRepository, _pivotResultCreator, _representationInfoRepository,
_statisticalDataCalculator, _lazyLoadTask, _observedCurveDataMapper);
}
protected override void Context()
{
_simulationPresenter = A.Fake <ICreateSimulationPresenter>();
_view = A.Fake <ISimulationSubjectConfigurationView>();
_simulationFactory = A.Fake <ISimulationFactory>();
_buildingBlockInSimulationManager = A.Fake <IBuildingBlockInSimulationManager>();
_simulation = A.Fake <Simulation>();
_lazyLoadTask = A.Fake <ILazyLoadTask>();
sut = new SimulationSubjectConfigurationPresenter(_view, _lazyLoadTask, _buildingBlockInSimulationManager);
A.CallTo(() => _view.BindTo(A <SimulationSubjectDTO> ._))
.Invokes(x => _simulationSubjectDTO = x.GetArgument <SimulationSubjectDTO>(0));
sut.InitializeWith(_simulationPresenter);
_subject = A.Fake <ISimulationSubject>();
var originData = new OriginData {
SpeciesPopulation = A.Fake <SpeciesPopulation>()
};
A.CallTo(() => _subject.OriginData).Returns(originData);
sut.Initialize();
}
public SimulationRunner(ISimulationEngineFactory simulationEngineFactory, ISimulationAnalysisCreator simulationAnalysisCreator, ILazyLoadTask lazyLoadTask,
IEntityValidationTask entityValidationTask, ISimulationSettingsRetriever simulationSettingsRetriever, ICloner cloner)
{
_simulationEngineFactory = simulationEngineFactory;
_simulationAnalysisCreator = simulationAnalysisCreator;
_lazyLoadTask = lazyLoadTask;
_entityValidationTask = entityValidationTask;
_simulationSettingsRetriever = simulationSettingsRetriever;
_cloner = cloner;
}
public SimpleProtocolTeXBuilder(ITeXBuilderRepository builderRepository, IReportGenerator reportGenerator, ILazyLoadTask lazyLoadTask) : base(builderRepository, reportGenerator, lazyLoadTask)
{
}
protected override Task Context()
{
_classificationMapper = A.Fake <ClassificationMapper>();
_snapshotMapper = A.Fake <ISnapshotMapper>();
_executionContext = A.Fake <IExecutionContext>();
_lazyLoadTask = A.Fake <ILazyLoadTask>();
_simulationMapper = A.Fake <SimulationMapper>();
_simulationComparisonMapper = A.Fake <SimulationComparisonMapper>();
_parameterIdentificationMapper = A.Fake <ParameterIdentificationMapper>();
_classificationSnapshotTask = A.Fake <IClassificationSnapshotTask>();
_qualificationPlanMapper = A.Fake <QualificationPlanMapper>();
_creationMetaDataFactory = A.Fake <ICreationMetaDataFactory>();
_logger = A.Fake <ILogger>();
sut = new ProjectMapper(
_simulationMapper,
_simulationComparisonMapper,
_parameterIdentificationMapper,
_qualificationPlanMapper,
_executionContext,
_classificationSnapshotTask,
_lazyLoadTask,
_creationMetaDataFactory,
_logger);
A.CallTo(() => _executionContext.Resolve <ISnapshotMapper>()).Returns(_snapshotMapper);
_individual = new Individual().WithName("IND");
_compound = new Compound().WithName("COMP");
_event = new PKSimEvent().WithName("EVENT");
_formulation = new Formulation().WithName("FORM");
_protocol = new SimpleProtocol().WithName("PROTO");
_population = new RandomPopulation().WithName("POP");
_observedData = new DataRepository().WithName("OD");
_parameterIdentification = new OSPSuite.Core.Domain.ParameterIdentifications.ParameterIdentification().WithName("PI").WithId("PI_ID");
_classifiableObservedData = new ClassifiableObservedData {
Subject = _observedData
};
_classification = new Classification {
ClassificationType = ClassificationType.ObservedData
}.WithName("OD Classification");
_simulationComparison = new IndividualSimulationComparison().WithName("COMP").WithId("SimComp");
_simulation = new IndividualSimulation().WithName("IND_SIM").WithId("IndSim");
_qualificationPlan = new QualificationPlan().WithName("QP").WithId("QP_ID");
_project = new PKSimProject();
_project.AddBuildingBlock(_individual);
_project.AddBuildingBlock(_compound);
_project.AddBuildingBlock(_event);
_project.AddBuildingBlock(_formulation);
_project.AddBuildingBlock(_protocol);
_project.AddBuildingBlock(_population);
_project.AddObservedData(_observedData);
_project.AddBuildingBlock(_simulation);
_project.AddClassifiable(_classifiableObservedData);
_project.AddClassification(_classification);
_project.AddSimulationComparison(_simulationComparison);
_project.AddParameterIdentification(_parameterIdentification);
_project.AddQualificationPlan(_qualificationPlan);
_compoundSnapshot = new Snapshots.Compound();
_individualSnapshot = new Snapshots.Individual();
_eventSnapshot = new Event();
_formulationSnapshot = new Snapshots.Formulation();
_protocolSnapshot = new Snapshots.Protocol();
_populationSnapshot = new Snapshots.Population();
_observedDataSnapshot = new Snapshots.DataRepository();
_parameterIdentificationSnapshot = new ParameterIdentification();
_observedDataClassificationSnapshot = new Snapshots.Classification();
_simulationComparisonSnapshot = new SimulationComparison();
_simulationClassificationSnapshot = new Snapshots.Classification();
_comparisonClassificationSnapshot = new Snapshots.Classification();
_parameterIdentificationClassificationSnapshot = new Snapshots.Classification();
_qualificationPlanClassificationSnapshot = new Snapshots.Classification();
_qualificationPlanSnapshot = new Snapshots.QualificationPlan();
_simulationSnapshot = new Simulation();
A.CallTo(() => _snapshotMapper.MapToSnapshot(_compound)).Returns(_compoundSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_individual)).Returns(_individualSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_event)).Returns(_eventSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_formulation)).Returns(_formulationSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_protocol)).Returns(_protocolSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_population)).Returns(_populationSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_observedData)).Returns(_observedDataSnapshot);
A.CallTo(() => _simulationMapper.MapToSnapshot(_simulation, _project)).Returns(_simulationSnapshot);
A.CallTo(() => _simulationComparisonMapper.MapToSnapshot(_simulationComparison)).Returns(_simulationComparisonSnapshot);
A.CallTo(() => _parameterIdentificationMapper.MapToSnapshot(_parameterIdentification, _project)).Returns(_parameterIdentificationSnapshot);
A.CallTo(() => _qualificationPlanMapper.MapToSnapshot(_qualificationPlan)).Returns(_qualificationPlanSnapshot);
A.CallTo(() => _classificationSnapshotTask.MapClassificationsToSnapshots <ClassifiableObservedData>(_project)).Returns(new[] { _observedDataClassificationSnapshot });
A.CallTo(() => _classificationSnapshotTask.MapClassificationsToSnapshots <ClassifiableSimulation>(_project)).Returns(new[] { _simulationClassificationSnapshot });
A.CallTo(() => _classificationSnapshotTask.MapClassificationsToSnapshots <ClassifiableComparison>(_project)).Returns(new[] { _comparisonClassificationSnapshot });
A.CallTo(() => _classificationSnapshotTask.MapClassificationsToSnapshots <ClassifiableParameterIdentification>(_project)).Returns(new[] { _parameterIdentificationClassificationSnapshot });
A.CallTo(() => _classificationSnapshotTask.MapClassificationsToSnapshots <ClassifiableQualificationPlan>(_project)).Returns(new[] { _qualificationPlanClassificationSnapshot });
return(_completed);
}
public AdvancedProtocolTeXBuilder(ITeXBuilderRepository builderRepository, IReportGenerator reportGenerator, ILazyLoadTask lazyLoadTask, IRepresentationInfoRepository representationInfoRepository)
: base(builderRepository, reportGenerator, lazyLoadTask)
{
_representationInfoRepository = representationInfoRepository;
}
public TimeProfileChartDataCreator(IDimensionRepository dimensionRepository, IPivotResultCreator pivotResultCreator, IRepresentationInfoRepository representationInfoRepository,
IStatisticalDataCalculator statisticalDataCalculator, ILazyLoadTask lazyLoadTask, IDataRepositoryToObservedCurveDataMapper observedCurveDataMapper)
: base(dimensionRepository, pivotResultCreator)
{
_representationInfoRepository = representationInfoRepository;
_statisticalDataCalculator = statisticalDataCalculator;
_lazyLoadTask = lazyLoadTask;
_observedCurveDataMapper = observedCurveDataMapper;
}
public ObserverSetTexBuilder(ITeXBuilderRepository builderRepository, IReportGenerator reportGenerator, ILazyLoadTask lazyLoadTask) : base(builderRepository, reportGenerator, lazyLoadTask)
{
}
public CreateTimeProfileAnalysisPresenter(ICreatePopulationAnalysisView view, ISubPresenterItemManager <IPopulationAnalysisItemPresenter> subPresenterItemManager,
IDialogCreator dialogCreator, IPopulationAnalysisTemplateTask populationAnalysisTemplateTask, IPopulationAnalysisChartFactory populationAnalysisChartFactory, ILazyLoadTask lazyLoadTask, IPopulationAnalysisTask populationAnalysisTask, IPopulationAnalysisFieldFactory populationAnalysisFieldFactory)
: base(view, subPresenterItemManager, TimeProfileItems.All, dialogCreator, populationAnalysisTemplateTask, populationAnalysisChartFactory, populationAnalysisTask, populationAnalysisFieldFactory)
{
_lazyLoadTask = lazyLoadTask;
View.Image = ApplicationIcons.TimeProfileAnalysis;
}
public IndividualSimulationComparisonReporter(ILazyLoadTask lazyLoadTask)
: base(lazyLoadTask)
{
}
public static void AddReferencedSimulations(this XElement parameterIdentificationElement, ParameterIdentification parameterIdentification, IWithIdRepository withIdRepository, ILazyLoadTask lazyLoadTask)
{
parameterIdentificationElement.AddReferencedObject <ParameterIdentification, ISimulation>(
parameterIdentification, x => x.AddSimulation, withIdRepository, lazyLoadTask, Constants.Serialization.SIMULATION);
}
public WorkspaceLayoutUpdater(IApplicationController applicationController, IWithIdRepository withIdRepository,
IOpenSingleStartPresenterInvoker openSingleStartPresenterInvoker, ILazyLoadTask lazyLoadTask, IEventPublisher eventPublisher, IWorkspace workspace)
{
_applicationController = applicationController;
_withIdRepository = withIdRepository;
_openSingleStartPresenterInvoker = openSingleStartPresenterInvoker;
_lazyLoadTask = lazyLoadTask;
_eventPublisher = eventPublisher;
_workspace = workspace;
}
public PopulationPKAnalysesTask(ILazyLoadTask lazyLoadTask, IPKValuesCalculator pkValuesCalculator, IPKParameterRepository pkParameterRepository,
IPKCalculationOptionsFactory pkCalculationOptionsFactory, IEntityPathResolver entityPathResolver) : base(lazyLoadTask, pkValuesCalculator, pkParameterRepository, pkCalculationOptionsFactory)
{
_lazyLoadTask = lazyLoadTask;
_entityPathResolver = entityPathResolver;
}
public PKCalculationOptionsFactory(ILazyLoadTask lazyLoadTask)
{
_lazyLoadTask = lazyLoadTask;
}
public SimulationSubjectConfigurationPresenter(ISimulationSubjectConfigurationView view, ILazyLoadTask lazyLoadTask, IBuildingBlockInSimulationManager buildingBlockInSimulationManager)
: base(view)
{
_lazyLoadTask = lazyLoadTask;
_buildingBlockInSimulationManager = buildingBlockInSimulationManager;
SubjectChanged = false;
}
public SimulationDiffBuilder(ILazyLoadTask lazyLoadTask, IObjectComparer comparer)
{
_lazyLoadTask = lazyLoadTask;
_comparer = comparer;
}
public ExportSimulationSnapshotUICommand(SimulationMapper simulationMapper, IPKSimProjectRetriever projectRetriever, ILazyLoadTask lazyLoadTask, ISnapshotTask snapshotTask)
{
_simulationMapper = simulationMapper;
_projectRetriever = projectRetriever;
_lazyLoadTask = lazyLoadTask;
_snapshotTask = snapshotTask;
}
public SimulationSelectionForComparisonPresenter(ISimulationSelectionForComparisonView view, IBuildingBlockRepository buildingBlockRepository, ILazyLoadTask lazyLoadTask) : base(view)
{
_buildingBlockRepository = buildingBlockRepository;
_lazyLoadTask = lazyLoadTask;
_selectionDTO = new SimulationComparisonSelectionDTO();
_nullSimulation = new NullSimulation();
_selectionDTO.Reference = _nullSimulation;
_selectionDTO.GroupingItem.Color = PKSimColors.StartGroupingColor;
}
public static void AddReferencedObject <TObectWithReference, TReference>(this XElement referenceElementList, TObectWithReference objectWithReference, Func <TObectWithReference, Action <TReference> > addAction,
IWithIdRepository withIdRepository, ILazyLoadTask lazyLoadTask, string referenceElementName) where TReference : class, IWithId
{
foreach (var referenceElement in referenceElementList.Descendants(referenceElementName))
{
var id = referenceElement.GetAttribute(Constants.Serialization.Attribute.ID);
//reference might have been deleted...in that case, simply ignore the simulation
if (!withIdRepository.ContainsObjectWithId(id))
{
continue;
}
var reference = withIdRepository.Get <TReference>(id);
var lazyLoadable = reference as ILazyLoadable;
if (lazyLoadable != null)
{
lazyLoadTask?.Load(lazyLoadable);
}
addAction(objectWithReference)(reference);
}
}
protected SimulationComparisonReporter(ILazyLoadTask lazyLoadTask)
{
_lazyLoadTask = lazyLoadTask;
}
public CompoundTeXBuilder(ITeXBuilderRepository builderRepository, IReportGenerator reportGenerator, ILazyLoadTask lazyLoadTask,
IRepresentationInfoRepository representationRepository, ICompoundAlternativeTask compoundAlternativeTask)
: base(builderRepository, reportGenerator, lazyLoadTask)
{
_representationRepository = representationRepository;
_compoundAlternativeTask = compoundAlternativeTask;
}
public PopulationSimulationComparisonReporter(ILazyLoadTask lazyLoadTask)
: base(lazyLoadTask)
{
}
