Java PropertyState.equals方法代码示例

import org.apache.jackrabbit.oak.api.PropertyState; //导入方法依赖的package包/类
/**
 * Determine whether this node state is modified wrt. the passed
 * {@code before} state.
 * <p>
 * A node state is modified if it either has not the same properties
 * or has not the same child nodes as a {@code before} state. A node
 * state has the same properties as a {@code before} state iff its
 * set of properties is equal to the set of properties of
 * {@code before}. A node state has the same child nodes as a
 * {@code before} state iff its set of child node names is equal to
 * the set of child node names of {@code before}.
 */
boolean isModified(NodeState before) {
    if (!exists()) {
        return false;
    } else if (nodes.isEmpty() && properties.isEmpty()) {
        return EqualsDiff.modified(before, base);
    }

    // was a child node added or removed?
    for (Entry<String, MutableNodeState> n : nodes.entrySet()) {
        if (n.getValue().exists() != before.hasChildNode(n.getKey())) {
            return true;
        }
    }

    // was a property added, removed or modified
    for (Entry<String, PropertyState> p : properties.entrySet()) {
        PropertyState pState = p.getValue();
        if (pState == null
                || !pState.equals(before.getProperty(p.getKey()))) {
            return true;
        }
    }

    return false;
}
 

import org.apache.jackrabbit.oak.api.PropertyState; //导入方法依赖的package包/类
@Override
public boolean propertyAdded(PropertyState after) {
    PropertyState other = builder.getProperty(after.getName());
    if (other == null) {
        builder.setProperty(after);
    } else if (!other.equals(after)) {
        addExistingProperty(builder, other, after);
    }
    return true;
}
 

import org.apache.jackrabbit.oak.api.PropertyState; //导入方法依赖的package包/类
@Override
public boolean propertyChanged(PropertyState before, PropertyState after) {
    PropertyState other = builder.getProperty(before.getName());
    if (other == null) {
        changeDeletedProperty(builder, after);
    } else if (other.equals(before)) {
        builder.setProperty(after);
    } else if (!other.equals(after)) {
        changeChangedProperty(builder, before, after);
    }
    return true;
}
 

import org.apache.jackrabbit.oak.api.PropertyState; //导入方法依赖的package包/类
@Override
public boolean propertyDeleted(PropertyState before) {
    PropertyState other = builder.getProperty(before.getName());
    if (other == null) {
        deleteDeletedProperty(builder, before);
    } else if (other.equals(before)) {
        builder.removeProperty(before.getName());
    } else {
        deleteChangedProperty(builder, before);
    }
    return true;
}
 

import org.apache.jackrabbit.oak.api.PropertyState; //导入方法依赖的package包/类
private static boolean compareProperties(
        PropertyState before, PropertyState after, NodeStateDiff diff) {
    if (before == null) {
        return after == null || diff.propertyAdded(after);
    } else if (after == null) {
        return diff.propertyDeleted(before);
    } else {
        return before.equals(after) || diff.propertyChanged(before, after);
    }
}
 

import org.apache.jackrabbit.oak.api.PropertyState; //导入方法依赖的package包/类
@Override
public boolean propertyChanged(PropertyState before, PropertyState after) {
    PropertyState other = builder.getProperty(before.getName());
    if (other != null && other.equals(before)) {
        builder.setProperty(after);
    }
    return true;
}
 

import org.apache.jackrabbit.oak.api.PropertyState; //导入方法依赖的package包/类
@Override
public boolean propertyDeleted(PropertyState before) {
    PropertyState other = builder.getProperty(before.getName());
    if (other != null && other.equals(before)) {
        builder.removeProperty(before.getName());
    }
    return true;
}
 

import org.apache.jackrabbit.oak.api.PropertyState; //导入方法依赖的package包/类
public static boolean equals(NodeState a, NodeState b) {
    if (a.exists() != b.exists()
            || a.getPropertyCount() != b.getPropertyCount()) {
        return false; // shortcut
    }

    // if one of the objects has few entries,
    // then compare the number of entries with the other one
    long max = 20;
    long c1 = a.getChildNodeCount(max);
    long c2 = b.getChildNodeCount(max);
    if (c1 <= max || c2 <= max) {
        // one has less than max entries
        if (c1 != c2) {
            return false;
        }
    } else if (c1 != Long.MAX_VALUE && c2 != Long.MAX_VALUE) {
        // we know the exact number for both
        if (c1 != c2) {
            return false;
        }
    }

    for (PropertyState property : a.getProperties()) {
        if (!property.equals(b.getProperty(property.getName()))) {
            return false;
        }
    }

    // TODO inefficient unless there are very few child nodes

    // compare the exact child node count
    // (before, we only compared up to 20 entries)
    c1 = a.getChildNodeCount(Long.MAX_VALUE);
    c2 = b.getChildNodeCount(Long.MAX_VALUE);
    if (c1 != c2) {
        return false;
    }

    // compare all child nodes recursively (this is potentially very slow,
    // as it recursively calls equals)
    for (ChildNodeEntry entry : a.getChildNodeEntries()) {
        if (!entry.getNodeState().equals(b.getChildNode(entry.getName()))) {
            return false;
        }
    }

    return true;
}
 

import org.apache.jackrabbit.oak.api.PropertyState; //导入方法依赖的package包/类
public boolean compare(RecordId thisId, RecordId thatId) {
    checkNotNull(thisId);
    checkNotNull(thatId);

    // Compare properties
    for (int i = 0; i < properties.length; i++) {
        PropertyState thisProperty = getProperty(thisId, i);
        PropertyState thatProperty = getProperty(thatId, i);
        if (!thisProperty.equals(thatProperty)) {
            return false;
        }
    }

    // Compare child nodes
    if (childName == ZERO_CHILD_NODES) {
        return true;
    } else if (childName != MANY_CHILD_NODES) {
        NodeState thisChild = getChildNode(childName, thisId);
        NodeState thatChild = getChildNode(childName, thatId);
        return thisChild.equals(thatChild);
    } else {
        // TODO: Leverage the HAMT data structure for the comparison
        MapRecord thisMap = getChildNodeMap(thisId);
        MapRecord thatMap = getChildNodeMap(thatId);
        if (fastEquals(thisMap, thatMap)) {
            return true; // shortcut
        } else if (thisMap.size() != thatMap.size()) {
            return false; // shortcut
        } else {
            // TODO: can this be optimized?
            for (MapEntry entry : thisMap.getEntries()) {
                String name = entry.getName();
                MapEntry thatEntry = thatMap.getEntry(name);
                if (thatEntry == null) {
                    return false;
                } else if (!entry.getNodeState().equals(thatEntry.getNodeState())) {
                    return false;
                }
            }
            return true;
        }
    }
}