public override void RegisterInContainer(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <RRegister>();
//Register Services
scan.IncludeNamespaceContainingType <ISimulationRunner>();
//Register Minimal implementations
scan.IncludeNamespaceContainingType <DisplayUnitRetriever>();
//Register Mappers
scan.IncludeNamespaceContainingType <ISensitivityAnalysisToCoreSensitivityAnalysisMapper>();
// This will be registered as singleton
scan.ExcludeType <RGroupRepository>();
scan.ExcludeType <CsvSeparatorSelector>();
scan.WithConvention <OSPSuiteRegistrationConvention>();
});
//Add specific implementations that are not registered automatically
container.Register <SimulationBatch, SimulationBatch>();
container.Register <ISimulationBatchFactory, SimulationBatchFactory>();
container.Register <IObjectTypeResolver, RObjectTypeResolver>();
//Singletons
container.Register <IGroupRepository, RGroupRepository>(LifeStyle.Singleton);
container.Register <IOSPSuiteExecutionContext, RExecutionContext>(LifeStyle.Singleton);
container.Register <IOSPSuiteLogger, RLogger, RLogger>(LifeStyle.Singleton);
container.Register <IEventPublisher, EventPublisher>(LifeStyle.Singleton);
container.Register <ICsvDynamicSeparatorSelector, ICsvSeparatorSelector, CsvSeparatorSelector>(LifeStyle.Singleton);
}
private static void registerTasks(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <InteractionTaskConvention>();
scan.IncludeNamespaceContainingType <InteractionTaskConvention>();
scan.WithConvention <InteractionTaskConvention>();
});
container.Register <IEditTaskFor <InteractionContainer>, EditTaskForInteractionContainer>();
container.Register <IEditTaskFor <IMoleculeBuilder>, EditTaksForMoleculeBuilder>();
container.Register <IEditTaskFor <IReactionBuilder>, EditTasksForReactionBuilder>();
container.Register <IEditTaskFor <ITransportBuilder>, EditTasksForTransportBuilder>();
container.Register <IEditTaskFor <IEventGroupBuilder>, EditTasksForEventGroupBuilder>();
container.Register <IEditTaskFor <IApplicationBuilder>, EditTasksForApplicationBuilder>();
container.Register <IEditTaskFor <IContainerObserverBuilder>, EditTasksForContainerObserverBuilder>();
container.Register <IEditTaskFor <IAmountObserverBuilder>, EditTasksForAmountObserverBuilder>();
container.Register <IEditTaskFor <OSPSuite.Core.Domain.IContainer>, EditTaskForContainer>();
container.Register <IEditTaskFor <IDistributedParameter>, EditTasksForDistributedParameter>();
container.Register <IEditTaskFor <IParameter>, EditTasksForParameter>();
container.Register <IEditTaskFor <IEventBuilder>, EditTaskForEventBuilder>();
container.Register <IEditTaskFor <TransporterMoleculeContainer>, EditTasksForTransporterMoleculeContainer>();
container.Register <IEditTaskFor <IApplicationMoleculeBuilder>, EditTaskForApplicationMoleculeBuilder>();
container.Register <IEditTaskFor <IEventAssignmentBuilder>, EditTaskForEventAssingmentBuilder>();
container.Register <IEditTaskFor <INeighborhoodBuilder>, EditTasksForNeighborhoodBuilder>();
container.Register <IEditTaskFor <IMoBiSimulation>, EditTasksForSimulation>();
container.Register <IEditTaskFor <IMoBiSpatialStructure>, EditTasksForSpatialStructure>();
container.Register(typeof(IEditTasksForBuildingBlock <>), typeof(EditTasksForBuildingBlock <>));
container.Register(typeof(IEditTaskFor <>), typeof(EditTasksForBuildingBlock <>));
}
public override void RegisterInContainer(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <CoreRegister>();
scan.ExcludeType <MoBiDimensionFactory>();
scan.ExcludeType <MoBiContext>();
scan.ExcludeType <MoBiDimensionFactory>();
scan.ExcludeType <MoBiConfiguration>();
scan.ExcludeType <ObjectTypeResolver>();
scan.ExcludeType <FormulaTypeCaptionRepository>();
scan.ExcludeType <GroupRepository>();
scan.ExcludeType <ClipboardManager>();
scan.ExcludeType <ApplicationSettings>();
scan.ExcludeType <MoBiLogger>();
scan.ExcludeNamespaceContainingType <IMoBiObjectConverter>();
scan.ExcludeNamespaceContainingType <ProjectReporter>();
scan.ExcludeNamespaceContainingType <MoBiSimulationDiffBuilder>();
scan.WithConvention(new OSPSuiteRegistrationConvention());
});
container.Register <IMoBiContext, IOSPSuiteExecutionContext, IWorkspace, MoBiContext>(LifeStyle.Singleton);
container.Register <OSPSuite.Core.IApplicationSettings, IApplicationSettings, ApplicationSettings>(LifeStyle.Singleton);
container.Register <IMoBiDimensionFactory, IDimensionFactory, MoBiDimensionFactory>(LifeStyle.Singleton);
container.Register <IObjectTypeResolver, ObjectTypeResolver>(LifeStyle.Singleton);
container.Register <FormulaTypeCaptionRepository, FormulaTypeCaptionRepository>(LifeStyle.Singleton);
container.Register <IObjectBaseFactory, ObjectBaseFactory>(LifeStyle.Singleton);
container.Register <IGroupRepository, GroupRepository>(LifeStyle.Singleton);
container.Register <IClipboardManager, ClipboardManager>(LifeStyle.Singleton);
container.Register <ICloneManager, CloneManagerForBuildingBlock>(LifeStyle.Singleton);
container.Register <ICompression, SharpLibCompression>();
container.Register <IStringCompression, StringCompression>();
container.Register <IProjectRetriever, MoBiProjectRetriever>();
container.Register <IHistoryManager, MoBiHistoryManager>();
container.Register <IObjectIdResetter, ObjectIdResetter>();
container.Register <ISetParameterTask, ParameterTask>();
container.Register <ITransferOptimizedParametersToSimulationsTask, TransferOptimizedParametersToSimulationsTask <IMoBiContext> >();
//Register opened types generics
container.Register(typeof(IRepository <>), typeof(ImplementationRepository <>));
container.Register(typeof(IEntitiesInBuildingBlockRetriever <>), typeof(EntitiesInBuildingBlockRetriever <>));
container.Register <IList <IDimensionMergingInformation>, List <IDimensionMergingInformation> >(LifeStyle.Singleton);
//Register abstract factories
container.RegisterFactory <IHistoryManagerFactory>();
container.RegisterFactory <IDiagramManagerFactory>();
registerReporters(container);
registerComparers(container);
registerCommitTasks(container);
registerConverters(container);
}
private static void registerCommitTasks(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <CoreRegister>();
scan.IncludeNamespaceContainingType <ICreateCommitChangesToBuildingBlockCommandTask>();
scan.WithConvention(new RegisterTypeConvention <ICreateCommitChangesToBuildingBlockCommandTask>(registerWithDefaultConvention: false));
});
}
private static void registerSingleStartPresenters(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <PresentationRegister>();
scan.IncludeNamespaceContainingType <AboutPresenter>();
scan.WithConvention(new RegisterTypeConvention <ISingleStartPresenter>(registerWithDefaultConvention: false));
});
}
private static void registerCreatePresenter(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <PresentationRegister>();
scan.IncludeNamespaceContainingType <AboutPresenter>();
scan.WithConvention <RegisterCreateAndEditPresenterConvention>();
});
}
private static void registerComparers(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <CoreRegister>();
scan.IncludeNamespaceContainingType <MoBiSimulationDiffBuilder>();
scan.WithConvention <RegisterTypeConvention <IDiffBuilder> >();
});
}
private static void registerContextMenuAndCommands(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <PresentationRegister>();
scan.IncludeNamespaceContainingType <ContextMenuBase>();
scan.IncludeNamespaceContainingType <IExitCommand>();
scan.WithConvention <AllInterfacesAndConcreteTypeRegistrationConvention>();
});
}
private static void registerTexReporters(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <InfrastructureRegister>();
scan.IncludeNamespaceContainingType <IndividualTeXBuilder>();
scan.IncludeNamespaceContainingType <SimulationReporter>();
scan.WithConvention <ReporterRegistrationConvention>();
});
}
private static void registerMarkdownBuilders(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <InfrastructureRegister>();
scan.IncludeNamespaceContainingType <IMarkdownBuilder>();
scan.ExcludeType <MarkdownBuilderRepository>();
scan.WithConvention <RegisterTypeConvention <IMarkdownBuilder> >();
});
container.Register <IMarkdownBuilderRepository, MarkdownBuilderRepository>(LifeStyle.Singleton);
}
private static void registerComparers(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <CoreRegister>();
scan.IncludeNamespaceContainingType <IndividualDiffBuilder>();
scan.WithConvention <RegisterTypeConvention <IDiffBuilder> >();
});
ParameterDiffBuilder.ShouldCompareParametersIn = PKSimParameterDiffBuilder.ShouldCompareParametersIn;
}
private static void registerConverters(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <CoreRegister>();
scan.IncludeNamespaceContainingType <IObjectConverter>();
scan.WithConvention <RegisterTypeConvention <IObjectConverter> >();
scan.ExcludeType <ObjectConverterFinder>();
});
container.Register <IObjectConverterFinder, ObjectConverterFinder>(LifeStyle.Singleton);
}
private static void registerReportBuilders(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <InfrastructureRegister>();
scan.IncludeNamespaceContainingType <IReportBuilder>();
scan.ExcludeType <ReportGenerator>();
scan.WithConvention <PKSimRegistrationConvention>();
});
container.Register <IReportGenerator, ReportGenerator>(LifeStyle.Singleton);
}
private static void registerReporters(IContainer container)
{
container.AddRegister(x => x.FromType <ReportingRegister>());
container.AddRegister(x => x.FromType <OSPSuite.Infrastructure.Reporting.ReportingRegister>());
container.AddScanner(scan =>
{
scan.AssemblyContainingType <CoreRegister>();
scan.IncludeNamespaceContainingType <ProjectReporter>();
scan.WithConvention <ReporterRegistrationConvention>();
});
}
private static void registerComparers(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <CoreRegister>();
scan.IncludeNamespaceContainingType <IDiffBuilder>();
scan.ExcludeType <DiffBuilderRepository>();
scan.WithConvention <RegisterTypeConvention <IDiffBuilder> >();
});
container.Register(typeof(WithValueOriginComparison <>), typeof(WithValueOriginComparison <>));
container.Register <EnumerableComparer, EnumerableComparer>();
}
public override void RegisterInContainer(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <TestRegister>();
scan.IncludeNamespaceContainingType <JournalTestPresenter>();
scan.IncludeNamespaceContainingType <JournalTestView>();
scan.IncludeNamespaceContainingType <ProjectRetriever>();
scan.IncludeNamespaceContainingType <LazyLoadTask>();
scan.ExcludeType <Workspace>();
scan.ExcludeType <ShellView>();
scan.ExcludeType <ShellPresenter>();
scan.ExcludeType <ProgressManager>();
scan.ExcludeType <GroupRepository>();
scan.ExcludeType <SimulationRepository>();
scan.ExcludeType <DimensionRetriever>();
scan.ExcludeType <ProjectRetriever>();
scan.ExcludeType <ApplicationSettings>();
scan.ExcludeType <HistoryManagerRetriever>();
});
container.Register <IToolTipCreator, ToolTipCreator>(LifeStyle.Singleton);
container.Register <IProjectRetriever, ProjectRetriever>(LifeStyle.Singleton);
container.Register <IWorkspace, Workspace>(LifeStyle.Singleton);
container.Register <IFileLocker, FileLocker>(LifeStyle.Singleton);
container.Register <IExceptionManager, ExceptionManager>(LifeStyle.Singleton);
container.Register <IHistoryManagerRetriever, HistoryManagerRetriever>(LifeStyle.Singleton);
container.Register <IProgressManager, ProgressManager>(LifeStyle.Singleton);
container.Register <IGroupRepository, GroupRepository>(LifeStyle.Singleton);
container.Register <IReactionDimensionRetriever, DimensionRetriever>(LifeStyle.Singleton);
container.Register <ISimulationRepository, SimulationRepository>(LifeStyle.Singleton);
container.Register <IShellPresenter, IMainViewPresenter, ShellPresenter>(LifeStyle.Singleton);
container.Register <IShell, IShellView, IMainView, ShellView>(LifeStyle.Singleton);
container.Register <IApplicationSettings, ApplicationSettings>(LifeStyle.Singleton);;
container.Register <IObjectIdResetter, ObjectIdResetter>();
container.Register <ITreeNodeFactory, TreeNodeFactory>();
container.Register <IDisplayNameProvider, DisplayNameProvider>();
container.Register <IPathToPathElementsMapper, PathToPathElementsMapper>();
container.Register <IDataColumnToPathElementsMapper, DataColumnToPathElementsMapper>();
container.Register <IQuantityPathToQuantityDisplayPathMapper, QuantityPathToQuantityDisplayPathMapper>();
container.Register <BarManager, BarManager>();
container.Register <ModelHelperForSpecs, ModelHelperForSpecs>();
container.Register <IDataNamingService, DataNamingServiceForSpecs>();
container.RegisterFactory <IHeavyWorkPresenterFactory>();
container.Register <TestEnvironment, TestEnvironment>();
container.Register <DataPersistor, DataPersistor>();
}
private static void registerConverters(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <CoreRegister>();
scan.IncludeNamespaceContainingType <IMoBiObjectConverter>();
scan.ExcludeType <MoBiObjectConverterFinder>();
scan.ExcludeType <ProjectConverterLogger>();
scan.WithConvention <RegisterTypeConvention <IMoBiObjectConverter> >();
});
//Needs to be registered as singleton
container.Register <IMoBiObjectConverterFinder, MoBiObjectConverterFinder>(LifeStyle.Singleton);
container.Register <IProjectConverterLogger, ProjectConverterLogger>(LifeStyle.Singleton);
}
private static void registerConverters(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <InfrastructureRegister>();
scan.IncludeNamespaceContainingType <IObjectConverter>();
scan.ExcludeType <ProjectConverterLogger>();
scan.ExcludeType <ObjectConverterFinder>();
scan.ExcludeType <Converter612To621>();
scan.WithConvention <PKSimRegistrationConvention>();
});
//required as singleton because of element caching
container.Register <Converter612To621, IObjectConverter, Converter612To621>(LifeStyle.Singleton);
container.Register <IObjectConverterFinder, ObjectConverterFinder>(LifeStyle.Singleton);
container.Register <IProjectConverterLogger, ProjectConverterLogger>(LifeStyle.Singleton);
}
private static void reigsterConverters(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <CoreRegister>();
scan.IncludeNamespaceContainingType <IObjectConverter>();
scan.WithConvention <RegisterTypeConvention <IObjectConverter> >();
scan.ExcludeType <ObjectConverterFinder>();
scan.ExcludeType <DimensionMapper>();
scan.ExcludeType <FormulaMapper>();
scan.ExcludeType <SerializationDimensionFactory>();
});
container.Register <IObjectConverterFinder, ObjectConverterFinder>(LifeStyle.Singleton);
container.Register <IDimensionMapper, DimensionMapper>(LifeStyle.Singleton);
container.Register <IFormulaMapper, FormulaMapper>(LifeStyle.Singleton);
container.Register <ISerializationDimensionFactory, SerializationDimensionFactory>(LifeStyle.Singleton);
}
private static void registerConverters(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <CoreRegister>();
scan.IncludeNamespaceContainingType <IMoBiObjectConverter>();
//this one needs to be global because of required flag during conversion
scan.ExcludeType <Converter341To351>();
scan.ExcludeType <MoBiObjectConverterFinder>();
scan.ExcludeType <ProjectConverterLogger>();
scan.WithConvention <RegisterTypeConvention <IMoBiObjectConverter> >();
});
//Needs to be registered as singleton
container.Register <IMoBiObjectConverterFinder, MoBiObjectConverterFinder>(LifeStyle.Singleton);
container.Register <IProjectConverterLogger, ProjectConverterLogger>(LifeStyle.Singleton);
container.Register <IMoBiObjectConverter, Converter341To351>(LifeStyle.Singleton);
}
public override void RegisterInContainer(IContainer container)
{
container.AddRegister(x => x.FromInstance(new OSPSuite.Core.CoreRegister {
RegisterParameter = false
}));
//Register PKSim.Core
container.AddScanner(scan =>
{
scan.AssemblyContainingType <CoreRegister>();
//Exclude type that should be register as singleton because of caching
scan.ExcludeType <FormulationValuesRetriever>();
scan.ExcludeType <ObjectTypeResolver>();
scan.ExcludeType <PKSimDimensionFactory>();
scan.ExcludeType <PKSimObjectBaseFactory>();
scan.ExcludeType <DistributionFormulaFactory>();
scan.ExcludeType <ApplicationSettings>();
scan.ExcludeType <ProjectChangedNotifier>();
scan.ExcludeType <IndividualSimulationEngine>();
scan.ExcludeType <DefaultIndividualRetriever>();
scan.ExcludeType <IPopulationSimulationEngine>();
//Do not register the InteractiveSimulationRunner as it should be registered only if needed
scan.ExcludeType <InteractiveSimulationRunner>();
scan.ExcludeType <SnapshotMapper>();
scan.ExcludeNamespaceContainingType <IndividualDiffBuilder>();
scan.WithConvention <PKSimRegistrationConvention>();
});
//Register singletons explicitly
container.AddScanner(scan =>
{
scan.AssemblyContainingType <CoreRegister>();
scan.IncludeType <FormulationValuesRetriever>();
scan.IncludeType <ObjectTypeResolver>();
scan.IncludeType <DistributionFormulaFactory>();
scan.IncludeType <ProjectChangedNotifier>();
scan.IncludeType <SnapshotMapper>();
scan.IncludeType <DefaultIndividualRetriever>();
scan.RegisterAs(LifeStyle.Singleton);
scan.WithConvention <PKSimRegistrationConvention>();
});
container.Register <ICoreSimulationFactory, SimulationFactory>();
container.Register <ISetParameterTask, ParameterTask>(LifeStyle.Transient);
container.Register <ITransferOptimizedParametersToSimulationsTask, TransferOptimizedParametersToSimulationsTask <IExecutionContext> >();
container.Register <IIndividualSimulationEngine, ISimulationEngine <IndividualSimulation, SimulationRunResults>, IndividualSimulationEngine>(LifeStyle.Transient);
container.Register <IPopulationSimulationEngine, ISimulationEngine <PopulationSimulation, PopulationRunResults>, PopulationSimulationEngine>(LifeStyle.Transient);
//other singleton external to application
container.Register <ICloneManager, Cloner>(LifeStyle.Singleton);
//Register special type for parameters so that core methods in the context of pksim creates a PKSimParameter
container.Register <IParameter, PKSimParameter>();
container.Register <IDistributedParameter, PKSimDistributedParameter>();
//specific PKSim Implementations
container.Register <IPathToPathElementsMapper, PKSimPathToPathElementsMapper>();
container.Register <IDataColumnToPathElementsMapper, PKSimDataColumnToPathElementsMapper>();
container.Register <IQuantityPathToQuantityDisplayPathMapper, PKSimQuantityPathToQuantityDisplayPathMapper>();
//Register Factories
container.RegisterFactory <ISimulationEngineFactory>();
container.RegisterFactory <IChartDataToTableMapperFactory>();
container.Register <IPKSimObjectBaseFactory, IObjectBaseFactory, PKSimObjectBaseFactory>(LifeStyle.Singleton);
container.Register <IPKSimDimensionFactory, IDimensionFactory, PKSimDimensionFactory>(LifeStyle.Singleton);
container.Register <IApplicationSettings, OSPSuite.Core.IApplicationSettings, ApplicationSettings>(LifeStyle.Singleton);
//Register opened types generics
container.Register <IInterpolation, LinearInterpolation>();
container.Register <IPivoter, Pivoter>();
container.Register <ISimulationSubject, Individual>();
container.Register <Protocol, SimpleProtocol>();
container.Register <Simulation, IndividualSimulation>();
container.Register <Population, RandomPopulation>();
container.Register <SchemaItem, SchemaItem>();
//generic command registration
container.Register <IOSPSuiteExecutionContext, ExecutionContext>();
registerMoleculeFactories(container);
registerComparers(container);
}
public override void RegisterInContainer(IContainer container)
{
//REGISTER DOMAIN OBJECTS
container.AddScanner(scan =>
{
scan.AssemblyContainingType <CoreRegister>();
scan.ExcludeNamespaceContainingType <IDiffBuilder>();
scan.ExcludeNamespaceContainingType <IObjectConverter>();
//special registration handled by other registers or conventions
scan.ExcludeNamespaceContainingType <CoreSerializerRegister>();
scan.ExcludeNamespaceContainingType <IOptimizationAlgorithm>();
//should be registered as singleton explicitly
scan.ExcludeType <ObjectBaseFactory>();
scan.ExcludeType <WithIdRepository>();
scan.ExcludeType <DimensionFactory>();
scan.ExcludeType <PKParameterRepository>();
scan.ExcludeType <CoreCalculationMethodRepository>();
scan.ExcludeType <PKParameterRepositoryLoader>();
scan.ExcludeType <ParameterIdentificationRunner>();
scan.ExcludeType <SensitivityAnalysisRunner>();
scan.ExcludeType(typeof(ExtendedProperty <>));
scan.ExcludeType(typeof(HistoryManager <>));
scan.ExcludeType(typeof(MacroCommand <>));
scan.ExcludeType(typeof(RollBackCommand <>));
//Exclude these implementations that are specific to each application
scan.ExcludeType <ObjectIdResetter>();
scan.ExcludeType <DisplayNameProvider>();
scan.ExcludeType <FullPathDisplayResolver>();
scan.ExcludeType <PathToPathElementsMapper>();
scan.ExcludeType <QuantityPathToQuantityDisplayPathMapper>();
scan.ExcludeType <DataColumnToPathElementsMapper>();
if (!RegisterParameter)
{
scan.ExcludeType <Parameter>();
scan.ExcludeType <DistributedParameter>();
}
scan.WithConvention(new OSPSuiteRegistrationConvention(registerConcreteType: true));
});
container.Register(typeof(IHistoryManager <>), typeof(HistoryManager <>));
//this should be registered as singleton
container.Register <IWithIdRepository, WithIdRepository>(LifeStyle.Singleton);
container.Register <IDiffBuilderRepository, DiffBuilderRepository>(LifeStyle.Singleton);
container.Register <IPKParameterRepository, PKParameterRepository>(LifeStyle.Singleton);
container.Register <ICoreCalculationMethodRepository, CoreCalculationMethodRepository>(LifeStyle.Singleton);
container.Register <IPKParameterRepositoryLoader, PKParameterRepositoryLoader>(LifeStyle.Singleton);
container.Register <IParameterIdentificationRunner, ParameterIdentificationRunner>(LifeStyle.Singleton);
container.Register <ISensitivityAnalysisRunner, SensitivityAnalysisRunner>(LifeStyle.Singleton);
registerComparers(container);
registerConverters(container);
registerParameterIdentificationRunFactories(container);
registerThirdPartyComponents(container);
container.RegisterFactory <IStartableProcessFactory>();
//Register Optimization algorithm explicitly
container.Register <IOptimizationAlgorithm, NelderMeadOptimizer>(Constants.OptimizationAlgorithm.NELDER_MEAD_PKSIM);
container.Register <IOptimizationAlgorithm, MPFitLevenbergMarquardtOptimizer>(Constants.OptimizationAlgorithm.MPFIT);
container.Register <IOptimizationAlgorithm, MonteCarloOptimizer>(Constants.OptimizationAlgorithm.MONTE_CARLO);
}
public override void RegisterInContainer(IContainer container)
{
container.AddRegister(x => x.FromInstance(new OSPSuite.Core.CoreRegister {
RegisterParameter = false
}));
//Register PKSim.Core
container.AddScanner(scan =>
{
scan.AssemblyContainingType <CoreRegister>();
//Exclude type that should be register as singleton because of caching
scan.ExcludeType <FormulationValuesRetriever>();
scan.ExcludeType <ObjectTypeResolver>();
scan.ExcludeType <PKSimDimensionFactory>();
scan.ExcludeType <PKSimObjectBaseFactory>();
scan.ExcludeType <DistributionFormulaFactory>();
scan.ExcludeType <ApplicationSettings>();
scan.ExcludeType <ProjectChangedNotifier>();
scan.ExcludeType <BatchLogger>();
scan.ExcludeType <SimulationRunner>();
scan.ExcludeNamespaceContainingType <IndividualDiffBuilder>();
scan.WithConvention <PKSimRegistrationConvention>();
});
//Register singletons explicitely
container.AddScanner(scan =>
{
scan.AssemblyContainingType <CoreRegister>();
scan.IncludeType <FormulationValuesRetriever>();
scan.IncludeType <ObjectTypeResolver>();
scan.IncludeType <PKSimObjectBaseFactory>();
scan.IncludeType <DistributionFormulaFactory>();
scan.IncludeType <ApplicationSettings>();
scan.IncludeType <ProjectChangedNotifier>();
scan.IncludeType <BatchLogger>();
scan.IncludeType <SimulationRunner>();
scan.RegisterAs(LifeStyle.Singleton);
scan.WithConvention <PKSimRegistrationConvention>();
});
container.Register <ICoreSimulationFactory, SimulationFactory>();
container.Register <ISetParameterTask, ParameterTask>();
container.Register <ITransferOptimizedParametersToSimulationsTask, TransferOptimizedParametersToSimulationsTask <IExecutionContext> >();
//other singleton external to application
container.Register <ICloneManager, Cloner>(LifeStyle.Singleton);
//Register special type for parameters so that core methods in the context of pksim creates a PKSimParameter
container.Register <IParameter, PKSimParameter>();
container.Register <IDistributedParameter, PKSimDistributedParameter>();
//Register Factories
container.RegisterFactory <ISimulationEngineFactory>();
container.RegisterFactory <IChartDataToTableMapperFactory>();
container.Register <IPKSimDimensionFactory, IDimensionFactory, PKSimDimensionFactory>(LifeStyle.Singleton);
//Register opened types generics
container.Register(typeof(IRepository <>), typeof(ImplementationRepository <>));
container.Register <IInterpolation, LinearInterpolation>();
container.Register <IPivoter, Pivoter>();
container.Register <ISimulationSubject, Individual>();
container.Register <Protocol, SimpleProtocol>();
container.Register <Simulation, IndividualSimulation>();
container.Register <Population, RandomPopulation>();
//generic command registration
container.Register <IOSPSuiteExecutionContext, ExecutionContext>();
registerMoleculeFactories(container);
registerComparers(container);
}
public override void RegisterInContainer(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <InfrastructureRegister>();
//ORM Repository should be registered as singleton
scan.ExcludeNamespaceContainingType <SpeciesRepository>();
//this type will be registered using another convention
scan.ExcludeNamespaceContainingType <IObjectConverter>(); //Converter
scan.ExcludeNamespaceContainingType <IReportBuilder>(); //report builder
scan.ExcludeNamespaceContainingType <SimulationReporter>(); //tex reporter
scan.ExcludeNamespaceContainingType <IndividualTeXBuilder>(); //tex builder
scan.ExcludeNamespaceContainingType <PKSimXmlSerializerRepository>(); //Serializer
scan.ExcludeType <CommandMetaDataRepository>();
scan.ExcludeType <DefaultIndividualRetriever>();
scan.ExcludeType <SessionManager>();
scan.ExcludeType <TemplateDatabase>();
scan.ExcludeType <ProteinExpressionDatabase>();
scan.ExcludeType <ProteinExpressionQueries>();
scan.ExcludeType <ModelDatabase>();
scan.ExcludeType <VersionChecker>();
scan.ExcludeType <Workspace>();
//already registered
scan.ExcludeType <PKSimXmlSerializerRepository>();
scan.ExcludeType <PKSimConfiguration>();
scan.ExcludeType <SerializationContext>();
scan.WithConvention <PKSimRegistrationConvention>();
});
container.AddScanner(scan =>
{
scan.AssemblyContainingType <InfrastructureRegister>();
scan.IncludeNamespaceContainingType <SpeciesRepository>(); //Repository
scan.IncludeType <CommandMetaDataRepository>();
scan.IncludeType <DefaultIndividualRetriever>();
scan.IncludeType <SessionManager>();
scan.IncludeType <TemplateDatabase>();
scan.IncludeType <ProteinExpressionDatabase>();
scan.IncludeType <ProteinExpressionQueries>();
scan.IncludeType <ModelDatabase>();
scan.IncludeType <VersionChecker>();
scan.RegisterAs(LifeStyle.Singleton);
scan.WithConvention <OSPSuiteRegistrationConvention>();
});
container.Register <IWorkspace, Workspace>(LifeStyle.Singleton);
registerConverters(container);
registerReportBuilders(container);
registerTexReporters(container);
container.Register <ICompression, SharpLibCompression>();
container.Register <IStringCompression, StringCompression>();
container.Register <IProjectRetriever, PKSimProjectRetriever>();
container.Register <IObservedDataConfiguration, ImportObservedDataTask>();
container.Register <IFlatContainerIdToContainerMapperSpecification, FlatContainerIdToFormulationMapper>();
container.Register <IFileLocker, FileLocker>(LifeStyle.Singleton);
registerORMDependencies();
var xmlRegister = new CoreSerializerRegister();
container.AddRegister(x => x.FromInstance(xmlRegister));
var sbsuiteSerializerRepository = container.Resolve <IOSPSuiteXmlSerializerRepository>();
sbsuiteSerializerRepository.AddPresentationSerializers();
xmlRegister.PerformMappingForSerializerIn(container);
container.AddRegister(x => x.FromType <ReportingRegister>());
container.AddRegister(x => x.FromType <OSPSuite.TeXReporting.ReportingRegister>());
container.AddRegister(x => x.FromType <OSPSuite.Infrastructure.InfrastructureRegister>());
//register factory also as IObjectBaseFactoryIBuildTrackerFactory
var factory = container.Resolve <IPKSimObjectBaseFactory>() as IObjectBaseFactory;
container.RegisterImplementationOf(factory);
var configuration = container.Resolve <IPKSimConfiguration>();
var versionChecker = container.Resolve <IVersionChecker>();
versionChecker.VersionFileUrl = CoreConstants.VERSION_FILE_URL;
versionChecker.CurrentVersion = configuration.Version;
versionChecker.ProductName = CoreConstants.PRODUCT_NAME;
}
public override void RegisterInContainer(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <PresentationRegister>();
scan.ExcludeNamespaceContainingType <IMenuAndToolBarPresenter>();
scan.ExcludeNamespaceContainingType <ContextMenuBase>();
scan.ExcludeNamespaceContainingType <IExitCommand>();
scan.ExcludeType <MenuBarItemRepository>();
scan.ExcludeType <SimulationRunner>();
scan.ExcludeType <MoBiApplicationController>();
scan.ExcludeType <MoBiXmlSerializerRepository>();
scan.ExcludeType <MoBiMainViewPresenter>();
scan.Exclude(t => t.IsAnImplementationOf <IMoBiBaseDiagramPresenter>());
//exclude presenter already registered at startup
scan.ExcludeType <SplashScreenPresenter>();
scan.WithConvention <OSPSuiteRegistrationConvention>();
});
container.Register <IMenuBarItemRepository, MenuBarItemRepository>(LifeStyle.Singleton);
container.Register <ISimulationRunner, SimulationRunner>(LifeStyle.Singleton);
container.Register <IMoBiApplicationController, IApplicationController, MoBiApplicationController>(LifeStyle.Singleton);
registerMainPresenters(container);
registerSingleStartPresenters(container);
registerCreatePresenter(container);
registerContextMenuAndCommands(container);
registerDiagramPresenter(container);
//selection presenter
container.Register <ISelectionPresenter <XElement>, SelectXmlElementPresenter>();
container.Register(typeof(IBuildingBlockSelectionPresenter <>), typeof(BuildingBlockSelectionPresenter <>));
container.Register(typeof(IDescriptorConditionListPresenter <>), typeof(DescriptorConditionListPresenter <>));
container.Register(typeof(IBuildingBlockMergePresenter <>), typeof(BuildingBlockMergePresenter <>));
container.Register(typeof(ICreateBuildingBlockMergePresenter <>), typeof(CreateBuildingBlockMergePresenter <>));
container.Register <ISelectManyPresenter <XElement>, SelectXmlElementPresenter>();
container.Register <ISelectManyPresenter <OSPSuite.Core.Domain.IContainer>, SelectObjectBasePresenter <OSPSuite.Core.Domain.IContainer> >();
container.Register <ISelectManyPresenter <IEventGroupBuilder>, SelectObjectBasePresenter <IEventGroupBuilder> >();
container.Register <ICreateStartValuesPresenter <IMoleculeStartValuesBuildingBlock>, CreateMoleculeStartValuesPresenter>();
container.Register <ICreateStartValuesPresenter <IParameterStartValuesBuildingBlock>, CreateParameterStartValuesPresenter>();
container.Register <ISettingsPersistor <IUserSettings>, UserSettingsPersistor>();
container.Register <ISettingsPersistor <IApplicationSettings>, ApplicationSettingsPersistor>();
container.Register(typeof(IItemToListItemMapper <>), typeof(ItemToListItemMapper <>));
container.RegisterFactory <IHeavyWorkPresenterFactory>();
container.Register <IObservedDataConfiguration, ObservedDataTask>();
container.Register <IPathToPathElementsMapper, PathToPathElementsMapper>();
container.Register <IDataColumnToPathElementsMapper, DataColumnToPathElementsMapper>();
container.Register <IDisplayNameProvider, DisplayNameProvider>();
container.Register <IRenameObjectDTOFactory, RenameObjectDTOFactory>();
registerTasks(container);
registerContextMenus(container);
ApplicationIcons.DefaultIcon = ApplicationIcons.MoBi;
//Create one instance of the invoker so that the object is available
//since it is not created anywhere and is only used as event listener
container.RegisterImplementationOf(container.Resolve <ICloseSubjectPresenterInvoker>());
container.Register <IWithWorkspaceLayout, Workspace>(LifeStyle.Singleton);
container.Register <IQuantityPathToQuantityDisplayPathMapper, MoBiQuantityPathToQuantityDisplayPathMapper>();
container.Register <IMoBiXmlSerializerRepository, MoBiXmlSerializerRepository>(LifeStyle.Singleton);
}
public override void RegisterInContainer(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <InfrastructureRegister>();
//ORM Repository should be registered as singleton
scan.ExcludeNamespaceContainingType <SpeciesRepository>();
//this type will be registered using another convention
scan.ExcludeNamespaceContainingType <IObjectConverter>(); //Converter
scan.ExcludeNamespaceContainingType <IReportBuilder>(); //report builder
scan.ExcludeNamespaceContainingType <IMarkdownBuilder>(); //Markdown builder
scan.ExcludeNamespaceContainingType <SimulationReporter>(); //tex reporter
scan.ExcludeNamespaceContainingType <IndividualTeXBuilder>(); //tex builder
scan.ExcludeNamespaceContainingType <PKSimXmlSerializerRepository>(); //Serializer
scan.ExcludeType <CommandMetaDataRepository>();
scan.ExcludeType <DefaultIndividualRetriever>();
scan.ExcludeType <SessionManager>();
scan.ExcludeType <TemplateDatabase>();
scan.ExcludeType <GeneExpressionDatabase>();
scan.ExcludeType <GeneExpressionQueries>();
scan.ExcludeType <ModelDatabase>();
scan.ExcludeType <VersionChecker>();
scan.ExcludeType <Workspace>();
scan.ExcludeType <PKSimLogger>();
scan.ExcludeType <StringSerializer>();
scan.ExcludeType <CompressedStringSerializer>();
//already registered
scan.ExcludeType <PKSimXmlSerializerRepository>();
scan.ExcludeType <PKSimConfiguration>();
scan.ExcludeType <SerializationContext>();
scan.WithConvention <PKSimRegistrationConvention>();
});
container.AddScanner(scan =>
{
scan.AssemblyContainingType <InfrastructureRegister>();
scan.IncludeNamespaceContainingType <SpeciesRepository>(); //Repository
scan.IncludeType <CommandMetaDataRepository>();
scan.IncludeType <DefaultIndividualRetriever>();
scan.IncludeType <SessionManager>();
scan.IncludeType <TemplateDatabase>();
scan.IncludeType <GeneExpressionDatabase>();
scan.IncludeType <GeneExpressionQueries>();
scan.IncludeType <ModelDatabase>();
scan.IncludeType <VersionChecker>();
scan.RegisterAs(LifeStyle.Singleton);
scan.WithConvention <OSPSuiteRegistrationConvention>();
});
registerConverters(container);
registerReportBuilders(container);
registerTexReporters(container);
registerMarkdownBuilders(container);
container.Register <IProjectRetriever, PKSimProjectRetriever>();
container.Register <IObservedDataConfiguration, ImportObservedDataTask>();
container.Register <IFlatContainerIdToContainerMapperSpecification, FlatContainerIdToFormulationMapper>();
container.Register <IFileLocker, FileLocker>(LifeStyle.Singleton);
registerORMDependencies(container);
container.AddRegister(x => x.FromType <ReportingRegister>());
container.AddRegister(x => x.FromType <InfrastructureSerializationRegister>());
container.AddRegister(x => x.FromType <InfrastructureReportingRegister>());
container.AddRegister(x => x.FromType <InfrastructureExportRegister>());
container.AddRegister(x => x.FromType <InfrastructureImportRegister>());
var configuration = container.Resolve <IPKSimConfiguration>();
var versionChecker = container.Resolve <IVersionChecker>();
versionChecker.VersionFileUrl = CoreConstants.VERSION_FILE_URL;
versionChecker.CurrentVersion = configuration.Version;
versionChecker.ProductName = CoreConstants.PRODUCT_NAME;
}
public override void RegisterInContainer(IContainer container)
{
//REGISTSTER DOMAIN OBJECTS
container.AddScanner(scan =>
{
scan.AssemblyContainingType <CoreRegister>();
scan.ExcludeNamespaceContainingType <IDiffBuilder>();
scan.ExcludeNamespaceContainingType <IObjectConverter>();
//sepcial registration handled by other registers or conventions
scan.ExcludeNamespaceContainingType <CoreSerializerRegister>();
scan.ExcludeNamespaceContainingType <IOptimizationAlgorithm>();
//should be registered as singleton explicitely
scan.ExcludeType <ObjectBaseFactory>();
scan.ExcludeType <WithIdRepository>();
scan.ExcludeType <DimensionFactory>();
scan.ExcludeType <PKParameterRepository>();
scan.ExcludeType <CoreCalculationMethodRepository>();
scan.ExcludeType <PKParameterRepositoryLoader>();
scan.ExcludeType <ParameterIdentificationRunner>();
scan.ExcludeType <SensitivityAnalysisRunner>();
//PK-Sim registers its own implementation
scan.ExcludeType <ObjectIdResetter>();
if (!RegisterParameter)
{
scan.ExcludeType <Parameter>();
scan.ExcludeType <DistributedParameter>();
}
scan.WithConvention(new OSPSuiteRegistrationConvention(registerConcreteType: true));
});
//this should be registered as singleton
container.Register <IWithIdRepository, WithIdRepository>(LifeStyle.Singleton);
container.Register <IDiffBuilderRepository, DiffBuilderRepository>(LifeStyle.Singleton);
container.Register <IPKParameterRepository, PKParameterRepository>(LifeStyle.Singleton);
container.Register <ICoreCalculationMethodRepository, CoreCalculationMethodRepository>(LifeStyle.Singleton);
container.Register <IPKParameterRepositoryLoader, PKParameterRepositoryLoader>(LifeStyle.Singleton);
container.Register <IParameterIdentificationRunner, ParameterIdentificationRunner>(LifeStyle.Singleton);
container.Register <ISensitivityAnalysisRunner, SensitivityAnalysisRunner>(LifeStyle.Singleton);
registerComparers(container);
reigsterConverters(container);
registerParameterIdentificationRunFactories(container);
//FACTORIES
container.RegisterFactory <IDiagramModelFactory>();
container.RegisterFactory <IModelValidatorFactory>();
container.RegisterFactory <IParameterIdentificationEngineFactory>();
container.RegisterFactory <ISimModelBatchFactory>();
container.RegisterFactory <IParameterIdentificationRunInitializerFactory>();
container.RegisterFactory <ISensitivityAnalysisEngineFactory>();
container.RegisterFactory <IStartableProcessFactory>();
container.RegisterFactory <ISimulationExportCreatorFactory>();
//Register Optimization algorithm explicitely
container.Register <IOptimizationAlgorithm, NelderMeadOptimizer>(Constants.OptimizationAlgorithm.NELDER_MEAD_PKSIM);
container.Register <IOptimizationAlgorithm, MPFitLevenbergMarquardtOptimizer>(Constants.OptimizationAlgorithm.MPFIT);
container.Register <IOptimizationAlgorithm, MonteCarloOptimizer>(Constants.OptimizationAlgorithm.MONTE_CARLO);
}
