@Override public <T> Supplier<T> provideDependency( final Class<T> type, final SelectionStrategy selector ) { return () -> resolveDependency( type, selector ); }
@Override public <T> Supplier<T> provideDependency( final Class<T> type ) { return () -> resolveDependency( type ); }
private <T> T resolveDependency( Class<T> clazz ) { return dependencies.resolveDependency( clazz ); } }
private static <T> T dependency( Dependencies dependencies, Class<T> type, Function<DependencyResolver,T> defaultSupplier ) { try { return dependencies.resolveDependency( type ); } catch ( IllegalArgumentException | UnsatisfiedDependencyException e ) { return dependencies.satisfyDependency( defaultSupplier.apply( dependencies ) ); } }
@Test public void givenSatisfiedTypeWhenResolveWithSuperTypeThenInstanceReturned() { // Given Dependencies dependencies = new Dependencies( ); AbstractList foo = new ArrayList( ); dependencies.satisfyDependency( foo ); // When AbstractList instance = dependencies.resolveDependency( AbstractList.class ); // Then assertThat(instance, equalTo(foo)); }
@Test public void givenSatisfiedTypeWhenResolveWithSubInterfaceThenInstanceReturned() { // Given Dependencies dependencies = new Dependencies( ); Collection foo = new ArrayList( ); dependencies.satisfyDependency( foo ); // When Collection instance = dependencies.resolveDependency( Collection.class ); // Then assertThat(instance, equalTo(foo)); }
@Test public void givenSatisfiedTypeWhenResolveWithInterfaceThenInstanceReturned() { // Given Dependencies dependencies = new Dependencies( ); List foo = new ArrayList( ); dependencies.satisfyDependency( foo ); // When List instance = dependencies.resolveDependency( List.class ); // Then assertThat(instance, equalTo(foo)); }
@Test public void givenSatisfiedTypeWhenResolveWithTypeThenInstanceReturned() { // Given Dependencies dependencies = new Dependencies( ); String foo = "foo"; dependencies.satisfyDependency( foo ); // When String instance = dependencies.resolveDependency( String.class ); // Then assertThat(instance, equalTo(foo)); }
@Test public void givenSatisfiedTypeInParentWhenResolveWithTypeInEmptyDependenciesThenInstanceReturned() { // Given Dependencies parent = new Dependencies( ); Dependencies dependencies = new Dependencies( parent ); Collection foo = new ArrayList( ); dependencies.satisfyDependency( foo ); // When Collection instance = dependencies.resolveDependency( Collection.class ); // Then assertThat(instance, equalTo(foo)); }
@Test public void givenSatisfiedTypeInParentAndDependenciesWhenResolveWithTypeInDependenciesThenInstanceReturned() { // Given Dependencies parent = new Dependencies( ); Dependencies dependencies = new Dependencies( parent ); Collection foo = new ArrayList( ); dependencies.satisfyDependency( foo ); parent.satisfyDependency( new ArrayList()); // When Collection instance = dependencies.resolveDependency( Collection.class ); // Then assertThat(instance, equalTo(foo)); }
@Test public void givenEmptyDependenciesWhenResolveWithTypeThenException() { // Given Dependencies dependencies = new Dependencies( ); // When try { dependencies.resolveDependency( Collection.class ); fail(); } catch ( UnsatisfiedDependencyException e ) { // Then } } }
private BasicContext prepareContext( SecurityContext securityContext ) { BasicContext ctx = new BasicContext(); ctx.put( Context.KERNEL_TRANSACTION, ktx ); ctx.put( Context.DATABASE_API, dataSourceDependencies.resolveDependency( GraphDatabaseAPI.class ) ); ctx.put( Context.DEPENDENCY_RESOLVER, dataSourceDependencies ); ctx.put( Context.THREAD, Thread.currentThread() ); ClockContext clocks = ktx.clocks(); ctx.put( Context.SYSTEM_CLOCK, clocks.systemClock() ); ctx.put( Context.STATEMENT_CLOCK, clocks.statementClock() ); ctx.put( Context.TRANSACTION_CLOCK, clocks.transactionClock() ); ctx.put( Context.SECURITY_CONTEXT, securityContext ); return ctx; }
Dependencies dependencies = new Dependencies(); storageEngine.satisfyDependencies( dependencies ); IndexProxy index = dependencies.resolveDependency( IndexingService.class ) .getIndexProxy( descriptor ); awaitOnline( index );
life.add( logFiles ); TransactionIdStore transactionIdStore = dataSourceDependencies.resolveDependency( TransactionIdStore.class ); LogVersionRepository logVersionRepository = dataSourceDependencies.resolveDependency( LogVersionRepository.class ); NeoStoreTransactionLogModule transactionLogModule = buildTransactionLogs( logFiles, config, logProvider, scheduler, storageEngine, logEntryReader, explicitIndexTransactionOrdering, transactionIdStore ); NodePropertyAccessor nodePropertyAccessor = dataSourceDependencies.resolveDependency( NodePropertyAccessor.class ); dataSourceDependencies.resolveDependency( IndexingService.class ), databaseSchemaState, dataSourceDependencies.resolveDependency( LabelScanStore.class ), storageEngine, indexConfigStore, life.add( new DatabaseDiagnostics( dataSourceDependencies.resolveDependency( DiagnosticsManager.class ), this, databaseInfo ) ); life.add( databaseAvailability ); life.setLast( lifecycleToTriggerCheckPointOnShutdown() );
publishEditionInfo( dependencies.resolveDependency( UsageData.class ), platformModule.databaseInfo, config );
panicEventGenerator = new DatabasePanicEventGenerator( eventHandlers ); publishPlatformInfo( dependencies.resolveDependency( UsageData.class ) );
@Override public <T> Supplier<T> provideDependency( final Class<T> type, final SelectionStrategy selector ) { return () -> resolveDependency( type, selector ); }
private <T> T resolveDependency( Class<T> clazz ) { return dependencies.resolveDependency( clazz ); } }
@Override public <T> Supplier<T> provideDependency( final Class<T> type ) { return () -> resolveDependency( type ); }
@Override public CheckPointer get() { return dependencies.resolveDependency( CheckPointer.class ); } }