+
+ public BindingNormalizedNodeCodecRegistry getCodecFactory() {
+ return this.codecRegistry;
+ }
+
+ // FIXME: This should be probably part of Binding Runtime context
+ public ImmutableBiMap<Method, SchemaPath> getRpcMethodToSchemaPath(final Class<? extends RpcService> key) {
+ final Module module = getModuleBlocking(key);
+ final ImmutableBiMap.Builder<Method, SchemaPath> ret = ImmutableBiMap.<Method, SchemaPath>builder();
+ try {
+ for (final RpcDefinition rpcDef : module.getRpcs()) {
+ final Method method = findRpcMethod(key, rpcDef);
+ ret.put(method, rpcDef.getPath());
+ }
+ } catch (final NoSuchMethodException e) {
+ throw new IllegalStateException("Rpc defined in model does not have representation in generated class.", e);
+ }
+ return ret.build();
+ }
+
+ protected ImmutableBiMap<Method, RpcDefinition> getRpcMethodToSchema(final Class<? extends RpcService> key) {
+ final Module module = getModuleBlocking(key);
+ final ImmutableBiMap.Builder<Method, RpcDefinition> ret = ImmutableBiMap.builder();
+ try {
+ for (final RpcDefinition rpcDef : module.getRpcs()) {
+ final Method method = findRpcMethod(key, rpcDef);
+ ret.put(method, rpcDef);
+ }
+ } catch (final NoSuchMethodException e) {
+ throw new IllegalStateException("Rpc defined in model does not have representation in generated class.", e);
+ }
+ return ret.build();
+ }
+
+ private Module getModuleBlocking(final Class<?> modeledClass) {
+ final QNameModule moduleName = BindingReflections.getQNameModule(modeledClass);
+ final URI namespace = moduleName.getNamespace();
+ final Date revision = moduleName.getRevision();
+ Module module = runtimeContext().getSchemaContext().findModuleByNamespaceAndRevision(namespace, revision);
+ if((module == null) && this.futureSchema.waitForSchema(namespace,revision)) {
+ module = runtimeContext().getSchemaContext().findModuleByNamespaceAndRevision(namespace, revision);
+ }
+ Preconditions.checkState(module != null, "Schema for %s is not available.", modeledClass);
+ return module;
+ }
+
+ private void waitForSchema(final Collection<Class<?>> binding, final MissingSchemaException e) {
+ LOG.warn("Blocking thread to wait for schema convergence updates for {} {}", this.futureSchema.getDuration(),
+ this.futureSchema.getUnit());
+ if(this.futureSchema.waitForSchema(binding)) {
+ return;
+ }
+
+ throw e;
+ }
+
+ private Method findRpcMethod(final Class<? extends RpcService> key, final RpcDefinition rpcDef) throws NoSuchMethodException {
+ final String methodName = BindingMapping.getMethodName(rpcDef.getQName());
+ if(rpcDef.getInput() != null && isExplicitStatement(rpcDef.getInput())) {
+ final Class<?> inputClz = runtimeContext().getClassForSchema(rpcDef.getInput());
+ return key.getMethod(methodName, inputClz);
+ }
+ return key.getMethod(methodName);
+ }
+
+ private static boolean isExplicitStatement(final ContainerSchemaNode node) {
+ return node instanceof EffectiveStatement
+ && ((EffectiveStatement) node).getDeclared().getStatementSource() == StatementSource.DECLARATION;
+ }
+
+ private BindingRuntimeContext runtimeContext() {
+ return this.futureSchema.runtimeContext();
+ }
+
+ @Override
+ public BindingCodecTree create(final BindingRuntimeContext context) {
+ return this.codecRegistry.create(context);
+ }
+
+ @Override
+ public BindingCodecTree create(final SchemaContext context, final Class<?>... bindingClasses) {
+ return this.codecRegistry.create(context, bindingClasses);
+ }
+
+ @Nonnull
+ protected Map.Entry<InstanceIdentifier<?>, BindingCodecTreeNode<?>> getSubtreeCodec(
+ final YangInstanceIdentifier domIdentifier) {
+
+ final BindingCodecTree currentCodecTree = this.codecRegistry.getCodecContext();
+ final InstanceIdentifier<?> bindingPath = this.codecRegistry.fromYangInstanceIdentifier(domIdentifier);
+ Preconditions.checkArgument(bindingPath != null);
+ /**
+ * If we are able to deserialize YANG instance identifier, getSubtreeCodec must
+ * return non-null value.
+ */
+ final BindingCodecTreeNode<?> codecContext = currentCodecTree.getSubtreeCodec(bindingPath);
+ return new SimpleEntry<>(bindingPath, codecContext);
+ }
+
+ @SuppressWarnings("unchecked")
+ public Set<Class<? extends Notification>> getNotificationClasses(final Set<SchemaPath> interested) {
+ final Set<Class<? extends Notification>> result = new HashSet<>();
+ final Set<NotificationDefinition> knownNotifications = runtimeContext().getSchemaContext().getNotifications();
+ for (final NotificationDefinition notification : knownNotifications) {
+ if (interested.contains(notification.getPath())) {
+ try {
+ result.add((Class<? extends Notification>) runtimeContext().getClassForSchema(notification));
+ } catch (final IllegalStateException e) {
+ // Ignore
+ LOG.warn("Class for {} is currently not known.",notification.getPath(),e);
+ }
+ }
+ }
+ return result;
+ }
+
+ private static Collection<Class<?>> decompose(final InstanceIdentifier<?> path) {
+ final Set<Class<?>> clazzes = new HashSet<>();
+ for(final InstanceIdentifier.PathArgument arg : path.getPathArguments()) {
+ clazzes.add(arg.getType());
+ }
+ return clazzes;
+ }
+