private void initGroupRepository(IContainer container)
{
var configuration = container.Resolve <IMoBiConfiguration>();
var groupRepository = container.Resolve <IGroupRepository>();
var persister = container.Resolve <IGroupRepositoryPersistor>();
persister.Load(groupRepository, configuration.GroupRepositoryFile);
}
private static void loadPKParameterRepository(IContainer container)
{
var pkParameterRepository = container.Resolve <IPKParameterRepository>();
var pKParameterLoader = container.Resolve <IPKParameterRepositoryLoader>();
var configuration = container.Resolve <IMoBiConfiguration>();
pKParameterLoader.Load(pkParameterRepository, configuration.PKParametersFilePath);
}
private static void loadPKParameters(IContainer container)
{
//register pk analyses values
var pkParameterRepository = container.Resolve <IPKParameterRepository>();
var pKParameterLoader = container.Resolve <IPKParameterRepositoryLoader>();
var pkSimConfiguration = container.Resolve <IPKSimConfiguration>();
pKParameterLoader.Load(pkParameterRepository, pkSimConfiguration.PKParametersFilePath);
}
public static void InitDimensions(IContainer container)
{
var configuration = container.Resolve <IMoBiConfiguration>();
var dimFactory = container.Resolve <IMoBiDimensionFactory>();
var persister = container.Resolve <IDimensionFactoryPersistor>();
persister.Load(dimFactory.BaseFactory, configuration.DimensionFilePath);
dimFactory.BaseFactory.AddDimension(Constants.Dimension.NO_DIMENSION);
container.RegisterImplementationOf <IDimensionFactory>(dimFactory);
setUpDimensionMergings(dimFactory.BaseFactory);
}
public static void InitCalculationMethodRepository(IContainer container)
{
var calculationMethodsRepositoryPersistor = container.Resolve <ICalculationMethodsRepositoryPersistor>();
calculationMethodsRepositoryPersistor.Load();
//Add Empty CM'S to use in non PK-Sim Models
var rep = container.Resolve <ICoreCalculationMethodRepository>();
var objectBaseFactory = container.Resolve <IObjectBaseFactory>();
rep.GetAllCategoriesDefault().Each(cm => rep.AddCalculationMethod(createDefaultCalculationMethodForCategory(cm.Category, objectBaseFactory)));
}
/// <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);
}
/// <summary>
/// All specific registration that needs to be performed once all other registrations are done
/// </summary>
private void finalizeRegistration(IContainer container)
{
var workspace = container.Resolve <IWorkspace>();
container.RegisterImplementationOf <IWithWorkspaceLayout>(workspace);
container.RegisterImplementationOf <OSPSuite.Core.IWorkspace>(workspace);
//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>();
container.Resolve <IExportToPDFInvoker>();
var mainPresenter = container.Resolve <IMainViewPresenter>();
container.RegisterImplementationOf((IChangePropagator)mainPresenter);
}
private void initializeConfiguration(IContainer container, ApiConfig apiConfig)
{
var applicationConfiguration = container.Resolve <IApplicationConfiguration>();
applicationConfiguration.PKParametersFilePath = apiConfig.PKParametersFilePath;
applicationConfiguration.DimensionFilePath = apiConfig.DimensionFilePath;
}
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 void initContext(IContainer container)
{
InitDimensions(container);
var userSettingsPersistor = container.Resolve <ISettingsPersistor <IUserSettings> >();
userSettingsPersistor.Load();
var applicationSettingsPersistor = container.Resolve <ISettingsPersistor <IApplicationSettings> >();
applicationSettingsPersistor.Load();
InitCalculationMethodRepository(container);
initGroupRepository(container);
loadPKParameterRepository(container);
}
private void configureLogger(IContainer container, LogLevel logLevel)
{
var loggerFactory = container.Resolve <ILoggerFactory>();
loggerFactory
.AddPresenter(logLevel)
.AddDebug(logLevel);
}
private static void registerConfigurationIn(IContainer container)
{
container.Register <IPKSimConfiguration, IApplicationConfiguration, PKSimConfiguration>(LifeStyle.Singleton);
var configuration = container.Resolve <IPKSimConfiguration>();
CoreConstants.ProductDisplayName = configuration.ProductDisplayName;
}
public static void LoadDefaultEntities(IContainer container)
{
//load unit serializer
container.Resolve <IUnitSystemXmlSerializerRepository>().PerformMapping();
//Then trigger dimension load to load the dimensions
loadDimensionRepository(container);
//Load pkml serializers
var ospSuiteXmlSerializerRepository = container.Resolve <IOSPSuiteXmlSerializerRepository>();
ospSuiteXmlSerializerRepository.AddPresentationSerializers();
ospSuiteXmlSerializerRepository.PerformMapping();
//then load pk parameters
loadPKParameters(container);
//last load all serializer
container.Resolve <IPKSimXmlSerializerRepository>().PerformMapping();
}
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 configureLogger(IContainer container, LogLevel logLevel)
{
var loggerCreator = container.Resolve <ILoggerCreator>();
loggerCreator
.AddLoggingBuilderConfiguration(builder =>
builder
.SetMinimumLevel(logLevel)
.AddFile("log.txt", logLevel, false)
);
}
private void configureLogger(IContainer container, LogLevel logLevel)
{
var loggerCreator = container.Resolve <ILoggerCreator>();
loggerCreator
.AddLoggingBuilderConfiguration(builder =>
builder
.SetMinimumLevel(logLevel)
.AddDebug()
.AddPresenter()
);
}
private static void initializeDimensions(IContainer container)
{
var applicationConfiguration = container.Resolve <IApplicationConfiguration>();
var dimensionFactory = container.Resolve <IDimensionFactory>();
var persistor = container.Resolve <IDimensionFactoryPersistor>();
persistor.Load(dimensionFactory, applicationConfiguration.DimensionFilePath);
dimensionFactory.AddDimension(Constants.Dimension.NO_DIMENSION);
var molarConcentrationDimension = dimensionFactory.Dimension(Constants.Dimension.MOLAR_CONCENTRATION);
var massConcentrationDimension = dimensionFactory.Dimension(Constants.Dimension.MASS_CONCENTRATION);
var amountDimension = dimensionFactory.Dimension(Constants.Dimension.MOLAR_AMOUNT);
var massDimension = dimensionFactory.Dimension(Constants.Dimension.MASS_AMOUNT);
var aucMolarDimension = dimensionFactory.Dimension(Constants.Dimension.MOLAR_AUC);
var aucMassDimension = dimensionFactory.Dimension(Constants.Dimension.MASS_AUC);
dimensionFactory.AddMergingInformation(new SimpleDimensionMergingInformation(molarConcentrationDimension, massConcentrationDimension));
dimensionFactory.AddMergingInformation(new SimpleDimensionMergingInformation(massConcentrationDimension, molarConcentrationDimension));
dimensionFactory.AddMergingInformation(new SimpleDimensionMergingInformation(amountDimension, massDimension));
dimensionFactory.AddMergingInformation(new SimpleDimensionMergingInformation(massDimension, amountDimension));
dimensionFactory.AddMergingInformation(new SimpleDimensionMergingInformation(aucMolarDimension, aucMassDimension));
dimensionFactory.AddMergingInformation(new SimpleDimensionMergingInformation(aucMassDimension, aucMolarDimension));
}
// because Setup cannot copy into each user profile app data, copy has to be done here
private void initUserProfileFileAppData(IContainer container)
{
var configuration = container.Resolve <IMoBiConfiguration>();
// template is not necessary in user profile app data, because if not available base template is used,
// but it may be helpful to support user to store his own template at the right location.
if (!Directory.Exists(configuration.CurrentUserFolderPath))
{
Directory.CreateDirectory(configuration.CurrentUserFolderPath);
}
if (!File.Exists(configuration.SpaceOrganismUserTemplate))
{
File.Copy(configuration.SpaceOrganismBaseTemplate, configuration.SpaceOrganismUserTemplate);
}
if (!Directory.Exists(configuration.ChartLayoutTemplateFolderPath))
{
Directory.CreateDirectory(configuration.ChartLayoutTemplateFolderPath);
}
}
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);
}
private static void loadDimensionRepository(IContainer container)
{
//Loading the dimension will trigger the load
container.Resolve <IDimensionRepository>().All();
}
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)
{
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>();
var config = container.Resolve <IMoBiConfiguration>();
XMLSchemaCache.InitializeFromFile(config.SimModelSchemaFilePath);
registerReporters(container);
registerComparers(container);
registerCommitTasks(container);
registerConverters(container);
}
public override void GlobalContext()
{
base.GlobalContext();
var windsorContainer = new CastleWindsorContainer();
IContainer container = windsorContainer;
windsorContainer.WindsorContainer.AddFacility <TypedFactoryFacility>();
IoC.InitializeWith(container);
IoC.RegisterImplementationOf(container);
//need to register these services for which the default implementation is in the UI
using (container.OptimizeDependencyResolution())
{
container.RegisterImplementationOf(new SynchronizationContext());
container.Register <IExceptionManager, ExceptionManagerForSpecs>(LifeStyle.Singleton);
container.RegisterImplementationOf(A.Fake <IUserSettings>());
container.RegisterImplementationOf(A.Fake <IDialogCreator>());
container.RegisterImplementationOf(A.Fake <IProgressUpdater>());
container.RegisterImplementationOf(A.Fake <IMoBiHistoryManager>());
container.RegisterImplementationOf(A.Fake <IXmlContentSelector>());
container.RegisterImplementationOf(A.Fake <IDiagramModel>());
container.RegisterImplementationOf(A.Fake <IDiagramTask>());
container.RegisterImplementationOf(A.Fake <IMRUProvider>());
container.RegisterImplementationOf(A.Fake <IFileLocker>());
container.RegisterImplementationOf(A.Fake <IDisplayUnitRetriever>());
container.RegisterImplementationOf(A.Fake <IJournalDiagramManagerFactory>());
container.RegisterImplementationOf(A.Fake <ISimulationDiagramManager>());
container.RegisterImplementationOf(A.Fake <ISpatialStructureDiagramManager>());
container.RegisterImplementationOf(A.Fake <IMoBiReactionDiagramManager>());
container.RegisterImplementationOf(A.Fake <ISimulationDiagramView>());
container.RegisterImplementationOf(A.Fake <IContainerBaseLayouter>());
container.RegisterImplementationOf(A.Fake <ILayerLayouter>());
container.Register <IDiagramModelToXmlMapper, BatchDiagramModelToXmlMapper>();
container.Register <IMoBiConfiguration, MoBiConfiguration>(LifeStyle.Singleton);
container.Register <IEventPublisher, EventPublisher>(LifeStyle.Singleton);
IHeavyWorkManager heavyWorkManager = new HeavyWorkManagerForSpecs();
container.RegisterImplementationOf(heavyWorkManager);
container.RegisterImplementationOf(A.Fake <IProgressManager>());
var config = container.Resolve <IMoBiConfiguration>();
container.RegisterImplementationOf((IApplicationConfiguration)config);
var register = new SerializerRegister();
container.AddRegister(x =>
{
x.FromType <CoreRegister>();
x.FromType <Core.CoreRegister>();
x.FromInstance(new PresentationRegister(false));
x.FromType <SBMLImportRegister>();
x.FromType <InfrastructureRegister>();
x.FromInstance(register);
});
register.PerformMappingForSerializerIn(container);
container.RegisterImplementationOf(A.Fake <IMoBiMainViewPresenter>());
setupDimensions(container);
setupCalculationMethods(container);
var context = container.Resolve <IMoBiContext>();
container.RegisterImplementationOf <IWorkspace>(context);
}
//Required for usage with nunit 3
Environment.CurrentDirectory = AppDomain.CurrentDomain.BaseDirectory;
}
