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>();
}
private static void registerReportBuilders(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <InfrastructureRegister>();
scan.IncludeNamespaceContainingType <IReportBuilder>();
scan.ExcludeType <ReportGenerator>();
scan.ExcludeType <ReportBuilderRepository>();
scan.WithConvention <RegisterTypeConvention <IReportBuilder> >();
});
container.Register <IReportGenerator, ReportGenerator>(LifeStyle.Singleton);
container.Register <IReportBuilderRepository, ReportBuilderRepository>(LifeStyle.Singleton);
}
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 registerCoreComponents(IContainer container)
{
container.AddRegister(x => x.FromType <CoreRegister>());
container.AddRegister(x => x.FromType <Core.CoreRegister>());
container.AddRegister(x => x.FromType <InfrastructureRegister>());
container.Register <IDimensionParser, DimensionParser>();
}
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 registerLogging(IContainer container)
{
var loggerFactory = new LoggerFactory();
container.RegisterImplementationOf((ILoggerFactory)loggerFactory);
container.Register <ILogger, PKSimLogger>(LifeStyle.Singleton);
}
public static void RegisterCommands(IContainer container)
{
container.Register <IHistoryManager, HistoryManager <IExecutionContext> >();
var historyBrowserConfiguration = container.Resolve <IHistoryBrowserConfiguration>();
historyBrowserConfiguration.AddDynamicColumn(Constants.Command.BUILDING_BLOCK_TYPE, PKSimConstants.UI.BuildingBlockType);
historyBrowserConfiguration.AddDynamicColumn(Constants.Command.BUILDING_BLOCK_NAME, PKSimConstants.UI.BuildingBlockName);
}
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 registerConfigurationIn(IContainer container)
{
container.Register <IPKSimConfiguration, IApplicationConfiguration, PKSimConfiguration>(LifeStyle.Singleton);
var configuration = container.Resolve <IPKSimConfiguration>();
CoreConstants.ProductDisplayName = configuration.ProductDisplayName;
}
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 registerCoreDependencies(IContainer container)
{
container.Register <IObjectBaseFactory, ObjectBaseFactory>(LifeStyle.Singleton);
container.Register <IApplicationConfiguration, RConfiguration>(LifeStyle.Singleton);
container.Register <IDimensionFactory, RDimensionFactory>(LifeStyle.Singleton);
container.Register <IFullPathDisplayResolver, FullPathDisplayResolver>();
container.Register <IPathToPathElementsMapper, PathToPathElementsMapper>();
container.Register <IQuantityPathToQuantityDisplayPathMapper, RQuantityPathToQuantityDisplayPathMapper>();
container.Register <IDataColumnToPathElementsMapper, DataColumnToPathElementsMapper>();
container.Register <IObjectIdResetter, ObjectIdResetter>();
}
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);
}
private static void registerConfigurationIn(IContainer container)
{
container.Register <IPKSimConfiguration, IApplicationConfiguration, PKSimConfiguration>(LifeStyle.Singleton);
var configuration = container.Resolve <IPKSimConfiguration>();
CoreConstants.ProductDisplayName = $"{CoreConstants.ProductNameWithTrademark} {configuration.MajorVersion}";
registerLoggerIn(container, configuration);
}
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 void registerMinimalImplementations(IContainer container)
{
container.Register <ICoreWorkspace, IWorkspace, CLIWorkspace>(LifeStyle.Singleton);
container.Register <ICoreUserSettings, CLIUserSettings>();
container.Register <IProgressUpdater, NoneProgressUpdater>();
container.Register <IDisplayUnitRetriever, CLIDisplayUnitRetriever>();
container.Register <IOntogenyTask, CLIIndividualOntogenyTask>();
container.Register <IExceptionManager, CLIExceptionManager>();
container.Register <IDialogCreator, CLIDialogCreator>();
}
public void Process(Type concreteType, IContainer container, LifeStyle lifeStyle)
{
var services = new List <Type>();
var createTypes = concreteType.GetDeclaredTypesForGeneric(typeof(ICreatePresenter <>));
services.AddRange(createTypes.Select(x => x.GenericType));
if (!services.Any())
{
return;
}
container.Register(services, concreteType, lifeStyle);
}
/// <summary>
/// All specific registration that needs to be performed once all other registrations are done
/// </summary>
private void finalizeRegistration(IContainer container)
{
InfrastructureRegister.RegisterWorkspace(container);
//Create one instance of the invokers so that the object is available in the application
//since the object is not created anywhere and is only used as event listener
container.Resolve <ICloseSubjectPresenterInvoker>();
var mainPresenter = container.Resolve <IMainViewPresenter>();
container.RegisterImplementationOf((IChangePropagator)mainPresenter);
//This runner is only register when running PKSim as an executable. All other implementation should use the ISimulationRunner
container.Register <IInteractiveSimulationRunner, InteractiveSimulationRunner>(LifeStyle.Singleton);
}
public static void RegisterSerializationDependencies(IContainer container)
{
container.Register <ISerializationManager, XmlSerializationManager>();
container.Register <IStringSerializer, StringSerializer>();
container.Register <IStringSerializer, CompressedStringSerializer>(CoreConstants.Serialization.Compressed);
container.Register <IPKSimXmlSerializerRepository, PKSimXmlSerializerRepository>(LifeStyle.Singleton);
container.Register(typeof(IXmlReader <>), typeof(XmlReader <>));
container.Register(typeof(IXmlWriter <>), typeof(XmlWriter <>));
//Core serialization to serialize to pkml compatible with core
container.AddRegister(x => x.FromType <CoreSerializerRegister>());
}
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;
}
private void registerMoleculeFactories(IContainer container)
{
container.Register <IIndividualMoleculeFactory, IndividualEnzymeFactory>();
container.Register <IIndividualMoleculeFactory, IndividualTransporterFactory>();
container.Register <IIndividualMoleculeFactory, IndividualOtherProteinFactory>();
}
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);
}
private void registerContextMenuForBuildingBlockFactory <T>(IContainer container) where T : IBuildingBlock
{
container.Register <ContextMenuFactoryForBuildingBlock <T>, IContextMenuSpecificationFactory <IViewItem>, ContextMenuFactoryForBuildingBlock <T> >(LifeStyle.Singleton);
}
private void registerContextMenus(IContainer container)
{
//Generic context menus
container.Register <IRootContextMenuFor <IMoBiProject, IMoleculeBuildingBlock>, RootContextMenuForMoleculeBuildingBlock>();
container.Register <IRootContextMenuFor <IMoBiProject, IMoBiSimulation>, RootContextMenuForSimulation>();
container.Register <IRootContextMenuFor <IMoBiProject, ParameterIdentification>, RootContextMenuForParameterIdentification>();
container.Register <IRootContextMenuFor <IMoBiProject, SensitivityAnalysis>, RootContextMenuForSensitivityAnalysis>();
container.Register <IContextMenuFor <IMoBiSimulation>, ContextMenuForSimulation>();
container.Register <IContextMenuForBuildingBlock <IParameterStartValuesBuildingBlock>, ContextMenuForParameterStartValuesBuildingBlock>();
container.Register <IContextMenuForBuildingBlock <IMoleculeStartValuesBuildingBlock>, ContextMenuForMoleculeStartValuesBuildingBlock>();
container.Register <IContextMenuForBuildingBlock <IMoBiReactionBuildingBlock>, ContextMenuForMergableBuildingBlock <IMoBiReactionBuildingBlock> >();
container.Register <IContextMenuForBuildingBlock <IObserverBuildingBlock>, ContextMenuForMergableBuildingBlock <IObserverBuildingBlock> >();
container.Register <IContextMenuForBuildingBlock <IPassiveTransportBuildingBlock>, ContextMenuForMergableBuildingBlock <IPassiveTransportBuildingBlock> >();
container.Register <IContextMenuForBuildingBlock <IMoleculeBuildingBlock>, ContextMenuForMergableBuildingBlock <IMoleculeBuildingBlock> >();
container.Register <IContextMenuForBuildingBlock <IEventGroupBuildingBlock>, ContextMenuForMergableBuildingBlock <IEventGroupBuildingBlock> >();
container.Register(typeof(IContextMenuForBuildingBlock <>), typeof(ContextMenuForBuildingBlock <>));
container.Register(typeof(IContextMenuFor <>), typeof(ContextMenuFor <>));
container.Register(typeof(IRootContextMenuFor <,>), typeof(RootContextMenuFor <,>));
//Generic context menu factory: One for each building block type
registerContextMenuForBuildingBlockFactory <IMoleculeBuildingBlock>(container);
registerContextMenuForBuildingBlockFactory <IMoBiReactionBuildingBlock>(container);
registerContextMenuForBuildingBlockFactory <IPassiveTransportBuildingBlock>(container);
registerContextMenuForBuildingBlockFactory <IMoBiSpatialStructure>(container);
registerContextMenuForBuildingBlockFactory <IObserverBuildingBlock>(container);
registerContextMenuForBuildingBlockFactory <IEventGroupBuildingBlock>(container);
registerContextMenuForBuildingBlockFactory <IMoleculeStartValuesBuildingBlock>(container);
registerContextMenuForBuildingBlockFactory <IParameterStartValuesBuildingBlock>(container);
registerContextMenuForBuildingBlockFactory <ISimulationSettings>(container);
}
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 <>));
}
private void registerMainPresenters(IContainer container)
{
if (_registerMainViewpresenter)
{
container.Register <IMainViewPresenter, IChangePropagator, MoBiMainViewPresenter>(LifeStyle.Singleton);
}
container.Register <IBuildingBlockExplorerPresenter, IMainViewItemPresenter, BuildingBlockExplorerPresenter>(LifeStyle.Singleton);
container.Register <IHistoryPresenter, IMainViewItemPresenter, HistoryPresenter>(LifeStyle.Singleton);
container.Register <IJournalDiagramMainPresenter, IMainViewItemPresenter, JournalDiagramMainPresenter>(LifeStyle.Singleton);
container.Register <IJournalPresenter, IMainViewItemPresenter, JournalPresenter>(LifeStyle.Singleton);
container.Register <IMenuAndToolBarPresenter, IMainViewItemPresenter, MenuAndToolBarPresenter>(LifeStyle.Singleton);
container.Register <ISimulationExplorerPresenter, IMainViewItemPresenter, SimulationExplorerPresenter>(LifeStyle.Singleton);
container.Register <IStatusBarPresenter, IMainViewItemPresenter, StatusBarPresenter>(LifeStyle.Singleton);
container.Register <IMainComparisonPresenter, IMainViewItemPresenter, MainComparisonPresenter>(LifeStyle.Singleton);
container.Register <ISearchPresenter, IMainViewItemPresenter, SearchPresenter>(LifeStyle.Singleton);
container.Register <INotificationPresenter, IMainViewItemPresenter, NotificationPresenter>(LifeStyle.Singleton);
}
private void registerDiagramPresenter(IContainer container)
{
container.Register <ISimulationDiagramPresenter, IMoBiBaseDiagramPresenter <IMoBiSimulation>, IBaseDiagramPresenter <IMoBiSimulation>, SimulationDiagramPresenter>(LifeStyle.Transient);
container.Register <ISpatialStructureDiagramPresenter, IMoBiBaseDiagramPresenter <IMoBiSpatialStructure>, IBaseDiagramPresenter <IMoBiSpatialStructure>, SpatialStructureDiagramPresenter>(LifeStyle.Transient);
}
private static void registerRunOptionsIn(IContainer container)
{
container.Register <StartOptions, IStartOptions, StartOptions>(LifeStyle.Singleton);
}
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 <IGroupRepository, GroupRepository>(LifeStyle.Singleton);
container.Register <IClipboardManager, ClipboardManager>(LifeStyle.Singleton);
container.Register <ICloneManager, CloneManagerForBuildingBlock>(LifeStyle.Singleton);
container.Register <IProjectRetriever, MoBiProjectRetriever>();
container.Register <IHistoryManager, MoBiHistoryManager>();
container.Register <IObjectIdResetter, ObjectIdResetter>();
container.Register <ISetParameterTask, ParameterTask>();
container.Register <ITransferOptimizedParametersToSimulationsTask, TransferOptimizedParametersToSimulationsTask <IMoBiContext> >();
//Register application specific core objects
container.Register <IObjectBaseFactory, ObjectBaseFactory>(LifeStyle.Singleton);
container.Register <IFullPathDisplayResolver, FullPathDisplayResolver>(LifeStyle.Singleton);
//Register opened types generics
container.Register(typeof(IEntitiesInBuildingBlockRetriever <>), typeof(EntitiesInBuildingBlockRetriever <>));
container.Register <IList <IDimensionMergingInformation>, List <IDimensionMergingInformation> >(LifeStyle.Singleton);
//Register abstract factories
container.RegisterFactory <IHistoryManagerFactory>();
container.RegisterFactory <IDiagramManagerFactory>();
container.Register <DimensionParser, DimensionParser>();
registerSerializers(container);
registerImporter(container);
registerReporters(container);
registerComparers(container);
registerCommitTasks(container);
registerConverters(container);
}
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);
}
private static void registerSettings(IContainer container)
{
container.Register <IUserSettings, IPresentationUserSettings, ICoreUserSettings, UserSettings>(LifeStyle.Singleton);
}
