com.activitystream.model.utils.ElementTraversal Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of as-sdk Show documentation
AS-SDK is a java library to allow easy interoperability with Activity Stream.
There is a newer version: 0.1.25
package com.activitystream.model.utils;

import com.activitystream.model.interfaces.LinkedElement;
import com.activitystream.model.entities.BusinessEntity;
import com.activitystream.model.entities.EntityReference;
import com.activitystream.model.relations.Relation;

import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Predicate;

public class ElementTraversal {

    private final LinkedElement root;

    public ElementTraversal(LinkedElement root) {
        this.root = root;
    }

    public void forEachElement(Consumer action) {
        traverse(t -> {
            action.accept(t);
            return true;
        });
    }

    public void forEachEntityReference(Consumer action) {
        traverse(element -> {
            element.onEachEntityReference(action);
            return true;
        });
    }

    public boolean anyAnyEntityReferencesMatch(Predicate predicate) {
        boolean[] result = new boolean[]{false};
        traverse(element -> {
            element.onEachEntityReference(reference -> {
                if (predicate.test(reference))
                    result[0] = true;
            });
            return !result[0];
        });
        return result[0];
    }

    public void forEachBusinessEntity(Consumer action) {
        traverse(element -> {
            if (element instanceof BusinessEntity)
                action.accept((BusinessEntity) element);
            return true;
        });
    }

    public boolean allBusinessEntitiesMatch(Predicate predicate) {
        boolean[] result = new boolean[]{true};
        traverse(element -> {
            if (element instanceof BusinessEntity && !predicate.test((BusinessEntity) element)) {
                result[0] = false;
                return false;
            }
            return true;
        });
        return result[0];
    }

    public void forEachRelationType(LinkedElement.StreamItemRelationTypeConsumer action) {
        traverse(element -> {
            element.onEachRelationType(action);
            return true;
        });
    }

    public void forEachEntityRelation(Consumer action) {
        traverse(element -> {
            element.onEachEntityRelation(action);
            return true;
        });
    }

    public boolean anyEntityRelationsMatch(Predicate predicate) {
        boolean[] result = new boolean[]{false};
        traverse(element -> {
            element.onEachEntityRelation(relation -> {
                if (predicate.test(relation))
                    result[0] = true;
            });
            return !result[0];
        });
        return result[0];
    }

    public Optional findFirstEntityRelation(Predicate predicate) {
        Relation[] result = new Relation[]{null};
        traverse(element -> {
            element.onEachEntityRelation(relation -> {
                if (result[0] == null && predicate.test(relation))
                    result[0] = relation;
            });
            return result[0] == null;
        });
        return Optional.ofNullable(result[0]);
    }

    private void traverse(LinkedElement.ElementVisitor visitor) {
        root.traverse(visitor);
    }
}