public AppPeerBenchmark(final DataBroker bindingDataBroker, final RpcProviderService rpcProviderRegistry,
final String appRibId) {
this.appRibId = requireNonNull(appRibId);
- this.txChain = bindingDataBroker.createTransactionChain(this);
+ this.txChain = bindingDataBroker.createMergingTransactionChain(this);
this.appIID = InstanceIdentifier.builder(ApplicationRib.class,
new ApplicationRibKey(new ApplicationRibId(appRibId))).build();
-->
<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0" xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0">
- <reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker" odl:type="pingpong"/>
+ <reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker" odl:type="default"/>
<reference id="rpcRegistry" interface="org.opendaylight.mdsal.binding.api.RpcProviderService"/>
<odl:clustered-app-config id="bgpBenchmarkConfig"
<bean factory-ref="bgpBenchmarkConfig" factory-method="getAppPeerId"/>
</argument>
</bean>
-</blueprint>
\ No newline at end of file
+</blueprint>
@Override
public void serializeEsi(final Esi esi, final ByteBuf buffer) {
- final EsiSerializer serializer = this.handlers.getSerializer(esi.getImplementedInterface());
+ final EsiSerializer serializer = this.handlers.getSerializer(esi.implementedInterface());
if (serializer == null) {
return;
}
@Override
public ByteBuf serializeEvpn(final EvpnChoice evpn, final ByteBuf common) {
- final EvpnSerializer serializer = this.handlers.getSerializer(evpn.getImplementedInterface());
+ final EvpnSerializer serializer = this.handlers.getSerializer(evpn.implementedInterface());
if (serializer == null) {
return common;
}
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.evpn.rev180329.esi.Esi;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.evpn.rev180329.evpn.routes.evpn.routes.EvpnRoute;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
private class NotRegistered implements Esi {
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<NotRegistered> implementedInterface() {
return NotRegistered.class;
}
}
public void registryEmptyModelTest() {
assertNull(SimpleEsiTypeRegistry.getInstance().parseEsiModel(null));
}
-}
\ No newline at end of file
+}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.evpn.rev180329.NlriType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.evpn.rev180329.evpn.EvpnChoice;
import org.opendaylight.yangtools.concepts.Registration;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
private class NotRegistered implements EvpnChoice {
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<NotRegistered> implementedInterface() {
return NotRegistered.class;
}
}
.build()).build();
assertNull(SimpleEvpnNlriRegistry.getInstance().serializeEvpnModel(choice.build()));
}
-}
\ No newline at end of file
+}
}
public FlowspecTypeSerializer getFlowspecTypeSerializer(final FlowspecType fsType) {
- return this.handlers.getSerializer(fsType.getImplementedInterface());
+ return this.handlers.getSerializer(fsType.implementedInterface());
}
public void serializeFlowspecType(final FlowspecType fsType, final ByteBuf output) {
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Routes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.AddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.UnicastSubsequentAddressFamily;
+import org.opendaylight.yangtools.yang.binding.BindingObject;
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.ChoiceIn;
import org.opendaylight.yangtools.yang.binding.DataObject;
private static final Logger LOG = LoggerFactory.getLogger(AbstractIPRibSupport.class);
private final NodeIdentifier prefixNid;
private final NodeIdentifier nlriRoutesList;
- private final ImmutableCollection<Class<? extends DataObject>> cacheableNlriObjects;
+ private final ImmutableCollection<Class<? extends BindingObject>> cacheableNlriObjects;
AbstractIPRibSupport(
final BindingNormalizedNodeSerializer mappingService,
}
@Override
- public final ImmutableCollection<Class<? extends DataObject>> cacheableNlriObjects() {
+ public final ImmutableCollection<Class<? extends BindingObject>> cacheableNlriObjects() {
return this.cacheableNlriObjects;
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.Tables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Routes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.AddressFamily;
+import org.opendaylight.yangtools.yang.binding.BindingObject;
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.ChoiceIn;
import org.opendaylight.yangtools.yang.binding.DataObject;
private static final Logger LOG = LoggerFactory.getLogger(AbstractL3vpnMcastIpRIBSupport.class);
private final NodeIdentifier nlriRoutesList;
private final NodeIdentifier rdNid;
- private final ImmutableCollection<Class<? extends DataObject>> cacheableNlriObjects;
+ private final ImmutableCollection<Class<? extends BindingObject>> cacheableNlriObjects;
/**
* Default constructor. Requires the QName of the container augmented under the routes choice
}
@Override
- public final ImmutableCollection<Class<? extends DataObject>> cacheableNlriObjects() {
+ public final ImmutableCollection<Class<? extends BindingObject>> cacheableNlriObjects() {
return this.cacheableNlriObjects;
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.segment.routing.ext.rev151014.adj.flags.flags.OspfAdjFlagsCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.segment.routing.ext.rev151014.sid.label.index.SidLabelIndex;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.concepts.rev131125.IsoSystemIdentifier;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
public final class SrLinkAttributesParser {
}
return new EpeAdjSidTlv() {
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<EpeAdjSidTlv> implementedInterface() {
return EpeAdjSidTlv.class;
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev180329.DomainIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev180329.NodeIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev180329.node.identifier.CRouterIdentifier;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.common.QName;
abstract class AbstractNodeDescriptorTlvCodec {
return new NodeIdentifier() {
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<NodeIdentifier> implementedInterface() {
return NodeIdentifier.class;
}
import org.opendaylight.protocol.bgp.linkstate.spi.LinkstateTlvParser;
import org.opendaylight.protocol.util.ByteBufWriteUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev180329.LinkLrIdentifiers;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.common.QName;
public final class LinkIdTlvParser implements LinkstateTlvParser.LinkstateTlvSerializer<LinkLrIdentifiers>,
final long remoteId = value.readUnsignedInt();
return new LinkLrIdentifiers() {
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<LinkLrIdentifiers> implementedInterface() {
return LinkLrIdentifiers.class;
}
public int getType() {
return LINK_LR_IDENTIFIERS;
}
-}
\ No newline at end of file
+}
for (final BindingSubTlvs subTlv : bindingSubTlvs) {
final BindingSubTlv bindingSubTlv = subTlv.getBindingSubTlv();
final BindingSubTlvsSerializer serializer = this.handlers.getSerializer(
- bindingSubTlv.getImplementedInterface());
+ bindingSubTlv.implementedInterface());
if (serializer == null) {
LOG.info("Unknown binding sub Tlv type {}", subTlv);
return;
requireNonNull(byteAggregator);
final ObjectType objectType = nlri.getObjectType();
final NlriTypeCaseSerializer serializer = this.nlriRegistry
- .getSerializer((Class<? extends ObjectType>) objectType.getImplementedInterface());
+ .getSerializer((Class<? extends ObjectType>) objectType.implementedInterface());
if (serializer == null) {
- LOG.warn("Linkstate NLRI serializer for Type: {} was not found.", objectType.getImplementedInterface());
+ LOG.warn("Linkstate NLRI serializer for Type: {} was not found.", objectType.implementedInterface());
return;
}
final ByteBuf nlriType = Unpooled.buffer();
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.Tables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Routes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.AddressFamily;
+import org.opendaylight.yangtools.yang.binding.BindingObject;
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.ChoiceIn;
import org.opendaylight.yangtools.yang.binding.DataObject;
S extends ChildOf<? super C> & MvpnRoutes> extends AbstractRIBSupport<C, S, MvpnRoute, MvpnRouteKey> {
private static final Logger LOG = LoggerFactory.getLogger(AbstractMvpnRIBSupport.class);
private final NodeIdentifier nlriRoutesList;
- private final ImmutableCollection<Class<? extends DataObject>> cacheableNlriObjects;
+ private final ImmutableCollection<Class<? extends BindingObject>> cacheableNlriObjects;
/**
* Default constructor. Requires the QName of the container augmented under the routes choice
}
@Override
- public final ImmutableCollection<Class<? extends DataObject>> cacheableNlriObjects() {
+ public final ImmutableCollection<Class<? extends BindingObject>> cacheableNlriObjects() {
return this.cacheableNlriObjects;
}
LOG.debug("Skipping serialization of null PMSI Tunnel Attribute");
return NO_TUNNEL_INFORMATION_PRESENT;
}
- final TunnelIdentifierSerializer serializer = this.handlers.getSerializer(tunnel.getImplementedInterface());
+ final TunnelIdentifierSerializer serializer = this.handlers.getSerializer(tunnel.implementedInterface());
if (serializer == null) {
LOG.debug("Skipping serialization of PMSI Tunnel Attribute {}", tunnel);
return NO_TUNNEL_INFORMATION_PRESENT;
@Override
public ByteBuf serializeMvpn(final MvpnChoice mvpn) {
- final MvpnSerializer serializer = this.handlers.getSerializer(mvpn.getImplementedInterface());
+ final MvpnSerializer serializer = this.handlers.getSerializer(mvpn.implementedInterface());
if (serializer == null) {
return Unpooled.buffer();
}
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pmsi.tunnel.rev180329.PAddressPMulticastGroup;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
public final class PAddressPMulticastGroupUtilTest {
private static final String IPV6_MODEL = "2001::1";
}
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
- return null;
+ public Class<MyPAddressPMulticastGroup> implementedInterface() {
+ return MyPAddressPMulticastGroup.class;
}
}
-}
\ No newline at end of file
+}
import org.opendaylight.protocol.bgp.mvpn.impl.NlriActivator;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.mvpn.rev180417.NlriType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.mvpn.rev180417.mvpn.MvpnChoice;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
public final class SimpleMvpnNlriRegistryTest {
@Before
private class NotRegistered implements MvpnChoice {
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<NotRegistered> implementedInterface() {
return NotRegistered.class;
}
}
-}
\ No newline at end of file
+}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.route.target.constrain.rev180618.update.attributes.mp.reach.nlri.advertized.routes.destination.type.destination.route.target.constrain.advertized._case.DestinationRouteTargetConstrainBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.route.target.constrain.rev180618.update.attributes.mp.unreach.nlri.withdrawn.routes.destination.type.DestinationRouteTargetConstrainWithdrawnCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.Ipv4AddressFamily;
+import org.opendaylight.yangtools.yang.binding.BindingObject;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
new RouteTargetConstrainRoutesCaseBuilder().setRouteTargetConstrainRoutes(EMPTY_CONTAINER).build();
private static final String ORIGIN_AS = "origin-as";
private static RouteTargetConstrainRIBSupport SINGLETON;
- private final ImmutableCollection<Class<? extends DataObject>> cacheableNlriObjects
+ private final ImmutableCollection<Class<? extends BindingObject>> cacheableNlriObjects
= ImmutableSet.of(RouteTargetConstrainRoutesCase.class);
private final NodeIdentifier originAsNid;
}
@Override
- public ImmutableCollection<Class<? extends DataObject>> cacheableNlriObjects() {
+ public ImmutableCollection<Class<? extends BindingObject>> cacheableNlriObjects() {
return this.cacheableNlriObjects;
}
}
@Override
- public List<RouteTargetConstrainRoute> extractAdjRibInRoutes(Routes routes) {
+ public List<RouteTargetConstrainRoute> extractAdjRibInRoutes(final Routes routes) {
verify(routes instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.route.target
.constrain.rev180618.bgp.rib.rib.peer.adj.rib.in.tables.routes.RouteTargetConstrainRoutesCase,
"Unrecognized routes %s", routes);
@SuppressWarnings("unchecked")
public ByteBuf serializeRouteTargetConstrain(final RouteTargetConstrainChoice routeTarget) {
final RouteTargetConstrainSerializer serializer
- = this.handlers.getSerializer(routeTarget.getImplementedInterface());
+ = this.handlers.getSerializer(routeTarget.implementedInterface());
if (serializer == null || serializer.getType() == null) {
return Unpooled.buffer();
}
}
@Override
- public Class<BgpTableType> getImplementedInterface() {
+ public Class<BgpTableType> implementedInterface() {
return BgpTableType.class;
}
final CParameters cap = optionalCapa.getCParameters();
final ByteBuf bytes = Unpooled.buffer();
this.reg.serializeCapability(cap, bytes);
- Preconditions.checkArgument(bytes != null, "Unhandled capability class %s", cap.getImplementedInterface());
+ Preconditions.checkArgument(bytes != null, "Unhandled capability class %s", cap.implementedInterface());
if (LOG.isTraceEnabled()) {
LOG.trace("BGP capability serialized to: {}", ByteBufUtil.hexDump(bytes));
@Override
public void serializeBgpPrefixSidTlv(final BgpPrefixSidTlv tlv, final ByteBuf bytes) {
- final BgpPrefixSidTlvSerializer serializer = this.handlers.getSerializer(tlv.getImplementedInterface());
+ final BgpPrefixSidTlvSerializer serializer = this.handlers.getSerializer(tlv.implementedInterface());
if (serializer == null) {
return;
}
@Override
public void serializeExtendedCommunity(final ExtendedCommunities extendedCommunity, final ByteBuf byteAggregator) {
final ExtendedCommunitySerializer serializer = this.handlers.getSerializer(extendedCommunity
- .getExtendedCommunity().getImplementedInterface());
+ .getExtendedCommunity().implementedInterface());
if (serializer == null) {
return;
}
@Override
protected void serializeMessageImpl(final Notification message, final ByteBuf buffer) {
- final MessageSerializer serializer = this.handlers.getSerializer(message.getImplementedInterface());
+ final MessageSerializer serializer = this.handlers.getSerializer(message.implementedInterface());
if (serializer == null) {
return;
}
final CNextHop cNextHop = mpReachNlri.getCNextHop();
if (cNextHop != null) {
final Entry<Class<? extends CNextHop>, BgpTableType> key = new SimpleEntry(
- cNextHop.getImplementedInterface(), new BgpTableTypeImpl(afi, safi));
+ cNextHop.implementedInterface(), new BgpTableTypeImpl(afi, safi));
final NextHopParserSerializer nextHopSerializer = this.nextHopSerializers.get(key);
final ByteBuf nextHopBuffer = Unpooled.buffer();
nextHopSerializer.serializeNextHop(cNextHop, nextHopBuffer);
@Override
public void serializeParameter(final BgpParameters parameter, final ByteBuf bytes) {
- final ParameterSerializer serializer = this.handlers.getSerializer(parameter.getImplementedInterface());
+ final ParameterSerializer serializer = this.handlers.getSerializer(parameter.implementedInterface());
if (serializer == null) {
return;
}
public void testSimpleParameter() throws Exception {
final ParameterRegistry paramReg = this.ctx.getParameterRegistry();
final BgpParameters param = mock(BgpParameters.class);
- Mockito.doReturn(BgpParameters.class).when(param).getImplementedInterface();
+ Mockito.doReturn(BgpParameters.class).when(param).implementedInterface();
final byte[] paramBytes = {
0x00, 0x00
};
};
final BgpPrefixSidTlv tlv = mock(BgpPrefixSidTlv.class);
- doReturn(BgpPrefixSidTlv.class).when(tlv).getImplementedInterface();
+ doReturn(BgpPrefixSidTlv.class).when(tlv).implementedInterface();
final ByteBuf buffer = Unpooled.buffer(tlvBytes.length);
sidTlvReg.serializeBgpPrefixSidTlv(tlv, buffer);
(byte) 0x00, (byte) 0x13, (byte) 0x00
};
final Notification msg = mock(Notification.class);
- doReturn(Notification.class).when(msg).getImplementedInterface();
+ doReturn(Notification.class).when(msg).implementedInterface();
final ByteBuf buffer = Unpooled.buffer(msgBytes.length);
msgRegistry.serializeMessage(msg, buffer);
import com.google.common.collect.ImmutableSet.Builder;
import java.util.Set;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeNode;
+import org.opendaylight.mdsal.binding.dom.codec.api.BindingDataObjectCodecTreeNode;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeCachingCodec;
import org.opendaylight.protocol.bgp.rib.impl.spi.Codecs;
import org.opendaylight.protocol.bgp.rib.spi.RIBSupport;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.BgpAggregator;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.Community;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.ExtendedCommunity;
+import org.opendaylight.yangtools.yang.binding.BindingObject;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
ATTRIBUTE_CACHEABLES = acb.build();
}
- private final ImmutableSet<Class<? extends DataObject>> cacheableAttributes;
+ private final ImmutableSet<Class<? extends BindingObject>> cacheableAttributes;
private BindingNormalizedNodeCachingCodec<Attributes> attributesCodec;
private BindingNormalizedNodeCachingCodec<MpReachNlri> reachNlriCodec;
private BindingNormalizedNodeCachingCodec<MpUnreachNlri> unreachNlriCodec;
public CodecsImpl(final RIBSupport<?, ?, ?, ?> ribSupport) {
this.ribSupport = requireNonNull(ribSupport);
- final Builder<Class<? extends DataObject>> acb = ImmutableSet.builder();
+ final Builder<Class<? extends BindingObject>> acb = ImmutableSet.builder();
acb.addAll(ATTRIBUTE_CACHEABLES);
acb.addAll(this.ribSupport.cacheableAttributeObjects());
this.cacheableAttributes = acb.build();
public void onCodecTreeUpdated(final BindingCodecTree tree) {
@SuppressWarnings("rawtypes")
- final BindingCodecTreeNode tableCodecContext = tree.getSubtreeCodec(TABLE_BASE_II);
- final BindingCodecTreeNode<? extends Route> routeListCodec = tableCodecContext
+ final BindingDataObjectCodecTreeNode tableCodecContext = tree.getSubtreeCodec(TABLE_BASE_II);
+ final BindingDataObjectCodecTreeNode<? extends Route> routeListCodec = tableCodecContext
.streamChild(Routes.class)
.streamChild(this.ribSupport.routesCaseClass())
.streamChild(this.ribSupport.routesContainerClass())
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Routes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.AddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.SubsequentAddressFamily;
+import org.opendaylight.yangtools.yang.binding.BindingObject;
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.ChoiceIn;
import org.opendaylight.yangtools.yang.binding.DataObject;
Class<R> routesListClass();
@Nonnull
- default ImmutableCollection<Class<? extends DataObject>> cacheableAttributeObjects() {
+ default ImmutableCollection<Class<? extends BindingObject>> cacheableAttributeObjects() {
return ImmutableSet.of();
}
@Nonnull
- default ImmutableCollection<Class<? extends DataObject>> cacheableNlriObjects() {
+ default ImmutableCollection<Class<? extends BindingObject>> cacheableNlriObjects() {
return ImmutableSet.of();
}
}
protected final Collection<MapEntryNode> createRoutes(final S routes) {
- Preconditions.checkArgument(routes.getImplementedInterface()
+ Preconditions.checkArgument(routes.implementedInterface()
.equals(this.abstractRIBSupport.routesContainerClass()));
final InstanceIdentifier<S> routesIId = routesIId();
final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedNode = this.mappingService
return new NodeId(ipv6.getGlobal().getValue());
} else {
- LOG.warn("Unhandled next hop class {}", nh.getImplementedInterface());
+ LOG.warn("Unhandled next hop class {}", nh.implementedInterface());
return null;
}
}
} else if (t instanceof PrefixCase) {
createPrefix(trans, base, value, (PrefixCase) t, value.getAttributes());
} else {
- LOG.debug(UNHANDLED_OBJECT_CLASS, t.getImplementedInterface());
+ LOG.debug(UNHANDLED_OBJECT_CLASS, t.implementedInterface());
}
}
} else if (t instanceof PrefixCase) {
removePrefix(trans, base, (PrefixCase) t);
} else {
- LOG.debug(UNHANDLED_OBJECT_CLASS, t.getImplementedInterface());
+ LOG.debug(UNHANDLED_OBJECT_CLASS, t.implementedInterface());
}
}
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.ospf.topology.rev131021.ospf.node.attributes.ospf.node.attributes.router.type.InternalBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.ospf.topology.rev131021.ospf.node.attributes.ospf.node.attributes.router.type.PseudonodeBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.ospf.topology.rev131021.ospf.prefix.attributes.OspfPrefixAttributesBuilder;
+import org.opendaylight.yangtools.yang.common.Empty;
public final class ProtocolUtil {
private ProtocolUtil() {
if (ri instanceof OspfPseudonodeCase) {
final OspfPseudonode pn = ((OspfPseudonodeCase) ri).getOspfPseudonode();
- ab.setRouterType(new PseudonodeBuilder().setPseudonode(Boolean.TRUE).build());
+ ab.setRouterType(new PseudonodeBuilder().setPseudonode(Empty.getInstance()).build());
ab.setDrInterfaceId(pn.getLanInterface().getValue());
} else if (ri instanceof OspfNodeCase && na.getNodeFlags() != null) {
// TODO: what should we do with in.getOspfRouterId()?
final NodeFlagBits nf = na.getNodeFlags();
if (nf.isAbr() != null) {
- ab.setRouterType(new AbrBuilder().setAbr(nf.isAbr()).build());
+ ab.setRouterType(new AbrBuilder().setAbr(nf.isAbr() ? Empty.getInstance() : null).build());
} else if (nf.isExternal() != null) {
- ab.setRouterType(new InternalBuilder().setInternal(!nf.isExternal()).build());
+ ab.setRouterType(new InternalBuilder().setInternal(nf.isExternal() ? null : Empty.getInstance())
+ .build());
}
}
}
return r.getOspfRouterId().toString() + ':' + r.getLanInterface().getValue();
}
LOG.warn("Unhandled router identifier type {}, fallback to toString()",
- routerIdentifier.getImplementedInterface());
+ routerIdentifier.implementedInterface());
return routerIdentifier.toString();
}
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>3.0.6</version>
+ <version>4.0.0</version>
<relativePath/>
</parent>
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeNode;
+import org.opendaylight.mdsal.binding.dom.codec.api.BindingDataObjectCodecTreeNode;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionConsumerContext;
import org.opendaylight.protocol.bmp.impl.spi.BmpRouterPeer;
private final YangInstanceIdentifier peerYangIId;
private final BmpRibInWriter prePolicyWriter;
private final BmpRibInWriter postPolicyWriter;
- private final BindingCodecTreeNode<SentOpen> sentOpenCodec;
- private final BindingCodecTreeNode<ReceivedOpen> receivedOpenCodec;
+ private final BindingDataObjectCodecTreeNode<SentOpen> sentOpenCodec;
+ private final BindingDataObjectCodecTreeNode<ReceivedOpen> receivedOpenCodec;
private boolean up = true;
private BmpRouterPeerImpl(final DOMTransactionChain domTxChain, final YangInstanceIdentifier peersYangIId,
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeNode;
+import org.opendaylight.mdsal.binding.dom.codec.api.BindingDataObjectCodecTreeNode;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeCachingCodec;
import org.opendaylight.protocol.bgp.rib.spi.RIBSupport;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev180329.Update;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.Attributes2;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.update.attributes.MpReachNlri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.update.attributes.MpUnreachNlri;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.Route;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Routes;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
this.tableSupport = requireNonNull(tableSupport);
this.tableId = requireNonNull(tableId);
final BindingCodecTreeNode tableCodecContext = tree.getSubtreeCodec(tableId);
- final BindingCodecTreeNode<? extends Route> routeListCodec = tableCodecContext
+ Preconditions.checkState(tableCodecContext instanceof BindingDataObjectCodecTreeNode);
+ final BindingDataObjectCodecTreeNode<?> routeListCodec = ((BindingDataObjectCodecTreeNode)tableCodecContext)
.streamChild(Routes.class)
.streamChild(this.tableSupport.routesCaseClass())
.streamChild(this.tableSupport.routesContainerClass())
@Override
public void serializeMessage(final Notification message, final ByteBuf buffer) {
- final BmpMessageSerializer serializer = this.handlers.getSerializer(message.getImplementedInterface());
+ final BmpMessageSerializer serializer = this.handlers.getSerializer(message.implementedInterface());
if (serializer == null) {
LOG.warn("BMP serializer for message type {} is not registered.", message.getClass());
return;
}
return msgType;
}
-}
\ No newline at end of file
+}
@Override
public void serializeTlv(final Tlv tlv, final ByteBuf output) {
- final BmpTlvSerializer serializer = this.handlers.getSerializer(tlv.getImplementedInterface());
+ final BmpTlvSerializer serializer = this.handlers.getSerializer(tlv.implementedInterface());
if (serializer == null) {
LOG.warn("BMP serializer for TLV type {} is not registered.", tlv.getClass());
return;
import org.opendaylight.protocol.bmp.spi.parser.BmpDeserializationException;
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.protocol.util.ByteBufWriteUtil;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.Notification;
public class SimpleBmpMessageRegistryTest {
}
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<BmpTestMessage> implementedInterface() {
return BmpTestMessage.class;
}
import org.opendaylight.protocol.bmp.spi.parser.BmpTlvParser;
import org.opendaylight.protocol.bmp.spi.parser.BmpTlvSerializer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.message.rev180329.Tlv;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
public class SimpleBmpTlvRegistryTest {
private final class MockDescriptionTlv implements Tlv {
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<MockDescriptionTlv> implementedInterface() {
return MockDescriptionTlv.class;
}
}
private final class MockTlv implements Tlv {
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<MockTlv> implementedInterface() {
return MockTlv.class;
}
TopologyDataChangeCounter(final DataBroker dataBroker, final String counterId, final String topologyName) {
this.dataBroker = dataBroker;
- this.transactionChain = this.dataBroker.createTransactionChain(this);
+ this.transactionChain = this.dataBroker.createMergingTransactionChain(this);
this.counterId = counterId;
this.counterInstanceId = InstanceIdentifier.builder(DataChangeCounter.class)
.child(Counter.class, new CounterKey(this.counterId)).build();
LOG.warn("Transaction chain failure. Transaction: {}", transaction, cause);
if (!closed.get()) {
this.transactionChain.close();
- this.transactionChain = dataBroker.createTransactionChain(this);
+ this.transactionChain = dataBroker.createMergingTransactionChain(this);
}
}
<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0">
- <reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker" odl:type="pingpong"/>
+ <reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker" odl:type="default"/>
<bean id="data-change-counter-deployer" class="org.opendaylight.protocol.data.change.counter.TopologyDataChangeCounterDeployer"
init-method="register"
destroy-method="close">
<argument ref="dataBroker"/>
</bean>
<service ref="data-change-counter-deployer" interface="org.opendaylight.protocol.data.change.counter.TopologyDataChangeCounterDeployer"/>
-</blueprint>
\ No newline at end of file
+</blueprint>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>3.0.6</version>
+ <version>4.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
Preconditions.checkArgument(bindingTypeValue != null,
"Missing Binding Value in Path Bidning TLV: %s", pTlv);
final ByteBuf body = Unpooled.buffer(MPLS_BINDING_LENGTH);
- final PathBindingTlvCodec codec = BT_SERIALIZERS.get(bindingTypeValue.getImplementedInterface());
+ final PathBindingTlvCodec codec = BT_SERIALIZERS.get(bindingTypeValue.implementedInterface());
Preconditions.checkArgument(codec != null,
- "Unsupported Path Binding Type: %s", bindingTypeValue.getImplementedInterface());
+ "Unsupported Path Binding Type: %s", bindingTypeValue.implementedInterface());
ByteBufWriteUtil.writeUnsignedShort(codec.getBindingType(), body);
body.writeBytes(codec.serialize(bindingTypeValue));
final LspIdentifiers lsp = (LspIdentifiers) tlv;
final AddressFamily afi = lsp.getAddressFamily();
final ByteBuf body = Unpooled.buffer();
- if (afi.getImplementedInterface().equals(Ipv6Case.class)) {
+ if (afi.implementedInterface().equals(Ipv6Case.class)) {
new Stateful07LSPIdentifierIpv6TlvParser().serializeTlv(tlv, buffer);
}
final Ipv4 ipv4 = ((Ipv4Case) afi).getIpv4();
Preconditions.checkArgument(tlv instanceof RsvpErrorSpec, "RSVPErrorSpecTlv is mandatory.");
final RsvpErrorSpec rsvp = (RsvpErrorSpec) tlv;
final ByteBuf body = Unpooled.buffer();
- if (rsvp.getErrorType().getImplementedInterface().equals(RsvpCase.class)) {
+ if (rsvp.getErrorType().implementedInterface().equals(RsvpCase.class)) {
final RsvpCase r = (RsvpCase) rsvp.getErrorType();
serializeRsvp(r.getRsvpError(), body);
TlvUtil.formatTlv(TYPE, body, buffer);
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.iana.rev130816.EnterpriseNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.vendor.information.EnterpriseSpecificInformation;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
public class TestVendorInformationTlvParser extends AbstractVendorInformationTlvParser {
}
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<TestEnterpriseSpecificInformation> implementedInterface() {
return TestEnterpriseSpecificInformation.class;
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev181109.sr.subobject.nai.IpNodeIdBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev181109.sr.subobject.nai.UnnumberedAdjacency;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.segment.routing.rev181109.sr.subobject.nai.UnnumberedAdjacencyBuilder;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
public abstract class AbstractSrSubobjectParser {
}
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<SrSubobject> implementedInterface() {
return SrSubobject.class;
}
package org.opendaylight.protocol.pcep.spi;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.ObjectHeader;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
/**
* Header parser for PCEP object.
}
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<ObjectHeader> implementedInterface() {
return ObjectHeader.class;
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcep.error.object.ErrorObjectBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcerr.message.pcerr.message.Errors;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcerr.message.pcerr.message.ErrorsBuilder;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
/**
* Placeholder object. This object should be injected by in positions where an object is either completely unknown or
}
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<Object> implementedInterface() {
return Object.class;
}
@Override
public void serializeSubobject(final Subobject subobject, final ByteBuf buffer) {
final EROSubobjectSerializer serializer = this.handlers.getSerializer(
- subobject.getSubobjectType().getImplementedInterface());
+ subobject.getSubobjectType().implementedInterface());
if (serializer == null) {
return;
}
@Override
public void serializeLabel(final boolean unidirectional, final boolean global, final LabelType label,
final ByteBuf buffer) {
- final LabelSerializer serializer = this.handlers.getSerializer(label.getImplementedInterface());
+ final LabelSerializer serializer = this.handlers.getSerializer(label.implementedInterface());
if (serializer != null) {
serializer.serializeLabel(unidirectional, global, label, buffer);
}
@Override
public void serializeMessage(final Message message, final ByteBuf buffer) {
- final MessageSerializer serializer = this.handlers.getSerializer(message.getImplementedInterface());
+ final MessageSerializer serializer = this.handlers.getSerializer(message.implementedInterface());
if (serializer == null) {
LOG.warn("PCEP serializer for message type {} is not registered.", message.getClass());
return;
@Override
public void serializeObject(final Object object, final ByteBuf buffer) {
- final ObjectSerializer serializer = this.handlers.getSerializer(object.getImplementedInterface());
+ final ObjectSerializer serializer = this.handlers.getSerializer(object.implementedInterface());
if (serializer == null) {
return;
}
@Override
public void serializeSubobject(final Subobject subobject, final ByteBuf buffer) {
final RROSubobjectSerializer serializer = this.handlers.getSerializer(
- subobject.getSubobjectType().getImplementedInterface());
+ subobject.getSubobjectType().implementedInterface());
if (serializer != null) {
serializer.serializeSubobject(subobject, buffer);
}
@Override
public void serializeTlv(final Tlv tlv, final ByteBuf buffer) {
- final TlvSerializer serializer = this.handlers.getSerializer(tlv.getImplementedInterface());
+ final TlvSerializer serializer = this.handlers.getSerializer(tlv.implementedInterface());
if (serializer == null) {
return;
}
@Override
public void serializeVendorInformationObject(final VendorInformationObject viObject, final ByteBuf buffer) {
final ObjectSerializer serializer = this.handlers.getSerializer(
- viObject.getEnterpriseSpecificInformation().getImplementedInterface());
+ viObject.getEnterpriseSpecificInformation().implementedInterface());
if (serializer == null) {
return;
}
@Override
public void serializeVendorInformationTlv(final VendorInformationTlv viTlv, final ByteBuf buffer) {
final TlvSerializer serializer = this.handlers.getSerializer(
- viTlv.getEnterpriseSpecificInformation().getImplementedInterface());
+ viTlv.getEnterpriseSpecificInformation().implementedInterface());
if (serializer == null) {
return;
}
@Override
public void serializeSubobject(final Subobject subobject, final ByteBuf buffer) {
final XROSubobjectSerializer serializer = this.handlers.getSerializer(
- subobject.getSubobjectType().getImplementedInterface());
+ subobject.getSubobjectType().implementedInterface());
if (serializer == null) {
return;
}
final Object o = new CCloseBuilder().build();
UnknownObject unknown = new UnknownObject(PCEPErrors.LSP_RSVP_ERROR, o);
- assertEquals(Object.class, unknown.getImplementedInterface());
+ assertEquals(Object.class, unknown.implementedInterface());
assertEquals(o, unknown.getInvalidObject());
}
}
doReturn(this.es).when(this.viTlv).getEnterpriseSpecificInformation();
- doReturn(EnterpriseSpecificInformation.class).when(this.es).getImplementedInterface();
+ doReturn(EnterpriseSpecificInformation.class).when(this.es).implementedInterface();
}
@Test
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev181109.pcep.client.attributes.path.computation.client.ReportedLspKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev181109.pcep.client.attributes.path.computation.client.reported.lsp.Path;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-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.common.RpcResult;
private final ProtocolVersion version = new ProtocolVersion((short) 1);
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<MessageHeader> implementedInterface() {
return MessageHeader.class;
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev181109.OperationResult;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev181109.operation.result.Error;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev181109.operation.result.ErrorBuilder;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
final class OperationResults implements OperationResult {
static final OperationResults NOACK = new OperationResults(FailureType.NoAck);
}
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<OperationResult> implementedInterface() {
return OperationResult.class;
}
}
Preconditions.checkArgument(holdStateNanos >= 0);
this.nodeId = topology.child(Node.class, new NodeKey(id));
this.holdStateNanos = holdStateNanos;
- this.chain = broker.createTransactionChain(this);
+ this.chain = broker.createMergingTransactionChain(this);
}
@Nonnull
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stats.rev171113.reply.time.grouping.ReplyTimeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.Message;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.open.object.Open;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
public final class SessionStateImpl implements PcepSessionState {
private final LongAdder lastReceivedRptMsgTimestamp = new LongAdder();
}
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
- return null;
+ public Class<PcepSessionState> implementedInterface() {
+ return PcepSessionState.class;
}
}
interface="org.opendaylight.bgpcep.pcep.topology.provider.TopologySessionListenerFactory"/>
<reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker"
- odl:type="pingpong"/>
+ odl:type="default"/>
<reference id="rpcProviderService" interface="org.opendaylight.mdsal.binding.api.RpcProviderService"/>
<reference id="pcepDispatcher" interface="org.opendaylight.protocol.pcep.PCEPDispatcher"/>
<reference id="clusterSingletonServiceProvider"
<argument ref="Stateful07TopologySessionListenerFactory"/>
<argument ref="topologySessionStatsRegistry"/>
</bean>
-</blueprint>
\ No newline at end of file
+</blueprint>
public synchronized void init() {
LOG.info("Initializing TopologyStatsProvider service.");
- this.transactionChain = this.dataBroker.createTransactionChain(this);
+ this.transactionChain = this.dataBroker.createMergingTransactionChain(this);
final TimerTask task = new TimerTask() {
@Override
public void run() {
if (!closed.get()) {
transactionChain.close();
- transactionChain = dataBroker.createTransactionChain(this);
+ transactionChain = dataBroker.createMergingTransactionChain(this);
}
}
<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0">
<reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker"
- odl:type="pingpong"/>
+ odl:type="default"/>
<odl:clustered-app-config id="pcepStatsConfig"
binding-class="org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.odl.pcep.stats.provider.config.rev171113.PcepProvider"/>
final TerminationPointType dpt = dp1.getIgpTerminationPointAttributes().getTerminationPointType();
// The types have to match
- Preconditions.checkArgument(spt.getImplementedInterface().equals(dpt.getImplementedInterface()));
+ Preconditions.checkArgument(spt.implementedInterface().equals(dpt.implementedInterface()));
// And they have to actually be Ip
final Ip sips = (Ip) spt;
srcIp = new IpAddress(ipv6.getIpv6TunnelSenderAddress());
dstIp = new IpAddress(ipv6.getIpv6TunnelSenderAddress());
} else {
- throw new IllegalArgumentException("Unsupported address family: " + af.getImplementedInterface());
+ throw new IllegalArgumentException("Unsupported address family: " + af.implementedInterface());
}
final Path path0 = value.getPath().get(0);
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.node.attributes.SupportingNode;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
final class TunelProgrammingUtil {
public static final ListenableFuture<OperationResult> RESULT = Futures.immediateFuture(new OperationResult() {
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<OperationResult> implementedInterface() {
return OperationResult.class;
}
<blueprint xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
<reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker"
- odl:type="pingpong"/>
+ odl:type="default"/>
<reference id="rpcProviderService" interface="org.opendaylight.mdsal.binding.api.RpcProviderService"/>
<reference id="rpcConsumerRegistry" interface="org.opendaylight.mdsal.binding.api.RpcConsumerRegistry"/>
<reference id="clusterSingletonServiceProvider"
<argument ref="blueprintBundleContext"/>
<argument ref="clusterSingletonServiceProvider"/>
</bean>
-</blueprint>
\ No newline at end of file
+</blueprint>
final Optional<Nanotime> deadline, final String... dependencyIds) {
final SubmitInstructionInput mockedSubmitInstruction = mock(SubmitInstructionInput.class);
- doReturn(PcepUpdateTunnelInput.class).when(mockedSubmitInstruction).getImplementedInterface();
+ doReturn(PcepUpdateTunnelInput.class).when(mockedSubmitInstruction).implementedInterface();
final List<InstructionId> dependencies = new ArrayList<>();
for (final String dependencyId : dependencyIds) {
dependencies.add(new InstructionId(dependencyId));
@Override
public void serializeSubobject(final SubobjectContainer subobject, final ByteBuf buffer) {
final EROSubobjectSerializer serializer = this.handlers.getSerializer(subobject.getSubobjectType()
- .getImplementedInterface());
+ .implementedInterface());
if (serializer == null) {
return;
}
@Override
public void serializeLabel(final boolean unidirectional, final boolean global, final LabelType label,
final ByteBuf buffer) {
- final LabelSerializer serializer = this.handlers.getSerializer(label.getImplementedInterface());
+ final LabelSerializer serializer = this.handlers.getSerializer(label.implementedInterface());
if (serializer != null) {
serializer.serializeLabel(unidirectional, global, label, buffer);
}
@Override
public void serializeSubobject(final SubobjectContainer subobject, final ByteBuf buffer) {
final RROSubobjectSerializer serializer = this.handlers.getSerializer(subobject.getSubobjectType()
- .getImplementedInterface());
+ .implementedInterface());
if (serializer == null) {
return;
}
if (parameter == null) {
return;
}
- final RSVPTeObjectSerializer serializer = this.serializerHandler.get(parameter.getImplementedInterface());
+ final RSVPTeObjectSerializer serializer = this.serializerHandler.get(parameter.implementedInterface());
if (serializer == null) {
return;
}
@Override
public void serializeSubobject(final SubobjectContainer subobject, final ByteBuf buffer) {
final XROSubobjectSerializer serializer = this.handlers.getSerializer(subobject.getSubobjectType()
- .getImplementedInterface());
+ .implementedInterface());
if (serializer == null) {
return;
}
@Before
public void setUp() throws RSVPParsingException {
Mockito.doReturn(this.parsedRsvpTeObj).when(this.rsvpTeParser).parseObject(Mockito.any(ByteBuf.class));
- Mockito.doReturn(RsvpTeObject.class).when(this.parsedRsvpTeObj).getImplementedInterface();
+ Mockito.doReturn(RsvpTeObject.class).when(this.parsedRsvpTeObj).implementedInterface();
Mockito.doReturn("parsedRsvpTeObj").when(this.parsedRsvpTeObj).toString();
Mockito.doNothing().when(this.rsvpTeSerializer).serializeObject(Mockito.any(RsvpTeObject.class),
Mockito.any(ByteBuf.class));
Mockito.any(Boolean.class));
Mockito.doReturn(this.subObjType).when(this.subObj).getSubobjectType();
Mockito.doReturn("SubobjectContainer").when(this.subObj).toString();
- Mockito.doReturn(SubobjectType.class).when(this.subObjType).getImplementedInterface();
+ Mockito.doReturn(SubobjectType.class).when(this.subObjType).implementedInterface();
Mockito.doNothing().when(this.xroObjSerializer).serializeSubobject(Mockito.any(SubobjectContainer.class),
Mockito.any(ByteBuf.class));
Mockito.doReturn(this.rroSubObjType).when(this.rroSubObj).getSubobjectType();
Mockito.doReturn("SubobjectContainer").when(this.rroSubObj).toString();
Mockito.doReturn(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.record.route
- .subobjects.SubobjectType.class).when(this.rroSubObjType).getImplementedInterface();
+ .subobjects.SubobjectType.class).when(this.rroSubObjType).implementedInterface();
Mockito.doNothing().when(this.rroSerializer).serializeSubobject(Mockito.any(org.opendaylight.yang.gen.v1.urn
.opendaylight.params.xml.ns.yang.rsvp.rev150820.record.route.subobjects.list.SubobjectContainer.class),
Mockito.any(ByteBuf.class));
Mockito.any(Boolean.class));
Mockito.doReturn(this.subObjType).when(this.eroSubObj).getSubobjectType();
Mockito.doReturn("EROSubobjectContainer").when(this.eroSubObj).toString();
- Mockito.doReturn(SubobjectType.class).when(this.subObjType).getImplementedInterface();
+ Mockito.doReturn(SubobjectType.class).when(this.subObjType).implementedInterface();
Mockito.doNothing().when(this.eroSerializer).serializeSubobject(Mockito.any(org.opendaylight.yang.gen.v1.urn
.opendaylight.params.xml.ns.yang.rsvp.rev150820.explicit.route.subobjects.list.SubobjectContainer.class),
Mockito.any(ByteBuf.class));
Mockito.doReturn(this.labelType).when(this.labelParser).parseLabel(Mockito.any(ByteBuf.class));
- Mockito.doReturn(LabelType.class).when(this.labelType).getImplementedInterface();
+ Mockito.doReturn(LabelType.class).when(this.labelType).implementedInterface();
Mockito.doReturn("LabelType").when(this.labelType).toString();
Mockito.doNothing().when(this.labelSerializer).serializeLabel(Mockito.anyBoolean(), Mockito.anyBoolean(),
Mockito.any(LabelType.class), Mockito.any(ByteBuf.class));
}
}
-}
\ No newline at end of file
+}
import org.opendaylight.protocol.rsvp.parser.spi.LabelSerializer;
import org.opendaylight.protocol.rsvp.parser.spi.RSVPParsingException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.label.subobject.LabelType;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
public class SimpleLabelRegistryTest {
private final short ctype = 1;
private final class MockLabelClass implements LabelType {
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<? extends LabelType> implementedInterface() {
return MockLabelClass.class;
}
}
private final class MockLabel implements LabelType {
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
+ public Class<? extends LabelType> implementedInterface() {
return MockLabel.class;
}
}
-}
\ No newline at end of file
+}
Code Review / bgpcep.git / commitdiff