Java Link.Type方法代码示例

import org.onosproject.net.Link; //导入方法依赖的package包/类
/**
 * Translates gRPC message to corresponding ONOS object.
 *
 * @param type gRPC message enum
 * @return {@link org.onosproject.net.Link.Type Link.Type}
 */
private Link.Type translate(LinkType type) {
    switch (type) {
    case DIRECT:
        return Link.Type.DIRECT;
    case EDGE:
        return Link.Type.EDGE;
    case INDIRECT:
        return Link.Type.INDIRECT;
    case OPTICAL:
        return Link.Type.INDIRECT;
    case TUNNEL:
        return Link.Type.TUNNEL;
    case VIRTUAL:
        return Link.Type.VIRTUAL;

    case UNRECOGNIZED:
    default:
        return Link.Type.DIRECT;
    }
}
 

import org.onosproject.net.Link; //导入方法依赖的package包/类
/**
 * Generates a LinkDescription containing fields from a LinkDescription and
 * a LinkConfig.
 *
 * @param cfg the link config entity from network config
 * @param descr a LinkDescription
 * @return LinkDescription based on both sources
 */
public static LinkDescription combine(BasicLinkConfig cfg, LinkDescription descr) {
    if (cfg == null) {
        return descr;
    }

    // cfg.type() defaults to DIRECT, so there is a risk of unwanted override.
    // do we want this behavior?
    Link.Type type = descr.type();
    if (cfg.type() != type) {
        type = cfg.type();
    }

    SparseAnnotations sa = combine(cfg, descr.annotations());
    return new DefaultLinkDescription(descr.src(), descr.dst(), type, sa);
}
 

import org.onosproject.net.Link; //导入方法依赖的package包/类
/**
 * Decodes a link type constraint.
 *
 * @return link type constraint object.
 */
private Constraint decodeLinkTypeConstraint() {
    boolean inclusive = nullIsIllegal(json.get(ConstraintCodec.INCLUSIVE),
            ConstraintCodec.INCLUSIVE + ConstraintCodec.MISSING_MEMBER_MESSAGE).asBoolean();

    JsonNode types = nullIsIllegal(json.get(ConstraintCodec.TYPES),
            ConstraintCodec.TYPES + ConstraintCodec.MISSING_MEMBER_MESSAGE);
    if (types.size() < 1) {
        throw new IllegalArgumentException(
                "types array in link constraint must have at least one value");
    }

    ArrayList<Link.Type> typesEntries = new ArrayList<>(types.size());
    IntStream.range(0, types.size())
            .forEach(index ->
                    typesEntries.add(Link.Type.valueOf(types.get(index).asText())));

    return new LinkTypeConstraint(inclusive,
            typesEntries.toArray(new Link.Type[types.size()]));
}
 

import org.onosproject.net.Link; //导入方法依赖的package包/类
/**
 * Encodes a link type constraint.
 *
 * @return JSON ObjectNode representing the constraint
 */
private ObjectNode encodeLinkTypeConstraint() {
    checkNotNull(constraint, "Link type constraint cannot be null");

    final LinkTypeConstraint linkTypeConstraint =
            (LinkTypeConstraint) constraint;

    final ObjectNode result = context.mapper().createObjectNode()
            .put(ConstraintCodec.INCLUSIVE, linkTypeConstraint.isInclusive());

    final ArrayNode jsonTypes = result.putArray(ConstraintCodec.TYPES);

    if (linkTypeConstraint.types() != null) {
        for (Link.Type type : linkTypeConstraint.types()) {
            jsonTypes.add(type.name());
        }
    }

    return result;
}
 

import org.onosproject.net.Link; //导入方法依赖的package包/类
/**
 * Matches a link type constraint against a JSON representation of the
 * constraint.
 *
 * @param linkTypeConstraint constraint object to match
 * @param constraintJson JSON representation of the constraint
 * @return true if the constraint and JSON match, false otherwise.
 */
private boolean matchLinkTypeConstraint(LinkTypeConstraint linkTypeConstraint,
                                        JsonNode constraintJson) {
    final JsonNode inclusiveJson = constraintJson.get("inclusive");
    final JsonNode typesJson = constraintJson.get("types");

    if (typesJson.size() != linkTypeConstraint.types().size()) {
        return false;
    }

    int foundType = 0;
    for (Link.Type type : linkTypeConstraint.types()) {
        for (int jsonIndex = 0; jsonIndex < typesJson.size(); jsonIndex++) {
            if (type.name().equals(typesJson.get(jsonIndex).asText())) {
                foundType++;
                break;
            }
        }
    }
    return (inclusiveJson != null &&
            inclusiveJson.asBoolean() == linkTypeConstraint.isInclusive()) &&
            foundType == typesJson.size();
}
 

import org.onosproject.net.Link; //导入方法依赖的package包/类
/**
 * Creates a link description using the supplied information.
 *
 * @param src         link source
 * @param dst         link destination
 * @param type        link type
 * @param isExpected  is the link expected to be part of this configuration
 * @param annotations optional key/value annotations
 */
public DefaultLinkDescription(ConnectPoint src, ConnectPoint dst,
                              Link.Type type,
                              boolean isExpected,
                              SparseAnnotations... annotations) {
    super(annotations);
    this.src = src;
    this.dst = dst;
    this.type = type;
    this.isExpected = isExpected;
}
 

import org.onosproject.net.Link; //导入方法依赖的package包/类
private Link addLink(DeviceId sd, PortNumber sp, DeviceId dd, PortNumber dp,
                     Link.Type type) {
    providerService.linkDetected(new DefaultLinkDescription(cp(sd, sp), cp(dd, dp), type));
    Link link = listener.events.get(0).subject();
    validateEvents(LINK_ADDED);
    return link;
}
 

import org.onosproject.net.Link; //导入方法依赖的package包/类
@Override
public Link.Type type() {
    return type;
}
 

import org.onosproject.net.Link; //导入方法依赖的package包/类
/**
 * Creates a new constraint for requesting connectivity using or avoiding
 * the specified link types.
 *
 * @param inclusive indicates whether the given link types are to be
 *                  permitted or avoided
 * @param types     link types
 */
public LinkTypeConstraint(boolean inclusive, Link.Type... types) {
    checkNotNull(types, "Link types cannot be null");
    checkArgument(types.length > 0, "There must be more than one type");
    this.types = ImmutableSet.copyOf(types);
    this.isInclusive = inclusive;
}
 

import org.onosproject.net.Link; //导入方法依赖的package包/类
/**
 * Returns the link type.
 *
 * @return link type
 */
Link.Type type();
 

import org.onosproject.net.Link; //导入方法依赖的package包/类
/**
 * Returns the set of link types.
 *
 * @return set of link types
 */
public Set<Link.Type> types() {
    return types;
}
 

import org.onosproject.net.Link; //导入方法依赖的package包/类
/**
 * Returns the link type.
 *
 * @return link type override
 */
public Link.Type type() {
    return get(TYPE, Link.Type.DIRECT, Link.Type.class);
}