<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>features-test</artifactId>
- <version>0.7.0-SNAPSHOT</version>
</dependency>
<!-- dependency for opendaylight-karaf-empty for use by testing -->
<dependency>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-checkstyle-plugin</artifactId>
- <version>${checkstyle.version}</version>
<configuration>
<failsOnError>true</failsOnError>
<configLocation>controller/checkstyle.xml</configLocation>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-checkstyle-plugin</artifactId>
- <version>${checkstyle.version}</version>
<configuration>
<failsOnError>true</failsOnError>
<configLocation>controller/checkstyle.xml</configLocation>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
- <version>${surefire.version}</version>
<configuration>
<skipTests>true</skipTests>
</configuration>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-checkstyle-plugin</artifactId>
- <version>${checkstyle.version}</version>
<configuration>
<failsOnError>true</failsOnError>
<configLocation>controller/checkstyle.xml</configLocation>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
- <version>${surefire.version}</version>
<configuration>
<argLine>${testvm.argLine} ${jacoco.agent.ut.arg}</argLine>
<systemProperties>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-checkstyle-plugin</artifactId>
- <version>${checkstyle.version}</version>
<configuration>
<excludes>**\/target\/,**\/bin\/,**\/target-ide\/,**\/configuration\/initial\/</excludes>
</configuration>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-checkstyle-plugin</artifactId>
- <version>${checkstyle.version}</version>
<configuration>
<excludes>**\/target\/,**\/bin\/,**\/target-ide\/,**\/configuration\/initial\/</excludes>
</configuration>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-checkstyle-plugin</artifactId>
- <version>${checkstyle.version}</version>
<configuration>
<excludes>**\/target\/,**\/bin\/,**\/target-ide\/,**\/configuration\/initial\/</excludes>
</configuration>
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
- <version>2.4</version>
</dependency>
<dependency>
<groupId>org.apache.servicemix.bundles</groupId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-inmemory-datastore</artifactId>
- <version>1.2.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<dependency>
<groupId>org.opendaylight.controller.model</groupId>
<artifactId>model-topology</artifactId>
- <version>1.2.0-SNAPSHOT</version>
</dependency>
<!-- toaster example I'm pretty sure we should trim -->
<dependency>
<groupId>org.opendaylight.controller.samples</groupId>
<artifactId>sample-toaster</artifactId>
- <version>${mdsal.version}</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller.samples</groupId>
<artifactId>sample-toaster-consumer</artifactId>
- <version>${mdsal.version}</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller.samples</groupId>
<artifactId>sample-toaster-provider</artifactId>
- <version>${mdsal.version}</version>
</dependency>
<dependency>
<groupId>org.apache.sshd</groupId>
<dependency>
<groupId>org.opendaylight.yangtools.thirdparty</groupId>
<artifactId>antlr4-runtime-osgi-nohead</artifactId>
- <version>4.0</version>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools.thirdparty</groupId>
<artifactId>xtend-lib-osgi</artifactId>
- <version>2.4.3</version>
</dependency>
<dependency>
<groupId>org.openexi</groupId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-clustering-commons</artifactId>
- <version>1.2.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
- <version>${slf4j.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>binding-data-codec</artifactId>
- <version>0.7.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
*/
package org.opendaylight.controller.config.yang.md.sal.binding.impl;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Hashtable;
-import java.util.Map.Entry;
-import java.util.Set;
import javassist.ClassPool;
import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
import org.opendaylight.controller.sal.binding.codegen.impl.SingletonHolder;
import org.opendaylight.yangtools.binding.data.codec.gen.impl.StreamWriterGenerator;
import org.opendaylight.yangtools.binding.data.codec.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.yangtools.concepts.Delegator;
import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.yangtools.sal.binding.generator.impl.RuntimeGeneratedMappingServiceImpl;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.RpcService;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService;
-import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry;
-import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException;
import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
*
*/
public final class RuntimeMappingModule extends AbstractRuntimeMappingModule {
- private static final Logger LOG = LoggerFactory.getLogger(RuntimeMappingModule.class);
-
private BundleContext bundleContext;
public RuntimeMappingModule(final org.opendaylight.controller.config.api.ModuleIdentifier identifier,
public java.lang.AutoCloseable createInstance() {
final GeneratedClassLoadingStrategy classLoading = getGlobalClassLoadingStrategy();
final BindingIndependentMappingService legacyMapping = getGlobalLegacyMappingService(classLoading);
- BindingNormalizedNodeCodecRegistry codecRegistry = new BindingNormalizedNodeCodecRegistry(new StreamWriterGenerator(SingletonHolder.JAVASSIST));
+ BindingNormalizedNodeCodecRegistry codecRegistry = new BindingNormalizedNodeCodecRegistry(StreamWriterGenerator.create(SingletonHolder.JAVASSIST));
BindingToNormalizedNodeCodec instance = new BindingToNormalizedNodeCodec(classLoading, legacyMapping, codecRegistry);
bundleContext.registerService(SchemaContextListener.class, instance, new Hashtable<String,String>());
return instance;
public void setBundleContext(final BundleContext bundleContext) {
this.bundleContext = bundleContext;
}
-
- private static final class RuntimeGeneratedMappingServiceProxy implements //
- BindingIndependentMappingService, //
- Delegator<BindingIndependentMappingService>, //
- AutoCloseable {
-
- private BindingIndependentMappingService delegate;
- private ServiceReference<BindingIndependentMappingService> reference;
- private BundleContext bundleContext;
-
- public RuntimeGeneratedMappingServiceProxy(final BundleContext bundleContext,
- final ServiceReference<BindingIndependentMappingService> serviceRef,
- final BindingIndependentMappingService delegate) {
- this.bundleContext = Preconditions.checkNotNull(bundleContext);
- this.reference = Preconditions.checkNotNull(serviceRef);
- this.delegate = Preconditions.checkNotNull(delegate);
- }
-
- @Override
- public CodecRegistry getCodecRegistry() {
- return delegate.getCodecRegistry();
- }
-
- @Override
- public CompositeNode toDataDom(final DataObject data) {
- return delegate.toDataDom(data);
- }
-
- @Override
- public Entry<YangInstanceIdentifier, CompositeNode> toDataDom(
- final Entry<InstanceIdentifier<? extends DataObject>, DataObject> entry) {
- return delegate.toDataDom(entry);
- }
-
- @Override
- public YangInstanceIdentifier toDataDom(final InstanceIdentifier<? extends DataObject> path) {
- return delegate.toDataDom(path);
- }
-
- @Override
- public DataObject dataObjectFromDataDom(
- final InstanceIdentifier<? extends DataObject> path,
- final CompositeNode result) throws DeserializationException {
- return delegate.dataObjectFromDataDom(path, result);
- }
-
- @Override
- public InstanceIdentifier<?> fromDataDom(final YangInstanceIdentifier entry)
- throws DeserializationException {
- return delegate.fromDataDom(entry);
- }
-
- @Override
- public Set<QName> getRpcQNamesFor(final Class<? extends RpcService> service) {
- return delegate.getRpcQNamesFor(service);
- }
-
- @Override
- public Optional<Class<? extends RpcService>> getRpcServiceClassFor(final String namespace, final String revision) {
- return delegate.getRpcServiceClassFor(namespace,revision);
- }
-
- @Override
- public DataContainer dataObjectFromDataDom(final Class<? extends DataContainer> inputClass, final CompositeNode domInput) {
- return delegate.dataObjectFromDataDom(inputClass, domInput);
- }
-
- @Override
- public void close() {
- if(delegate != null) {
- delegate = null;
-
- try {
- bundleContext.ungetService(reference);
- } catch (IllegalStateException e) {
- // Indicates the BundleContext is no longer valid which can happen normally on shutdown.
- LOG.debug( "Error unregistering service", e );
- }
-
- bundleContext= null;
- reference = null;
- }
- }
-
- @Override
- public BindingIndependentMappingService getDelegate() {
- return delegate;
- }
- }
}
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-test-model</artifactId>
- <version>1.2.0-SNAPSHOT</version>
</dependency>
</dependencies>
<build>
<dependency>
<groupId>com.google.code.findbugs</groupId>
<artifactId>jsr305</artifactId>
- <version>2.0.1</version>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
<dependency>
<groupId>xmlunit</groupId>
<artifactId>xmlunit</artifactId>
- <version>1.5</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
- <version>${slf4j.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<dependency>
<groupId>xmlunit</groupId>
<artifactId>xmlunit</artifactId>
- <version>1.5</version>
</dependency>
<dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
- <version>${slf4j.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.google.code.findbugs</groupId>
<artifactId>jsr305</artifactId>
- <version>2.0.1</version>
</dependency>
<dependency>
<groupId>com.codahale.metrics</groupId>
public T mailboxCapacity(int capacity) {
Preconditions.checkArgument(capacity > 0, "mailbox capacity must be >0");
- Map<String, Object> boundedMailbox = (Map) configHolder.get(TAG_MAILBOX);
+ Map<String, Object> boundedMailbox = (Map<String, Object>) configHolder.get(TAG_MAILBOX);
boundedMailbox.put(TAG_MAILBOX_CAPACITY, capacity);
return (T)this;
}
Duration pushTimeout = Duration.create(timeout);
Preconditions.checkArgument(pushTimeout.isFinite(), "invalid value for mailbox push timeout");
- Map<String, Object> boundedMailbox = (Map) configHolder.get(TAG_MAILBOX);
+ Map<String, Object> boundedMailbox = (Map<String, Object>) configHolder.get(TAG_MAILBOX);
boundedMailbox.put(TAG_MAILBOX_PUSH_TIMEOUT, timeout);
return (T)this;
}
public class NormalizedNodeGetter implements
NormalizedNodeVisitor {
private final String path;
- NormalizedNode output;
+ NormalizedNode<?, ?> output;
public NormalizedNodeGetter(String path){
Preconditions.checkNotNull(path);
}
@Override
- public void visitNode(int level, String parentPath, NormalizedNode normalizedNode) {
+ public void visitNode(int level, String parentPath, NormalizedNode<?, ?> normalizedNode) {
String nodePath = parentPath + "/"+ PathUtils.toString(normalizedNode.getIdentifier());
if(nodePath.toString().equals(path)){
}
}
- public NormalizedNode getOutput(){
+ public NormalizedNode<?, ?> getOutput(){
return output;
}
}
String newParentPath = parentPath + "/" + node.getIdentifier().toString();
final Iterable<? extends NormalizedNode<?, ?>> value = node.getValue();
- for(NormalizedNode normalizedNode : value){
+ for(NormalizedNode<?, ?> normalizedNode : value){
if(normalizedNode instanceof MixinNode && normalizedNode instanceof NormalizedNodeContainer){
navigateNormalizedNodeContainerMixin(level + 1, newParentPath, (NormalizedNodeContainer) normalizedNode);
} else {
private void navigateNormalizedNode(int level, String parentPath, NormalizedNode<?,?> normalizedNode){
if(normalizedNode instanceof DataContainerNode){
- final DataContainerNode<?> dataContainerNode = (DataContainerNode) normalizedNode;
+ final DataContainerNode<?> dataContainerNode = (DataContainerNode<?>) normalizedNode;
navigateDataContainerNode(level + 1, parentPath, dataContainerNode);
} else {
}
@Override
- public void visitNode(int level, String parentPath, NormalizedNode normalizedNode) {
+ public void visitNode(int level, String parentPath, NormalizedNode<?, ?> normalizedNode) {
System.out.println(spaces((level) * 4) + normalizedNode.getClass().toString() + ":" + normalizedNode.getIdentifier());
if(normalizedNode instanceof LeafNode || normalizedNode instanceof LeafSetEntryNode){
System.out.println(spaces((level) * 4) + " parentPath = " + parentPath);
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
public interface NormalizedNodeVisitor {
- public void visitNode(int level, String parentPath, NormalizedNode normalizedNode);
+ public void visitNode(int level, String parentPath, NormalizedNode<?, ?> normalizedNode);
}
* @param node
* @return
*/
- public static NormalizedNodeMessages.Node serialize(NormalizedNode node){
+ public static NormalizedNodeMessages.Node serialize(NormalizedNode<?, ?> node){
Preconditions.checkNotNull(node, "node should not be null");
return new Serializer(node).serialize();
}
- public static Serializer newSerializer(NormalizedNode node) {
+ public static Serializer newSerializer(NormalizedNode<?, ?> node) {
Preconditions.checkNotNull(node, "node should not be null");
return new Serializer(node);
}
* @param node
* @return
*/
- public static NormalizedNode deSerialize(NormalizedNodeMessages.Node node) {
+ public static NormalizedNode<?, ?> deSerialize(NormalizedNodeMessages.Node node) {
Preconditions.checkNotNull(node, "node should not be null");
return new DeSerializer(null, node).deSerialize();
}
public static class Serializer extends QNameSerializationContextImpl
implements NormalizedNodeSerializationContext {
- private final NormalizedNode node;
+ private final NormalizedNode<?, ?> node;
private NormalizedNodeMessages.InstanceIdentifier serializedPath;
- private Serializer(NormalizedNode node) {
+ private Serializer(NormalizedNode<?, ?> node) {
this.node = node;
}
}
private NormalizedNodeMessages.Node.Builder serialize(
- NormalizedNode node) {
+ NormalizedNode<?, ?> node) {
NormalizedNodeMessages.Node.Builder builder =
NormalizedNodeMessages.Node.newBuilder();
for (Object o : iterable) {
if (o instanceof NormalizedNode) {
- builder.addChild(serialize((NormalizedNode) o));
+ builder.addChild(serialize((NormalizedNode<?, ?>) o));
}
}
} else if (value instanceof NormalizedNode) {
- builder.addChild(serialize((NormalizedNode) value));
+ builder.addChild(serialize((NormalizedNode<?, ?>) value));
} else {
static {
deSerializationFunctions.put(CONTAINER_NODE_TYPE,
new DeSerializationFunction() {
- @Override public NormalizedNode apply(
+ @Override public NormalizedNode<?, ?> apply(
DeSerializer deSerializer,
NormalizedNodeMessages.Node node) {
DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode>
deSerializationFunctions.put(LEAF_NODE_TYPE,
new DeSerializationFunction() {
- @Override public NormalizedNode apply(
+ @Override public NormalizedNode<?, ?> apply(
DeSerializer deSerializer,
NormalizedNodeMessages.Node node) {
NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, Object, LeafNode<Object>>
deSerializationFunctions.put(MAP_NODE_TYPE,
new DeSerializationFunction() {
- @Override public NormalizedNode apply(
+ @Override public NormalizedNode<?, ?> apply(
DeSerializer deSerializer,
NormalizedNodeMessages.Node node) {
CollectionNodeBuilder<MapEntryNode, MapNode>
deSerializationFunctions.put(MAP_ENTRY_NODE_TYPE,
new DeSerializationFunction() {
- @Override public NormalizedNode apply(
+ @Override public NormalizedNode<?, ?> apply(
DeSerializer deSerializer,
NormalizedNodeMessages.Node node) {
DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode>
deSerializationFunctions.put(AUGMENTATION_NODE_TYPE,
new DeSerializationFunction() {
- @Override public NormalizedNode apply(
+ @Override public NormalizedNode<?, ?> apply(
DeSerializer deSerializer,
NormalizedNodeMessages.Node node) {
DataContainerNodeBuilder<YangInstanceIdentifier.AugmentationIdentifier, AugmentationNode>
deSerializationFunctions.put(LEAF_SET_NODE_TYPE,
new DeSerializationFunction() {
- @Override public NormalizedNode apply(
+ @Override public NormalizedNode<?, ?> apply(
DeSerializer deSerializer,
NormalizedNodeMessages.Node node) {
ListNodeBuilder<Object, LeafSetEntryNode<Object>>
deSerializationFunctions.put(LEAF_SET_ENTRY_NODE_TYPE,
new DeSerializationFunction() {
- @Override public NormalizedNode apply(
+ @Override public NormalizedNode<?, ?> apply(
DeSerializer deSerializer,
NormalizedNodeMessages.Node node) {
NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeWithValue, Object, LeafSetEntryNode<Object>>
deSerializationFunctions.put(CHOICE_NODE_TYPE,
new DeSerializationFunction() {
- @Override public NormalizedNode apply(
+ @Override public NormalizedNode<?, ?> apply(
DeSerializer deSerializer,
NormalizedNodeMessages.Node node) {
DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ChoiceNode>
deSerializationFunctions.put(ORDERED_LEAF_SET_NODE_TYPE,
new DeSerializationFunction() {
- @Override public NormalizedNode apply(
+ @Override public NormalizedNode<?, ?> apply(
DeSerializer deSerializer,
NormalizedNodeMessages.Node node) {
ListNodeBuilder<Object, LeafSetEntryNode<Object>>
deSerializationFunctions.put(ORDERED_MAP_NODE_TYPE,
new DeSerializationFunction() {
- @Override public NormalizedNode apply(
+ @Override public NormalizedNode<?, ?> apply(
DeSerializer deSerializer,
NormalizedNodeMessages.Node node) {
CollectionNodeBuilder<MapEntryNode, OrderedMapNode>
deSerializationFunctions.put(UNKEYED_LIST_NODE_TYPE,
new DeSerializationFunction() {
- @Override public NormalizedNode apply(
+ @Override public NormalizedNode<?, ?> apply(
DeSerializer deSerializer,
NormalizedNodeMessages.Node node) {
CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode>
deSerializationFunctions.put(UNKEYED_LIST_ENTRY_NODE_TYPE,
new DeSerializationFunction() {
- @Override public NormalizedNode apply(
+ @Override public NormalizedNode<?, ?> apply(
DeSerializer deSerializer,
NormalizedNodeMessages.Node node) {
DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, UnkeyedListEntryNode>
deSerializationFunctions.put(ANY_XML_NODE_TYPE,
new DeSerializationFunction() {
- @Override public NormalizedNode apply(
+ @Override public NormalizedNode<?, ?> apply(
DeSerializer deSerializer,
NormalizedNodeMessages.Node node) {
NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode>
return deserializedPath;
}
- public NormalizedNode deSerialize() {
- NormalizedNode deserializedNode = deSerialize(node);
+ public NormalizedNode<?, ?> deSerialize() {
+ NormalizedNode<?, ?> deserializedNode = deSerialize(node);
if(path != null) {
deserializedPath = InstanceIdentifierUtils.fromSerializable(path, this);
}
return deserializedNode;
}
- private NormalizedNode deSerialize(NormalizedNodeMessages.Node node){
+ private NormalizedNode<?, ?> deSerialize(NormalizedNodeMessages.Node node){
Preconditions.checkNotNull(node, "node should not be null");
DeSerializationFunction deSerializationFunction = deSerializationFunctions.get(
}
- private NormalizedNode buildCollectionNode(
+ private NormalizedNode<?, ?> buildCollectionNode(
CollectionNodeBuilder builder,
NormalizedNodeMessages.Node node) {
}
- private NormalizedNode buildListNode(
+ private NormalizedNode<?, ?> buildListNode(
ListNodeBuilder<Object, LeafSetEntryNode<Object>> builder,
NormalizedNodeMessages.Node node) {
builder.withNodeIdentifier(toNodeIdentifier(node.getPathArgument()));
return builder.build();
}
- private NormalizedNode buildDataContainer(DataContainerNodeBuilder builder, NormalizedNodeMessages.Node node){
+ private NormalizedNode<?, ?> buildDataContainer(DataContainerNodeBuilder builder, NormalizedNodeMessages.Node node){
for(NormalizedNodeMessages.Node child : node.getChildList()){
builder.withChild((DataContainerChild<?, ?>) deSerialize(child));
return builder.build();
}
- private NormalizedNode buildNormalizedNode(NormalizedNodeAttrBuilder builder, NormalizedNodeMessages.Node node){
+ private NormalizedNode<?, ?> buildNormalizedNode(NormalizedNodeAttrBuilder builder, NormalizedNodeMessages.Node node){
builder.withValue(ValueSerializer.deSerialize(this, node));
}
private static interface DeSerializationFunction {
- NormalizedNode apply(DeSerializer deserializer, NormalizedNodeMessages.Node node);
+ NormalizedNode<?, ?> apply(DeSerializer deserializer, NormalizedNodeMessages.Node node);
}
}
}
UNKEYED_LIST_ENTRY_NODE_TYPE,
ANY_XML_NODE_TYPE;
- public static NormalizedNodeType getSerializableNodeType(NormalizedNode node){
+ public static NormalizedNodeType getSerializableNodeType(NormalizedNode<?, ?> node){
Preconditions.checkNotNull(node, "node should not be null");
if(node instanceof LeafNode){
case NodeTypes.ANY_XML_NODE :
LOG.debug("Read xml node");
- Node value = (Node) readObject();
+ Node<?> value = (Node<?>) readObject();
return Builders.anyXmlBuilder().withValue(value).build();
case NodeTypes.MAP_NODE :
PathUtils.toString(YangInstanceIdentifier.builder().build()), documentOne);
// Validate the value of id can be retrieved from the normalized node
- NormalizedNode output = normalizedNodeGetter.getOutput();
+ NormalizedNode<?, ?> output = normalizedNodeGetter.getOutput();
assertNotNull(output);
start = System.nanoTime();
- NormalizedNode actualNode =
+ NormalizedNode<?, ?> actualNode =
NormalizedNodeSerializer.deSerialize(expected);
System.out.println("DeSerialize Time = " + (System.nanoTime() - start)/1000000);
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-inmemory-datastore</artifactId>
- <version>1.2.0-SNAPSHOT</version>
-
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
- <version>${slf4j.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
- <version>${slf4j.version}</version>
<scope>test</scope>
</dependency>
<dependency>
public class ConditionalProbe {
private final ActorRef actorRef;
- private final Predicate predicate;
+ private final Predicate<Object> predicate;
Logger log = LoggerFactory.getLogger(ConditionalProbe.class);
- public ConditionalProbe(ActorRef actorRef, Predicate predicate) {
+ public ConditionalProbe(ActorRef actorRef, Predicate<Object> predicate) {
this.actorRef = actorRef;
this.predicate = predicate;
}
final JavaTestKit probe = new JavaTestKit(node);
ConditionalProbe conditionalProbe =
- new ConditionalProbe(probe.getRef(), new Predicate() {
+ new ConditionalProbe(probe.getRef(), new Predicate<Object>() {
@Override
public boolean apply(@Nullable Object input) {
if (input != null)
<artifactId>sal-rest-docgen</artifactId>
<packaging>bundle</packaging>
- <properties>
- <jaxrs-api.version>3.0.4.Final</jaxrs-api.version>
- </properties>
-
<dependencies>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<dependency>
<groupId>org.jboss.resteasy</groupId>
<artifactId>jaxrs-api</artifactId>
- <version>${jaxrs-api.version}</version>
</dependency>
<dependency>
@Override
public void start(BundleContext context) throws Exception {
bundleContext = context;
- brokerServiceTracker = new ServiceTracker(context, Broker.class, this);
+ brokerServiceTracker = new ServiceTracker<>(context, Broker.class, this);
brokerServiceTracker.open();
}
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
- <version>${slf4j.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
protected Object preprocess(Object value) {
Util.checkType(value, Map.class);
- Preconditions.checkArgument(((Map)value).size() == 1, "Unexpected number of values in %s, expected 1", value);
- return ((Map)value).values().iterator().next();
+ Preconditions.checkArgument(((Map<?, ?>)value).size() == 1, "Unexpected number of values in %s, expected 1", value);
+ return ((Map<?, ?>)value).values().iterator().next();
}
}
protected Object preprocess(Object value) {
Util.checkType(value, Map.class);
- Preconditions.checkArgument(((Map)value).size() == 1, "Unexpected number of values in %s, expected 1", value);
- Object stringValue = ((Map) value).values().iterator().next();
+ Preconditions.checkArgument(((Map<?, ?>)value).size() == 1, "Unexpected number of values in %s, expected 1", value);
+ Object stringValue = ((Map<?, ?>) value).values().iterator().next();
Util.checkType(stringValue, String.class);
return stringValue;
protected Object preprocess(Object value) {
Util.checkType(value, Map.class);
- Preconditions.checkArgument(((Map)value).size() == 1, "Unexpected number of values in %s, expected 1", value);
- Object listOfStrings = ((Map) value).values().iterator().next();
+ Preconditions.checkArgument(((Map<?, ?>)value).size() == 1, "Unexpected number of values in %s, expected 1", value);
+ Object listOfStrings = ((Map<?, ?>) value).values().iterator().next();
Util.checkType(listOfStrings, List.class);
StringBuilder b = new StringBuilder();
import org.opendaylight.controller.netconf.util.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.protocol.framework.SessionListenerFactory;
import org.opendaylight.protocol.framework.SessionNegotiator;
-
import static org.junit.Assert.assertNotNull;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
public void testGetSessionNegotiator() throws Exception {
NetconfClientSessionListener sessionListener = mock(NetconfClientSessionListener.class);
Timer timer = new HashedWheelTimer();
- SessionListenerFactory listenerFactory = mock(SessionListenerFactory.class);
+ SessionListenerFactory<NetconfClientSessionListener> listenerFactory = mock(SessionListenerFactory.class);
doReturn(sessionListener).when(listenerFactory).getSessionListener();
Channel channel = mock(Channel.class);
- Promise promise = mock(Promise.class);
+ Promise<NetconfClientSession> promise = mock(Promise.class);
NetconfClientSessionNegotiatorFactory negotiatorFactory = new NetconfClientSessionNegotiatorFactory(timer,
Optional.<NetconfHelloMessageAdditionalHeader>absent(), 200L);
- SessionNegotiator sessionNegotiator = negotiatorFactory.getSessionNegotiator(listenerFactory, channel, promise);
+ SessionNegotiator<?> sessionNegotiator = negotiatorFactory.getSessionNegotiator(listenerFactory, channel, promise);
assertNotNull(sessionNegotiator);
}
}
return pipeline;
}
- private NetconfClientSessionNegotiator createNetconfClientSessionNegotiator(final Promise promise,
+ private NetconfClientSessionNegotiator createNetconfClientSessionNegotiator(final Promise<NetconfClientSession> promise,
final NetconfMessage startExi) {
ChannelProgressivePromise progressivePromise = mock(ChannelProgressivePromise.class);
NetconfClientSessionPreferences preferences = new NetconfClientSessionPreferences(helloMessage, startExi);
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
- <version>2.4</version>
<executions>
<execution>
<goals>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-checkstyle-plugin</artifactId>
- <version>2.12</version>
<configuration>
<failsOnError>false</failsOnError>
<failOnViolation>false</failOnViolation>
package org.opendaylight.controller.networkconfig.neutron.northbound;
import java.util.List;
-
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
-
import org.opendaylight.controller.networkconfig.neutron.NeutronNetwork;
@XmlRootElement
@XmlAccessorType(XmlAccessType.NONE)
-public class NeutronNetworkRequest implements INeutronRequest {
+public class NeutronNetworkRequest implements INeutronRequest<NeutronNetwork> {
// See OpenStack Network API v2.0 Reference for description of
// annotated attributes
singletonNetwork = net;
}
+ @Override
public NeutronNetwork getSingleton() {
return singletonNetwork;
}
+ @Override
public boolean isSingleton() {
return (singletonNetwork != null);
}
+ @Override
public List<NeutronNetwork> getBulk() {
return bulkRequest;
}
package org.opendaylight.controller.networkconfig.neutron.northbound;
import java.util.List;
-
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
-
import org.opendaylight.controller.networkconfig.neutron.NeutronPort;
@XmlRootElement
@XmlAccessorType(XmlAccessType.NONE)
-public class NeutronPortRequest implements INeutronRequest {
+public class NeutronPortRequest implements INeutronRequest<NeutronPort> {
// See OpenStack Network API v2.0 Reference for description of
// annotated attributes
singletonPort = port;
}
+ @Override
public NeutronPort getSingleton() {
return singletonPort;
}
+ @Override
public boolean isSingleton() {
return (singletonPort != null);
}
+ @Override
public List<NeutronPort> getBulk() {
return bulkRequest;
}
package org.opendaylight.controller.networkconfig.neutron.northbound;
import java.util.List;
-
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
-
import org.opendaylight.controller.networkconfig.neutron.NeutronSubnet;
@XmlRootElement
@XmlAccessorType(XmlAccessType.NONE)
-
-public class NeutronSubnetRequest implements INeutronRequest {
+public class NeutronSubnetRequest implements INeutronRequest<NeutronSubnet> {
// See OpenStack Network API v2.0 Reference for description of
// annotated attributes
links = null;
}
+ @Override
public NeutronSubnet getSingleton() {
return singletonSubnet;
}
+ @Override
public List<NeutronSubnet> getBulk() {
return bulkRequest;
}
+ @Override
public boolean isSingleton() {
return (singletonSubnet != null);
}
package org.opendaylight.controller.networkconfig.neutron.northbound;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import javax.ws.rs.core.UriInfo;
import org.opendaylight.controller.networkconfig.neutron.INeutronObject;
import org.opendaylight.controller.networkconfig.neutron.NeutronNetwork;
import org.opendaylight.controller.networkconfig.neutron.NeutronPort;
import org.opendaylight.controller.northbound.commons.exception.BadRequestException;
import org.opendaylight.controller.northbound.commons.exception.ResourceNotFoundException;
-import javax.ws.rs.core.UriInfo;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-
public class PaginatedRequestFactory {
public static class PaginationResults<T extends INeutronObject> {
}
}
- public static <T extends INeutronObject> INeutronRequest createRequest(Integer limit, String marker,
+ /*
+ * SuppressWarnings is needed because the compiler does not understand that we
+ * are actually safe here.
+ *
+ * FIXME: the only caller performs a cast back, so this is not actually necessary.
+ */
+ @SuppressWarnings("unchecked")
+ public static <T extends INeutronObject> INeutronRequest<T> createRequest(Integer limit, String marker,
Boolean pageReverse,
UriInfo uriInfo,
List<T> collection,
Class<T> clazz) {
- PaginationResults results = _paginate(limit, marker, pageReverse, uriInfo, collection);
+ PaginationResults<T> results = _paginate(limit, marker, pageReverse, uriInfo, collection);
if (clazz.equals(NeutronNetwork.class)){
- return new NeutronNetworkRequest(results.collection, results.links);
+ return (INeutronRequest<T>) new NeutronNetworkRequest((List<NeutronNetwork>) results.collection, results.links);
}
if (clazz.equals(NeutronSubnet.class)){
- return new NeutronSubnetRequest(results.collection, results.links);
+ return (INeutronRequest<T>) new NeutronSubnetRequest((List<NeutronSubnet>) results.collection, results.links);
}
if (clazz.equals(NeutronPort.class)){
- return new NeutronPortRequest(results.collection, results.links);
+ return (INeutronRequest<T>) new NeutronPortRequest((List<NeutronPort>) results.collection, results.links);
}
return null;
}
- private static <T extends INeutronObject> PaginationResults _paginate(Integer limit, String marker, Boolean pageReverse, UriInfo uriInfo, List<T> collection) {
+ private static <T extends INeutronObject> PaginationResults<T> _paginate(Integer limit, String marker, Boolean pageReverse, UriInfo uriInfo, List<T> collection) {
List<NeutronPageLink> links = new ArrayList<>();
Integer startPos = null;
String startMarker;
class MarkerObject implements INeutronObject {
private String id;
+ @Override
public String getID() {
return id;
}
+ @Override
public void setID(String id) {
this.id = id;
}
links.add(previous);
}
- return new PaginationResults(collection, links);
+ return new PaginationResults<T>(collection, links);
}
}
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-
import org.opendaylight.controller.sal.connection.ConnectionConstants;
import org.opendaylight.controller.sal.connection.ConnectionLocality;
import org.opendaylight.controller.sal.connection.IConnectionListener;
private ConcurrentMap<String, IPluginInConnectionService> pluginService =
new ConcurrentHashMap<String, IPluginInConnectionService>();
- void setPluginService (Map props, IPluginInConnectionService s) {
+ void setPluginService (Map<?, ?> props, IPluginInConnectionService s) {
String type = null;
Object value = props.get(GlobalConstants.PROTOCOLPLUGINTYPE.toString());
if (value instanceof String) {
}
}
- void unsetPluginService(Map props, IPluginInConnectionService s) {
+ void unsetPluginService(Map<?, ?> props, IPluginInConnectionService s) {
String type = null;
Object value = props.get(GlobalConstants.PROTOCOLPLUGINTYPE.toString());
}
}
- void setPluginInDataService(Map props, IPluginInDataPacketService s) {
+ void setPluginInDataService(Map<?, ?> props, IPluginInDataPacketService s) {
ProtocolService.set(this.pluginInDataService, props, s, logger);
}
- void unsetPluginInDataService(Map props, IPluginInDataPacketService s) {
+ void unsetPluginInDataService(Map<?, ?> props, IPluginInDataPacketService s) {
ProtocolService.unset(this.pluginInDataService, props, s, logger);
}
- void setListenDataPacket(Map props, IListenDataPacket s) {
+ void setListenDataPacket(Map<?, ?> props, IListenDataPacket s) {
if (this.listenDataPacket == null || this.indexDataPacket == null) {
logger.error("data structure to store data is NULL");
return;
}
logger.trace("Received setListenDataPacket request");
- for (Object e : props.entrySet()) {
- Map.Entry entry = (Map.Entry) e;
- logger.trace("Prop key:({}) value:({})",entry.getKey(), entry.getValue());
+ for (Map.Entry<?, ?> e : props.entrySet()) {
+ logger.trace("Prop key:({}) value:({})",e.getKey(), e.getValue());
}
String listenerName = null;
}
}
- void unsetListenDataPacket(Map props, IListenDataPacket s) {
+ void unsetListenDataPacket(Map<?, ?> props, IListenDataPacket s) {
if (this.listenDataPacket == null || this.indexDataPacket == null) {
logger.error("data structure to store data is NULL");
return;
}
logger.trace("Received UNsetListenDataPacket request");
- for (Object e : props.entrySet()) {
- Map.Entry entry = (Map.Entry) e;
- logger.trace("Prop key:({}) value:({})",entry.getKey(), entry.getValue());
+ for (Map.Entry<?, ?> e : props.entrySet()) {
+ logger.trace("Prop key:({}) value:({})",e.getKey(), e.getValue());
}
String listenerName = null;
return false;
}
- ProtocolService plugin = (ProtocolService)o;
+ ProtocolService<?> plugin = (ProtocolService<?>)o;
return (service.equals(plugin.service) && priority == plugin.priority);
}
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>topologymanager</artifactId>
- <version>${topologymanager.version}</version>
</dependency>
</dependencies>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<configuration>
<instructions>
<Import-Package>org.apache.felix.service.command,
Code Review / controller.git / commitdiff