--- /dev/null
+/*
+ * Copyright (c) 2018 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.openflowplugin.extension.api;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.annotations.Beta;
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.concepts.Immutable;
+import org.opendaylight.yangtools.yang.binding.Augmentable;
+import org.opendaylight.yangtools.yang.binding.Augmentation;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+
+/**
+ * Resolver providing a bridge between a grouping and its various instantiations via augment. This is useful for
+ * extracting the grouping's content from a DataObject's augmentations without knowing from which instantiation it
+ * comes from.
+ *
+ * <p>
+ * Typical use case is, given a base grouping module:
+ * <pre>
+ * module foo;
+ *
+ * grouping foo {
+ * container augmentable {
+ *
+ * }
+ * }
+ * </pre>
+ * and a module independent of it:
+ * <pre>
+ * module bar;
+ *
+ * container bar {
+ * uses foo:foo;
+ * }
+ * </pre>
+ * and
+ * <pre>
+ * module baz;
+ *
+ * container baz {
+ * uses foo:foo;
+ * }
+ * </pre>
+ * an external module can perform:
+ * <pre>
+ * module xyzzy;
+ *
+ * import bar { prefix bar; }
+ * import baz { prefix baz; }
+ *
+ * grouping something {
+ * // ...
+ * }
+ *
+ * augment /bar:bar/bar:augmentable {
+ * uses something;
+ * }
+ *
+ * augment /baz:baz/baz:augmentable {
+ * uses something;
+ * }
+ * </pre>
+ * The augmentations of {@code bar} and {@code baz} instantiations of {@code grouping foo} have an equivalent
+ * augmentation introduced by {@code xyzzy}. This equivalence is not expressed is generated code, in that it is
+ * not apparent given {@code bar} or {@code baz} there is an augmentation which provides {@code something}.
+ *
+ * <p>
+ * This class provides the static knowledge to ask for the contents of {@code something} given an instance of
+ * {@code augmentable}, without knowing which augmentation introduces it.
+ *
+ * @param <G> Grouping type
+ * @param <T> Augmentable type
+ */
+@Beta
+public final class AugmentationGroupingResolver<G extends DataObject, T extends Augmentable<T>> implements Immutable {
+ private final Class<? extends Augmentation<T>>[] augmentations;
+ private final Class<G> grouping;
+
+ AugmentationGroupingResolver(final Class<G> grouping, final Class<? extends Augmentation<T>>[] augmentations) {
+ this.grouping = requireNonNull(grouping);
+ this.augmentations = requireNonNull(augmentations);
+ }
+
+ public @NonNull Optional<G> findExtension(final T data) {
+ requireNonNull(data);
+
+ for (Class<? extends Augmentation<T>> cls : augmentations) {
+ final Augmentation<T> potential = data.augmentation(cls);
+ if (potential != null) {
+ return Optional.of(grouping.cast(potential));
+ }
+ }
+ return Optional.empty();
+ }
+
+ public static <G extends DataObject, T extends Augmentable<T>> @NonNull Builder<G, T> builder(
+ final Class<G> groupingClass) {
+ return new Builder<>(groupingClass);
+ }
+
+ @SuppressWarnings("unchecked")
+ public static <T extends Augmentable<T>> @NonNull Factory<T> factory(final Class<T> augmentableClass,
+ final Set<Class<? extends Augmentation<T>>> augmentationClasses) {
+ // Defensive copy via .clone() to guard against evil Set implementations
+ final Class<?>[] array = augmentationClasses.toArray(new Class<?>[0]).clone();
+
+ // Defensive check of all array elements
+ for (Class<?> clazz : array) {
+ checkArgument(Augmentation.class.isAssignableFrom(clazz), "Class %s is not an Augmentation", clazz);
+ }
+
+ return new Factory<>((Class<? extends Augmentation<T>>[]) array);
+ }
+
+ public static final class Builder<G extends DataObject, T extends Augmentable<T>>
+ implements org.opendaylight.yangtools.concepts.Builder<AugmentationGroupingResolver<G, T>> {
+ private final Set<Class<? extends Augmentation<T>>> augmentations = new HashSet<>();
+ private final Class<G> grouping;
+
+ Builder(final Class<G> groupingClass) {
+ grouping = requireNonNull(groupingClass);
+ }
+
+ public <X extends Augmentation<T>> @NonNull Builder<G, T> addAugmentationClass(
+ final Class<X> augmentationClass) {
+ checkAssignable(grouping, augmentationClass);
+ augmentations.add(augmentationClass);
+ return this;
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public @NonNull AugmentationGroupingResolver<G, T> build() {
+ return new AugmentationGroupingResolver<>(grouping,
+ (Class<? extends Augmentation<T>>[]) augmentations.toArray(new Class<?>[0]));
+ }
+ }
+
+ public static final class Factory<T extends Augmentable<T>> implements Immutable {
+ private final Class<? extends Augmentation<T>>[] augmentations;
+
+ Factory(final Class<? extends Augmentation<T>>[] augmentations) {
+ this.augmentations = requireNonNull(augmentations);
+ }
+
+ public <G extends DataObject> @NonNull AugmentationGroupingResolver<G, T> createResolver(
+ final Class<G> groupingClass) {
+ for (Class<? extends Augmentation<T>> cls : augmentations) {
+ checkAssignable(groupingClass, cls);
+ }
+
+ return new AugmentationGroupingResolver<>(groupingClass, augmentations);
+ }
+ }
+
+ static void checkAssignable(final Class<?> groupingClass, final Class<?> augmentationClass) {
+ checkArgument(groupingClass.isAssignableFrom(augmentationClass), "%s is not compatible with grouping %s",
+ augmentationClass, groupingClass);
+ }
+}
*
* @param <G> grouping
* @param <T> Augmentable
+ * @deprecated Use {@link AugmentationGroupingResolver} instead.
*/
+@Deprecated
public class GroupingResolver<G, T extends Augmentable<T>> {
Class<G> commonInterface;
Set<Class<? extends Augmentation<T>>> classes;
- public GroupingResolver(Class<G> commonInterface) {
+ public GroupingResolver(final Class<G> commonInterface) {
this.commonInterface = commonInterface;
classes = new HashSet<>();
}
* @param cls equivalent augmentation class
* @return this for chaining
*/
- public <X extends Augmentation<T>> GroupingResolver<G, T> add(Class<X> cls) {
+ public <X extends Augmentation<T>> GroupingResolver<G, T> add(final Class<X> cls) {
Preconditions.checkArgument(commonInterface.isAssignableFrom(cls));
classes.add(cls);
return this;
*
* @param clses set of equivalent augmentation classes
*/
- public void setAugmentations(Set<Class<? extends Augmentation<T>>> clses) {
+ public void setAugmentations(final Set<Class<? extends Augmentation<T>>> clses) {
for (Class<? extends Augmentation<T>> cls : clses) {
Preconditions.checkArgument(commonInterface.isAssignableFrom(cls));
}
* @return shared grouping
*/
@SuppressWarnings("unchecked")
- public Optional<G> getExtension(T data) {
+ public Optional<G> getExtension(final T data) {
for (Class<? extends Augmentation<T>> cls : classes) {
Augmentation<T> potential = data.augmentation(cls);
if (potential != null) {
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfArpOpGrouping> matchGrouping = MatchUtil.ARP_OP_RESOLVER.getExtension(extension);
+ Optional<NxmOfArpOpGrouping> matchGrouping = MatchUtil.ARP_OP_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxArpShaGrouping> matchGrouping = MatchUtil.ARP_SHA_RESOLVER.getExtension(extension);
+ Optional<NxmNxArpShaGrouping> matchGrouping = MatchUtil.ARP_SHA_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfArpSpaGrouping> matchGrouping = MatchUtil.ARP_SPA_RESOLVER.getExtension(extension);
+ Optional<NxmOfArpSpaGrouping> matchGrouping = MatchUtil.ARP_SPA_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxArpThaGrouping> matchGrouping = MatchUtil.ARP_THA_RESOLVER.getExtension(extension);
+ Optional<NxmNxArpThaGrouping> matchGrouping = MatchUtil.ARP_THA_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfArpTpaGrouping> matchGrouping = MatchUtil.ARP_TPA_RESOLVER.getExtension(extension);
+ Optional<NxmOfArpTpaGrouping> matchGrouping = MatchUtil.ARP_TPA_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
*/
@Override
public ExtensionAugment<? extends Augmentation<Extension>> convert(MatchEntry input, MatchPath path) {
- CtMarkCaseValue ctMarkCaseValue = ((CtMarkCaseValue) input.getMatchEntryValue());
+ CtMarkCaseValue ctMarkCaseValue = (CtMarkCaseValue) input.getMatchEntryValue();
NxmNxCtMarkBuilder ctMarkBuilder = new NxmNxCtMarkBuilder();
ctMarkBuilder.setCtMark(ctMarkCaseValue.getCtMarkValues().getCtMark());
ctMarkBuilder.setMask(ctMarkCaseValue.getCtMarkValues().getMask());
*/
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxCtMarkGrouping> matchGrouping = MatchUtil.CT_MARK_RESOLVER.getExtension(extension);
+ Optional<NxmNxCtMarkGrouping> matchGrouping = MatchUtil.CT_MARK_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxCtStateGrouping> matchGrouping = MatchUtil.CT_STATE_RESOLVER.getExtension(extension);
+ Optional<NxmNxCtStateGrouping> matchGrouping = MatchUtil.CT_STATE_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxCtTpDstGrouping> matchGrouping = MatchUtil.CT_TP_DST_RESOLVER.getExtension(extension);
+ Optional<NxmNxCtTpDstGrouping> matchGrouping = MatchUtil.CT_TP_DST_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxCtTpSrcGrouping> matchGrouping = MatchUtil.CT_TP_SRC_RESOLVER.getExtension(extension);
+ Optional<NxmNxCtTpSrcGrouping> matchGrouping = MatchUtil.CT_TP_SRC_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxCtZoneGrouping> matchGrouping = MatchUtil.CT_ZONE_RESOLVER.getExtension(extension);
+ Optional<NxmNxCtZoneGrouping> matchGrouping = MatchUtil.CT_ZONE_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfEthDstGrouping> matchGrouping = MatchUtil.ETH_DST_RESOLVER.getExtension(extension);
+ Optional<NxmOfEthDstGrouping> matchGrouping = MatchUtil.ETH_DST_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfEthSrcGrouping> matchGrouping = MatchUtil.ETH_SRC_RESOLVER.getExtension(extension);
+ Optional<NxmOfEthSrcGrouping> matchGrouping = MatchUtil.ETH_SRC_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfEthTypeGrouping> matchGrouping = MatchUtil.ETH_TYPE_RESOLVER.getExtension(extension);
+ Optional<NxmOfEthTypeGrouping> matchGrouping = MatchUtil.ETH_TYPE_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014, 2017 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
import com.google.common.base.Joiner;
import com.google.common.base.Splitter;
+import com.google.common.collect.ImmutableSet;
import com.google.common.primitives.Longs;
import com.google.common.primitives.UnsignedBytes;
-import java.util.HashSet;
import java.util.Iterator;
-import java.util.Set;
-import org.opendaylight.openflowplugin.extension.api.GroupingResolver;
+import org.opendaylight.openflowplugin.extension.api.AugmentationGroupingResolver;
+import org.opendaylight.openflowplugin.extension.api.AugmentationGroupingResolver.Factory;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev150225.oxm.container.match.entry.value.ExperimenterIdCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev150225.oxm.container.match.entry.value.ExperimenterIdCaseBuilder;
private static final Splitter SPLITTER = Splitter.on('.');
private static final Joiner JOINER = Joiner.on('.');
- private static final Set<Class<? extends Augmentation<Extension>>> AUGMENTATIONS_OF_EXTENSION = new HashSet<>();
- public static final GroupingResolver<NxmNxRegGrouping, Extension> REG_RESOLVER = new GroupingResolver<>(
- NxmNxRegGrouping.class);
- public static final GroupingResolver<NxmNxTunIdGrouping, Extension> TUN_ID_RESOLVER = new GroupingResolver<>(
- NxmNxTunIdGrouping.class);
- public static final GroupingResolver<NxmNxArpShaGrouping, Extension> ARP_SHA_RESOLVER = new GroupingResolver<>(
- NxmNxArpShaGrouping.class);
- public static final GroupingResolver<NxmNxArpThaGrouping, Extension> ARP_THA_RESOLVER = new GroupingResolver<>(
- NxmNxArpThaGrouping.class);
- public static final GroupingResolver<NxmOfArpOpGrouping, Extension> ARP_OP_RESOLVER = new GroupingResolver<>(
- NxmOfArpOpGrouping.class);
- public static final GroupingResolver<NxmOfArpSpaGrouping, Extension> ARP_SPA_RESOLVER = new GroupingResolver<>(
- NxmOfArpSpaGrouping.class);
- public static final GroupingResolver<NxmOfArpTpaGrouping, Extension> ARP_TPA_RESOLVER = new GroupingResolver<>(
- NxmOfArpTpaGrouping.class);
- public static final GroupingResolver<NxmNxTunIpv4DstGrouping, Extension> TUN_IPV4_DST_RESOLVER =
- new GroupingResolver<>(NxmNxTunIpv4DstGrouping.class);
- public static final GroupingResolver<NxmNxTunIpv4SrcGrouping, Extension> TUN_IPV4_SRC_RESOLVER =
- new GroupingResolver<>(NxmNxTunIpv4SrcGrouping.class);
- public static final GroupingResolver<NxmOfEthDstGrouping, Extension> ETH_DST_RESOLVER = new GroupingResolver<>(
- NxmOfEthDstGrouping.class);
- public static final GroupingResolver<NxmOfEthSrcGrouping, Extension> ETH_SRC_RESOLVER = new GroupingResolver<>(
- NxmOfEthSrcGrouping.class);
- public static final GroupingResolver<NxmOfEthTypeGrouping, Extension> ETH_TYPE_RESOLVER = new GroupingResolver<>(
- NxmOfEthTypeGrouping.class);
- public static final GroupingResolver<NxmNxNsiGrouping, Extension> NSI_RESOLVER = new GroupingResolver<>(
- NxmNxNsiGrouping.class);
- public static final GroupingResolver<NxmNxNspGrouping, Extension> NSP_RESOLVER = new GroupingResolver<>(
- NxmNxNspGrouping.class);
- public static final GroupingResolver<NxmNxNshc1Grouping, Extension> NSC1_RESOLVER = new GroupingResolver<>(
- NxmNxNshc1Grouping.class);
- public static final GroupingResolver<NxmNxNshc2Grouping, Extension> NSC2_RESOLVER = new GroupingResolver<>(
- NxmNxNshc2Grouping.class);
- public static final GroupingResolver<NxmNxNshc3Grouping, Extension> NSC3_RESOLVER = new GroupingResolver<>(
- NxmNxNshc3Grouping.class);
- public static final GroupingResolver<NxmNxNshc4Grouping, Extension> NSC4_RESOLVER = new GroupingResolver<>(
- NxmNxNshc4Grouping.class);
- public static final GroupingResolver<NxmNxNshFlagsGrouping, Extension> NSH_FLAGS_RESOLVER =
- new GroupingResolver<>(NxmNxNshFlagsGrouping.class);
- public static final GroupingResolver<NxmNxNshMdtypeGrouping, Extension> NSH_MDTYPE_RESOLVER =
- new GroupingResolver<>(NxmNxNshMdtypeGrouping.class);
- public static final GroupingResolver<NxmNxNshNpGrouping, Extension> NSH_NP_RESOLVER = new GroupingResolver<>(
- NxmNxNshNpGrouping.class);
- public static final GroupingResolver<NxmNxNshTtlGrouping, Extension> NSH_TTL_RESOLVER =
- new GroupingResolver<>(NxmNxNshTtlGrouping.class);
- public static final GroupingResolver<NxmOfTcpSrcGrouping, Extension> TCP_SRC_RESOLVER = new GroupingResolver<>(
- NxmOfTcpSrcGrouping.class);
- public static final GroupingResolver<NxmOfTcpDstGrouping, Extension> TCP_DST_RESOLVER = new GroupingResolver<>(
- NxmOfTcpDstGrouping.class);
- public static final GroupingResolver<NxmOfUdpSrcGrouping, Extension> UDP_SRC_RESOLVER = new GroupingResolver<>(
- NxmOfUdpSrcGrouping.class);
- public static final GroupingResolver<NxmOfUdpDstGrouping, Extension> UDP_DST_RESOLVER = new GroupingResolver<>(
- NxmOfUdpDstGrouping.class);
- public static final GroupingResolver<NxmNxCtMarkGrouping, Extension> CT_MARK_RESOLVER = new GroupingResolver<>(
- NxmNxCtMarkGrouping.class);
- public static final GroupingResolver<NxmNxCtStateGrouping, Extension> CT_STATE_RESOLVER = new GroupingResolver<>(
- NxmNxCtStateGrouping.class);
- public static final GroupingResolver<NxmNxCtZoneGrouping, Extension> CT_ZONE_RESOLVER = new GroupingResolver<>(
- NxmNxCtZoneGrouping.class);
- public static final GroupingResolver<NxmNxCtTpSrcGrouping, Extension> CT_TP_SRC_RESOLVER = new GroupingResolver<>(
- NxmNxCtTpSrcGrouping.class);
- public static final GroupingResolver<NxmNxCtTpDstGrouping, Extension> CT_TP_DST_RESOLVER = new GroupingResolver<>(
- NxmNxCtTpDstGrouping.class);
- public static final GroupingResolver<NxmNxPktMarkGrouping, Extension> PKT_MARK_RESOLVER = new GroupingResolver<>(
- NxmNxPktMarkGrouping.class);
- public static final GroupingResolver<NxmOfInPortGrouping, Extension> NXM_OF_INPORT_RESOLVER =
- new GroupingResolver<>(NxmOfInPortGrouping.class);
+ public static final AugmentationGroupingResolver<NxmNxRegGrouping, Extension> REG_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxTunIdGrouping, Extension> TUN_ID_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxArpShaGrouping, Extension> ARP_SHA_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxArpThaGrouping, Extension> ARP_THA_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfArpOpGrouping, Extension> ARP_OP_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfArpSpaGrouping, Extension> ARP_SPA_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfArpTpaGrouping, Extension> ARP_TPA_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxTunIpv4DstGrouping, Extension> TUN_IPV4_DST_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxTunIpv4SrcGrouping, Extension> TUN_IPV4_SRC_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfEthDstGrouping, Extension> ETH_DST_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfEthSrcGrouping, Extension> ETH_SRC_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfEthTypeGrouping, Extension> ETH_TYPE_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNsiGrouping, Extension> NSI_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNspGrouping, Extension> NSP_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNshc1Grouping, Extension> NSC1_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNshc2Grouping, Extension> NSC2_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNshc3Grouping, Extension> NSC3_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNshc4Grouping, Extension> NSC4_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNshFlagsGrouping, Extension> NSH_FLAGS_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNshMdtypeGrouping, Extension> NSH_MDTYPE_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNshNpGrouping, Extension> NSH_NP_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxNshTtlGrouping, Extension> NSH_TTL_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfTcpSrcGrouping, Extension> TCP_SRC_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfTcpDstGrouping, Extension> TCP_DST_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfUdpSrcGrouping, Extension> UDP_SRC_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfUdpDstGrouping, Extension> UDP_DST_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxCtMarkGrouping, Extension> CT_MARK_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxCtStateGrouping, Extension> CT_STATE_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxCtZoneGrouping, Extension> CT_ZONE_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxCtTpSrcGrouping, Extension> CT_TP_SRC_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxCtTpDstGrouping, Extension> CT_TP_DST_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmNxPktMarkGrouping, Extension> PKT_MARK_RESOLVER;
+ public static final AugmentationGroupingResolver<NxmOfInPortGrouping, Extension> NXM_OF_INPORT_RESOLVER;
static {
- AUGMENTATIONS_OF_EXTENSION.add(NxAugMatchRpcAddFlow.class);
- AUGMENTATIONS_OF_EXTENSION.add(NxAugMatchRpcRemoveFlow.class);
- AUGMENTATIONS_OF_EXTENSION.add(NxAugMatchRpcUpdateFlowOriginal.class);
- AUGMENTATIONS_OF_EXTENSION.add(NxAugMatchRpcUpdateFlowUpdated.class);
- AUGMENTATIONS_OF_EXTENSION.add(NxAugMatchNodesNodeTableFlow.class);
- AUGMENTATIONS_OF_EXTENSION.add(NxAugMatchNotifSwitchFlowRemoved.class);
- AUGMENTATIONS_OF_EXTENSION.add(NxAugMatchNotifPacketIn.class);
- //augmentationsOfExtension.add(NxAugMatchNotifUpdateFlowStats.class);
- AUGMENTATIONS_OF_EXTENSION.add(NxAugMatchPacketInMessage.class);
- REG_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- TUN_ID_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- ARP_SHA_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- ARP_THA_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- ARP_OP_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- ARP_SPA_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- ARP_TPA_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- TUN_IPV4_DST_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- TUN_IPV4_SRC_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- ETH_DST_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- ETH_SRC_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- ETH_TYPE_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSP_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSI_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSC1_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSC2_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSC3_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSC4_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSH_FLAGS_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSH_MDTYPE_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSH_NP_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NSH_TTL_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- TCP_SRC_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- TCP_DST_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- UDP_SRC_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- UDP_DST_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- CT_STATE_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- CT_ZONE_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- NXM_OF_INPORT_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- CT_MARK_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- CT_TP_SRC_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- CT_TP_DST_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
- PKT_MARK_RESOLVER.setAugmentations(AUGMENTATIONS_OF_EXTENSION);
+ final Factory<Extension> factory = AugmentationGroupingResolver.factory(Extension.class, ImmutableSet.of(
+ NxAugMatchRpcAddFlow.class,
+ NxAugMatchRpcRemoveFlow.class,
+ NxAugMatchRpcUpdateFlowOriginal.class,
+ NxAugMatchRpcUpdateFlowUpdated.class,
+ NxAugMatchNodesNodeTableFlow.class,
+ NxAugMatchNotifSwitchFlowRemoved.class,
+ NxAugMatchNotifPacketIn.class,
+ // NxAugMatchNotifUpdateFlowStats.class,
+ NxAugMatchPacketInMessage.class));
+
+ REG_RESOLVER = factory.createResolver(NxmNxRegGrouping.class);
+ TUN_ID_RESOLVER = factory.createResolver(NxmNxTunIdGrouping.class);
+ ARP_SHA_RESOLVER = factory.createResolver(NxmNxArpShaGrouping.class);
+ ARP_THA_RESOLVER = factory.createResolver(NxmNxArpThaGrouping.class);
+ ARP_OP_RESOLVER = factory.createResolver(NxmOfArpOpGrouping.class);
+ ARP_SPA_RESOLVER = factory.createResolver(NxmOfArpSpaGrouping.class);
+ ARP_TPA_RESOLVER = factory.createResolver(NxmOfArpTpaGrouping.class);
+ TUN_IPV4_DST_RESOLVER = factory.createResolver(NxmNxTunIpv4DstGrouping.class);
+ TUN_IPV4_SRC_RESOLVER = factory.createResolver(NxmNxTunIpv4SrcGrouping.class);
+ ETH_DST_RESOLVER = factory.createResolver(NxmOfEthDstGrouping.class);
+ ETH_SRC_RESOLVER = factory.createResolver(NxmOfEthSrcGrouping.class);
+ ETH_TYPE_RESOLVER = factory.createResolver(NxmOfEthTypeGrouping.class);
+ NSP_RESOLVER = factory.createResolver(NxmNxNspGrouping.class);
+ NSI_RESOLVER = factory.createResolver(NxmNxNsiGrouping.class);
+ NSC1_RESOLVER = factory.createResolver(NxmNxNshc1Grouping.class);
+ NSC2_RESOLVER = factory.createResolver(NxmNxNshc2Grouping.class);
+ NSC3_RESOLVER = factory.createResolver(NxmNxNshc3Grouping.class);
+ NSC4_RESOLVER = factory.createResolver(NxmNxNshc4Grouping.class);
+ NSH_FLAGS_RESOLVER = factory.createResolver(NxmNxNshFlagsGrouping.class);
+ NSH_MDTYPE_RESOLVER = factory.createResolver(NxmNxNshMdtypeGrouping.class);
+ NSH_NP_RESOLVER = factory.createResolver(NxmNxNshNpGrouping.class);
+ NSH_TTL_RESOLVER = factory.createResolver(NxmNxNshTtlGrouping.class);
+ TCP_SRC_RESOLVER = factory.createResolver(NxmOfTcpSrcGrouping.class);
+ TCP_DST_RESOLVER = factory.createResolver(NxmOfTcpDstGrouping.class);
+ UDP_SRC_RESOLVER = factory.createResolver(NxmOfUdpSrcGrouping.class);
+ UDP_DST_RESOLVER = factory.createResolver(NxmOfUdpDstGrouping.class);
+ CT_STATE_RESOLVER = factory.createResolver(NxmNxCtStateGrouping.class);
+ CT_ZONE_RESOLVER = factory.createResolver(NxmNxCtZoneGrouping.class);
+ NXM_OF_INPORT_RESOLVER = factory.createResolver(NxmOfInPortGrouping.class);
+ CT_MARK_RESOLVER = factory.createResolver(NxmNxCtMarkGrouping.class);
+ CT_TP_SRC_RESOLVER = factory.createResolver(NxmNxCtTpSrcGrouping.class);
+ CT_TP_DST_RESOLVER = factory.createResolver(NxmNxCtTpDstGrouping.class);
+ PKT_MARK_RESOLVER = factory.createResolver(NxmNxPktMarkGrouping.class);
}
private MatchUtil() {
}
- public static MatchEntryBuilder createDefaultMatchEntryBuilder(Class<? extends MatchField> matchField,
- Class<? extends OxmClassBase> oxmClass,
- MatchEntryValue matchEntryValue) {
+ public static MatchEntryBuilder createDefaultMatchEntryBuilder(final Class<? extends MatchField> matchField,
+ final Class<? extends OxmClassBase> oxmClass,
+ final MatchEntryValue matchEntryValue) {
MatchEntryBuilder matchEntryBuilder = new MatchEntryBuilder();
matchEntryBuilder.setHasMask(false);
matchEntryBuilder.setOxmMatchField(matchField);
}
public static <V extends Augmentation<ExperimenterIdCase>> MatchEntryBuilder createExperimenterMatchEntryBuilder(
- Class<? extends MatchField> matchField,
- long experimenterId,
- NxExpMatchEntryValue value) {
+ final Class<? extends MatchField> matchField,
+ final long experimenterId,
+ final NxExpMatchEntryValue value) {
ExperimenterBuilder experimenterBuilder = new ExperimenterBuilder();
experimenterBuilder.setExperimenter(new ExperimenterId(experimenterId));
ExperimenterIdCaseBuilder expCaseBuilder = new ExperimenterIdCaseBuilder();
return createDefaultMatchEntryBuilder(matchField, ExperimenterClass.class, expCaseBuilder.build());
}
- public static Long ipv4ToLong(Ipv4Address ipv4) {
+ public static Long ipv4ToLong(final Ipv4Address ipv4) {
Iterator<String> iterator = SPLITTER.split(ipv4.getValue()).iterator();
byte[] bytes = new byte[8];
for (int i = 0; i < bytes.length; i++) {
return result;
}
- public static Ipv4Address longToIpv4Address(Long value) {
+ public static Ipv4Address longToIpv4Address(final Long value) {
byte[] bytes = Longs.toByteArray(value);
String[] strArray = new String[4];
for (int i = 4; i < bytes.length; i++) {
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNshFlagsGrouping> matchGrouping = MatchUtil.NSH_FLAGS_RESOLVER.getExtension(extension);
+ Optional<NxmNxNshFlagsGrouping> matchGrouping = MatchUtil.NSH_FLAGS_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNshMdtypeGrouping> matchGrouping = MatchUtil.NSH_MDTYPE_RESOLVER.getExtension(extension);
+ Optional<NxmNxNshMdtypeGrouping> matchGrouping = MatchUtil.NSH_MDTYPE_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNshNpGrouping> matchGrouping = MatchUtil.NSH_NP_RESOLVER.getExtension(extension);
+ Optional<NxmNxNshNpGrouping> matchGrouping = MatchUtil.NSH_NP_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNshTtlGrouping> matchGrouping = MatchUtil.NSH_TTL_RESOLVER.getExtension(extension);
+ Optional<NxmNxNshTtlGrouping> matchGrouping = MatchUtil.NSH_TTL_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNshc1Grouping> matchGrouping = MatchUtil.NSC1_RESOLVER.getExtension(extension);
+ Optional<NxmNxNshc1Grouping> matchGrouping = MatchUtil.NSC1_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNshc2Grouping> matchGrouping = MatchUtil.NSC2_RESOLVER.getExtension(extension);
+ Optional<NxmNxNshc2Grouping> matchGrouping = MatchUtil.NSC2_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNshc3Grouping> matchGrouping = MatchUtil.NSC3_RESOLVER.getExtension(extension);
+ Optional<NxmNxNshc3Grouping> matchGrouping = MatchUtil.NSC3_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNshc4Grouping> matchGrouping = MatchUtil.NSC4_RESOLVER.getExtension(extension);
+ Optional<NxmNxNshc4Grouping> matchGrouping = MatchUtil.NSC4_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNsiGrouping> matchGrouping = MatchUtil.NSI_RESOLVER.getExtension(extension);
+ Optional<NxmNxNsiGrouping> matchGrouping = MatchUtil.NSI_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.api.NiciraConstants;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxNspGrouping> matchGrouping = MatchUtil.NSP_RESOLVER.getExtension(extension);
+ Optional<NxmNxNspGrouping> matchGrouping = MatchUtil.NSP_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfInPortGrouping> matchGrouping = MatchUtil.NXM_OF_INPORT_RESOLVER
- .getExtension(extension);
+ Optional<NxmOfInPortGrouping> matchGrouping = MatchUtil.NXM_OF_INPORT_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxPktMarkGrouping> matchGrouping = MatchUtil.PKT_MARK_RESOLVER.getExtension(extension);
+ Optional<NxmNxPktMarkGrouping> matchGrouping = MatchUtil.PKT_MARK_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.openflowjava.nx.codec.match.NiciraMatchCodecs;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxRegGrouping> matchGrouping = MatchUtil.REG_RESOLVER.getExtension(extension);
+ Optional<NxmNxRegGrouping> matchGrouping = MatchUtil.REG_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfTcpDstGrouping> matchGrouping = MatchUtil.TCP_DST_RESOLVER.getExtension(extension);
+ Optional<NxmOfTcpDstGrouping> matchGrouping = MatchUtil.TCP_DST_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfTcpSrcGrouping> matchGrouping = MatchUtil.TCP_SRC_RESOLVER.getExtension(extension);
+ Optional<NxmOfTcpSrcGrouping> matchGrouping = MatchUtil.TCP_SRC_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxTunIpv4DstGrouping> matchGrouping = MatchUtil.TUN_IPV4_DST_RESOLVER.getExtension(extension);
+ Optional<NxmNxTunIpv4DstGrouping> matchGrouping = MatchUtil.TUN_IPV4_DST_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmNxTunIpv4SrcGrouping> matchGrouping = MatchUtil.TUN_IPV4_SRC_RESOLVER.getExtension(extension);
+ Optional<NxmNxTunIpv4SrcGrouping> matchGrouping = MatchUtil.TUN_IPV4_SRC_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
-/**
+/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
*/
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
import java.math.BigInteger;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(final Extension extension) {
- Optional<NxmNxTunIdGrouping> matchGrouping = MatchUtil.TUN_ID_RESOLVER.getExtension(extension);
+ Optional<NxmNxTunIdGrouping> matchGrouping = MatchUtil.TUN_ID_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfUdpDstGrouping> matchGrouping = MatchUtil.UDP_DST_RESOLVER.getExtension(extension);
+ Optional<NxmOfUdpDstGrouping> matchGrouping = MatchUtil.UDP_DST_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.extension.vendor.nicira.convertor.match;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.openflowplugin.extension.api.ConvertorFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConvertorToOFJava;
import org.opendaylight.openflowplugin.extension.api.ExtensionAugment;
@Override
public MatchEntry convert(Extension extension) {
- Optional<NxmOfUdpSrcGrouping> matchGrouping = MatchUtil.UDP_SRC_RESOLVER.getExtension(extension);
+ Optional<NxmOfUdpSrcGrouping> matchGrouping = MatchUtil.UDP_SRC_RESOLVER.findExtension(extension);
if (!matchGrouping.isPresent()) {
throw new CodecPreconditionException(extension);
}
Code Review / openflowplugin.git / commitdiff