blob: 904fb4aea02b5a49f68eb0f057018b0aef20a6a3 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
package test;
import dagger.internal.DaggerGenerated;
import dagger.internal.InstanceFactory;
import dagger.internal.Preconditions;
import java.util.Optional;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
final class DaggerTestComponent {
/**
* A {@link Provider} that returns {@code Optional.empty()}.
*/
@SuppressWarnings("rawtypes")
private static final Provider ABSENT_JDK_OPTIONAL_PROVIDER = InstanceFactory.create(Optional.empty());
private DaggerTestComponent() {
}
public static Builder builder() {
return new Builder();
}
public static TestComponent create() {
return new Builder().build();
}
/**
* Returns a {@link Provider} that returns {@code Optional.empty()}.
*/
private static <T> Provider<Optional<T>> absentJdkOptionalProvider() {
@SuppressWarnings("unchecked") // safe covariant cast
Provider<Optional<T>> provider = (Provider<Optional<T>>) ABSENT_JDK_OPTIONAL_PROVIDER;
return provider;
}
/**
* A {@code Provider<Optional<T>>} that uses a delegate {@code Provider<T>}.
*/
private static final class PresentJdkOptionalInstanceProvider<T> implements Provider<Optional<T>> {
private final Provider<T> delegate;
private PresentJdkOptionalInstanceProvider(Provider<T> delegate) {
this.delegate = Preconditions.checkNotNull(delegate);
}
@Override
public Optional<T> get() {
return Optional.of(delegate.get());
}
private static <T> Provider<Optional<T>> of(Provider<T> delegate) {
return new PresentJdkOptionalInstanceProvider<T>(delegate);
}
}
static final class Builder {
private Builder() {
}
public TestComponent build() {
return new TestComponentImpl();
}
}
private static final class TestComponentImpl implements TestComponent {
private final TestComponentImpl testComponentImpl = this;
private Provider<Optional<Present>> optionalOfPresentProvider;
private Provider<Optional<Absent>> optionalOfAbsentProvider;
private TestComponentImpl() {
initialize();
}
@SuppressWarnings("unchecked")
private void initialize() {
this.optionalOfPresentProvider = PresentJdkOptionalInstanceProvider.of(TestModule_PFactory.create());
this.optionalOfAbsentProvider = absentJdkOptionalProvider();
}
@Override
public Provider<Optional<Present>> providerOfOptionalOfPresent() {
return optionalOfPresentProvider;
}
@Override
public Provider<Optional<Absent>> providerOfOptionalOfAbsent() {
return optionalOfAbsentProvider;
}
}
}
|
