@Override public Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { return codecRegistry.fromNormalizedNode(path, data); }
@Override public <T extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalizedNode( final InstanceIdentifier<T> path, final T data) { return codecRegistry.toNormalizedNode(path, data); }
@Override public YangInstanceIdentifier toYangInstanceIdentifier(final InstanceIdentifier<?> binding) { return codecRegistry.toYangInstanceIdentifier(binding); }
/** * Creates a new BindingToNormalizedNodeCodec instance. * * @param classLoadingStrategy * @return the BindingToNormalizedNodeCodec instance */ public static BindingToNormalizedNodeCodec newInstance(ClassLoadingStrategy classLoadingStrategy) { BindingNormalizedNodeCodecRegistry codecRegistry = new BindingNormalizedNodeCodecRegistry( StreamWriterGenerator.create(SingletonHolder.JAVASSIST)); return new BindingToNormalizedNodeCodec(classLoadingStrategy, codecRegistry, true); }
@Override public ContainerNode toNormalizedNodeRpcData(final DataContainer data) { return codecRegistry.toNormalizedNodeRpcData(data); }
@Override public DataObject fromNormalizedNodeRpcData(final SchemaPath path, final ContainerNode data) { return codecRegistry.fromNormalizedNodeRpcData(path, data); }
@Override public ContainerNode toNormalizedNodeNotification(final Notification data) { return codecRegistry.toNormalizedNodeNotification(data); }
@Override public InstanceIdentifier<?> fromYangInstanceIdentifier(final YangInstanceIdentifier dom) { return codecRegistry.fromYangInstanceIdentifier(dom); }
@Override public BindingCodecTree create(final BindingRuntimeContext context) { return codecRegistry.create(context); }
@Override public Notification fromNormalizedNodeNotification(final SchemaPath path, final ContainerNode data) { return codecRegistry.fromNormalizedNodeNotification(path, data); }
public <T extends DataObject> Function<Optional<NormalizedNode<?, ?>>, Optional<T>> deserializeFunction(final InstanceIdentifier<T> path) { return codecRegistry.deserializeFunction(path); }
public DataObject dataObjectFromNormalizedNode(NormalizedNode<?, ?> nn) { return codecRegistry.fromNormalizedNode(TOP_ODL_TTPS_PATH, nn).getValue(); }
private static NormalizedNode<?, ?> toNormalized(final Netconf netconfSubtree) { return NotificationsTransformUtil.CODEC_REGISTRY.toNormalizedNode(NETCONF_SUBTREE_INSTANCE_IDENTIFIER, netconfSubtree).getValue(); }
/** * Translates supplied Binding Instance Identifier into NormalizedNode * instance identifier. * * @param binding * Binding Instance Identifier * @return DOM Instance Identifier * @throws IllegalArgumentException * If supplied Instance Identifier is not valid. */ public YangInstanceIdentifier toNormalized(final InstanceIdentifier<? extends DataObject> binding) { return codecRegistry.toYangInstanceIdentifier(binding); }
/** * * Returns a Binding-Aware instance identifier from normalized * instance-identifier if it is possible to create representation. * * Returns Optional.absent for cases where target is mixin node except * augmentation. * */ public Optional<InstanceIdentifier<? extends DataObject>> toBinding(final YangInstanceIdentifier normalized) throws DeserializationException { try { return Optional.<InstanceIdentifier<? extends DataObject>>fromNullable(codecRegistry.fromYangInstanceIdentifier(normalized)); } catch (final IllegalArgumentException e) { return Optional.absent(); } }
@Override public BindingCodecTree create(final SchemaContext context, final Class<?>... bindingClasses) { return codecRegistry.create(context, bindingClasses); }
@Override public void onComplete(Throwable failure, NormalizedNodeMessage success) throws Throwable { if (failure != null) { settableFuture.setException(failure); return; } final Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode = codecRegistry.fromNormalizedNode(success.getIdentifier(), success.getNode()); final Node value = (Node) fromNormalizedNode.getValue(); settableFuture.set(value); } }, TypedActor.context().dispatcher());
@Override public void onSuccess(Node result) { final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecRegistry.toNormalizedNode(iid, result); promise.success(new NormalizedNodeMessage(entry.getKey(), entry.getValue())); }
YangInstanceIdentifier toYangInstanceIdentifierBlocking(final InstanceIdentifier<? extends DataObject> binding) { try { return codecRegistry.toYangInstanceIdentifier(binding); } catch (final MissingSchemaException e) { waitForSchema(decompose(binding),e); return codecRegistry.toYangInstanceIdentifier(binding); } }
public BindingMountPointAdapter(final BindingToNormalizedNodeCodec codec, final DOMMountPoint domMountPoint) { identifier = codec.getCodecRegistry().fromYangInstanceIdentifier(domMountPoint.getIdentifier()); services = CacheBuilder.newBuilder().build(new BindingDOMAdapterLoader(codec) { @Override protected DOMService getDelegate(Class<? extends DOMService> reqDeleg) { return domMountPoint.getService(reqDeleg).orNull(); } }); }