Java DataObjectModification.ModificationType方法代码示例

import org.opendaylight.controller.md.sal.binding.api.DataObjectModification; //导入方法依赖的package包/类
@Override
public DataObjectModification.ModificationType getModificationType() {
    switch(domData.getModificationType()) {
        case WRITE:
            return DataObjectModification.ModificationType.WRITE;
        case APPEARED:
        case SUBTREE_MODIFIED:
            return DataObjectModification.ModificationType.SUBTREE_MODIFIED;
        case DISAPPEARED:
        case DELETE:
            return DataObjectModification.ModificationType.DELETE;
        default:
            // TODO: Should we lie about modification type instead of exception?
            throw new IllegalStateException("Unsupported DOM Modification type " + domData.getModificationType());
    }
}
 

import org.opendaylight.controller.md.sal.binding.api.DataObjectModification; //导入方法依赖的package包/类
/**
 * Only when Subtree modification happen this is called .
 * @param key - IID of child data
 * @param parentModification - Modified data
 * @param updatedMacsGrouped - Subtree updated data
 * @param deletedMacsGrouped - Subtree deleted datas
 */
private void extractDataChanged(final InstanceIdentifier<P> key,
                                final DataObjectModification<P> parentModification,
                                final Map<G, Map<InstanceIdentifier, C>> updatedMacsGrouped,
                                final Map<G, Map<InstanceIdentifier, C>> deletedMacsGrouped) {

    Map<InstanceIdentifier<C>, DataObjectModification<C>> children = getChildMod(key, parentModification);
    for (Map.Entry<InstanceIdentifier<C>, DataObjectModification<C>> entry : children.entrySet()) {
        DataObjectModification<C> childMod = entry.getValue();
        InstanceIdentifier<C> childIid = entry.getKey();
        DataObjectModification.ModificationType modificationType = getModificationType(childMod);
        G group;
        C dataBefore = childMod.getDataBefore();
        C dataAfter = childMod.getDataAfter();
        switch (modificationType) {
            case WRITE:
            case SUBTREE_MODIFIED:
                group = getGroup(childIid, dataAfter);
                updatedMacsGrouped.computeIfAbsent(group, (grp) -> new ConcurrentHashMap<>());
                updatedMacsGrouped.get(group).put(childIid, dataAfter);
                break;
            case DELETE:
                group = getGroup(childIid, dataBefore);
                deletedMacsGrouped.computeIfAbsent(group, (grp) -> new ConcurrentHashMap<>());
                deletedMacsGrouped.get(group).put(childIid, dataBefore);
                break;
            default:
                break;
        }
    }
}
 

import org.opendaylight.controller.md.sal.binding.api.DataObjectModification; //导入方法依赖的package包/类
protected DataObjectModification.ModificationType getModificationType(
        final DataObjectModification<? extends DataObject> mod) {
    try {
        return mod.getModificationType();
    } catch (IllegalStateException e) {
        //LOG.warn("Failed to get the modification type for mod {}", mod);
    }
    return null;
}
 

import org.opendaylight.controller.md.sal.binding.api.DataObjectModification; //导入方法依赖的package包/类
private DataObjectModification.ModificationType getModificationType(
        DataObjectModification<? extends DataObject> mod) {
    try {
        return mod.getModificationType();
    } catch (IllegalStateException e) {
        //not sure why this getter throws this exception, could be some mdsal bug
        LOG.warn("Failed to get the modification type for mod {}", mod);
    }
    return null;
}
 

import org.opendaylight.controller.md.sal.binding.api.DataObjectModification; //导入方法依赖的package包/类
private void extractDataChanged(final Collection<DataObjectModification<? extends DataObject>> children,
                                final Map<Class<? extends Identifiable>, List<Identifiable>> updatedData,
                                final Map<Class<? extends Identifiable>, List<Identifiable>> deletedData) {
    if (children == null) {
        return;
    }
    for (DataObjectModification<? extends DataObject> child : children) {
        DataObjectModification.ModificationType type = getModificationType(child);
        if (type == null) {
            continue;
        }
        InstanceIdentifier instanceIdentifier = null;
        Class<? extends Identifiable> childClass = (Class<? extends Identifiable>) child.getDataType();
        InstanceIdentifier.PathArgument pathArgument = child.getIdentifier();
        switch (type) {
            case WRITE:
            case SUBTREE_MODIFIED:
                DataObject dataAfter = child.getDataAfter();
                if (!(dataAfter instanceof Identifiable)) {
                    continue;
                }
                DataObject before = child.getDataBefore();
                if (Objects.equals(dataAfter, before)) {
                    /*
                    in cluster reboot scenarios,
                    application rewrites the data tx.put( logicalswitchiid, logicalswitch )
                    that time it fires the update again ignoring such updates here
                     */
                    continue;
                }
                Identifiable identifiable = (Identifiable) dataAfter;
                addToUpdatedData(updatedData, childClass, identifiable);
                break;
            case DELETE:
                DataObject dataBefore = child.getDataBefore();
                if (!(dataBefore instanceof Identifiable)) {
                    continue;
                }
                addToUpdatedData(deletedData, childClass, (Identifiable)dataBefore);
                break;
        }
    }
}