private static void registerTexReporters(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <InfrastructureRegister>();
scan.IncludeNamespaceContainingType <IndividualTeXBuilder>();
scan.IncludeNamespaceContainingType <SimulationReporter>();
scan.WithConvention <ReporterRegistrationConvention>();
});
}
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>();
}
private static void registerContextMenuAndCommands(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <PresentationRegister>();
scan.IncludeNamespaceContainingType <ContextMenuBase>();
scan.IncludeNamespaceContainingType <IExitCommand>();
scan.WithConvention <AllInterfacesAndConcreteTypeRegistrationConvention>();
});
}
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);
}
public MoBiMainView(IContainer container)
{
InitializeComponent();
container.RegisterImplementationOf(ribbonControl.Manager);
container.RegisterImplementationOf(ribbonControl.Manager as BarManager);
container.RegisterImplementationOf(applicationMenu);
container.RegisterImplementationOf(defaultLookAndFeel);
container.RegisterImplementationOf(defaultLookAndFeel.LookAndFeel);
container.RegisterImplementationOf(panelControlAppMenuFileLabels);
container.RegisterImplementationOf(dockManager);
}
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 registerComparers(IContainer container)
{
container.AddScanner(scan =>
{
scan.AssemblyContainingType <CoreRegister>();
scan.IncludeNamespaceContainingType <IndividualDiffBuilder>();
scan.WithConvention <RegisterTypeConvention <IDiffBuilder> >();
});
ParameterDiffBuilder.ShouldCompareParametersIn = PKSimParameterDiffBuilder.ShouldCompareParametersIn;
}
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 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 configureLogger(IContainer container, LogLevel logLevel)
{
var loggerCreator = container.Resolve <ILoggerCreator>();
loggerCreator
.AddLoggingBuilderConfiguration(builder =>
builder
.SetMinimumLevel(logLevel)
.AddFile("log.txt", logLevel, false)
);
}
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>();
}
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 IContainer Initialize(ApiConfig apiConfig)
{
if (_container != null)
{
return(_container);
}
_container = new ApplicationStartup().performInitialization(apiConfig);
return(_container);
}
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)));
}
private void configureLogger(IContainer container, LogLevel logLevel)
{
var loggerCreator = container.Resolve <ILoggerCreator>();
loggerCreator
.AddLoggingBuilderConfiguration(builder =>
builder
.SetMinimumLevel(logLevel)
.AddDebug()
.AddPresenter()
);
}
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>();
});
}
protected override void Context()
{
_parameterFactory = A.Fake <IParameterFactory>();
_containerTask = A.Fake <IContainerTask>();
_entityPathResolver = A.Fake <IEntityPathResolver>();
_parameterQuery = A.Fake <IParameterQuery>();
_genderRepository = A.Fake <IGenderRepository>();
_container = A.Fake <IContainer>();
_dimensionMapper = A.Fake <IDimensionMapper>();
sut = new ParameterValuesCacheConverter(_containerTask, _entityPathResolver, _parameterQuery, _parameterFactory,
_genderRepository, _container, _dimensionMapper);
}
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 static IContainer Initialize()
{
if (_container != null)
{
return(_container);
}
redirectAssemblies();
_container = new ApplicationStartup().performInitialization();
return(_container);
}
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>();
}
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 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);
}
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);
}
/// <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 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 <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 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);
}
public void Process(Type concreteType, IContainer container, LifeStyle lifeStyle)
{
if (concreteType.IsEnum)
{
return;
}
if (concreteType.IsNested)
{
return;
}
var interactionInterfaces = concreteType.GetInterfaces()
.Where(i => i.IsGenericType && i.Name.StartsWith("IInteractionTasksFor")).ToList();
interactionInterfaces.Each(interfaceType => register(concreteType, container, lifeStyle, interfaceType));
}
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);
}
