*/
package org.opendaylight.yangtools.sal.binding.generator.impl
+import com.google.common.collect.ImmutableList
+import java.util.ArrayList
+import java.util.Collections
+import java.util.HashMap
+import java.util.List
+import java.util.Map
+import java.util.WeakHashMap
+import java.util.concurrent.ConcurrentHashMap
+import org.opendaylight.yangtools.yang.binding.Augmentation
+import org.opendaylight.yangtools.yang.binding.DataObject
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier
-import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem
-import org.opendaylight.yangtools.yang.common.QName
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.Item
-import java.util.Map
-import java.util.WeakHashMap
+import org.opendaylight.yangtools.yang.binding.util.BindingReflections
+import org.opendaylight.yangtools.yang.common.QName
+import org.opendaylight.yangtools.yang.data.api.CompositeNode
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates
-import java.util.ArrayList
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument
+import org.opendaylight.yangtools.yang.data.api.Node
+import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl
+import org.opendaylight.yangtools.yang.data.impl.SimpleNodeTOImpl
+import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry
+import org.opendaylight.yangtools.yang.data.impl.codec.IdentifierCodec
import org.opendaylight.yangtools.yang.data.impl.codec.InstanceIdentifierCodec
import org.opendaylight.yangtools.yang.data.impl.codec.ValueWithQName
-import java.util.HashMap
import org.slf4j.LoggerFactory
-import java.util.List
-import org.opendaylight.yangtools.yang.binding.DataObject
-import org.opendaylight.yangtools.yang.data.impl.codec.IdentifierCodec
-import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl
-import org.opendaylight.yangtools.yang.data.api.Node
-import org.opendaylight.yangtools.yang.data.impl.SimpleNodeTOImpl
-import org.opendaylight.yangtools.yang.data.api.CompositeNode
-import org.opendaylight.yangtools.yang.binding.Augmentable
-import com.google.common.collect.ImmutableList
-import org.opendaylight.yangtools.yang.binding.Augmentation
-import java.util.concurrent.ConcurrentHashMap
-import org.opendaylight.yangtools.yang.binding.util.BindingReflections
-import java.util.Collections
class InstanceIdentifierCodecImpl implements InstanceIdentifierCodec {
var Class<?> baType = null
val biArgs = input.path
val scannedPath = new ArrayList<QName>(biArgs.size);
- val baArgs = new ArrayList<org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument>(biArgs.size)
+ val baArgs = new ArrayList<InstanceIdentifier.PathArgument>(biArgs.size)
for(biArg : biArgs) {
scannedPath.add(biArg.nodeType);
val baArg = deserializePathArgument(biArg,scannedPath)
return ret;
}
- private def dispatch org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument deserializePathArgument(NodeIdentifier argument,List<QName> processedPath) {
+ private def dispatch InstanceIdentifier.PathArgument deserializePathArgument(NodeIdentifier argument,List<QName> processedPath) {
val Class cls = codecRegistry.getClassForPath(processedPath);
return new Item(cls);
}
- private def dispatch org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument deserializePathArgument(NodeIdentifierWithPredicates argument,List<QName> processedPath) {
+ private def dispatch InstanceIdentifier.PathArgument deserializePathArgument(NodeIdentifierWithPredicates argument,List<QName> processedPath) {
val Class type = codecRegistry.getClassForPath(processedPath);
val IdentifierCodec codec = codecRegistry.getIdentifierCodecForIdentifiable(type);
val value = codec.deserialize(argument.toCompositeNode())?.value;
return new CompositeNodeTOImpl(predicates.nodeType,null,values);
}
- override serialize(InstanceIdentifier input) {
+ override serialize(InstanceIdentifier<?> input) {
var Class<?> previousAugmentation = null
- val pathArgs = input.path as List<org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument>
+ val pathArgs = input.path as List<InstanceIdentifier.PathArgument>
var QName previousQName = null;
val components = new ArrayList<PathArgument>(pathArgs.size);
val qnamePath = new ArrayList<QName>(pathArgs.size);
previousAugmentation = null;
} else {
- previousQName = codecRegistry.getQNameForAugmentation(baArg.type as Class);
+ previousQName = codecRegistry.getQNameForAugmentation(baArg.type as Class<?>);
previousAugmentation = baArg.type;
}
}
classToPreviousAugment.get(class1).put(list,augmentation);
}
- private def dispatch PathArgument serializePathArgument(Item argument, QName previousQname) {
+ private def dispatch PathArgument serializePathArgument(Item<?> argument, QName previousQname) {
val type = argument.type;
val qname = BindingReflections.findQName(type);
if(previousQname == null || (BindingReflections.isAugmentationChild(argument.type))) {
*/
package org.opendaylight.yangtools.restconf.client;
-import com.google.common.base.Function;
-import com.google.common.base.Optional;
-import com.sun.jersey.api.client.ClientResponse;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
+
import org.opendaylight.yangtools.restconf.client.to.RestRpcError;
import org.opendaylight.yangtools.restconf.client.to.RestRpcResult;
import org.opendaylight.yangtools.restconf.common.ResourceUri;
import org.w3c.dom.ls.DOMImplementationLS;
import org.w3c.dom.ls.LSSerializer;
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.sun.jersey.api.client.ClientResponse;
+
public class BindingToRestRpc implements InvocationHandler {
private final RestconfClientImpl client;
private final SchemaContext schcemaContext;
private final Module module;
- public BindingToRestRpc(Class proxiedInterface,BindingIndependentMappingService mappingService,RestconfClientImpl client,SchemaContext schemaContext) throws Exception {
+ public BindingToRestRpc(Class<?> proxiedInterface,BindingIndependentMappingService mappingService,RestconfClientImpl client,SchemaContext schemaContext) throws Exception {
this.mappingService = mappingService;
this.client = client;
this.schcemaContext = schemaContext;
*/
package org.opendaylight.yangtools.restconf.client;
-import com.google.common.base.Charsets;
-import com.google.common.base.Function;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.ListeningExecutorService;
-import com.google.common.util.concurrent.MoreExecutors;
-import com.sun.jersey.api.client.ClientResponse;
import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
+
import java.io.UnsupportedEncodingException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
+
import javax.ws.rs.core.MediaType;
+
import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.restconf.client.api.event.EventStreamInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import com.google.common.base.Charsets;
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.sun.jersey.api.client.ClientResponse;
+
*/
package org.opendaylight.yangtools.yang.binding.test;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import org.junit.Test;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Test
public void constructWithPredicates() {
-
+
InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).toInstance();
-
+
assertNotNull(nodes);
assertEquals(Nodes.class, nodes.getTargetType());
-
-
- InstanceIdentifier<Node> node = InstanceIdentifier.builder(nodes).node(Node.class).toInstance();
-
+
+
+ InstanceIdentifier<Node> node = InstanceIdentifier.builder(nodes).child(Node.class).toInstance();
+
assertNotNull(node);
assertEquals(Node.class, node.getTargetType());
-
+
assertTrue(nodes.contains(node));
}
assertTrue(nodes.contains(node));
}
-
-
+
+
@Test
public void negativeContains() {
InstanceIdentifier<FooChild> fooChild = InstanceIdentifier.builder(Nodes.class).child(InstantiatedFoo.class).child(FooChild.class).build();
-
+
InstanceIdentifier<Node> nodeTen = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class,new NodeKey(10)).toInstance();
InstanceIdentifier<Node> nodeOne = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class,new NodeKey(1)).toInstance();
InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).toInstance();
-
+
assertFalse(fooChild.contains(nodeTen));
assertFalse(nodeTen.contains(nodes));
-
+
assertFalse(nodeOne.contains(nodes));
assertTrue(nodes.contains(nodeOne));
}
-
+
@Test
public void containsWildcarded() {
InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).toInstance();
InstanceIdentifier<NodeChild> wildcardedChildren = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class) //
.child(NodeChild.class).build();
-
+
assertTrue(wildcarded.isWildcarded());
assertTrue(wildcardedChildren.isWildcarded());
-
-
+
+
InstanceIdentifier<Node> nodeTen = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class,new NodeKey(10)).toInstance();
InstanceIdentifier<Node> nodeOne = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class,new NodeKey(1)).toInstance();
-
+
assertFalse(nodeTen.isWildcarded());
assertFalse(nodeOne.isWildcarded());
assertTrue(nodes.containsWildcarded(nodeOne));
assertTrue(wildcarded.containsWildcarded(nodeOne));
assertTrue(wildcarded.containsWildcarded(nodeTen));
-
-
+
+
InstanceIdentifier<NodeChild> nodeTenChildWildcarded = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class,new NodeKey(10)).child(NodeChild.class).toInstance();
-
+
assertTrue(nodeTenChildWildcarded.isWildcarded());
-
+
InstanceIdentifier<NodeChild> nodeTenChild = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class,new NodeKey(10)).child(NodeChild.class, new NodeChildKey(10)).toInstance();
InstanceIdentifier<NodeChild> nodeOneChild = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class,new NodeKey(1)).child(NodeChild.class, new NodeChildKey(1)).toInstance();
-
+
assertFalse(nodeTenChildWildcarded.containsWildcarded(nodeOneChild));
assertTrue(nodeTenChildWildcarded.containsWildcarded(nodeTenChild));
-
+
}
-
-
+
+
void childOfTest() {
InstanceIdentifier.builder(Nodes.class).child(InstantiatedFoo.class).child(FooChild.class);
}
public class NodeChildKey implements //
Identifier<NodeChild> {
-
- private final int id;
+ private static final long serialVersionUID = 1L;
+ private final int id;
public NodeChildKey(int id) {
super();
public class NodeKey implements //
Identifier<Node> {
-
- private final int id;
+ private static final long serialVersionUID = 1L;
+ private final int id;
public NodeKey(int id) {
super();