/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.tinkerpop.gremlin.structure.util;
import org.apache.tinkerpop.gremlin.structure.Direction;
import org.apache.tinkerpop.gremlin.structure.Edge;
import org.apache.tinkerpop.gremlin.structure.Element;
import org.apache.tinkerpop.gremlin.structure.Graph;
import org.apache.tinkerpop.gremlin.structure.Property;
import org.apache.tinkerpop.gremlin.structure.T;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.apache.tinkerpop.gremlin.structure.VertexProperty;
import java.util.Iterator;
import java.util.Optional;
import java.util.function.Function;
/**
* An interface that provides methods for detached properties and elements to be re-attached to the {@link Graph}.
* There are two general ways in which they can be attached: {@link Method#get} or {@link Method#create}.
* A {@link Method#get} will find the property/element at the host location and return it.
* A {@link Method#create} will create the property/element at the host location and return it.
*
* @author Marko A. Rodriguez (http://markorodriguez.com)
* @author Stephen Mallette (http://stephen.genoprime.com)
*/
public interface Attachable<V> {
/**
* Get the raw object trying to be attached.
*
* @return the raw object to attach
*/
public V get();
/**
* Provide a way to attach an {@link Attachable} implementation to a host. Note that the context of the host
* is not defined by way of the attachment method itself that is supplied as an argument. It is up to the
* implementer to supply that context.
*
* @param method a {@link Function} that takes an {@link Attachable} and returns the "re-attached" object
* @return the return value of the {@code method}
* @throws IllegalStateException if the {@link Attachable} is not a "graph" object (i.e. host or
* attachable don't work together)
*/
public default V attach(final Function<Attachable<V>, V> method) throws IllegalStateException {
return method.apply(this);
}
/**
* A collection of general methods of attachment. Note that more efficient methods of attachment might exist
* if the user knows the source data being attached and the features of the graph that the data is being
* attached to.
*/
public static class Method {
public static <V> Function<Attachable<V>, V> get(final Host hostVertexOrGraph) {
return (Attachable<V> attachable) -> {
final Object base = attachable.get();
if (base instanceof Vertex) {
final Optional<Vertex> optional = hostVertexOrGraph instanceof Graph ?
Method.getVertex((Attachable<Vertex>) attachable, (Graph) hostVertexOrGraph) :
Method.getVertex((Attachable<Vertex>) attachable, (Vertex) hostVertexOrGraph);
return (V) optional.orElseThrow(() -> hostVertexOrGraph instanceof Graph ?
Attachable.Exceptions.canNotGetAttachableFromHostGraph(attachable, (Graph) hostVertexOrGraph) :
Attachable.Exceptions.canNotGetAttachableFromHostVertex(attachable, (Vertex) hostVertexOrGraph));
} else if (base instanceof Edge) {
final Optional<Edge> optional = hostVertexOrGraph instanceof Graph ?
Method.getEdge((Attachable<Edge>) attachable, (Graph) hostVertexOrGraph) :
Method.getEdge((Attachable<Edge>) attachable, (Vertex) hostVertexOrGraph);
return (V) optional.orElseThrow(() -> hostVertexOrGraph instanceof Graph ?
Attachable.Exceptions.canNotGetAttachableFromHostGraph(attachable, (Graph) hostVertexOrGraph) :
Attachable.Exceptions.canNotGetAttachableFromHostVertex(attachable, (Vertex) hostVertexOrGraph));
} else if (base instanceof VertexProperty) {
final Optional<VertexProperty> optional = hostVertexOrGraph instanceof Graph ?
Method.getVertexProperty((Attachable<VertexProperty>) attachable, (Graph) hostVertexOrGraph) :
Method.getVertexProperty((Attachable<VertexProperty>) attachable, (Vertex) hostVertexOrGraph);
return (V) optional.orElseThrow(() -> hostVertexOrGraph instanceof Graph ?
Attachable.Exceptions.canNotGetAttachableFromHostGraph(attachable, (Graph) hostVertexOrGraph) :
Attachable.Exceptions.canNotGetAttachableFromHostVertex(attachable, (Vertex) hostVertexOrGraph));
} else if (base instanceof Property) {
final Optional<Property> optional = hostVertexOrGraph instanceof Graph ?
Method.getProperty((Attachable<Property>) attachable, (Graph) hostVertexOrGraph) :
Method.getProperty((Attachable<Property>) attachable, (Vertex) hostVertexOrGraph);
return (V) optional.orElseThrow(() -> hostVertexOrGraph instanceof Graph ?
Attachable.Exceptions.canNotGetAttachableFromHostGraph(attachable, (Graph) hostVertexOrGraph) :
Attachable.Exceptions.canNotGetAttachableFromHostVertex(attachable, (Vertex) hostVertexOrGraph));
} else
throw Attachable.Exceptions.providedAttachableMustContainAGraphObject(attachable);
};
}
public static <V> Function<Attachable<V>, V> getOrCreate(final Host hostVertexOrGraph) {
return (Attachable<V> attachable) -> {
final Object base = attachable.get();
if (base instanceof Vertex) {
return (V) (hostVertexOrGraph instanceof Graph ?
Method.getVertex((Attachable<Vertex>) attachable, (Graph) hostVertexOrGraph) :
Method.getVertex((Attachable<Vertex>) attachable, (Vertex) hostVertexOrGraph))
.orElseGet(() -> hostVertexOrGraph instanceof Graph ?
Method.createVertex((Attachable<Vertex>) attachable, (Graph) hostVertexOrGraph) :
Method.createVertex((Attachable<Vertex>) attachable, (Vertex) hostVertexOrGraph));
} else if (base instanceof Edge) {
return (V) (hostVertexOrGraph instanceof Graph ?
Method.getEdge((Attachable<Edge>) attachable, (Graph) hostVertexOrGraph) :
Method.getEdge((Attachable<Edge>) attachable, (Vertex) hostVertexOrGraph))
.orElseGet(() -> hostVertexOrGraph instanceof Graph ?
Method.createEdge((Attachable<Edge>) attachable, (Graph) hostVertexOrGraph) :
Method.createEdge((Attachable<Edge>) attachable, (Vertex) hostVertexOrGraph));
} else if (base instanceof VertexProperty) {
return (V) (hostVertexOrGraph instanceof Graph ?
Method.getVertexProperty((Attachable<VertexProperty>) attachable, (Graph) hostVertexOrGraph) :
Method.getVertexProperty((Attachable<VertexProperty>) attachable, (Vertex) hostVertexOrGraph))
.orElseGet(() -> hostVertexOrGraph instanceof Graph ?
Method.createVertexProperty((Attachable<VertexProperty>) attachable, (Graph) hostVertexOrGraph) :
Method.createVertexProperty((Attachable<VertexProperty>) attachable, (Vertex) hostVertexOrGraph));
} else if (base instanceof Property) {
return (V) (hostVertexOrGraph instanceof Graph ?
Method.getProperty((Attachable<Property>) attachable, (Graph) hostVertexOrGraph) :
Method.getProperty((Attachable<Property>) attachable, (Vertex) hostVertexOrGraph))
.orElseGet(() -> hostVertexOrGraph instanceof Graph ?
Method.createProperty((Attachable<Property>) attachable, (Graph) hostVertexOrGraph) :
Method.createProperty((Attachable<Property>) attachable, (Vertex) hostVertexOrGraph));
} else
throw Attachable.Exceptions.providedAttachableMustContainAGraphObject(attachable);
};
}
public static <V> Function<Attachable<V>, V> create(final Host hostVertexOrGraph) {
return (Attachable<V> attachable) -> {
final Object base = attachable.get();
if (base instanceof Vertex) {
return hostVertexOrGraph instanceof Graph ?
(V) Method.createVertex((Attachable<Vertex>) attachable, (Graph) hostVertexOrGraph) :
(V) Method.createVertex((Attachable<Vertex>) attachable, (Vertex) hostVertexOrGraph);
} else if (base instanceof Edge) {
return hostVertexOrGraph instanceof Graph ?
(V) Method.createEdge((Attachable<Edge>) attachable, (Graph) hostVertexOrGraph) :
(V) Method.createEdge((Attachable<Edge>) attachable, (Vertex) hostVertexOrGraph);
} else if (base instanceof VertexProperty) {
return hostVertexOrGraph instanceof Graph ?
(V) Method.createVertexProperty((Attachable<VertexProperty>) attachable, (Graph) hostVertexOrGraph) :
(V) Method.createVertexProperty((Attachable<VertexProperty>) attachable, (Vertex) hostVertexOrGraph);
} else if (base instanceof Property) {
return hostVertexOrGraph instanceof Graph ?
(V) Method.createProperty((Attachable<Property>) attachable, (Graph) hostVertexOrGraph) :
(V) Method.createProperty((Attachable<Property>) attachable, (Vertex) hostVertexOrGraph);
} else
throw Attachable.Exceptions.providedAttachableMustContainAGraphObject(attachable);
};
}
///////////////////
///// GET HELPER METHODS
public static Optional<Vertex> getVertex(final Attachable<Vertex> attachableVertex, final Graph hostGraph) {
final Iterator<Vertex> vertexIterator = hostGraph.vertices(attachableVertex.get().id());
return vertexIterator.hasNext() ? Optional.of(vertexIterator.next()) : Optional.empty();
}
public static Optional<Vertex> getVertex(final Attachable<Vertex> attachableVertex, final Vertex hostVertex) {
return ElementHelper.areEqual(attachableVertex.get(), hostVertex) ? Optional.of(hostVertex) : Optional.empty();
}
public static Optional<Edge> getEdge(final Attachable<Edge> attachableEdge, final Graph hostGraph) {
final Iterator<Edge> edgeIterator = hostGraph.edges(attachableEdge.get().id());
return edgeIterator.hasNext() ? Optional.of(edgeIterator.next()) : Optional.empty();
}
public static Optional<Edge> getEdge(final Attachable<Edge> attachableEdge, final Vertex hostVertex) {
final Edge baseEdge = attachableEdge.get();
final Iterator<Edge> edgeIterator = hostVertex.edges(Direction.OUT, attachableEdge.get().label());
while (edgeIterator.hasNext()) {
final Edge edge = edgeIterator.next();
if (ElementHelper.areEqual(edge, baseEdge))
return Optional.of(edge);
}
return Optional.empty();
}
public static Optional<VertexProperty> getVertexProperty(final Attachable<VertexProperty> attachableVertexProperty, final Graph hostGraph) {
final VertexProperty baseVertexProperty = attachableVertexProperty.get();
final Iterator<Vertex> vertexIterator = hostGraph.vertices(baseVertexProperty.element().id());
if (vertexIterator.hasNext()) {
final Iterator<VertexProperty<Object>> vertexPropertyIterator = vertexIterator.next().properties(baseVertexProperty.key());
while (vertexPropertyIterator.hasNext()) {
final VertexProperty vertexProperty = vertexPropertyIterator.next();
if (ElementHelper.areEqual(vertexProperty, baseVertexProperty))
return Optional.of(vertexProperty);
}
}
return Optional.empty();
}
public static Optional<VertexProperty> getVertexProperty(final Attachable<VertexProperty> attachableVertexProperty, final Vertex hostVertex) {
final VertexProperty baseVertexProperty = attachableVertexProperty.get();
final Iterator<VertexProperty<Object>> vertexPropertyIterator = hostVertex.properties(baseVertexProperty.key());
while (vertexPropertyIterator.hasNext()) {
final VertexProperty vertexProperty = vertexPropertyIterator.next();
if (ElementHelper.areEqual(vertexProperty, baseVertexProperty))
return Optional.of(vertexProperty);
}
return Optional.empty();
}
public static Optional<Property> getProperty(final Attachable<Property> attachableProperty, final Graph hostGraph) {
final Property baseProperty = attachableProperty.get();
final Element propertyElement = attachableProperty.get().element();
if (propertyElement instanceof Vertex) {
return (Optional) Method.getVertexProperty((Attachable) attachableProperty, hostGraph);
} else if (propertyElement instanceof Edge) {
final Iterator<Edge> edgeIterator = hostGraph.edges(propertyElement.id());
while (edgeIterator.hasNext()) {
final Property property = edgeIterator.next().property(baseProperty.key());
if (property.isPresent() && property.value().equals(baseProperty.value()))
return Optional.of(property);
}
return Optional.empty();
} else { // vertex property
final Iterator<Vertex> vertexIterator = hostGraph.vertices(((VertexProperty) propertyElement).element().id());
if (vertexIterator.hasNext()) {
final Iterator<VertexProperty<Object>> vertexPropertyIterator = vertexIterator.next().properties();
while (vertexPropertyIterator.hasNext()) {
final VertexProperty vertexProperty = vertexPropertyIterator.next();
if (ElementHelper.areEqual(vertexProperty, baseProperty.element())) {
final Property property = vertexProperty.property(baseProperty.key());
if (property.isPresent() && property.value().equals(baseProperty.value()))
return Optional.of(property);
else
return Optional.empty();
}
}
}
return Optional.empty();
}
}
public static Optional<Property> getProperty(final Attachable<Property> attachableProperty, final Vertex hostVertex) {
final Property baseProperty = attachableProperty.get();
final Element propertyElement = attachableProperty.get().element();
if (propertyElement instanceof Vertex) {
return (Optional) Method.getVertexProperty((Attachable) attachableProperty, hostVertex);
} else if (propertyElement instanceof Edge) {
final Iterator<Edge> edgeIterator = hostVertex.edges(Direction.OUT);
while (edgeIterator.hasNext()) {
final Edge edge = edgeIterator.next();
if (ElementHelper.areEqual(edge, propertyElement)) {
final Property property = edge.property(baseProperty.key());
if (ElementHelper.areEqual(baseProperty, property))
return Optional.of(property);
}
}
return Optional.empty();
} else { // vertex property
final Iterator<VertexProperty<Object>> vertexPropertyIterator = hostVertex.properties();
while (vertexPropertyIterator.hasNext()) {
final VertexProperty vertexProperty = vertexPropertyIterator.next();
if (ElementHelper.areEqual(vertexProperty, baseProperty.element())) {
final Property property = vertexProperty.property(baseProperty.key());
if (property.isPresent() && property.value().equals(baseProperty.value()))
return Optional.of(property);
else
return Optional.empty();
}
}
return Optional.empty();
}
}
///// CREATE HELPER METHODS
public static Vertex createVertex(final Attachable<Vertex> attachableVertex, final Graph hostGraph) {
final Vertex baseVertex = attachableVertex.get();
final Vertex vertex = hostGraph.features().vertex().willAllowId(baseVertex.id()) ?
hostGraph.addVertex(T.id, baseVertex.id(), T.label, baseVertex.label()) :
hostGraph.addVertex(T.label, baseVertex.label());
baseVertex.properties().forEachRemaining(vp -> {
final VertexProperty vertexProperty = hostGraph.features().vertex().properties().willAllowId(vp.id()) ?
vertex.property(hostGraph.features().vertex().getCardinality(vp.key()), vp.key(), vp.value(), T.id, vp.id()) :
vertex.property(hostGraph.features().vertex().getCardinality(vp.key()), vp.key(), vp.value());
vp.properties().forEachRemaining(p -> vertexProperty.property(p.key(), p.value()));
});
return vertex;
}
public static Vertex createVertex(final Attachable<Vertex> attachableVertex, final Vertex hostVertex) {
throw new IllegalStateException("It is not possible to create a vertex at a host vertex");
}
public static Edge createEdge(final Attachable<Edge> attachableEdge, final Graph hostGraph) {
final Edge baseEdge = attachableEdge.get();
Iterator<Vertex> vertices = hostGraph.vertices(baseEdge.outVertex().id());
final Vertex outV = vertices.hasNext() ? vertices.next() : hostGraph.features().vertex().willAllowId(baseEdge.outVertex().id()) ? hostGraph.addVertex(T.id, baseEdge.outVertex().id()) : hostGraph.addVertex();
vertices = hostGraph.vertices(baseEdge.inVertex().id());
final Vertex inV = vertices.hasNext() ? vertices.next() : hostGraph.features().vertex().willAllowId(baseEdge.inVertex().id()) ? hostGraph.addVertex(T.id, baseEdge.inVertex().id()) : hostGraph.addVertex();
if (ElementHelper.areEqual(outV, inV)) {
final Iterator<Edge> itty = outV.edges(Direction.OUT, baseEdge.label());
while (itty.hasNext()) {
final Edge e = itty.next();
if (ElementHelper.areEqual(baseEdge, e))
return e;
}
}
final Edge e = hostGraph.features().edge().willAllowId(baseEdge.id()) ? outV.addEdge(baseEdge.label(), inV, T.id, baseEdge.id()) : outV.addEdge(baseEdge.label(), inV);
baseEdge.properties().forEachRemaining(p -> e.property(p.key(), p.value()));
return e;
}
public static Edge createEdge(final Attachable<Edge> attachableEdge, final Vertex hostVertex) {
return Method.createEdge(attachableEdge, hostVertex.graph()); // TODO (make local to vertex)
}
public static VertexProperty createVertexProperty(final Attachable<VertexProperty> attachableVertexProperty, final Graph hostGraph) {
final VertexProperty<Object> baseVertexProperty = attachableVertexProperty.get();
final Iterator<Vertex> vertexIterator = hostGraph.vertices(baseVertexProperty.element().id());
if (vertexIterator.hasNext()) {
final VertexProperty vertexProperty = hostGraph.features().vertex().properties().willAllowId(baseVertexProperty.id()) ?
vertexIterator.next().property(hostGraph.features().vertex().getCardinality(baseVertexProperty.key()), baseVertexProperty.key(), baseVertexProperty.value(), T.id, baseVertexProperty.id()) :
vertexIterator.next().property(hostGraph.features().vertex().getCardinality(baseVertexProperty.key()), baseVertexProperty.key(), baseVertexProperty.value());
baseVertexProperty.properties().forEachRemaining(p -> vertexProperty.property(p.key(), p.value()));
return vertexProperty;
}
throw new IllegalStateException("Could not find vertex to create the attachable vertex property on");
}
public static VertexProperty createVertexProperty(final Attachable<VertexProperty> attachableVertexProperty, final Vertex hostVertex) {
final VertexProperty<Object> baseVertexProperty = attachableVertexProperty.get();
final VertexProperty vertexProperty = hostVertex.graph().features().vertex().properties().willAllowId(baseVertexProperty.id()) ?
hostVertex.property(hostVertex.graph().features().vertex().getCardinality(baseVertexProperty.key()), baseVertexProperty.key(), baseVertexProperty.value(), T.id, baseVertexProperty.id()) :
hostVertex.property(hostVertex.graph().features().vertex().getCardinality(baseVertexProperty.key()), baseVertexProperty.key(), baseVertexProperty.value());
baseVertexProperty.properties().forEachRemaining(p -> vertexProperty.property(p.key(), p.value()));
return vertexProperty;
}
public static Property createProperty(final Attachable<Property> attachableProperty, final Graph hostGraph) {
final Property baseProperty = attachableProperty.get();
final Element baseElement = baseProperty.element();
if (baseElement instanceof Vertex) {
return Method.createVertexProperty((Attachable) attachableProperty, hostGraph);
} else if (baseElement instanceof Edge) {
final Iterator<Edge> edgeIterator = hostGraph.edges(baseElement.id());
if (edgeIterator.hasNext())
return edgeIterator.next().property(baseProperty.key(), baseProperty.value());
throw new IllegalStateException("Could not find edge to create the attachable property on");
} else { // vertex property
final Iterator<Vertex> vertexIterator = hostGraph.vertices(((VertexProperty) baseElement).element().id());
if (vertexIterator.hasNext()) {
final Vertex vertex = vertexIterator.next();
final Iterator<VertexProperty<Object>> vertexPropertyIterator = vertex.properties(((VertexProperty) baseElement).key());
while (vertexPropertyIterator.hasNext()) {
final VertexProperty<Object> vp = vertexPropertyIterator.next();
if (ElementHelper.areEqual(vp, baseElement))
return vp.property(baseProperty.key(), baseProperty.value());
}
}
throw new IllegalStateException("Could not find vertex property to create the attachable property on");
}
}
public static Property createProperty(final Attachable<Property> attachableProperty, final Vertex hostVertex) {
final Property baseProperty = attachableProperty.get();
final Element baseElement = baseProperty.element();
if (baseElement instanceof Vertex) {
return Method.createVertexProperty((Attachable) attachableProperty, hostVertex);
} else if (baseElement instanceof Edge) {
final Iterator<Edge> edgeIterator = hostVertex.edges(Direction.OUT);
if (edgeIterator.hasNext())
return edgeIterator.next().property(baseProperty.key(), baseProperty.value());
throw new IllegalStateException("Could not find edge to create the property on");
} else { // vertex property
final Iterator<VertexProperty<Object>> vertexPropertyIterator = hostVertex.properties(((VertexProperty) baseElement).key());
while (vertexPropertyIterator.hasNext()) {
final VertexProperty<Object> vp = vertexPropertyIterator.next();
if (ElementHelper.areEqual(vp, baseElement))
return vp.property(baseProperty.key(), baseProperty.value());
}
throw new IllegalStateException("Could not find vertex property to create the attachable property on");
}
}
}
public static class Exceptions {
private Exceptions() {
}
public static IllegalStateException canNotGetAttachableFromHostVertex(final Attachable<?> attachable, final Vertex hostVertex) {
return new IllegalStateException("Can not get the attachable from the host vertex: " + attachable + "-/->" + hostVertex);
}
public static IllegalStateException canNotGetAttachableFromHostGraph(final Attachable<?> attachable, final Graph hostGraph) {
return new IllegalStateException("Can not get the attachable from the host vertex: " + attachable + "-/->" + hostGraph);
}
public static IllegalArgumentException providedAttachableMustContainAGraphObject(final Attachable<?> attachable) {
return new IllegalArgumentException("The provided attachable must contain a graph object: " + attachable);
}
}
}