opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/NodeMapping.java

   1 /**
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.controller.sal.compatibility;
   9
  10 import java.math.BigInteger;
  11 import java.util.Date;
  12 import java.util.HashSet;
  13 import java.util.List;
  14
  15 import org.opendaylight.controller.sal.common.util.Arguments;
  16 import org.opendaylight.controller.sal.core.AdvertisedBandwidth;
  17 import org.opendaylight.controller.sal.core.Bandwidth;
  18 import org.opendaylight.controller.sal.core.Buffers;
  19 import org.opendaylight.controller.sal.core.Capabilities;
  20 import org.opendaylight.controller.sal.core.Config;
  21 import org.opendaylight.controller.sal.core.ConstructionException;
  22 import org.opendaylight.controller.sal.core.Description;
  23 import org.opendaylight.controller.sal.core.MacAddress;
  24 import org.opendaylight.controller.sal.core.Name;
  25 import org.opendaylight.controller.sal.core.Node.NodeIDType;
  26 import org.opendaylight.controller.sal.core.NodeConnector.NodeConnectorIDType;
  27 import org.opendaylight.controller.sal.core.PeerBandwidth;
  28 import org.opendaylight.controller.sal.core.Property;
  29 import org.opendaylight.controller.sal.core.SupportedBandwidth;
  30 import org.opendaylight.controller.sal.core.Tables;
  31 import org.opendaylight.controller.sal.core.TimeStamp;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FeatureCapability;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorUpdated;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeUpdated;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityArpMatchIp;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityFlowStats;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityIpReasm;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityPortStats;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityQueueStats;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityStp;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityTableStats;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowNode;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowNodeConnector;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.flow.node.SwitchFeatures;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortConfig;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortFeatures;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.flow.capable.port.State;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.OutputPortValues;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorUpdated;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeUpdated;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  61 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  62 import org.slf4j.Logger;
  63 import org.slf4j.LoggerFactory;
  64
  65 import com.google.common.annotations.VisibleForTesting;
  66 import com.google.common.base.Objects;
  67 import com.google.common.base.Preconditions;
  68
  69 public final class NodeMapping {
  70
  71     private static final Logger LOG = LoggerFactory
  72             .getLogger(NodeMapping.class);
  73
  74     /** openflow id prefix */
  75     public static final String OPENFLOW_ID_PREFIX = "openflow:";
  76
  77     public final static String MD_SAL_TYPE = "MD_SAL_DEPRECATED";
  78
  79     private final static Class<Node> NODE_CLASS = Node.class;
  80
  81     private final static Class<NodeConnector> NODECONNECTOR_CLASS = NodeConnector.class;
  82
  83     private NodeMapping() {
  84         throw new UnsupportedOperationException("Utility class. Instantiation is not allowed.");
  85     }
  86
  87     public static org.opendaylight.controller.sal.core.Node toADNode(final InstanceIdentifier<? extends Object> node) throws ConstructionException {
  88         NodeId nodeId = NodeMapping.toNodeId(node);
  89         return NodeMapping.toADNode(nodeId);
  90     }
  91
  92     public static org.opendaylight.controller.sal.core.Node toADNode(final NodeId id) throws ConstructionException {
  93         Long aDNodeId = openflowFullNodeIdToLong(NodeMapping.toADNodeId(id));
  94         return new org.opendaylight.controller.sal.core.Node(NodeIDType.OPENFLOW, aDNodeId);
  95     }
  96
  97     /**
  98      * @param adNodeId
  99      * @return nodeId as long
 100      */
 101     @VisibleForTesting
 102     public static Long openflowFullNodeIdToLong(String adNodeId) {
 103         if (adNodeId == null) {
 104             return null;
 105         }
 106         return new BigInteger(adNodeId.replaceFirst("^.*:", "")).longValue();
 107     }
 108
 109     public static NodeId toNodeId(final InstanceIdentifier<?> id) {
 110         final NodeKey key = id.firstKeyOf(Node.class, NodeKey.class);
 111         Preconditions.checkArgument(key != null, "No node identifier found in %s", id);
 112         return key.getId();
 113     }
 114
 115     /**
 116      * @param nodeId containing "&lt;NodeTypeString&gt;:&lt;plainIntegerId&gt;"
 117      * @return adNodeId form
 118      */
 119     public static String toADNodeId(final NodeId nodeId) {
 120         if (nodeId == null) {
 121             return null;
 122         }
 123         return nodeId.getValue();
 124     }
 125
 126     public static org.opendaylight.controller.sal.core.NodeConnector toADNodeConnector(final NodeConnectorRef source) throws ConstructionException {
 127         final InstanceIdentifier<?> id = Preconditions.checkNotNull(source.getValue());
 128         final NodeConnectorKey key = id.firstKeyOf(NodeConnector.class, NodeConnectorKey.class);
 129         return NodeMapping.toADNodeConnector(key.getId(), NodeMapping.toNodeId(id));
 130     }
 131
 132     public static org.opendaylight.controller.sal.core.NodeConnector toADNodeConnector(final NodeConnectorId ncid, final NodeId nid) throws ConstructionException {
 133         String nodeConnectorType = NodeMapping.toNodeConnectorType(ncid, nid);
 134         Object aDNodeConnectorId = NodeMapping.toADNodeConnectorId(ncid, nid);
 135         org.opendaylight.controller.sal.core.Node aDNode = NodeMapping.toADNode(nid);
 136         return new org.opendaylight.controller.sal.core.NodeConnector(nodeConnectorType, aDNodeConnectorId, aDNode);
 137     }
 138
 139     /**
 140      * @param ncid nodeConnector identifier, e.g.: OF:21 or CTRL
 141      * @param node
 142      * @return nodeConnector attached to given node
 143      * @throws ConstructionException
 144      */
 145     public static org.opendaylight.controller.sal.core.NodeConnector toADNodeConnector(
 146             final NodeConnectorId ncid, final org.opendaylight.controller.sal.core.Node aDNode) throws ConstructionException {
 147         NodeId nid = NodeMapping.toNodeId(aDNode);
 148         String nodeConnectorType = NodeMapping.toNodeConnectorType(ncid, nid);
 149         Object aDNodeConnectorId = NodeMapping.toADNodeConnectorId(ncid, nid);
 150         return new org.opendaylight.controller.sal.core.NodeConnector(nodeConnectorType, aDNodeConnectorId, aDNode);
 151     }
 152
 153     /**
 154      * @param aDNode
 155      * @return
 156      */
 157     private static NodeId toNodeId(org.opendaylight.controller.sal.core.Node aDNode) {
 158         return new NodeId(aDNode.getType() + ":" +String.valueOf(aDNode.getID()));
 159     }
 160
 161     public static String toNodeConnectorType(final NodeConnectorId ncId, final NodeId nodeId) {
 162         if (ncId.equals(toLocalNodeConnectorId(nodeId))) {
 163             return NodeConnectorIDType.SWSTACK;
 164         } else if (ncId.equals(toNormalNodeConnectorId(nodeId))) {
 165             return NodeConnectorIDType.HWPATH;
 166         } else if (ncId.equals(toControllerNodeConnectorId(nodeId))) {
 167             return NodeConnectorIDType.CONTROLLER;
 168         }
 169         return NodeConnectorIDType.OPENFLOW;
 170     }
 171
 172     public static Object toADNodeConnectorId(final NodeConnectorId nodeConnectorId, final NodeId nodeId) {
 173         if (nodeConnectorId.equals(toLocalNodeConnectorId(nodeId)) ||
 174                 nodeConnectorId.equals(toNormalNodeConnectorId(nodeId)) ||
 175                 nodeConnectorId.equals(toControllerNodeConnectorId(nodeId))) {
 176             return org.opendaylight.controller.sal.core.NodeConnector.SPECIALNODECONNECTORID;
 177         }
 178
 179         String nodeConnectorIdStripped = nodeConnectorId.getValue().replaceFirst("^.*:", "");
 180         if (nodeConnectorIdStripped.matches("[0-9]+")) {
 181             Short nodeConnectorIdVal = null;
 182             try {
 183                 nodeConnectorIdVal = Short.valueOf(nodeConnectorIdStripped);
 184             } catch (NumberFormatException e) {
 185                 LOG.warn("nodeConnectorId not supported (short): {}", nodeConnectorIdStripped, e);
 186             }
 187             return nodeConnectorIdVal;
 188         }
 189         return nodeConnectorIdStripped;
 190     }
 191
 192     public static NodeId toAdNodeId(final NodeConnectorId nodeConnectorId) {
 193         NodeId nodeId = null;
 194         if (nodeConnectorId != null) {
 195             nodeId = new NodeId(nodeConnectorId.getValue().replaceFirst(":[0-9]+$", ""));
 196         }
 197         return nodeId;
 198     }
 199
 200     public static NodeConnectorId toControllerNodeConnectorId(final NodeId node) {
 201         return new NodeConnectorId(node.getValue() + ":" + OutputPortValues.CONTROLLER.toString());
 202     }
 203
 204     public static NodeConnectorId toLocalNodeConnectorId(final NodeId node) {
 205         return new NodeConnectorId(node.getValue() + ":" + OutputPortValues.LOCAL.toString());
 206     }
 207
 208     public static NodeConnectorId toNormalNodeConnectorId(final NodeId node) {
 209         return new NodeConnectorId(node.getValue() + ":" + OutputPortValues.NORMAL.toString());
 210     }
 211
 212     public static NodeRef toNodeRef(final org.opendaylight.controller.sal.core.Node node) {
 213         Preconditions.checkArgument(NodeIDType.OPENFLOW.equals(node.getType()));
 214         final Long nodeId = Arguments.<Long>checkInstanceOf(node.getID(), Long.class);
 215         final NodeKey nodeKey = new NodeKey(new NodeId(OPENFLOW_ID_PREFIX+nodeId));
 216         final InstanceIdentifier<Node> nodePath = InstanceIdentifier.builder(Nodes.class).child(NODE_CLASS, nodeKey).toInstance();
 217         return new NodeRef(nodePath);
 218     }
 219
 220     public static NodeConnectorRef toNodeConnectorRef(final org.opendaylight.controller.sal.core.NodeConnector nodeConnector) {
 221
 222         final NodeRef node = NodeMapping.toNodeRef(nodeConnector.getNode());
 223         @SuppressWarnings("unchecked")
 224         final InstanceIdentifier<Node> nodePath = ((InstanceIdentifier<Node>) node.getValue());
 225         NodeConnectorId nodeConnectorId = null;
 226
 227         if (nodeConnector.getID().equals(org.opendaylight.controller.sal.core.NodeConnector.SPECIALNODECONNECTORID)) {
 228             final NodeId nodeId = toNodeId(nodePath);
 229             final String nodeConnectorType = nodeConnector.getType();
 230             if (nodeConnectorType.equals(NodeConnectorIDType.SWSTACK)) {
 231                 nodeConnectorId = toLocalNodeConnectorId(nodeId);
 232             } else if (nodeConnectorType.equals(NodeConnectorIDType.HWPATH)) {
 233                 nodeConnectorId = toNormalNodeConnectorId(nodeId);
 234             } else if (nodeConnectorType.equals(NodeConnectorIDType.CONTROLLER)) {
 235                 nodeConnectorId = toControllerNodeConnectorId(nodeId);
 236             }
 237         } else {
 238             nodeConnectorId = new NodeConnectorId(OPENFLOW_ID_PREFIX
 239                     + Arguments.<Short>checkInstanceOf(nodeConnector.getID(), Short.class));
 240         }
 241         final NodeConnectorKey connectorKey = new NodeConnectorKey(nodeConnectorId);
 242         final InstanceIdentifier<NodeConnector> path = nodePath.child(NODECONNECTOR_CLASS, connectorKey);
 243         return new NodeConnectorRef(path);
 244     }
 245
 246     public static org.opendaylight.controller.sal.core.Node toADNode(final NodeRef node) throws ConstructionException {
 247         return NodeMapping.toADNode(node.getValue());
 248     }
 249
 250     public static HashSet<Property> toADNodeConnectorProperties(final NodeConnectorUpdated nc) {
 251         final FlowCapableNodeConnectorUpdated fcncu = nc.<FlowCapableNodeConnectorUpdated>getAugmentation(FlowCapableNodeConnectorUpdated.class);
 252         if (!Objects.equal(fcncu, null)) {
 253             HashSet<Property> adNodeConnectorProperties = NodeMapping.toADNodeConnectorProperties(fcncu);
 254             return adNodeConnectorProperties;
 255         }
 256         return new HashSet<Property>();
 257     }
 258
 259     /**
 260      * @param id
 261      * @return node description in AD form, e.g.: OF|00:00:00:...:01
 262      */
 263     private static Description toADDescription(NodeRef nodeRef) {
 264         Description desc;
 265         try {
 266             desc = new Description(toADNode(nodeRef).toString());
 267         } catch (ConstructionException e) {
 268             desc = new Description("none");
 269             LOG.warn("node description extraction failed: {}", nodeRef);
 270         }
 271         return desc;
 272     }
 273
 274     public static HashSet<Property> toADNodeConnectorProperties(final NodeConnector nc) {
 275         final FlowCapableNodeConnector fcnc = nc.<FlowCapableNodeConnector>getAugmentation(FlowCapableNodeConnector.class);
 276         if (!Objects.equal(fcnc, null)) {
 277             return NodeMapping.toADNodeConnectorProperties(fcnc);
 278         }
 279         return new HashSet<Property>();
 280     }
 281
 282     public static HashSet<Property> toADNodeConnectorProperties(final FlowNodeConnector fcncu) {
 283
 284         final HashSet<org.opendaylight.controller.sal.core.Property> props = new HashSet<>();
 285         if (fcncu != null) {
 286             if (fcncu.getCurrentFeature() != null && toAdBandwidth(fcncu.getCurrentFeature()) != null) {
 287                 props.add(toAdBandwidth(fcncu.getCurrentFeature()));
 288             }
 289             if (fcncu.getAdvertisedFeatures() != null && toAdAdvertizedBandwidth(fcncu.getAdvertisedFeatures()) != null) {
 290                 props.add(toAdAdvertizedBandwidth(fcncu.getAdvertisedFeatures()));
 291             }
 292             if (fcncu.getSupported() != null && toAdSupportedBandwidth(fcncu.getSupported()) != null) {
 293                 props.add(toAdSupportedBandwidth(fcncu.getSupported()));
 294             }
 295             if (fcncu.getPeerFeatures() != null && toAdPeerBandwidth(fcncu.getPeerFeatures()) != null) {
 296                 props.add(toAdPeerBandwidth(fcncu.getPeerFeatures()));
 297             }
 298             if (fcncu.getName() != null && toAdName(fcncu.getName()) != null) {
 299                 props.add(toAdName(fcncu.getName()));
 300             }
 301             if (fcncu.getConfiguration() != null && toAdConfig(fcncu.getConfiguration()) != null) {
 302                 props.add(toAdConfig(fcncu.getConfiguration()));
 303             }
 304             if (fcncu.getState() != null && toAdState(fcncu.getState()) != null) {
 305                 props.add(toAdState(fcncu.getState()));
 306             }
 307         }
 308         return props;
 309     }
 310
 311     public static Name toAdName(final String name) {
 312         return new Name(name);
 313     }
 314
 315     public static Config toAdConfig(final PortConfig pc) {
 316         Config config = null;
 317         if (pc.isPORTDOWN()) {
 318             config = new Config(Config.ADMIN_DOWN);
 319         } else {
 320             config = new Config(Config.ADMIN_UP);
 321         }
 322         return config;
 323     }
 324
 325     public static org.opendaylight.controller.sal.core.State toAdState(final State s) {
 326
 327         org.opendaylight.controller.sal.core.State state = null;
 328         if (s.isLinkDown()) {
 329             state = new org.opendaylight.controller.sal.core.State(org.opendaylight.controller.sal.core.State.EDGE_DOWN);
 330         } else {
 331             state = new org.opendaylight.controller.sal.core.State(org.opendaylight.controller.sal.core.State.EDGE_UP);
 332         }
 333         return state;
 334     }
 335
 336     public static Bandwidth toAdBandwidth(final PortFeatures pf) {
 337         Bandwidth bw = null;
 338         if (pf.isTenMbHd() || pf.isTenMbFd()) {
 339             bw = new Bandwidth(Bandwidth.BW10Mbps);
 340         } else if (pf.isHundredMbHd() || pf.isHundredMbFd()) {
 341             bw = new Bandwidth(Bandwidth.BW100Mbps);
 342         } else if (pf.isOneGbHd() || pf.isOneGbFd()) {
 343             bw = new Bandwidth(Bandwidth.BW1Gbps);
 344         } else if (pf.isOneGbFd()) {
 345             bw = new Bandwidth(Bandwidth.BW10Gbps);
 346         } else if (pf.isTenGbFd()) {
 347             bw = new Bandwidth(Bandwidth.BW10Gbps);
 348         } else if (pf.isFortyGbFd()) {
 349             bw = new Bandwidth(Bandwidth.BW40Gbps);
 350         } else if (pf.isHundredGbFd()) {
 351             bw = new Bandwidth(Bandwidth.BW100Gbps);
 352         } else if (pf.isOneTbFd()) {
 353             bw = new Bandwidth(Bandwidth.BW1Tbps);
 354         }
 355         return bw;
 356     }
 357
 358     public static AdvertisedBandwidth toAdAdvertizedBandwidth(final PortFeatures pf) {
 359         AdvertisedBandwidth abw = null;
 360         final Bandwidth bw = toAdBandwidth(pf);
 361         if (bw != null) {
 362             abw = new AdvertisedBandwidth(bw.getValue());
 363         }
 364         return abw;
 365     }
 366
 367     public static SupportedBandwidth toAdSupportedBandwidth(final PortFeatures pf) {
 368         SupportedBandwidth sbw = null;
 369         final Bandwidth bw = toAdBandwidth(pf);
 370         if (bw != null) {
 371             sbw = new SupportedBandwidth(bw.getValue());
 372         }
 373         return sbw;
 374     }
 375
 376     public static PeerBandwidth toAdPeerBandwidth(final PortFeatures pf) {
 377         PeerBandwidth pbw = null;
 378         final Bandwidth bw = toAdBandwidth(pf);
 379         if (bw != null) {
 380             pbw = new PeerBandwidth(bw.getValue());
 381         }
 382         return pbw;
 383     }
 384
 385     public static HashSet<Property> toADNodeProperties(final NodeUpdated nu) {
 386         final FlowCapableNodeUpdated fcnu = nu.getAugmentation(FlowCapableNodeUpdated.class);
 387         if (fcnu != null) {
 388             HashSet<Property> adNodeProperties = toADNodeProperties(fcnu, nu.getId());
 389             adNodeProperties.add(toADDescription(nu.getNodeRef()));
 390             return adNodeProperties;
 391         }
 392         return new HashSet<org.opendaylight.controller.sal.core.Property>();
 393     }
 394
 395     public static HashSet<Property> toADNodeProperties(final FlowNode fcnu, final NodeId id) {
 396
 397         final HashSet<org.opendaylight.controller.sal.core.Property> props = new HashSet<>();
 398
 399         if (fcnu != null) {
 400             props.add(toADTimestamp());
 401
 402             // props.add(fcnu.supportedActions.toADActions) - TODO
 403             if (id != null) {
 404                 props.add(toADMacAddress(id));
 405             }
 406             SwitchFeatures switchFeatures = fcnu.getSwitchFeatures();
 407             if (switchFeatures != null) {
 408                 if (switchFeatures.getMaxTables() != null) {
 409                     props.add(toADTables(switchFeatures.getMaxTables()));
 410                 }
 411                 if (switchFeatures.getCapabilities() != null) {
 412                     props.add(toADCapabiliities(switchFeatures.getCapabilities()));
 413                 }
 414                 if (switchFeatures.getMaxBuffers() != null) {
 415                     props.add(toADBuffers(switchFeatures.getMaxBuffers()));
 416                 }
 417             }
 418         }
 419         return props;
 420     }
 421
 422     public static TimeStamp toADTimestamp() {
 423         final Date date = new Date();
 424         final TimeStamp timestamp = new TimeStamp(date.getTime(), "connectedSince");
 425         return timestamp;
 426     }
 427
 428     public static MacAddress toADMacAddress(final NodeId id) {
 429         final String nodeId = id.getValue().replaceAll(OPENFLOW_ID_PREFIX, "");
 430         BigInteger nodeIdRaw = new BigInteger(nodeId);
 431         long lNodeId = nodeIdRaw.longValue();
 432         byte[] bytesFromDpid = ToSalConversionsUtils.bytesFromDpid(lNodeId);
 433         return new MacAddress(bytesFromDpid);
 434     }
 435
 436     public static Tables toADTables(final Short tables) {
 437         return new Tables(tables.byteValue());
 438     }
 439
 440     public static Capabilities toADCapabiliities(final List<Class<? extends FeatureCapability>> capabilities) {
 441
 442         int b = 0;
 443         for (Class<? extends FeatureCapability> capability : capabilities) {
 444             if (capability.equals(FlowFeatureCapabilityFlowStats.class)) {
 445                 b = Capabilities.CapabilitiesType.FLOW_STATS_CAPABILITY.getValue() | b;
 446             } else if (capability.equals(FlowFeatureCapabilityTableStats.class)) {
 447                 b = Capabilities.CapabilitiesType.TABLE_STATS_CAPABILITY.getValue() | b;
 448             } else if (capability.equals(FlowFeatureCapabilityPortStats.class)) {
 449                 b = Capabilities.CapabilitiesType.PORT_STATS_CAPABILITY.getValue() | b;
 450             } else if (capability.equals(FlowFeatureCapabilityStp.class)) {
 451                 b = Capabilities.CapabilitiesType.STP_CAPABILITY.getValue() | b;
 452             } else if (capability.equals(FlowFeatureCapabilityIpReasm.class)) {
 453                 b = Capabilities.CapabilitiesType.IP_REASSEM_CAPABILITY.getValue() | b;
 454             } else if (capability.equals(FlowFeatureCapabilityQueueStats.class)) {
 455                 b = Capabilities.CapabilitiesType.QUEUE_STATS_CAPABILITY.getValue() | b;
 456             } else if (capability.equals(FlowFeatureCapabilityArpMatchIp.class)) {
 457                 b = Capabilities.CapabilitiesType.ARP_MATCH_IP_CAPABILITY.getValue() | b;
 458             }
 459         }
 460         return new Capabilities(b);
 461     }
 462
 463     public static Buffers toADBuffers(final Long buffers) {
 464         return new Buffers(buffers.intValue());
 465     }
 466 }