import java.util.concurrent.ConcurrentMap;
import org.opendaylight.yangtools.concepts.AbstractObjectRegistration;
-import org.opendaylight.yangtools.concepts.Registration;
-import org.opendaylight.yangtools.sal.binding.generator.util.ClassLoaderUtils;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
+import org.opendaylight.yangtools.sal.binding.generator.api.ClassLoadingStrategy;
+import org.opendaylight.yangtools.sal.binding.generator.api.ModuleInfoRegistry;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
+import org.opendaylight.yangtools.yang.binding.util.ClassLoaderUtils;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
import org.opendaylight.yangtools.yang.model.util.repo.AdvancedSchemaSourceProvider;
import org.opendaylight.yangtools.yang.model.util.repo.SourceIdentifier;
import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
public class ModuleInfoBackedContext extends GeneratedClassLoadingStrategy //
implements //
- AdvancedSchemaSourceProvider<InputStream> {
+ AdvancedSchemaSourceProvider<InputStream>, ModuleInfoRegistry, SchemaContextProvider {
- private ModuleInfoBackedContext(GeneratedClassLoadingStrategy loadingStrategy) {
+ private ModuleInfoBackedContext(final ClassLoadingStrategy loadingStrategy) {
this.backingLoadingStrategy = loadingStrategy;
}
return new ModuleInfoBackedContext(getTCCLClassLoadingStrategy());
}
- public static ModuleInfoBackedContext create(GeneratedClassLoadingStrategy loadingStrategy) {
+ public static ModuleInfoBackedContext create(final ClassLoadingStrategy loadingStrategy) {
return new ModuleInfoBackedContext(loadingStrategy);
}
private final ConcurrentMap<String, WeakReference<ClassLoader>> packageNameToClassLoader = new ConcurrentHashMap<>();
private final ConcurrentMap<SourceIdentifier, YangModuleInfo> sourceIdentifierToModuleInfo = new ConcurrentHashMap<>();
- private final GeneratedClassLoadingStrategy backingLoadingStrategy;
+ private final ClassLoadingStrategy backingLoadingStrategy;
@Override
- public Class<?> loadClass(String fullyQualifiedName) throws ClassNotFoundException {
+ public Class<?> loadClass(final String fullyQualifiedName) throws ClassNotFoundException {
String modulePackageName = BindingReflections.getModelRootPackageName(fullyQualifiedName);
WeakReference<ClassLoader> classLoaderRef = packageNameToClassLoader.get(modulePackageName);
return sourceStreams.build();
}
- private boolean resolveModuleInfo(Class<?> cls) {
+ private boolean resolveModuleInfo(final Class<?> cls) {
try {
return resolveModuleInfo(BindingReflections.getModuleInfo(cls));
} catch (Exception e) {
- throw new IllegalStateException(e);
+ throw new IllegalStateException(String.format("Failed to resolve module information for class %s", cls), e);
}
}
- private boolean resolveModuleInfo(YangModuleInfo moduleInfo) {
+ private boolean resolveModuleInfo(final YangModuleInfo moduleInfo) {
SourceIdentifier identifier = sourceIdentifierFrom(moduleInfo);
YangModuleInfo previous = sourceIdentifierToModuleInfo.putIfAbsent(identifier, moduleInfo);
return true;
}
- private SourceIdentifier sourceIdentifierFrom(YangModuleInfo moduleInfo) {
+ private SourceIdentifier sourceIdentifierFrom(final YangModuleInfo moduleInfo) {
return SourceIdentifier.create(moduleInfo.getName(), Optional.of(moduleInfo.getRevision()));
}
- public void addModuleInfos(Iterable<? extends YangModuleInfo> moduleInfos) {
+ public void addModuleInfos(final Iterable<? extends YangModuleInfo> moduleInfos) {
for (YangModuleInfo yangModuleInfo : moduleInfos) {
registerModuleInfo(yangModuleInfo);
}
}
- public Registration<YangModuleInfo> registerModuleInfo(YangModuleInfo yangModuleInfo) {
+ @Override
+ public ObjectRegistration<YangModuleInfo> registerModuleInfo(final YangModuleInfo yangModuleInfo) {
YangModuleInfoRegistration registration = new YangModuleInfoRegistration(yangModuleInfo, this);
resolveModuleInfo(yangModuleInfo);
}
@Override
- public Optional<InputStream> getSchemaSource(SourceIdentifier sourceIdentifier) {
+ public Optional<InputStream> getSchemaSource(final SourceIdentifier sourceIdentifier) {
YangModuleInfo info = sourceIdentifierToModuleInfo.get(sourceIdentifier);
if (info == null) {
return Optional.absent();
}
@Override
- public Optional<InputStream> getSchemaSource(String moduleName, Optional<String> revision) {
+ public Optional<InputStream> getSchemaSource(final String moduleName, final Optional<String> revision) {
return getSchemaSource(SourceIdentifier.create(moduleName, revision));
}
private final ModuleInfoBackedContext context;
- public YangModuleInfoRegistration(YangModuleInfo instance, ModuleInfoBackedContext context) {
+ public YangModuleInfoRegistration(final YangModuleInfo instance, final ModuleInfoBackedContext context) {
super(instance);
this.context = context;
}
}
- private void remove(YangModuleInfoRegistration registration) {
+ private void remove(final YangModuleInfoRegistration registration) {
// FIXME implement
}
+
+ @Override
+ public SchemaContext getSchemaContext() {
+ return tryToCreateSchemaContext().get();
+ }
}