Move the SchemaPath/Method map closer to where we instantiate invokers.
This has the benefit of speeding up registration code very slightly,
but more importantly it allows instantiating more efficient invokers, as
we have the SchemaPath->Method map readily available.
Change-Id: Iefc0faadcfd7df6c40240ce1f78c7b734f06c618
Signed-off-by: Robert Varga <rovarga@cisco.com>
*/
package org.opendaylight.controller.md.sal.binding.impl;
*/
package org.opendaylight.controller.md.sal.binding.impl;
+import com.google.common.base.Preconditions;
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.JdkFutureAdapters;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.JdkFutureAdapters;
import com.google.common.util.concurrent.ListenableFuture;
+import java.lang.reflect.Method;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcIdentifier;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementation;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcIdentifier;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementation;
public class BindingDOMRpcImplementationAdapter implements DOMRpcImplementation {
public class BindingDOMRpcImplementationAdapter implements DOMRpcImplementation {
+ private static final Cache<Class<?>, RpcServiceInvoker> SERVICE_INVOKERS = CacheBuilder.newBuilder().weakKeys().build();
+
private final BindingNormalizedNodeCodecRegistry codec;
private final RpcServiceInvoker invoker;
private final RpcService delegate;
private final QNameModule module;
private final BindingNormalizedNodeCodecRegistry codec;
private final RpcServiceInvoker invoker;
private final RpcService delegate;
private final QNameModule module;
- public <T extends RpcService> BindingDOMRpcImplementationAdapter(final BindingNormalizedNodeCodecRegistry codec, final Class<T> type ,final T delegate) {
- this.codec = codec;
- this.delegate = delegate;
- invoker = RpcServiceInvoker.from(type);
+ public <T extends RpcService> BindingDOMRpcImplementationAdapter(final BindingNormalizedNodeCodecRegistry codec, final Class<T> type, final Map<SchemaPath, Method> localNameToMethod, final T delegate) {
+ try {
+ this.invoker = SERVICE_INVOKERS.get(type, new Callable<RpcServiceInvoker>() {
+ @Override
+ public RpcServiceInvoker call() {
+ return RpcServiceInvoker.from(type);
+ }
+ });
+ } catch (ExecutionException e) {
+ throw new IllegalArgumentException("Failed to create invokers for type " + type, e);
+ }
+
+ this.codec = Preconditions.checkNotNull(codec);
+ this.delegate = Preconditions.checkNotNull(delegate);
module = BindingReflections.getQNameModule(type);
}
module = BindingReflections.getQNameModule(type);
}
}
private DataObject deserilialize(final SchemaPath rpcPath, final NormalizedNode<?, ?> input) {
}
private DataObject deserilialize(final SchemaPath rpcPath, final NormalizedNode<?, ?> input) {
- if(input instanceof LazySerializedContainerNode) {
+ if (input instanceof LazySerializedContainerNode) {
return ((LazySerializedContainerNode) input).bindingData();
}
final SchemaPath inputSchemaPath = rpcPath.createChild(QName.create(module,"input"));
return ((LazySerializedContainerNode) input).bindingData();
}
final SchemaPath inputSchemaPath = rpcPath.createChild(QName.create(module,"input"));
private CheckedFuture<DOMRpcResult, DOMRpcException> transformResult(final SchemaPath schemaPath,
final ListenableFuture<RpcResult<?>> bindingResult) {
private CheckedFuture<DOMRpcResult, DOMRpcException> transformResult(final SchemaPath schemaPath,
final ListenableFuture<RpcResult<?>> bindingResult) {
- return LazyDOMRpcResultFuture.create(codec,bindingResult);
+ return LazyDOMRpcResultFuture.create(codec, bindingResult);
package org.opendaylight.controller.md.sal.binding.impl;
import com.google.common.collect.ImmutableSet;
package org.opendaylight.controller.md.sal.binding.impl;
import com.google.common.collect.ImmutableSet;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collection;
import java.util.HashSet;
import java.util.HashSet;
import java.util.Set;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcIdentifier;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationRegistration;
import java.util.Set;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcIdentifier;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationRegistration;
public <S extends RpcService, T extends S> ObjectRegistration<T> registerRpcImplementation(final Class<S> type,
final T implementation) {
public <S extends RpcService, T extends S> ObjectRegistration<T> registerRpcImplementation(final Class<S> type,
final T implementation) {
- return register(type,implementation,createDomRpcIdentifiers(type,GLOBAL));
+ return register(type, implementation, GLOBAL);
}
public <S extends RpcService, T extends S> ObjectRegistration<T> registerRpcImplementation(final Class<S> type,
final T implementation, final Set<InstanceIdentifier<?>> paths) {
}
public <S extends RpcService, T extends S> ObjectRegistration<T> registerRpcImplementation(final Class<S> type,
final T implementation, final Set<InstanceIdentifier<?>> paths) {
- return register(type,implementation,createDomRpcIdentifiers(type,toYangInstanceIdentifiers(paths)));
+ return register(type, implementation, toYangInstanceIdentifiers(paths));
- private <S extends RpcService, T extends S> ObjectRegistration<T> register(final Class<S> type, final T implementation, final Set<DOMRpcIdentifier> domRpcs) {
- final BindingDOMRpcImplementationAdapter adapter = new BindingDOMRpcImplementationAdapter(codec.getCodecRegistry(), type, implementation);
-
+ private <S extends RpcService, T extends S> ObjectRegistration<T> register(final Class<S> type, final T implementation, final Collection<YangInstanceIdentifier> rpcContextPaths) {
+ final Map<SchemaPath, Method> rpcs = codec.getRpcMethodToSchemaPath(type).inverse();
+ final BindingDOMRpcImplementationAdapter adapter = new BindingDOMRpcImplementationAdapter(codec.getCodecRegistry(), type, rpcs, implementation);
+ final Set<DOMRpcIdentifier> domRpcs = createDomRpcIdentifiers(rpcs.keySet(), rpcContextPaths);
final DOMRpcImplementationRegistration<?> domReg = domRpcRegistry.registerRpcImplementation(adapter, domRpcs);
return new BindingRpcAdapterRegistration<>(implementation, domReg);
}
final DOMRpcImplementationRegistration<?> domReg = domRpcRegistry.registerRpcImplementation(adapter, domRpcs);
return new BindingRpcAdapterRegistration<>(implementation, domReg);
}
- private Set<DOMRpcIdentifier> createDomRpcIdentifiers(final Class<? extends RpcService> type, final Set<YangInstanceIdentifier> paths) {
- final Set<SchemaPath> rpcs = getRpcSchemaPaths(type);
-
+ private static Set<DOMRpcIdentifier> createDomRpcIdentifiers(final Set<SchemaPath> rpcs, final Collection<YangInstanceIdentifier> paths) {
final Set<DOMRpcIdentifier> ret = new HashSet<>();
final Set<DOMRpcIdentifier> ret = new HashSet<>();
- for(final YangInstanceIdentifier path : paths) {
- for(final SchemaPath rpc : rpcs) {
+ for (final YangInstanceIdentifier path : paths) {
+ for (final SchemaPath rpc : rpcs) {
ret.add(DOMRpcIdentifier.create(rpc, path));
}
}
return ret;
}
ret.add(DOMRpcIdentifier.create(rpc, path));
}
}
return ret;
}
- private Set<YangInstanceIdentifier> toYangInstanceIdentifiers(final Set<InstanceIdentifier<?>> identifiers) {
- final Set<YangInstanceIdentifier> ret = new HashSet<>();
- for(final InstanceIdentifier<?> binding: identifiers) {
+ private Collection<YangInstanceIdentifier> toYangInstanceIdentifiers(final Set<InstanceIdentifier<?>> identifiers) {
+ final Collection<YangInstanceIdentifier> ret = new ArrayList<>(identifiers.size());
+ for (final InstanceIdentifier<?> binding : identifiers) {
ret.add(codec.toYangInstanceIdentifierCached(binding));
}
return ret;
}
ret.add(codec.toYangInstanceIdentifierCached(binding));
}
return ret;
}
-
- private Set<SchemaPath> getRpcSchemaPaths(final Class<? extends RpcService> type) {
- return codec.getRpcMethodToSchemaPath(type).values();
- }
-