index int64 | repo_id string | file_path string | content string |
|---|---|---|---|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/infrastructure/textRenderer | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/infrastructure/textRenderer/edge/TextEdgeRenderer.java | package ai.stapi.graph.renderer.infrastructure.textRenderer.edge;
import ai.stapi.graph.renderer.infrastructure.idLessTextRenderer.edge.IdLessTextEdgeRenderer;
import ai.stapi.graph.renderer.model.edgeRenderer.EdgeRenderer;
import ai.stapi.graph.renderer.model.nodeRenderer.RendererOptions;
import ai.stapi.graph.traversableGraphElements.TraversableEdge;
import org.springframework.beans.factory.annotation.Autowired;
public class TextEdgeRenderer implements EdgeRenderer {
private IdLessTextEdgeRenderer idLessTextEdgeRenderer;
@Autowired
public TextEdgeRenderer(IdLessTextEdgeRenderer idLessTextEdgeRenderer) {
this.idLessTextEdgeRenderer = idLessTextEdgeRenderer;
}
@Override
public TextEdgeRenderOutput render(TraversableEdge edge) {
var edgeStringWithoutId = idLessTextEdgeRenderer.render(edge).toPrintableString();
var edgeId = edge.getId();
return new TextEdgeRenderOutput(
String.format(
"edge_id: %s\n",
edgeId
) + edgeStringWithoutId
);
}
@Override
public TextEdgeRenderOutput render(TraversableEdge edge, RendererOptions options) {
return render(edge);
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/infrastructure/textRenderer | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/infrastructure/textRenderer/node/TextNodeRenderOutput.java | package ai.stapi.graph.renderer.infrastructure.textRenderer.node;
import ai.stapi.graph.renderer.model.RenderOutput;
public class TextNodeRenderOutput implements RenderOutput {
private String renderedString;
public TextNodeRenderOutput(String renderedString) {
this.renderedString = renderedString;
}
public String toPrintableString() {
return renderedString;
}
public void setRenderedString(String renderedString) {
this.renderedString = renderedString;
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/infrastructure/textRenderer | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/infrastructure/textRenderer/node/TextNodeRenderer.java | package ai.stapi.graph.renderer.infrastructure.textRenderer.node;
import ai.stapi.graph.renderer.infrastructure.idLessTextRenderer.IdLessTextRendererOptions;
import ai.stapi.graph.renderer.infrastructure.idLessTextRenderer.node.IdLessTextNodeRenderer;
import ai.stapi.graph.renderer.infrastructure.textRenderer.TextRendererOptions;
import ai.stapi.graph.renderer.model.RenderOutput;
import ai.stapi.graph.renderer.model.nodeRenderer.NodeRenderer;
import ai.stapi.graph.renderer.model.nodeRenderer.RendererOptions;
import ai.stapi.graph.traversableGraphElements.TraversableNode;
import ai.stapi.utils.LineFormatter;
import org.springframework.beans.factory.annotation.Autowired;
public class TextNodeRenderer implements NodeRenderer {
private IdLessTextNodeRenderer idLessTextNodeRenderer;
@Autowired
public TextNodeRenderer(IdLessTextNodeRenderer idLessTextNodeRenderer) {
this.idLessTextNodeRenderer = idLessTextNodeRenderer;
}
@Override
public boolean supports(RendererOptions options) {
return options.getClass().equals(TextRendererOptions.class);
}
@Override
public RenderOutput render(TraversableNode node) {
return this.render(
node,
new TextRendererOptions()
);
}
@Override
public RenderOutput render(TraversableNode node, RendererOptions options) {
var downtypedOptions = (TextRendererOptions) options;
var indentLevel = downtypedOptions.getIndentLevel();
var idLessRenderedNodeString = idLessTextNodeRenderer.render(
node,
new IdLessTextRendererOptions(indentLevel)
).toPrintableString();
var renderedNodeIdLine = LineFormatter.createLine(
"node_id: " + node.getId(),
indentLevel
);
return new TextNodeRenderOutput(
renderedNodeIdLine +
idLessRenderedNodeString
);
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model/GenericGraphRenderer.java | package ai.stapi.graph.renderer.model;
import ai.stapi.graph.Graph;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graph.renderer.model.nodeRenderer.RendererOptions;
import ai.stapi.graph.renderer.model.nodeRenderer.exceptions.OptionsAreNotSupportedByAnyRendererException;
import ai.stapi.graph.renderer.model.nodeRenderer.exceptions.OptionsAreSupportedByMultipleRenderersException;
import java.util.List;
import java.util.stream.Collectors;
import org.jetbrains.annotations.NotNull;
import org.springframework.beans.factory.annotation.Autowired;
public class GenericGraphRenderer {
private final List<GraphRenderer> graphRenderers;
@Autowired
public GenericGraphRenderer(
List<GraphRenderer> existingGraphRenderers) {
this.graphRenderers = existingGraphRenderers;
}
public RenderOutput render(Graph graph, RendererOptions options) {
return this.render(
new InMemoryGraphRepository(graph),
options
);
}
public RenderOutput render(InMemoryGraphRepository graph,
RendererOptions options) {
GraphRenderer renderer = this.getGraphRenderer(options);
return renderer.render(
graph,
options
);
}
@NotNull
private GraphRenderer getGraphRenderer(RendererOptions options) {
var supportingGraphRenderers = graphRenderers.stream()
.filter(parser -> parser.supports(options))
.collect(Collectors.toSet());
if (supportingGraphRenderers.isEmpty()) {
throw new OptionsAreNotSupportedByAnyRendererException(options);
}
if (supportingGraphRenderers.size() > 1) {
throw new OptionsAreSupportedByMultipleRenderersException(options);
}
return supportingGraphRenderers.stream()
.findFirst()
.orElseThrow();
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model/GraphRenderOutput.java | package ai.stapi.graph.renderer.model;
public interface GraphRenderOutput extends RenderOutput {
String toPrintableString();
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model/GraphRenderer.java | package ai.stapi.graph.renderer.model;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graph.renderer.model.nodeRenderer.RendererOptions;
public interface GraphRenderer {
GraphRenderOutput render(InMemoryGraphRepository graph);
GraphRenderOutput render(InMemoryGraphRepository graph, RendererOptions options);
boolean supports(RendererOptions options);
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model/RenderOutput.java | package ai.stapi.graph.renderer.model;
public interface RenderOutput {
String toPrintableString();
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model/StringGraphRenderOutput.java | package ai.stapi.graph.renderer.model;
public class StringGraphRenderOutput implements GraphRenderOutput {
private String graph;
public StringGraphRenderOutput(String graphString) {
this.graph = graphString;
}
@Override
public String toPrintableString() {
return this.graph;
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model/edgeRenderer/EdgeRenderer.java | package ai.stapi.graph.renderer.model.edgeRenderer;
import ai.stapi.graph.traversableGraphElements.TraversableEdge;
import ai.stapi.graph.renderer.model.RenderOutput;
import ai.stapi.graph.renderer.model.nodeRenderer.RendererOptions;
public interface EdgeRenderer {
RenderOutput render(TraversableEdge edge);
RenderOutput render(TraversableEdge edge, RendererOptions options);
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model/exceptions/GraphRendererException.java | package ai.stapi.graph.renderer.model.exceptions;
public class GraphRendererException extends RuntimeException {
public GraphRendererException(String message) {
super(message);
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model/exceptions/RenderOptionsNotRecognizedException.java | package ai.stapi.graph.renderer.model.exceptions;
import ai.stapi.graph.renderer.model.nodeRenderer.RendererOptions;
public class RenderOptionsNotRecognizedException extends RuntimeException {
public RenderOptionsNotRecognizedException(Class<? extends RendererOptions> supports,
Class<? extends RendererOptions> provided) {
super(
String.format(
"Renderer supports only %s Provided: %s",
supports,
provided
)
);
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model/nodeRenderer/GenericNodeRenderer.java | package ai.stapi.graph.renderer.model.nodeRenderer;
import ai.stapi.graph.renderer.model.RenderOutput;
import ai.stapi.graph.renderer.model.nodeRenderer.exceptions.OptionsAreNotSupportedByAnyRendererException;
import ai.stapi.graph.renderer.model.nodeRenderer.exceptions.OptionsAreSupportedByMultipleRenderersException;
import ai.stapi.graph.traversableGraphElements.TraversableNode;
import java.util.List;
import java.util.stream.Collectors;
import org.jetbrains.annotations.NotNull;
public class GenericNodeRenderer {
private final List<NodeRenderer> nodeRenderers;
public GenericNodeRenderer(List<NodeRenderer> existingNodeRenderers) {
this.nodeRenderers = existingNodeRenderers;
}
public RenderOutput render(TraversableNode node, RendererOptions options) {
NodeRenderer renderer = this.getNodeRenderer(options);
return renderer.render(
node,
options
);
}
@NotNull
private NodeRenderer getNodeRenderer(RendererOptions options) {
var supportingNodeRenderers = nodeRenderers.stream()
.filter(parser -> parser.supports(options))
.collect(Collectors.toSet());
if (supportingNodeRenderers.isEmpty()) {
throw new OptionsAreNotSupportedByAnyRendererException(options);
}
if (supportingNodeRenderers.size() > 1) {
throw new OptionsAreSupportedByMultipleRenderersException(options);
}
return supportingNodeRenderers.stream()
.findFirst()
.orElseThrow();
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model/nodeRenderer/NodeRenderer.java | package ai.stapi.graph.renderer.model.nodeRenderer;
import ai.stapi.graph.renderer.model.RenderOutput;
import ai.stapi.graph.traversableGraphElements.TraversableNode;
import org.jetbrains.annotations.NotNull;
public interface NodeRenderer {
RenderOutput render(TraversableNode node);
RenderOutput render(TraversableNode node, @NotNull RendererOptions options);
boolean supports(@NotNull RendererOptions options);
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model/nodeRenderer/RendererOptions.java | package ai.stapi.graph.renderer.model.nodeRenderer;
public interface RendererOptions {
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model/nodeRenderer | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model/nodeRenderer/exceptions/OptionsAreNotSupportedByAnyRendererException.java | package ai.stapi.graph.renderer.model.nodeRenderer.exceptions;
import ai.stapi.graph.renderer.model.exceptions.GraphRendererException;
import ai.stapi.graph.renderer.model.nodeRenderer.RendererOptions;
public class OptionsAreNotSupportedByAnyRendererException extends GraphRendererException {
public OptionsAreNotSupportedByAnyRendererException(RendererOptions options) {
super(
createMessage(options)
);
}
private static String createMessage(RendererOptions options) {
return String.format(
"Renderer options %s are not supported by any renderer.",
options.getClass()
);
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model/nodeRenderer | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/renderer/model/nodeRenderer/exceptions/OptionsAreSupportedByMultipleRenderersException.java | package ai.stapi.graph.renderer.model.nodeRenderer.exceptions;
import ai.stapi.graph.renderer.model.exceptions.GraphRendererException;
import ai.stapi.graph.renderer.model.nodeRenderer.RendererOptions;
public class OptionsAreSupportedByMultipleRenderersException extends GraphRendererException {
public OptionsAreSupportedByMultipleRenderersException(RendererOptions options) {
super(
createMessage(options)
);
}
private static String createMessage(RendererOptions options) {
return String.format(
"Renderer options %s are supported by more than one renderer.",
options.getClass()
);
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/repositorypruner/InMemoryRepositoryPruner.java | package ai.stapi.graph.repositorypruner;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
public class InMemoryRepositoryPruner implements RepositoryPruner {
private final InMemoryGraphRepository inMemoryGraphRepository;
public InMemoryRepositoryPruner(InMemoryGraphRepository inMemoryGraphRepository) {
this.inMemoryGraphRepository = inMemoryGraphRepository;
}
@Override
public void prune() {
this.inMemoryGraphRepository.prune();
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/repositorypruner/RepositoryPruner.java | package ai.stapi.graph.repositorypruner;
public interface RepositoryPruner {
void prune();
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/traversableGraphElements/GraphElementNamer.java | package ai.stapi.graph.traversableGraphElements;
public interface GraphElementNamer {
String getSortingName(TraversableGraphElement graphElement);
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/traversableGraphElements/TraversableEdge.java | package ai.stapi.graph.traversableGraphElements;
import ai.stapi.graph.AttributeContainer;
import ai.stapi.graph.NodeLoader;
import ai.stapi.graph.NodeRepository;
import ai.stapi.graph.NullNodeLoader;
import ai.stapi.graph.RepositoryNodeLoader;
import ai.stapi.graph.attribute.AbstractAttributeContainer;
import ai.stapi.graph.attribute.Attribute;
import ai.stapi.graph.graphelements.Edge;
import ai.stapi.graph.graphelements.Node;
import ai.stapi.graph.versionedAttributes.VersionedAttributeGroup;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.identity.UniversallyUniqueIdentifier;
import java.util.Objects;
public class TraversableEdge extends AbstractAttributeContainer implements TraversableGraphElement,
Comparable<TraversableEdge> {
private final UniqueIdentifier edgeId;
private final String edgeType;
private final UniqueIdentifier nodeFromId;
private final UniqueIdentifier nodeToId;
private final String nodeFromType;
private final String nodeToType;
private final NodeLoader nodeLoader;
public static TraversableEdge from(
Edge edge,
NodeRepository nodeRepository
) {
return new TraversableEdge(
edge.getId(),
edge.getType(),
edge.getNodeFromId(),
edge.getNodeFromType(),
edge.getNodeToId(),
edge.getNodeToType(),
edge.getVersionedAttributes(),
new RepositoryNodeLoader(nodeRepository)
);
}
public TraversableEdge(Node nodeFrom, String edgeType, Node nodeTo) {
this.edgeId = UniversallyUniqueIdentifier.randomUUID();
this.edgeType = edgeType;
this.nodeFromId = nodeFrom.getId();
this.nodeFromType = nodeFrom.getType();
this.nodeToId = nodeTo.getId();
this.nodeToType = nodeTo.getType();
this.nodeLoader = new NullNodeLoader();
}
public TraversableEdge(
UniqueIdentifier edgeId,
TraversableNode nodeFrom,
String edgeType,
TraversableNode nodeTo,
VersionedAttributeGroup attributeGroup,
NodeLoader nodeLoader
) {
super(attributeGroup);
this.edgeId = edgeId;
this.edgeType = edgeType;
this.nodeFromId = nodeFrom.getId();
this.nodeFromType = nodeFrom.getType();
this.nodeToId = nodeTo.getId();
this.nodeToType = nodeTo.getType();
this.nodeLoader = nodeLoader;
}
public TraversableEdge(
UniqueIdentifier edgeId,
String edgeType,
UniqueIdentifier nodeFromId,
String nodeFromType,
UniqueIdentifier nodeToId,
String nodeToType,
VersionedAttributeGroup attributeGroup,
NodeLoader nodeLoader
) {
super(attributeGroup);
this.edgeId = edgeId;
this.edgeType = edgeType;
this.nodeFromId = nodeFromId;
this.nodeFromType = nodeFromType;
this.nodeToId = nodeToId;
this.nodeToType = nodeToType;
this.nodeLoader = nodeLoader;
}
@Override
public TraversableEdge add(Attribute<?> attribute) {
return (TraversableEdge) super.add(attribute);
}
public UniqueIdentifier getId() {
return edgeId;
}
public String getType() {
return edgeType;
}
public UniqueIdentifier getNodeFromId() {
return nodeFromId;
}
public UniqueIdentifier getNodeToId() {
return nodeToId;
}
public String getNodeFromType() {
return this.nodeFromType;
}
public String getNodeToType() {
return this.nodeToType;
}
@Override
protected AttributeContainer withNewAttributes(VersionedAttributeGroup newAttributes) {
return new TraversableEdge(
this.getId(),
this.getType(),
this.getNodeFromId(),
this.getNodeFromType(),
this.getNodeToId(),
this.getNodeToType(),
newAttributes,
this.nodeLoader
);
}
@Override
public boolean equals(Object other) {
if (this == other) {
return true;
}
if (!(other instanceof TraversableEdge edge)) {
return false;
}
return
this.getType().equals(edge.getType()) &&
this.getNodeFrom().getIdlessHashCode() == edge.getNodeFrom().getIdlessHashCode() &&
this.getNodeTo().getIdlessHashCode() == edge.getNodeTo().getIdlessHashCode() &&
this.getVersionedAttributes().equals(edge.getVersionedAttributes());
}
@Override
public int hashCode() {
int result = getType().hashCode();
result = 31 * result + getNodeFrom().getIdlessHashCode();
result = 31 * result + getNodeTo().getIdlessHashCode();
result = 31 * result + getVersionedAttributes().hashCode();
return result;
}
public TraversableNode getNodeFrom() {
return this.nodeLoader.loadNode(
this.getNodeFromId(),
this.getNodeFromType()
);
}
public TraversableNode getNodeTo() {
return this.nodeLoader.loadNode(
this.getNodeToId(),
this.getNodeToType()
);
}
@Override
protected int getHashCodeWithoutAttributes() {
return Objects.hash(this.getId()) + this.getIdlessHashCodeWithoutAttributes();
}
@Override
protected int getIdlessHashCodeWithoutAttributes() {
return Objects.hash(
this.getType(),
this.getNodeFrom().getIdlessHashCode(),
this.getNodeTo().getIdlessHashCode()
);
}
public int compareTo(TraversableEdge other) {
return this.edgeId.compareTo(other.edgeId);
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/traversableGraphElements/TraversableGraphElement.java | package ai.stapi.graph.traversableGraphElements;
import ai.stapi.graph.AttributeContainer;
import ai.stapi.identity.UniqueIdentifier;
public interface TraversableGraphElement extends AttributeContainer {
UniqueIdentifier getId();
String getType();
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/traversableGraphElements/TraversableNode.java | package ai.stapi.graph.traversableGraphElements;
import ai.stapi.graph.AttributeContainer;
import ai.stapi.graph.EdgeLoader;
import ai.stapi.graph.EdgeRepository;
import ai.stapi.graph.Graph;
import ai.stapi.graph.NullEdgeLoader;
import ai.stapi.graph.RepositoryEdgeLoader;
import ai.stapi.graph.attribute.AbstractAttributeContainer;
import ai.stapi.graph.attribute.Attribute;
import ai.stapi.graph.graphelements.Edge;
import ai.stapi.graph.graphelements.Node;
import ai.stapi.graph.versionedAttributes.VersionedAttributeGroup;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.identity.UniversallyUniqueIdentifier;
import java.util.List;
import java.util.Objects;
import java.util.UUID;
import java.util.stream.Stream;
public class TraversableNode extends AbstractAttributeContainer implements TraversableGraphElement {
private final UniqueIdentifier id;
private final String nodeType;
private final EdgeLoader edgeLoader;
public static TraversableNode from(
Node node,
EdgeRepository edgeRepository
) {
return new TraversableNode(
node.getId(),
node.getType(),
node.getVersionedAttributes(),
new RepositoryEdgeLoader(edgeRepository)
);
}
public TraversableNode(String nodeType) {
this(
UniversallyUniqueIdentifier.randomUUID(),
nodeType
);
}
public TraversableNode(UniqueIdentifier id, String nodeType) {
this.id = id;
this.nodeType = nodeType;
this.edgeLoader = new NullEdgeLoader();
}
public TraversableNode(
UniqueIdentifier uniqueIdentifier,
String nodeType,
VersionedAttributeGroup attributeGroup,
EdgeLoader edgeLoader
) {
super(attributeGroup);
this.id = uniqueIdentifier;
this.nodeType = nodeType;
this.edgeLoader = edgeLoader;
}
@Override
public TraversableNode add(Attribute<?> attribute) {
return (TraversableNode) super.add(attribute);
}
public UniqueIdentifier getId() {
return this.id;
}
public String getType() {
return this.nodeType;
}
public List<TraversableEdge> getEdges(String edgeType) {
return this.edgeLoader.loadEdges(
this.id,
this.nodeType,
edgeType
);
}
public List<TraversableEdge> getOutgoingEdges(String edgeType) {
return this.edgeLoader.loadEdges(
this.id,
this.nodeType,
edgeType
).stream()
.filter(edge -> edge.getNodeFromId().equals(this.id))
.toList();
}
public List<TraversableEdge> getIngoingEdges(String edgeType) {
return this.edgeLoader.loadEdges(
this.id,
this.nodeType,
edgeType
).stream()
.filter(edge -> edge.getNodeToId().equals(this.id))
.toList();
}
public List<TraversableEdge> getEdges() {
return this.edgeLoader.loadEdges(
this.id,
this.nodeType
);
}
public List<TraversableEdge> getOutgoingEdges() {
return this.edgeLoader.loadEdges(
this.id,
this.nodeType
).stream()
.filter(edge -> edge.getNodeFromId().equals(this.id))
.toList();
}
public List<TraversableEdge> getIngoingEdges() {
return this.edgeLoader.loadEdges(
this.id,
this.nodeType
).stream()
.filter(edge -> edge.getNodeToId().equals(this.id))
.toList();
}
@Override
protected AttributeContainer withNewAttributes(VersionedAttributeGroup newAttributes) {
return new TraversableNode(
this.getId(),
this.getType(),
newAttributes,
this.edgeLoader
);
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof TraversableNode node)) {
return false;
}
return getId().equals(node.getId())
&& getType().equals(node.getType())
&& getEdges().equals(node.getEdges());
//TODO && getUsableIdentificators().equals(node.getUsableIdentificators());
}
@Override
public int hashCode() {
int result = getId().hashCode();
result = 31 * result + getType().hashCode();
result = 31 * result + getEdges().hashCode();
return result;
}
public int getIdlessHashCodeWithEdges() {
String type = this.getType();
VersionedAttributeGroup versionedAttributes = this.getVersionedAttributes();
int hashCodeForEdgesOnNode = this.getHashCodeForEdgesOnNode();
return Objects.hash(
type,
versionedAttributes,
hashCodeForEdgesOnNode
);
}
private int getHashCodeForEdgesOnNode() {
return this.edgeLoader.getIdlessHashCodeForEdgesOnNode(this.getId(), this.getType());
}
@Override
protected int getHashCodeWithoutAttributes() {
return Objects.hash(this.getId()) + this.getIdlessHashCodeWithoutAttributes();
}
@Override
protected int getIdlessHashCodeWithoutAttributes() {
return Objects.hash(this.getType());
}
public String getSortingNameWithHashCodeFallback() {
var maybeBestName = this.guessBestName();
if (maybeBestName != null) {
return maybeBestName;
}
return String.valueOf(this.getIdlessHashCodeWithEdges());
}
public String getSortingNameWithNodeTypeFallback() {
var idName = this.id.toString();
try {
UUID.fromString(idName);
} catch (IllegalArgumentException e) {
return idName;
}
var maybeBestName = this.guessBestName();
if (maybeBestName != null) {
return maybeBestName;
}
return this.getType();
}
public Graph getNeighborhoodGraph(int maxLimit) {
if (maxLimit == 0) {
return new Graph(new Node(
this.id,
this.nodeType,
this.getVersionedAttributes()
));
}
var nodesFrom = this.getEdges()
.stream()
.limit(maxLimit)
.map(traversableEdge -> new Node(traversableEdge.getNodeFrom()));
var nodesTo = this.getEdges()
.stream()
.limit(maxLimit)
.map(traversableEdge -> new Node(traversableEdge.getNodeTo()));
var edges = this.getEdges()
.stream()
.limit(maxLimit)
.map(Edge::new);
var nodesStream = Stream.concat(
nodesFrom,
nodesTo
);
var resultStream = Stream.concat(
nodesStream,
edges
);
return new Graph(
resultStream.distinct().toArray(AttributeContainer[]::new)
);
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/versionedAttributes/AbstractVersionedAttribute.java | package ai.stapi.graph.versionedAttributes;
import ai.stapi.graph.attribute.Attribute;
import ai.stapi.graph.versionedAttributes.exceptions.CannotAddNewVersionOfAttribute;
import ai.stapi.graph.versionedAttributes.exceptions.CannotMergeTwoVersionedAttributes;
import ai.stapi.graph.versionedAttributes.exceptions.VersionedAttributeCannotBeEmpty;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Stream;
public abstract class AbstractVersionedAttribute<T extends Attribute<?>>
implements VersionedAttribute<T> {
protected String attributeName;
protected List<T> attributeVersions;
protected AbstractVersionedAttribute() {
}
protected AbstractVersionedAttribute(List<T> attributeVersions) {
this();
if (attributeVersions.isEmpty()) {
throw new VersionedAttributeCannotBeEmpty();
}
this.attributeName = attributeVersions.get(0).getName();
List<T> newAttributeVersions = new ArrayList<>();
for (T attributeVersion : attributeVersions) {
newAttributeVersions = protectedAddToList(attributeVersion, newAttributeVersions);
}
this.attributeVersions = ImmutableList.copyOf(newAttributeVersions);
}
protected AbstractVersionedAttribute(List<T> attributeVersions, Attribute<?> attribute) {
this();
this.attributeName = attributeVersions.get(0).getName();
this.attributeVersions = this.protectedAddToList(attribute, attributeVersions);
}
@Override
public boolean containsValue(Object value) {
return this.attributeVersions.stream()
.anyMatch(attribute -> attribute.getValue().equals(value));
}
@Override
public T getCurrent() {
return this.attributeVersions.get(0);
}
protected VersionedAttribute<T> protectedMergeOverwrite(VersionedAttribute<?> other) {
if (!this.getName().equals(other.getName())) {
throw CannotMergeTwoVersionedAttributes.becauseTheyHaveDifferentNames(
this,
other
);
}
var updatedVersions = new ArrayList<>(this.attributeVersions);
//TODO Check Structure Type
updatedVersions.addAll(
other.streamAttributeVersions()
.map(attribute -> (T) attribute)
.filter(otherAttribute -> !this.attributeVersions.contains(otherAttribute))
.toList()
);
return new ImmutableVersionedAttribute<T>(updatedVersions);
}
@Override
public List<T> getAttributeVersions() {
return attributeVersions;
}
@Override
public Stream<T> streamAttributeVersions() {
return this.attributeVersions.stream();
}
@Override
public Iterator<T> iterateVersionsFromOldest() {
return Lists.reverse(this.attributeVersions).iterator();
}
@Override
public int numberOfVersions() {
return attributeVersions.size();
}
@Override
public String getName() {
return this.attributeName;
}
@Override
public boolean equals(Object other) {
if (this == other) {
return true;
}
if (!(other instanceof VersionedAttribute<?> otherVersionedAttribute)) {
return false;
}
return this.getAttributeVersions().equals(otherVersionedAttribute.getAttributeVersions());
}
@Override
public int hashCode() {
return Objects.hash(Lists.reverse(this.getAttributeVersions()));
}
protected List<T> protectedAddToList(Attribute<?> attribute, List<T> currentList) {
if (currentList == null) {
return currentList;
}
List<T> newAttributeList = new ArrayList<>(currentList);
T mostRecentFromCurrentList = null;
if (!currentList.isEmpty()) {
mostRecentFromCurrentList = currentList.get(0);
if (attribute.getValue().equals(mostRecentFromCurrentList.getValue())) {
return newAttributeList;
}
if (!attribute.getName().equals(mostRecentFromCurrentList.getName())) {
throw CannotAddNewVersionOfAttribute.becauseNewVersionHasDifferentNames(
mostRecentFromCurrentList.getName(),
attribute.getName()
);
}
}
if (currentList.isEmpty() || !Objects.requireNonNull(mostRecentFromCurrentList)
.equals(attribute.getValue())) {
if (attribute.getCreatedAt() == null) {
attribute.setCreatedAt(Instant.now());
}
newAttributeList.add((T) attribute);
newAttributeList.sort((a1, a2) -> a2.getCreatedAt().compareTo(a1.getCreatedAt()));
}
return newAttributeList;
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/versionedAttributes/AbstractVersionedAttributeGroup.java | package ai.stapi.graph.versionedAttributes;
import ai.stapi.graph.attribute.Attribute;
import ai.stapi.graph.attribute.exceptions.AttributeNotFoundException;
import com.google.common.collect.ImmutableList;
import java.util.HashMap;
import java.util.List;
import java.util.Objects;
public abstract class AbstractVersionedAttributeGroup implements VersionedAttributeGroup {
protected HashMap<String, VersionedAttribute<?>> rawMap;
public AbstractVersionedAttributeGroup() {
this.rawMap = new HashMap<>();
}
public AbstractVersionedAttributeGroup(HashMap<String, VersionedAttribute<?>> rawMap) {
this.rawMap = rawMap;
}
@Override
public Attribute<?> getCurrentAttribute(String name) {
if (!this.rawMap.containsKey(name)) {
throw new AttributeNotFoundException(name);
}
return this.rawMap.get(name).getCurrent();
}
@Override
public Object getCurrentAttributeValue(String name) {
return this.getCurrentAttribute(name).getValue();
}
@Override
public boolean hasAttribute(String name) {
return this.rawMap.containsKey(name);
}
@Override
public boolean isValuePresentInAnyVersion(String attributeName, Object attributeValue) {
if (!this.rawMap.containsKey(attributeName)) {
return false;
}
return this.rawMap.get(attributeName).containsValue(attributeValue);
}
@Override
public VersionedAttribute<?> getVersionedAttribute(String name) {
return this.rawMap.get(name);
}
@Override
public List<VersionedAttribute<?>> getVersionedAttributeList() {
return ImmutableList.copyOf(this.rawMap.values());
}
@Override
public int numberOfUniqueAttributeNames() {
return this.rawMap.size();
}
@Override
public boolean equals(Object other) {
if (this == other) {
return true;
}
if (!(other instanceof AbstractVersionedAttributeGroup otherAbstractVersionedAttributeGroup)) {
return false;
}
return rawMap.equals(otherAbstractVersionedAttributeGroup.rawMap);
}
@Override
public int hashCode() {
return Objects.hash(rawMap);
}
protected HashMap<String, VersionedAttribute<?>> addAttributeToRawMap(
Attribute<?> attribute,
HashMap<String, VersionedAttribute<?>> rawMap
) {
HashMap<String, VersionedAttribute<?>> newMap = new HashMap<>(rawMap);
if (newMap.containsKey(attribute.getName())) {
var versionedAttribute = newMap.get(attribute.getName());
var newVersionedAttribute = versionedAttribute.add(attribute);
newMap.put(attribute.getName(), newVersionedAttribute);
} else {
newMap.put(
attribute.getName(),
new ImmutableVersionedAttribute<>(attribute)
);
}
return newMap;
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/versionedAttributes/ImmutableVersionedAttribute.java | package ai.stapi.graph.versionedAttributes;
import ai.stapi.graph.attribute.Attribute;
import java.util.Arrays;
import java.util.List;
public class ImmutableVersionedAttribute<T extends Attribute<?>>
extends AbstractVersionedAttribute<T> {
public static final String SERIALIZATION_TYPE = "ImmutableVersionedAttribute";
private ImmutableVersionedAttribute() {
}
@SafeVarargs
public ImmutableVersionedAttribute(T... attributeVersions) {
this(Arrays.stream(attributeVersions).toList());
}
public ImmutableVersionedAttribute(List<T> attributeVersions) {
super(attributeVersions);
}
public ImmutableVersionedAttribute(List<T> attributeVersions, Attribute<?> attribute) {
super(attributeVersions, attribute);
}
public VersionedAttribute<T> add(Attribute<?> attribute) {
return new ImmutableVersionedAttribute<>(this.attributeVersions, attribute);
}
public VersionedAttribute<T> mergeOverwrite(VersionedAttribute<?> other) {
return this.protectedMergeOverwrite(other);
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/versionedAttributes/ImmutableVersionedAttributeGroup.java | package ai.stapi.graph.versionedAttributes;
import ai.stapi.graph.attribute.Attribute;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
public class ImmutableVersionedAttributeGroup extends AbstractVersionedAttributeGroup {
public static final String SERIALIZATION_TYPE = "ImmutableVersionedAttributeGroup";
public ImmutableVersionedAttributeGroup() {
super();
}
public ImmutableVersionedAttributeGroup(Attribute<?>... attributes) {
super();
this.rawMap = addAttributesToEmptyMap(Arrays.stream(attributes).toList());
}
public ImmutableVersionedAttributeGroup(List<Attribute<?>> attributes) {
super();
this.rawMap = addAttributesToEmptyMap(attributes);
}
public ImmutableVersionedAttributeGroup(
HashMap<String, VersionedAttribute<?>> rawMap
) {
super(rawMap);
}
private HashMap<String, VersionedAttribute<?>> addAttributesToEmptyMap(
List<Attribute<?>> attributes) {
HashMap<String, VersionedAttribute<?>> map = new HashMap<>();
for (Attribute<?> attribute : attributes) {
map = addAttributeToRawMap(attribute, map);
}
return map;
}
public VersionedAttributeGroup add(Attribute<?> attribute) {
var newMap = this.addAttributeToRawMap(attribute, this.rawMap);
return new ImmutableVersionedAttributeGroup(newMap);
}
public VersionedAttributeGroup mergeOverwrite(VersionedAttributeGroup other) {
var newrawMap = new HashMap<>(this.rawMap);
other.getVersionedAttributeList().forEach(
(otherVersionedAttribute) -> {
var otherName = otherVersionedAttribute.getName();
if (newrawMap.containsKey(otherName)) {
newrawMap.put(
otherName, newrawMap.get(otherName).mergeOverwrite(otherVersionedAttribute)
);
} else {
newrawMap.put(
otherName,
otherVersionedAttribute
);
}
}
);
return new ImmutableVersionedAttributeGroup(newrawMap);
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/versionedAttributes/VersionedAttribute.java | package ai.stapi.graph.versionedAttributes;
import ai.stapi.graph.attribute.Attribute;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;
public interface VersionedAttribute<T extends Attribute<?>> {
T getCurrent();
String getName();
List<T> getAttributeVersions();
Iterator<T> iterateVersionsFromOldest();
Stream<T> streamAttributeVersions();
boolean containsValue(Object value);
int numberOfVersions();
@Override
boolean equals(Object other);
@Override
int hashCode();
VersionedAttribute<T> add(Attribute<?> attribute);
VersionedAttribute<T> mergeOverwrite(VersionedAttribute<?> other);
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/versionedAttributes/VersionedAttributeGroup.java | package ai.stapi.graph.versionedAttributes;
import ai.stapi.graph.attribute.Attribute;
import java.util.List;
public interface VersionedAttributeGroup {
Attribute<?> getCurrentAttribute(String name);
Object getCurrentAttributeValue(String name);
boolean hasAttribute(String name);
boolean isValuePresentInAnyVersion(String attributeName, Object attributeValue);
int numberOfUniqueAttributeNames();
VersionedAttribute<?> getVersionedAttribute(String name);
List<VersionedAttribute<?>> getVersionedAttributeList();
VersionedAttributeGroup add(Attribute<?> attribute);
VersionedAttributeGroup mergeOverwrite(VersionedAttributeGroup other);
@Override
boolean equals(Object other);
@Override
int hashCode();
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/versionedAttributes | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/versionedAttributes/exceptions/CannotAddNewVersionOfAttribute.java | package ai.stapi.graph.versionedAttributes.exceptions;
public class CannotAddNewVersionOfAttribute extends VersionedAttributesException {
protected CannotAddNewVersionOfAttribute(String message) {
super("Cannot add new version of attribute, " + message);
}
public static CannotAddNewVersionOfAttribute becauseNewVersionHasDifferentNames(String firstName,
String secondName) {
return new CannotAddNewVersionOfAttribute(
String.format(
"because name \"%s\" is not same as \"%s\".",
firstName,
secondName
)
);
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/versionedAttributes | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/versionedAttributes/exceptions/CannotMergeTwoVersionedAttributes.java | package ai.stapi.graph.versionedAttributes.exceptions;
import ai.stapi.graph.versionedAttributes.VersionedAttribute;
public class CannotMergeTwoVersionedAttributes extends VersionedAttributesException {
protected CannotMergeTwoVersionedAttributes(String message) {
super("Cannot merge two versioned attributes, " + message);
}
public static CannotMergeTwoVersionedAttributes becauseTheyHaveDifferentNames(
VersionedAttribute<?> oldAttribute,
VersionedAttribute<?> newAttribute
) {
return new CannotMergeTwoVersionedAttributes(
"""
because they have different names.
Original - Name: '%s', Current Value: '%s'
New - Name: '%s', Current Value: '%s'
""".formatted(
oldAttribute.getName(),
oldAttribute.getCurrent().getValue(),
newAttribute.getName(),
newAttribute.getCurrent().getValue()
)
);
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/versionedAttributes | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/versionedAttributes/exceptions/VersionedAttributeCannotBeCreatedWithDifferentTypes.java | package ai.stapi.graph.versionedAttributes.exceptions;
import ai.stapi.graph.exceptions.GraphException;
import java.util.List;
public class VersionedAttributeCannotBeCreatedWithDifferentTypes extends GraphException {
public VersionedAttributeCannotBeCreatedWithDifferentTypes(String expectedType,
List<String> providedType) {
super(
String.format(
"Versioned Attribute cannot be created with different types of attributes." +
"Expected type: %s" +
"Provided type: %s",
expectedType,
providedType
)
);
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/versionedAttributes | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/versionedAttributes/exceptions/VersionedAttributeCannotBeEmpty.java | package ai.stapi.graph.versionedAttributes.exceptions;
import ai.stapi.graph.exceptions.GraphException;
public class VersionedAttributeCannotBeEmpty extends GraphException {
public VersionedAttributeCannotBeEmpty() {
super("Versioned attribute cannot be empty.");
}
}
|
0 | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/versionedAttributes | java-sources/ai/stapi/graph/0.3.2/ai/stapi/graph/versionedAttributes/exceptions/VersionedAttributesException.java | package ai.stapi.graph.versionedAttributes.exceptions;
import ai.stapi.graph.exceptions.GraphException;
public abstract class VersionedAttributesException extends GraphException {
public VersionedAttributesException(String message) {
super(message);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/configuration/ClassNameProviderConfiguration.java | package ai.stapi.graphoperations.configuration;
import ai.stapi.graphoperations.graphLanguage.classnameprovider.GraphDescriptionClassNameProvider;
import ai.stapi.graphoperations.objectGraphLanguage.classnameprovider.ObjectGraphMappingClassNameProvider;
import ai.stapi.graphoperations.objectLanguage.classnameprovider.ObjectLanguageClassNameProvider;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.context.annotation.Bean;
@AutoConfiguration
public class ClassNameProviderConfiguration {
@Bean
public GraphDescriptionClassNameProvider graphDescriptionClassNameProvider() {
return new GraphDescriptionClassNameProvider();
}
@Bean
public ObjectGraphMappingClassNameProvider objectGraphMappingClassNameProvider() {
return new ObjectGraphMappingClassNameProvider();
}
@Bean
public ObjectLanguageClassNameProvider objectLanguageClassNameProvider() {
return new ObjectLanguageClassNameProvider();
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/configuration/DAGToObjectConverterConfiguration.java | package ai.stapi.graphoperations.configuration;
import ai.stapi.graphoperations.dagtoobjectconverter.DAGToObjectConverter;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.context.annotation.Bean;
@AutoConfiguration
public class DAGToObjectConverterConfiguration {
@Bean
public DAGToObjectConverter dagToObjectConverter(StructureSchemaFinder structureSchemaFinder) {
return new DAGToObjectConverter(structureSchemaFinder);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/configuration/GraphLoaderConfiguration.java | package ai.stapi.graphoperations.configuration;
import ai.stapi.configuration.SerializationConfiguration;
import ai.stapi.graph.configuration.GraphRepositoryConfiguration;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graphoperations.graphLoader.GraphLoader;
import ai.stapi.graphoperations.graphLoader.graphLoaderOGMFactory.GraphLoaderOgmFactory;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryAscendingSortResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryDescendingSortResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGenericSearchOptionResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGraphLoader;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGraphLoaderProvider;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryOffsetPaginationResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemorySearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.GenericInMemoryFilterOptionResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryAllMatchFilterResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryAndFilterResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryAnyMatchFilterResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryContainsFilterResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryEndsWithFilterResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryEqualsFilterResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryFilterResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryGreaterThanFilterResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryGreaterThanOrEqualsFilterResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryIsNullFilterResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryLowerThanFilterResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryLowerThanOrEqualFilterResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryNoneMatchFilterResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryNotEqualsFilterResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryNotFilterResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryNotNullFilterResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryOrFilterResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.filter.InMemoryStartsWithFilterResolver;
import ai.stapi.graphoperations.graphLoader.search.SearchOptionResolver;
import ai.stapi.graphoperations.graphLoader.search.filterOption.factory.FilterOptionFactory;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Lazy;
@AutoConfiguration
@AutoConfigureAfter({SerializationConfiguration.class, GraphRepositoryConfiguration.class})
public class GraphLoaderConfiguration {
@Bean
public GraphLoaderOgmFactory graphLoaderOgmFactory() {
return new GraphLoaderOgmFactory();
}
@Bean
public FilterOptionFactory filterOptionFactory() {
return new FilterOptionFactory();
}
@Bean
public InMemoryGraphLoaderProvider inMemoryGraphLoaderProvider(
InMemoryGenericSearchOptionResolver searchOptionResolver,
StructureSchemaFinder structureSchemaFinder,
ObjectMapper objectMapper
) {
return new InMemoryGraphLoaderProvider(searchOptionResolver, structureSchemaFinder, objectMapper);
}
@Bean
@ConditionalOnBean(InMemoryGraphRepository.class)
public InMemoryGraphLoader inMemoryGraphLoader(
InMemoryGraphRepository inMemoryGraphRepository,
InMemoryGenericSearchOptionResolver inMemoryGenericSearchOptionResolver,
StructureSchemaFinder structureSchemaFinder,
ObjectMapper objectMapper
) {
return new InMemoryGraphLoader(
inMemoryGraphRepository,
inMemoryGenericSearchOptionResolver,
structureSchemaFinder,
objectMapper
);
}
@Bean
@ConditionalOnMissingBean
@ConditionalOnBean(InMemoryGraphLoader.class)
public GraphLoader inMemoryGraphLoaderImplementation(
InMemoryGraphLoader inMemoryGraphLoader
) {
return inMemoryGraphLoader;
}
@Bean
public InMemoryGenericSearchOptionResolver inMemoryGenericSearchOptionResolver(
List<SearchOptionResolver<InMemorySearchResolvingContext>> searchOptionResolvers
) {
return new InMemoryGenericSearchOptionResolver(searchOptionResolvers);
}
@Bean
public InMemoryAscendingSortResolver inMemoryAscendingSortResolver(
StructureSchemaFinder structureSchemaFinder,
@Lazy InMemoryGraphLoader inMemoryGraphLoader
) {
return new InMemoryAscendingSortResolver(
structureSchemaFinder,
inMemoryGraphLoader
);
}
@Bean
public InMemoryDescendingSortResolver inMemoryDescendingSortResolver(
StructureSchemaFinder structureSchemaFinder,
@Lazy InMemoryGraphLoader inMemoryGraphLoader
) {
return new InMemoryDescendingSortResolver(
structureSchemaFinder,
inMemoryGraphLoader
);
}
@Bean
public InMemoryOffsetPaginationResolver inMemoryOffsetPaginationResolver(
StructureSchemaFinder structureSchemaFinder
) {
return new InMemoryOffsetPaginationResolver(structureSchemaFinder);
}
@Bean
public GenericInMemoryFilterOptionResolver genericInMemoryFilterOptionResolver(
@Lazy List<InMemoryFilterResolver> inMemoryFilterResolvers
) {
return new GenericInMemoryFilterOptionResolver(inMemoryFilterResolvers);
}
@Bean
public InMemoryAndFilterResolver inMemoryAndFilterResolver(
StructureSchemaFinder structureSchemaFinder,
GenericInMemoryFilterOptionResolver genericInMemoryFilterOptionResolver
) {
return new InMemoryAndFilterResolver(structureSchemaFinder, genericInMemoryFilterOptionResolver);
}
@Bean
public InMemoryOrFilterResolver inMemoryOrFilterResolver(
StructureSchemaFinder structureSchemaFinder,
GenericInMemoryFilterOptionResolver genericInMemoryFilterOptionResolver
) {
return new InMemoryOrFilterResolver(structureSchemaFinder, genericInMemoryFilterOptionResolver);
}
@Bean
public InMemoryNotFilterResolver inMemoryNotFilterResolver(
StructureSchemaFinder structureSchemaFinder,
GenericInMemoryFilterOptionResolver genericInMemoryFilterOptionResolver
) {
return new InMemoryNotFilterResolver(structureSchemaFinder, genericInMemoryFilterOptionResolver);
}
@Bean
public InMemoryAllMatchFilterResolver inMemoryAllMatchFilterResolver(
StructureSchemaFinder structureSchemaFinder,
GenericInMemoryFilterOptionResolver genericInMemoryFilterOptionResolver,
@Lazy InMemoryGraphLoader inMemoryGraphLoader
) {
return new InMemoryAllMatchFilterResolver(
structureSchemaFinder,
genericInMemoryFilterOptionResolver,
inMemoryGraphLoader
);
}
@Bean
public InMemoryAnyMatchFilterResolver inMemoryAnyMatchFilterResolver(
StructureSchemaFinder structureSchemaFinder,
GenericInMemoryFilterOptionResolver genericInMemoryFilterOptionResolver,
@Lazy InMemoryGraphLoader inMemoryGraphLoader
) {
return new InMemoryAnyMatchFilterResolver(
structureSchemaFinder,
genericInMemoryFilterOptionResolver,
inMemoryGraphLoader
);
}
@Bean
public InMemoryNoneMatchFilterResolver inMemoryNoneMatchFilterResolver(
StructureSchemaFinder structureSchemaFinder,
GenericInMemoryFilterOptionResolver genericInMemoryFilterOptionResolver,
@Lazy InMemoryGraphLoader inMemoryGraphLoader
) {
return new InMemoryNoneMatchFilterResolver(
structureSchemaFinder,
genericInMemoryFilterOptionResolver,
inMemoryGraphLoader
);
}
@Bean
public InMemoryContainsFilterResolver inMemoryContainsFilterResolver(
StructureSchemaFinder structureSchemaFinder,
@Lazy InMemoryGraphLoader inMemoryGraphLoader
) {
return new InMemoryContainsFilterResolver(
structureSchemaFinder,
inMemoryGraphLoader
);
}
@Bean
public InMemoryEndsWithFilterResolver inMemoryEndsWithFilterResolver(
StructureSchemaFinder structureSchemaFinder,
@Lazy InMemoryGraphLoader inMemoryGraphLoader
) {
return new InMemoryEndsWithFilterResolver(
structureSchemaFinder,
inMemoryGraphLoader
);
}
@Bean
public InMemoryEqualsFilterResolver inMemoryEqualsFilterResolver(
StructureSchemaFinder structureSchemaFinder,
@Lazy InMemoryGraphLoader inMemoryGraphLoader
) {
return new InMemoryEqualsFilterResolver(
structureSchemaFinder,
inMemoryGraphLoader
);
}
@Bean
public InMemoryGreaterThanFilterResolver inMemoryGreaterThanFilterResolver(
StructureSchemaFinder structureSchemaFinder,
@Lazy InMemoryGraphLoader inMemoryGraphLoader
) {
return new InMemoryGreaterThanFilterResolver(
structureSchemaFinder,
inMemoryGraphLoader
);
}
@Bean
public InMemoryGreaterThanOrEqualsFilterResolver inMemoryGreaterThanOrEqualsFilterResolver(
StructureSchemaFinder structureSchemaFinder,
@Lazy InMemoryGraphLoader inMemoryGraphLoader
) {
return new InMemoryGreaterThanOrEqualsFilterResolver(
structureSchemaFinder,
inMemoryGraphLoader
);
}
@Bean
public InMemoryIsNullFilterResolver inMemoryIsNullFilterResolver(
StructureSchemaFinder structureSchemaFinder,
@Lazy InMemoryGraphLoader inMemoryGraphLoader
) {
return new InMemoryIsNullFilterResolver(
structureSchemaFinder,
inMemoryGraphLoader
);
}
@Bean
public InMemoryLowerThanFilterResolver inMemoryLowerThanFilterResolver(
StructureSchemaFinder structureSchemaFinder,
@Lazy InMemoryGraphLoader inMemoryGraphLoader
) {
return new InMemoryLowerThanFilterResolver(
structureSchemaFinder,
inMemoryGraphLoader
);
}
@Bean
public InMemoryLowerThanOrEqualFilterResolver inMemoryLowerThanOrEqualFilterResolver(
StructureSchemaFinder structureSchemaFinder,
@Lazy InMemoryGraphLoader inMemoryGraphLoader
) {
return new InMemoryLowerThanOrEqualFilterResolver(
structureSchemaFinder,
inMemoryGraphLoader
);
}
@Bean
public InMemoryNotNullFilterResolver inMemoryNotNullFilterResolver(
StructureSchemaFinder structureSchemaFinder,
@Lazy InMemoryGraphLoader inMemoryGraphLoader
) {
return new InMemoryNotNullFilterResolver(
structureSchemaFinder,
inMemoryGraphLoader
);
}
@Bean
public InMemoryNotEqualsFilterResolver inMemoryNotEqualsFilterResolver(
StructureSchemaFinder structureSchemaFinder,
@Lazy InMemoryGraphLoader inMemoryGraphLoader
) {
return new InMemoryNotEqualsFilterResolver(
structureSchemaFinder,
inMemoryGraphLoader
);
}
@Bean
public InMemoryStartsWithFilterResolver inMemoryStartsWithFilterResolver(
StructureSchemaFinder structureSchemaFinder,
@Lazy InMemoryGraphLoader inMemoryGraphLoader
) {
return new InMemoryStartsWithFilterResolver(
structureSchemaFinder,
inMemoryGraphLoader
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/configuration/GraphMappingProviderConfiguration.java | package ai.stapi.graphoperations.configuration;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import ai.stapi.graphoperations.ogmProviders.specific.SpecificGraphMappingProvider;
import ai.stapi.graphoperations.ogmProviders.specific.dynamicObjectGraphMappingProvider.DynamicOgmProvider;
import ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders.BooleanAttributeGraphMappingProvider;
import ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders.EntityIdentifierGraphMappingProvider;
import ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders.IncomingEdgeDescriptionGraphMappingProvider;
import ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders.IntegerAttributeGraphMappingProvider;
import ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders.InterfaceGraphDescriptionGraphMappingProvider;
import ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders.LeafAttributeGraphMappingProvider;
import ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders.NodeDescriptionGraphMappingProvider;
import ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders.OutgoingEdgeDescriptionGraphMappingProvider;
import ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders.RemovalEdgeDescriptionGraphMappingProvider;
import ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders.RemovalNodeDescriptionGraphMappingProvider;
import ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders.StringAttributeGraphMappingProvider;
import ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders.UuidGraphDescriptionGraphMappingProvider;
import ai.stapi.graphoperations.ogmProviders.specific.objectGraphMappingMappingProviders.InterfaceOgmProvider;
import ai.stapi.graphoperations.ogmProviders.specific.objectGraphMappingMappingProviders.LeafOgmProvider;
import ai.stapi.graphoperations.ogmProviders.specific.objectGraphMappingMappingProviders.ListOgmProvider;
import ai.stapi.graphoperations.ogmProviders.specific.objectGraphMappingMappingProviders.MapOgmProvider;
import ai.stapi.graphoperations.ogmProviders.specific.objectGraphMappingMappingProviders.ObjectFieldOgmProvider;
import ai.stapi.graphoperations.ogmProviders.specific.objectGraphMappingMappingProviders.ObjectOgmProvider;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaProvider;
import java.util.List;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.context.annotation.Bean;
@AutoConfiguration
public class GraphMappingProviderConfiguration {
@Bean
public GenericGraphMappingProvider genericGraphMappingProvider(
List<SpecificGraphMappingProvider> specificGraphMappingProviders
) {
return new GenericGraphMappingProvider(specificGraphMappingProviders);
}
@Bean
public DynamicOgmProvider dynamicOgmProvider(
StructureSchemaProvider structureSchemaProvider
) {
return new DynamicOgmProvider(structureSchemaProvider);
}
@Bean
public BooleanAttributeGraphMappingProvider booleanAttributeGraphMappingProvider() {
return new BooleanAttributeGraphMappingProvider();
}
@Bean
public EntityIdentifierGraphMappingProvider entityIdentifierGraphMappingProvider() {
return new EntityIdentifierGraphMappingProvider();
}
@Bean
public IncomingEdgeDescriptionGraphMappingProvider incomingEdgeDescriptionGraphMappingProvider() {
return new IncomingEdgeDescriptionGraphMappingProvider();
}
@Bean
public IntegerAttributeGraphMappingProvider integerAttributeGraphMappingProvider() {
return new IntegerAttributeGraphMappingProvider();
}
@Bean
public InterfaceGraphDescriptionGraphMappingProvider interfaceGraphDescriptionGraphMappingProvider() {
return new InterfaceGraphDescriptionGraphMappingProvider();
}
@Bean
public LeafAttributeGraphMappingProvider leafAttributeGraphMappingProvider() {
return new LeafAttributeGraphMappingProvider();
}
@Bean
public NodeDescriptionGraphMappingProvider nodeDescriptionGraphMappingProvider() {
return new NodeDescriptionGraphMappingProvider();
}
@Bean
public OutgoingEdgeDescriptionGraphMappingProvider outgoingEdgeDescriptionGraphMappingProvider() {
return new OutgoingEdgeDescriptionGraphMappingProvider();
}
@Bean
public RemovalEdgeDescriptionGraphMappingProvider removalEdgeDescriptionGraphMappingProvider() {
return new RemovalEdgeDescriptionGraphMappingProvider();
}
@Bean
public RemovalNodeDescriptionGraphMappingProvider removalNodeDescriptionGraphMappingProvider() {
return new RemovalNodeDescriptionGraphMappingProvider();
}
@Bean
public StringAttributeGraphMappingProvider stringAttributeGraphMappingProvider() {
return new StringAttributeGraphMappingProvider();
}
@Bean
public UuidGraphDescriptionGraphMappingProvider uuidGraphDescriptionGraphMappingProvider() {
return new UuidGraphDescriptionGraphMappingProvider();
}
@Bean
public InterfaceOgmProvider interfaceOgmProvider() {
return new InterfaceOgmProvider();
}
@Bean
public LeafOgmProvider leafOgmProvider() {
return new LeafOgmProvider();
}
@Bean
public ListOgmProvider listOgmProvider() {
return new ListOgmProvider();
}
@Bean
public MapOgmProvider mapOgmProvider() {
return new MapOgmProvider();
}
@Bean
public ObjectFieldOgmProvider objectFieldOgmProvider() {
return new ObjectFieldOgmProvider();
}
@Bean
public ObjectOgmProvider objectOgmProvider() {
return new ObjectOgmProvider();
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/configuration/GraphReaderConfiguration.java | package ai.stapi.graphoperations.configuration;
import ai.stapi.graphoperations.graphReader.GraphReader;
import ai.stapi.graphoperations.graphReader.mappingPartReadResolvers.AttributeDescriptionReadResolver;
import ai.stapi.graphoperations.graphReader.mappingPartReadResolvers.AttributeValueDescriptionReadResolver;
import ai.stapi.graphoperations.graphReader.mappingPartReadResolvers.EdgeDescriptionReadResolver;
import ai.stapi.graphoperations.graphReader.mappingPartReadResolvers.GraphDescriptionReadResolver;
import ai.stapi.graphoperations.graphReader.mappingPartReadResolvers.NodeDescriptionReadResolver;
import ai.stapi.graphoperations.graphReader.mappingPartReadResolvers.UuidDescriptionReadResolver;
import java.util.List;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.context.annotation.Bean;
@AutoConfiguration
public class GraphReaderConfiguration {
@Bean
public GraphReader graphReader(
List<GraphDescriptionReadResolver> graphDescriptionResolvers
) {
return new GraphReader(graphDescriptionResolvers);
}
@Bean
public AttributeDescriptionReadResolver attributeDescriptionReadResolver() {
return new AttributeDescriptionReadResolver();
}
@Bean
public AttributeValueDescriptionReadResolver attributeValueDescriptionReadResolver() {
return new AttributeValueDescriptionReadResolver();
}
@Bean
public EdgeDescriptionReadResolver edgeDescriptionReadResolver() {
return new EdgeDescriptionReadResolver();
}
@Bean
public NodeDescriptionReadResolver nodeDescriptionReadResolver() {
return new NodeDescriptionReadResolver();
}
@Bean
public UuidDescriptionReadResolver uuidDescriptionReadResolver() {
return new UuidDescriptionReadResolver();
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/configuration/GraphSerializationConfiguration.java | package ai.stapi.graphoperations.configuration;
import ai.stapi.graph.attribute.attributeFactory.GenericAttributeFactory;
import ai.stapi.graph.attribute.attributeFactory.attributeValueFactory.GenericAttributeValueFactory;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.GenericGraphToObjectDeserializer;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.specific.InterfaceGraphToObjectDeserializer;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.specific.LeafGraphToObjectDeserializer;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.specific.ListGraphToObjectDeserializer;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.specific.MapGraphToObjectDeserializer;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.specific.ObjectGraphToObjectDeserializer;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.specific.SpecificGraphToObjectDeserializer;
import ai.stapi.graphoperations.graphReader.GraphReader;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import ai.stapi.graphoperations.serializableGraph.deserializer.SerializableAttributeDeserializer;
import ai.stapi.graphoperations.serializableGraph.deserializer.SerializableEdgeDeserializer;
import ai.stapi.graphoperations.serializableGraph.deserializer.SerializableGraphDeserializer;
import ai.stapi.graphoperations.serializableGraph.deserializer.SerializableNodeDeserializer;
import ai.stapi.graphoperations.serializableGraph.jackson.SerializableGraphConfigurer;
import ai.stapi.graphoperations.serializationTypeProvider.GenericSerializationTypeByNodeProvider;
import ai.stapi.graphoperations.serializationTypeProvider.specific.ByMapSerializationTypeProvider;
import ai.stapi.graphoperations.serializationTypeProvider.specific.SpecificSerializationTypeProvider;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Lazy;
@AutoConfiguration
public class GraphSerializationConfiguration {
@Bean
public SerializableGraphConfigurer serializableGraphConfigurer(
SerializableGraphDeserializer serializableGraphDeserializer
) {
return new SerializableGraphConfigurer(serializableGraphDeserializer);
}
@Bean
public SerializableGraphDeserializer serializableGraphDeserializer(
SerializableNodeDeserializer serializableNodeDeserializer,
SerializableEdgeDeserializer serializableEdgeDeserializer
) {
return new SerializableGraphDeserializer(serializableNodeDeserializer, serializableEdgeDeserializer);
}
@Bean
public SerializableNodeDeserializer serializableNodeDeserializer(
SerializableAttributeDeserializer serializableAttributeDeserializer
) {
return new SerializableNodeDeserializer(serializableAttributeDeserializer);
}
@Bean
public SerializableEdgeDeserializer serializableEdgeDeserializer(
SerializableAttributeDeserializer serializableAttributeDeserializer
) {
return new SerializableEdgeDeserializer(serializableAttributeDeserializer);
}
@Bean
public SerializableAttributeDeserializer serializableAttributeDeserializer(
StructureSchemaFinder structureSchemaFinder,
GenericAttributeFactory genericAttributeFactory,
GenericAttributeValueFactory genericAttributeValueFactory
) {
return new SerializableAttributeDeserializer(
structureSchemaFinder,
genericAttributeFactory,
genericAttributeValueFactory
);
}
@Bean
@ConditionalOnBean
public ObjectMapper graphOperationsObjectMapper(
ObjectMapper objectMapper,
SerializableGraphConfigurer serializableGraphConfigurer
) {
serializableGraphConfigurer.configure(objectMapper);
return objectMapper;
}
@Bean
public GenericGraphToObjectDeserializer genericGraphToObjectDeserializer(
@Lazy List<SpecificGraphToObjectDeserializer> specificGraphToObjectDeserializers,
GraphReader graphReader,
ObjectMapper objectMapper,
GenericGraphMappingProvider genericGraphMappingProvider
) {
return new GenericGraphToObjectDeserializer(
specificGraphToObjectDeserializers,
graphReader,
objectMapper,
genericGraphMappingProvider
);
}
@Bean
public InterfaceGraphToObjectDeserializer interfaceGraphToObjectDeserializer(
GraphReader graphReader,
GenericGraphToObjectDeserializer genericDeserializer,
GenericSerializationTypeByNodeProvider serializationTypeProvider,
GenericGraphMappingProvider mappingProvider
) {
return new InterfaceGraphToObjectDeserializer(
graphReader,
genericDeserializer,
serializationTypeProvider,
mappingProvider
);
}
@Bean
public LeafGraphToObjectDeserializer leafGraphToObjectDeserializer(
GraphReader graphReader,
GenericGraphToObjectDeserializer genericDeserializer,
GenericSerializationTypeByNodeProvider serializationTypeProvider,
GenericGraphMappingProvider mappingProvider
) {
return new LeafGraphToObjectDeserializer(
graphReader,
genericDeserializer,
serializationTypeProvider,
mappingProvider
);
}
@Bean
public ListGraphToObjectDeserializer listGraphToObjectDeserializer(
GraphReader graphReader,
GenericGraphToObjectDeserializer genericDeserializer,
GenericSerializationTypeByNodeProvider serializationTypeProvider,
GenericGraphMappingProvider mappingProvider
) {
return new ListGraphToObjectDeserializer(
graphReader,
genericDeserializer,
serializationTypeProvider,
mappingProvider
);
}
@Bean
public MapGraphToObjectDeserializer mapGraphToObjectDeserializer(
GraphReader graphReader,
GenericGraphToObjectDeserializer genericDeserializer,
GenericSerializationTypeByNodeProvider serializationTypeProvider,
GenericGraphMappingProvider mappingProvider
) {
return new MapGraphToObjectDeserializer(
graphReader,
genericDeserializer,
serializationTypeProvider,
mappingProvider
);
}
@Bean
public ObjectGraphToObjectDeserializer objectGraphToObjectDeserializer(
GraphReader graphReader,
GenericGraphToObjectDeserializer genericDeserializer,
GenericSerializationTypeByNodeProvider serializationTypeProvider,
GenericGraphMappingProvider mappingProvider
) {
return new ObjectGraphToObjectDeserializer(
graphReader,
genericDeserializer,
serializationTypeProvider,
mappingProvider
);
}
@Bean
public GenericSerializationTypeByNodeProvider genericSerializationTypeByNodeProvider(
List<SpecificSerializationTypeProvider> specificSerializationTypeProviders
) {
return new GenericSerializationTypeByNodeProvider(specificSerializationTypeProviders);
}
@Bean
public ByMapSerializationTypeProvider byMapSerializationTypeProvider() {
return new ByMapSerializationTypeProvider();
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/configuration/GraphSynchronizationConfiguration.java | package ai.stapi.graphoperations.configuration;
import ai.stapi.graph.EdgeRepository;
import ai.stapi.graph.NodeRepository;
import ai.stapi.graphoperations.graphLoader.GraphLoader;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGenericSearchOptionResolver;
import ai.stapi.graphoperations.graphReader.GraphReader;
import ai.stapi.graphoperations.synchronization.GraphSynchronizer;
import ai.stapi.graphoperations.synchronization.IdentifyingGraphSynchronizer;
import ai.stapi.graphoperations.synchronization.nodeIdentificator.DefaultUuidIdentityIdentificatorProvider;
import ai.stapi.graphoperations.synchronization.nodeIdentificator.GenericNodeIdentificatorsProvider;
import ai.stapi.graphoperations.synchronization.nodeIdentificator.NodeIdentificatorsProvider;
import ai.stapi.graphoperations.synchronization.nodeIdentificator.NodeIdentifyingFiltersResolver;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Lazy;
@AutoConfiguration
public class GraphSynchronizationConfiguration {
@Bean
@ConditionalOnMissingBean
public GraphSynchronizer identifyingGraphSynchronizer(
@Lazy NodeRepository nodeRepository,
@Lazy EdgeRepository edgeRepository,
NodeIdentifyingFiltersResolver nodeIdentifyingFiltersResolver,
GraphLoader graphLoader,
InMemoryGenericSearchOptionResolver searchOptionResolver,
ObjectMapper objectMapper,
StructureSchemaFinder structureSchemaFinder
) {
return new IdentifyingGraphSynchronizer(
nodeRepository,
edgeRepository,
nodeIdentifyingFiltersResolver,
graphLoader,
searchOptionResolver,
objectMapper,
structureSchemaFinder
);
}
@Bean
public GenericNodeIdentificatorsProvider genericNodeIdentificatorsProvider(
List<NodeIdentificatorsProvider> nodeIdentificatorsProviders
) {
return new GenericNodeIdentificatorsProvider(nodeIdentificatorsProviders);
}
@Bean
public DefaultUuidIdentityIdentificatorProvider defaultUuidIdentityIdentificatorProvider() {
return new DefaultUuidIdentityIdentificatorProvider();
}
@Bean
public NodeIdentifyingFiltersResolver nodeIdentifyingFiltersResolver(
GenericNodeIdentificatorsProvider genericNodeIdentificatorsProvider,
GraphReader graphReader
) {
return new NodeIdentifyingFiltersResolver(genericNodeIdentificatorsProvider, graphReader);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/configuration/GraphToMapObjectMapperConfiguration.java | package ai.stapi.graphoperations.configuration;
import ai.stapi.graphoperations.graphReader.GraphReader;
import ai.stapi.graphoperations.graphToMapObjectMapper.GraphToMapObjectMapper;
import ai.stapi.graphoperations.graphToMapObjectMapper.specific.InterfaceGraphToMapMapper;
import ai.stapi.graphoperations.graphToMapObjectMapper.specific.LeafGraphToMapMapper;
import ai.stapi.graphoperations.graphToMapObjectMapper.specific.ListGraphToMapMapper;
import ai.stapi.graphoperations.graphToMapObjectMapper.specific.ObjectGraphToMapMapper;
import ai.stapi.graphoperations.graphToMapObjectMapper.specific.ReferenceGraphToMapMapper;
import ai.stapi.graphoperations.graphToMapObjectMapper.specific.SpecificGraphToMapMapper;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import java.util.List;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Lazy;
@AutoConfiguration
public class GraphToMapObjectMapperConfiguration {
@Bean
public GraphToMapObjectMapper graphToMapObjectMapper(
@Lazy List<SpecificGraphToMapMapper> specificGraphToMapMappers,
GenericGraphMappingProvider genericGraphMappingProvider
) {
return new GraphToMapObjectMapper(specificGraphToMapMappers, genericGraphMappingProvider);
}
@Bean
public InterfaceGraphToMapMapper interfaceGraphToMapMapper(
GraphReader graphReader,
GraphToMapObjectMapper graphToMapObjectMapper,
GenericGraphMappingProvider genericGraphMappingProvider
) {
return new InterfaceGraphToMapMapper(graphReader, graphToMapObjectMapper, genericGraphMappingProvider);
}
@Bean
public LeafGraphToMapMapper leafGraphToMapMapper(
GraphReader graphReader,
GraphToMapObjectMapper graphToMapObjectMapper,
GenericGraphMappingProvider genericGraphMappingProvider
) {
return new LeafGraphToMapMapper(graphReader, graphToMapObjectMapper, genericGraphMappingProvider);
}
@Bean
public ListGraphToMapMapper listGraphToMapMapper(
GraphReader graphReader,
GraphToMapObjectMapper graphToMapObjectMapper,
GenericGraphMappingProvider genericGraphMappingProvider
) {
return new ListGraphToMapMapper(graphReader, graphToMapObjectMapper, genericGraphMappingProvider);
}
@Bean
public ObjectGraphToMapMapper objectGraphToMapMapper(
GraphReader graphReader,
GraphToMapObjectMapper graphToMapObjectMapper,
GenericGraphMappingProvider genericGraphMappingProvider
) {
return new ObjectGraphToMapMapper(graphReader, graphToMapObjectMapper, genericGraphMappingProvider);
}
@Bean
public ReferenceGraphToMapMapper referenceGraphToMapMapper(
GraphReader graphReader,
GraphToMapObjectMapper graphToMapObjectMapper,
GenericGraphMappingProvider genericGraphMappingProvider
) {
return new ReferenceGraphToMapMapper(graphReader, graphToMapObjectMapper, genericGraphMappingProvider);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/configuration/GraphWriterConfiguration.java | package ai.stapi.graphoperations.configuration;
import ai.stapi.graph.attribute.attributeFactory.GenericAttributeFactory;
import ai.stapi.graphoperations.graphWriter.GenericGraphWriter;
import ai.stapi.graphoperations.graphWriter.SpecificGraphWriter;
import ai.stapi.graphoperations.graphWriter.specific.AttributeGraphWriter;
import ai.stapi.graphoperations.graphWriter.specific.AttributeValueSpecificGraphWriter;
import ai.stapi.graphoperations.graphWriter.specific.ConstantSpecificGraphWriter;
import ai.stapi.graphoperations.graphWriter.specific.EdgeGraphWriter;
import ai.stapi.graphoperations.graphWriter.specific.NodeGraphWriter;
import ai.stapi.graphoperations.graphWriter.specific.RemovalEdgeGraphWriter;
import ai.stapi.graphoperations.graphWriter.specific.RemovalNodeGraphWriter;
import ai.stapi.graphoperations.graphWriter.specific.UuidGraphWriter;
import java.util.List;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.context.annotation.Bean;
@AutoConfiguration
public class GraphWriterConfiguration {
@Bean
public GenericGraphWriter genericGraphWriter(
List<SpecificGraphWriter> specificGraphWriters,
GenericAttributeFactory genericAttributeFactory
) {
return new GenericGraphWriter(specificGraphWriters, genericAttributeFactory);
}
@Bean
public AttributeGraphWriter attributeGraphWriter() {
return new AttributeGraphWriter();
}
@Bean
public AttributeValueSpecificGraphWriter attributeValueSpecificGraphWriter() {
return new AttributeValueSpecificGraphWriter();
}
@Bean
public ConstantSpecificGraphWriter constantSpecificGraphWriter() {
return new ConstantSpecificGraphWriter();
}
@Bean
public EdgeGraphWriter edgeGraphWriter() {
return new EdgeGraphWriter();
}
@Bean
public NodeGraphWriter nodeGraphWriter() {
return new NodeGraphWriter();
}
@Bean
public RemovalEdgeGraphWriter removalEdgeGraphWriter() {
return new RemovalEdgeGraphWriter();
}
@Bean
public RemovalNodeGraphWriter removalNodeGraphWriter() {
return new RemovalNodeGraphWriter();
}
@Bean
public UuidGraphWriter uuidGraphWriter() {
return new UuidGraphWriter();
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/configuration/ObjectGraphMapperConfiguration.java | package ai.stapi.graphoperations.configuration;
import ai.stapi.graphoperations.graphWriter.GenericGraphWriter;
import ai.stapi.graphoperations.objectGraphMapper.infrastructure.structureSchema.StructureSchemaInterfaceSpecificObjectGraphMapperFixStrategy;
import ai.stapi.graphoperations.objectGraphMapper.model.GenericObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.SpecificObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.specific.InterfaceSpecificObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.specific.InterfaceSpecificObjectGraphMapperFixStrategy;
import ai.stapi.graphoperations.objectGraphMapper.model.specific.LeafSpecificObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.specific.ListSpecificObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.specific.MapSpecificObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.specific.ObjectSpecificObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.specific.ReferenceSpecificObjectGraphMapper;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaProvider;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Lazy;
@AutoConfiguration
public class ObjectGraphMapperConfiguration {
@Bean
public GenericObjectGraphMapper genericObjectGraphMapper(
@Lazy List<SpecificObjectGraphMapper> specificObjectGraphMappers,
GenericGraphWriter writer,
GenericGraphMappingProvider mappingProvider
) {
return new GenericObjectGraphMapper(specificObjectGraphMappers, writer, mappingProvider);
}
@Bean
public InterfaceSpecificObjectGraphMapper interfaceSpecificObjectGraphMapper(
GenericObjectGraphMapper genericGraphMapper,
GenericGraphMappingProvider mappingProvider,
@Autowired(required = false)
InterfaceSpecificObjectGraphMapperFixStrategy interfaceSpecificObjectGraphMapperFixStrategy
) {
return new InterfaceSpecificObjectGraphMapper(
genericGraphMapper,
mappingProvider,
interfaceSpecificObjectGraphMapperFixStrategy
);
}
@Bean
public LeafSpecificObjectGraphMapper leafSpecificObjectGraphMapper(
GenericObjectGraphMapper genericObjectGraphMapper
) {
return new LeafSpecificObjectGraphMapper(genericObjectGraphMapper);
}
@Bean
public ListSpecificObjectGraphMapper listSpecificObjectGraphMapper(
GenericObjectGraphMapper genericObjectGraphMapper
) {
return new ListSpecificObjectGraphMapper(genericObjectGraphMapper);
}
@Bean
public MapSpecificObjectGraphMapper mapSpecificObjectGraphMapper(
GenericObjectGraphMapper genericObjectGraphMapper
) {
return new MapSpecificObjectGraphMapper(genericObjectGraphMapper);
}
@Bean
public ObjectSpecificObjectGraphMapper objectSpecificObjectGraphMapper(
GenericObjectGraphMapper genericObjectGraphMapper
) {
return new ObjectSpecificObjectGraphMapper(genericObjectGraphMapper);
}
@Bean
public ReferenceSpecificObjectGraphMapper referenceSpecificObjectGraphMapper(
GenericObjectGraphMapper genericObjectGraphMapper,
GenericGraphMappingProvider mappingProvider
) {
return new ReferenceSpecificObjectGraphMapper(genericObjectGraphMapper, mappingProvider);
}
@Bean
public StructureSchemaInterfaceSpecificObjectGraphMapperFixStrategy structureSchemaInterfaceSpecificObjectGraphMapperFixStrategy(
StructureSchemaProvider structureSchemaProvider
) {
return new StructureSchemaInterfaceSpecificObjectGraphMapperFixStrategy(structureSchemaProvider);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/dagtoobjectconverter/DAGToObjectConverter.java | package ai.stapi.graphoperations.dagtoobjectconverter;
import ai.stapi.graph.traversableGraphElements.TraversableEdge;
import ai.stapi.graph.traversableGraphElements.TraversableNode;
import ai.stapi.graphoperations.dagtoobjectconverter.exceptions.CannotConvertDAGToObject;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import org.jetbrains.annotations.NotNull;
import java.util.*;
public class DAGToObjectConverter {
private static final String ID_FIELD_NAME = "id";
private final StructureSchemaFinder structureSchemaFinder;
public DAGToObjectConverter(StructureSchemaFinder structureSchemaFinder) {
this.structureSchemaFinder = structureSchemaFinder;
}
public Map<String, Object> convert(TraversableNode startNode) throws CannotConvertDAGToObject {
return new Convertor(this.structureSchemaFinder).convert(startNode);
}
private static class Convertor {
private final NodeSet nodeSet;
private final StructureSchemaFinder structureSchemaFinder;
public Convertor(StructureSchemaFinder structureSchemaFinder) {
this.nodeSet = new NodeSet();
this.structureSchemaFinder = structureSchemaFinder;
}
public Map<String, Object> convert(TraversableNode startNode) throws CannotConvertDAGToObject {
this.nodeSet.saveNode(startNode);
var object = this.convertNodeToObject(startNode);
startNode.getOutgoingEdges()
.stream()
.sorted(Comparator.comparingInt(TraversableEdge::hashCode))
.forEach(edge -> {
var nodeTo = edge.getNodeTo();
if (this.nodeSet.hasNode(nodeTo)) {
throw CannotConvertDAGToObject.becauseItContainsCycle(nodeTo);
}
var fieldDefinition = this.structureSchemaFinder.getFieldDefinitionOrFallback(
startNode.getType(),
edge.getType()
);
if (fieldDefinition.isList()) {
var list = (List<Object>) object.computeIfAbsent(edge.getType(), key -> new ArrayList<>());
list.add(this.convert(nodeTo));
} else {
object.put(edge.getType(), this.convert(nodeTo));
}
});
return object;
}
@NotNull
private HashMap<String, Object> convertNodeToObject(TraversableNode startNode) {
var object = new HashMap<String, Object>(Map.of(
ID_FIELD_NAME, startNode.getId().getId()
));
startNode.getVersionedAttributeList().forEach(versionedAttribute -> {
var current = versionedAttribute.getCurrent();
object.put(current.getName(), current.getValue());
});
return object;
}
}
private static class NodeSet {
private final Map<String, Set<UniqueIdentifier>> visitedNodes;
public NodeSet() {
this.visitedNodes = new HashMap<>();
}
public void saveNode(TraversableNode node) {
this.visitedNodes
.computeIfAbsent(node.getType(), key -> new HashSet<>())
.add(node.getId());
}
public boolean hasNode(TraversableNode node) {
var nodesByType = this.visitedNodes.get(node.getType());
return nodesByType != null && nodesByType.contains(node.getId());
}
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/dagtoobjectconverter | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/dagtoobjectconverter/exceptions/CannotConvertDAGToObject.java | package ai.stapi.graphoperations.dagtoobjectconverter.exceptions;
import ai.stapi.graph.traversableGraphElements.TraversableNode;
public class CannotConvertDAGToObject extends RuntimeException {
private CannotConvertDAGToObject(String message) {
super("Cannot convert DAG to Object, because " + message);
}
public static CannotConvertDAGToObject becauseItContainsCycle(TraversableNode twiceVisitedNode) {
return new CannotConvertDAGToObject(
String.format(
"it contains cycle. Twice visited node: '%s/%s'",
twiceVisitedNode.getType(),
twiceVisitedNode.getId()
)
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/declaration/AbstractDeclaration.java | package ai.stapi.graphoperations.declaration;
import ai.stapi.serialization.AbstractSerializableObject;
public abstract class AbstractDeclaration extends AbstractSerializableObject
implements Declaration {
protected AbstractDeclaration(String serializationType) {
super(serializationType);
}
protected AbstractDeclaration() {
}
@Override
public abstract String getDeclarationType();
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/declaration/Declaration.java | package ai.stapi.graphoperations.declaration;
import ai.stapi.serialization.SerializableObject;
public interface Declaration extends SerializableObject {
String INTERFACE_UUID = "1b70940b-a231-45c7-ab32-51381a7163a2";
String getSerializationType();
String getDeclarationType();
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer/GenericGraphToObjectDeserializer.java | package ai.stapi.graphoperations.graphDeserializers.ogmDeserializer;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.exception.GenericGraphOgmDeserializerException;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.specific.InterfaceGraphToObjectDeserializer;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.specific.SpecificGraphToObjectDeserializer;
import ai.stapi.graphoperations.graphReader.GraphReader;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import com.fasterxml.jackson.databind.ObjectMapper;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.serialization.SerializableObject;
import java.util.List;
public class GenericGraphToObjectDeserializer {
protected final GraphReader graphReader;
protected final GenericGraphMappingProvider mappingProvider;
private final List<SpecificGraphToObjectDeserializer> specificDeserializers;
private final ObjectMapper objectMapper;
public GenericGraphToObjectDeserializer(
List<SpecificGraphToObjectDeserializer> specificDeserializers,
GraphReader graphReader,
ObjectMapper objectMapper,
GenericGraphMappingProvider mappingProvider
) {
this.specificDeserializers = specificDeserializers;
this.graphReader = graphReader;
this.objectMapper = objectMapper;
this.mappingProvider = mappingProvider;
}
@SuppressWarnings("unchecked")
public <T extends SerializableObject> T deserialize(
TraversableGraphElement element,
Class<T> classType,
InMemoryGraphRepository contextualGraph,
MissingTraversalTargetResolvingStrategy missingTraversalTargetResolvingStrategy
) {
var anonymousObject = this.getInterfaceDeserializer().deserialize(
List.of(element),
new NullGraphDescription(),
null,
contextualGraph,
missingTraversalTargetResolvingStrategy
);
return (T) this.objectMapper.convertValue(anonymousObject, SerializableObject.class);
}
@SuppressWarnings("unchecked")
public <T extends SerializableObject> T deserialize(
TraversableGraphElement element,
Class<T> classType,
InMemoryGraphRepository contextualGraph
) {
var anonymousObject = this.getInterfaceDeserializer().deserialize(
List.of(element),
new NullGraphDescription(),
null,
contextualGraph,
MissingTraversalTargetResolvingStrategy.STRICT
);
return (T) this.objectMapper.convertValue(anonymousObject, SerializableObject.class);
}
public Object resolveInternally(
List<TraversableGraphElement> elements,
GraphDescription parentGraphDescription,
ObjectGraphMapping objectGraphMapping,
InMemoryGraphRepository contextualGraph,
MissingTraversalTargetResolvingStrategy missingTraversalTargetResolvingStrategy
) {
var deserializer = this.getSupportingDeserializer(
elements,
objectGraphMapping
);
return deserializer.deserialize(
elements,
parentGraphDescription,
objectGraphMapping,
contextualGraph,
missingTraversalTargetResolvingStrategy
);
}
private SpecificGraphToObjectDeserializer getSupportingDeserializer(
List<TraversableGraphElement> elements,
ObjectGraphMapping objectGraphMapping
) {
var supportingDeserializers = this.specificDeserializers.stream()
.filter(deserializer -> deserializer.supports(objectGraphMapping, elements))
.toList();
if (supportingDeserializers.isEmpty()) {
throw GenericGraphOgmDeserializerException.becauseNodeTypeIsNotSupported(
elements.get(0).getType());
}
if (supportingDeserializers.size() > 1) {
throw GenericGraphOgmDeserializerException.becauseNodeTypeIsSupportedByMultipleDeserializers(
elements.get(0).getType(),
supportingDeserializers.stream()
.map(SpecificGraphToObjectDeserializer::getClass)
.map(Class::getSimpleName)
.toList()
);
}
return supportingDeserializers.get(0);
}
private SpecificGraphToObjectDeserializer getInterfaceDeserializer() {
return this.specificDeserializers.stream()
.filter(InterfaceGraphToObjectDeserializer.class::isInstance)
.toList()
.get(0);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer/MissingTraversalTargetResolvingStrategy.java | package ai.stapi.graphoperations.graphDeserializers.ogmDeserializer;
public enum MissingTraversalTargetResolvingStrategy {
STRICT,
LENIENT
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer/SpecificDeserializer.java | package ai.stapi.graphoperations.graphDeserializers.ogmDeserializer;
public interface SpecificDeserializer {
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer/exception/GenericGraphOgmDeserializerException.java | package ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.exception;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.ogmProviders.specific.objectGraphMappingMappingProviders.OgmGraphElementTypes;
import ai.stapi.graphoperations.graphReader.exception.GraphReaderException;
import ai.stapi.graphoperations.graphReader.readResults.ReadResult;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectObjectGraphMapping;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.graphoperations.serializationTypeProvider.specific.SpecificSerializationTypeProvider;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
public class GenericGraphOgmDeserializerException extends RuntimeException {
private GenericGraphOgmDeserializerException(String message) {
super(message);
}
public static GenericGraphOgmDeserializerException becauseNodeTypeIsNotSupported(
String nodeType) {
return new GenericGraphOgmDeserializerException(
"There are no supporting "
+ SpecificSerializationTypeProvider.class.getSimpleName()
+ " provider for node of type '"
+ nodeType + "'."
);
}
public static GenericGraphOgmDeserializerException becauseNodeTypeIsSupportedByMultipleDeserializers(
String nodeType,
List<String> supportingDeserializerClassNames
) {
return new GenericGraphOgmDeserializerException(
"Node of type '" + nodeType
+ "' is supported by multiple deserializers: ["
+ StringUtils.join(supportingDeserializerClassNames, ", ")
+ "]."
);
}
public static GenericGraphOgmDeserializerException becauseDeserializationHasToStartFromObjectGraphMapping(
String providedNodeType) {
return new GenericGraphOgmDeserializerException(
"Deserialization has to start from "
+ ObjectObjectGraphMapping.class.getSimpleName()
+ " serialized under node '"
+ OgmGraphElementTypes.OGM_OBJECT_NODE
+ "'. Provided node type was: '"
+ providedNodeType + "'."
);
}
public static GenericGraphOgmDeserializerException becauseThereIsMultipleGraphBranchesButMappingIsNotForList() {
return new GenericGraphOgmDeserializerException(
"Graph description led to multiple graph branches but provided "
+ ObjectGraphMapping.class.getSimpleName()
+ " did not point to list."
);
}
public static GenericGraphOgmDeserializerException becauseGraphTraversingLedToMultipleBranches(
String elementType) {
return new GenericGraphOgmDeserializerException(
GraphDescription.class.getSimpleName()
+ " inside " + ObjectObjectGraphMapping.class.getSimpleName()
+ " led from element of type '" + elementType
+ "' to multiple graph branches and that is not allowed."
);
}
public static GenericGraphOgmDeserializerException becauseGraphReadingAccordingToOgmFailed(
String currentElementType,
PositiveGraphDescription declaration,
GraphReaderException exception
) {
return new GenericGraphOgmDeserializerException(
"Traversing graph from element of type '" + currentElementType
+ "' using " + declaration.getClass().getSimpleName()
+ " failed. Ogm doesn't correspond to the actual graph structure saved. "
+ System.lineSeparator()
+ "Cause: " + exception.getMessage()
);
}
public static GenericGraphOgmDeserializerException becauseElementWasNotFound(
UniqueIdentifier graphElementId) {
return new GenericGraphOgmDeserializerException(
"Graph element with id [" + graphElementId
+ "] was not found in graph. This should have never happen!"
);
}
public static GenericGraphOgmDeserializerException givenReadResultIsNotGraphElement() {
return new GenericGraphOgmDeserializerException(
ReadResult.class.getSimpleName() + " does not contain traversable graph element in it."
);
}
public static GenericGraphOgmDeserializerException becauseGraphTraversingLedToNoBranches(
String type) {
return new GenericGraphOgmDeserializerException(
GraphDescription.class.getSimpleName()
+ " inside " + ObjectObjectGraphMapping.class.getSimpleName()
+ " led from element of type '" + type
+ "' to no graph branches and that is not allowed."
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer/specific/AbstractSpecificGraphToObjectDeserializer.java | package ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.specific;
import ai.stapi.graph.exceptions.NodeNotFound;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graph.traversableGraphElements.TraversableEdge;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graph.traversableGraphElements.TraversableNode;
import ai.stapi.graphoperations.declaration.Declaration;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.GenericGraphToObjectDeserializer;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.MissingTraversalTargetResolvingStrategy;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.exception.GenericGraphOgmDeserializerException;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.EdgeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.IngoingEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.OutgoingEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphReader.GraphReader;
import ai.stapi.graphoperations.graphReader.exception.GraphReaderException;
import ai.stapi.graphoperations.graphReader.readResults.AbstractGraphElementReadResult;
import ai.stapi.graphoperations.graphReader.readResults.ReadResult;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import ai.stapi.graphoperations.serializationTypeProvider.GenericSerializationTypeByNodeProvider;
import ai.stapi.identity.UniqueIdentifier;
import java.util.ArrayList;
import java.util.List;
public abstract class AbstractSpecificGraphToObjectDeserializer implements SpecificGraphToObjectDeserializer {
protected final GraphReader graphReader;
protected final GenericGraphToObjectDeserializer genericDeserializer;
protected final GenericSerializationTypeByNodeProvider serializationTypeProvider;
protected final GenericGraphMappingProvider mappingProvider;
protected AbstractSpecificGraphToObjectDeserializer(
GraphReader graphReader,
GenericGraphToObjectDeserializer genericDeserializer,
GenericSerializationTypeByNodeProvider serializationTypeProvider,
GenericGraphMappingProvider mappingProvider
) {
this.graphReader = graphReader;
this.genericDeserializer = genericDeserializer;
this.serializationTypeProvider = serializationTypeProvider;
this.mappingProvider = mappingProvider;
}
protected TraversableGraphElement traverseSingleGraphBranch(
UniqueIdentifier firstElementId,
String firstElementType,
Declaration declaration,
InMemoryGraphRepository contextualGraph
) {
var traversable = this.loadElement(firstElementId, firstElementType, contextualGraph);
if (!(declaration instanceof PositiveGraphDescription graphDescription)) {
return traversable;
}
if (declaration instanceof NullGraphDescription) {
return traversable;
}
List<ReadResult> results;
try {
if (this.doesGraphDescriptionDescribesGivenGraphElement(traversable, graphDescription)) {
results = this.graphReader.read(
firstElementId,
(PositiveGraphDescription) declaration,
contextualGraph
);
} else {
results = this.graphReader.readFromUncertainFirstElement(
firstElementId,
firstElementType,
(PositiveGraphDescription) declaration,
contextualGraph
);
}
if (results.size() > 1) {
throw GenericGraphOgmDeserializerException.becauseGraphTraversingLedToMultipleBranches(
traversable.getType());
}
if (results.isEmpty()) {
throw GenericGraphOgmDeserializerException.becauseGraphTraversingLedToNoBranches(
traversable.getType()
);
}
return this.convertReadResultToTraversableGraphElement(results.get(0));
} catch (GraphReaderException exception) {
throw GenericGraphOgmDeserializerException.becauseGraphReadingAccordingToOgmFailed(
traversable.getType(),
(PositiveGraphDescription) declaration,
exception
);
}
}
protected List<TraversableGraphElement> traverseMultipleGraphBranch(
UniqueIdentifier firstElementId,
String firstElementType,
Declaration declaration,
InMemoryGraphRepository contextualGraph
) {
var traversable = this.loadElement(firstElementId, firstElementType, contextualGraph);
if (!(declaration instanceof PositiveGraphDescription graphDescription)) {
return List.of(traversable);
}
if (declaration instanceof NullGraphDescription) {
return List.of(traversable);
}
List<ReadResult> results;
try {
if (this.doesGraphDescriptionDescribesGivenGraphElement(traversable, graphDescription)) {
results = this.graphReader.read(
firstElementId,
(PositiveGraphDescription) declaration,
contextualGraph
);
} else {
results = this.graphReader.readFromUncertainFirstElement(
firstElementId,
firstElementType,
(PositiveGraphDescription) declaration,
contextualGraph
);
}
return results.stream()
.map(this::convertReadResultToTraversableGraphElement)
.toList();
} catch (GraphReaderException exception) {
throw GenericGraphOgmDeserializerException.becauseGraphReadingAccordingToOgmFailed(
traversable.getType(),
(PositiveGraphDescription) declaration,
exception
);
}
}
protected Object traverseSingleGraphBranchToValue(
UniqueIdentifier firstElementId,
String firstElementType,
Declaration declaration,
InMemoryGraphRepository contextualGraph,
MissingTraversalTargetResolvingStrategy missingFieldStrategy
) {
var traversable = this.loadElement(firstElementId, firstElementType, contextualGraph);
if (!(declaration instanceof PositiveGraphDescription graphDescription)) {
return "";
}
if (declaration instanceof NullGraphDescription) {
return "";
}
List<Object> results;
try {
if (this.doesGraphDescriptionDescribesGivenGraphElement(traversable, graphDescription)) {
results = this.graphReader.readValues(
firstElementId,
(PositiveGraphDescription) declaration,
contextualGraph
);
} else {
results = this.graphReader.readValuesFromUncertainFirstElement(
firstElementId,
firstElementType,
(PositiveGraphDescription) declaration,
contextualGraph
);
}
if (results.size() > 1) {
throw GenericGraphOgmDeserializerException.becauseGraphTraversingLedToMultipleBranches(
traversable.getType());
}
if (missingFieldStrategy.equals(MissingTraversalTargetResolvingStrategy.LENIENT)) {
if (results.isEmpty()) {
return null;
}
}
return results.get(0);
} catch (GraphReaderException exception) {
throw GenericGraphOgmDeserializerException.becauseGraphReadingAccordingToOgmFailed(
traversable.getType(),
(PositiveGraphDescription) declaration,
exception
);
}
}
protected boolean doesGraphDescriptionDescribesGivenGraphElement(
TraversableGraphElement element,
GraphDescription graphDescription
) {
if (element instanceof TraversableNode node
&& graphDescription instanceof NodeDescription nodeDescription) {
var parameters = (NodeDescriptionParameters) nodeDescription.getParameters();
return node.getType().equals(parameters.getNodeType());
}
if (element instanceof TraversableEdge edge
&& graphDescription instanceof AbstractEdgeDescription edgeDescription) {
var parameters = (EdgeDescriptionParameters) edgeDescription.getParameters();
return edge.getType().equals(parameters.getEdgeType());
}
return false;
}
protected TraversableGraphElement loadElement(
UniqueIdentifier graphElementId,
String graphElementType,
InMemoryGraphRepository graph
) {
try {
return graph.loadNode(graphElementId, graphElementType);
} catch (NodeNotFound ignored) {
}
try {
return graph.loadEdge(graphElementId, graphElementType);
} catch (NodeNotFound ignored) {
}
throw GenericGraphOgmDeserializerException.becauseElementWasNotFound(graphElementId);
}
protected TraversableGraphElement convertReadResultToTraversableGraphElement(
ReadResult readResult
) {
if (readResult instanceof AbstractGraphElementReadResult elementReadResult) {
return elementReadResult.getGraphElement();
}
throw GenericGraphOgmDeserializerException.givenReadResultIsNotGraphElement();
}
protected GraphDescription updateLastGraphDescription(GraphDescription lastGraphDescription,
GraphDescription lastlyTraversedDescription) {
if (lastlyTraversedDescription instanceof NullGraphDescription) {
return lastGraphDescription;
}
return GraphDescriptionBuilder.getGraphDescriptionAsStream(lastlyTraversedDescription)
.filter(description -> description.getChildGraphDescriptions().isEmpty())
.toList()
.get(0);
}
protected List<TraversableGraphElement> ensureElementsAreNodes(
List<TraversableGraphElement> traversedField, GraphDescription lastGraphDescription) {
if (traversedField.isEmpty()) {
return new ArrayList<>();
}
if (!(traversedField.get(0) instanceof TraversableEdge)) {
return traversedField;
}
if (lastGraphDescription instanceof OutgoingEdgeDescription) {
return traversedField.stream()
.map(TraversableEdge.class::cast)
.map(traversableEdge -> (TraversableGraphElement) traversableEdge.getNodeTo())
.toList();
}
if (lastGraphDescription instanceof IngoingEdgeDescription) {
return traversedField.stream()
.map(TraversableEdge.class::cast)
.map(traversableEdge -> (TraversableGraphElement) traversableEdge.getNodeFrom())
.toList();
}
return traversedField;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer/specific/InterfaceGraphToObjectDeserializer.java | package ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.specific;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.GenericGraphToObjectDeserializer;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.MissingTraversalTargetResolvingStrategy;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.exception.GenericGraphOgmDeserializerException;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.graphReader.GraphReader;
import ai.stapi.graphoperations.objectGraphLanguage.InterfaceObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectObjectGraphMapping;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import ai.stapi.serialization.AbstractSerializableObject;
import ai.stapi.graphoperations.serializationTypeProvider.GenericSerializationTypeByNodeProvider;
import java.util.List;
import java.util.Map;
public class InterfaceGraphToObjectDeserializer extends AbstractSpecificGraphToObjectDeserializer {
public InterfaceGraphToObjectDeserializer(
GraphReader graphReader,
GenericGraphToObjectDeserializer genericDeserializer,
GenericSerializationTypeByNodeProvider serializationTypeProvider,
GenericGraphMappingProvider mappingProvider
) {
super(graphReader, genericDeserializer, serializationTypeProvider, mappingProvider);
}
@SuppressWarnings("unchecked")
@Override
public Object deserialize(
List<TraversableGraphElement> elements,
GraphDescription lastGraphDescription,
ObjectGraphMapping graphMapping,
InMemoryGraphRepository contextualGraph,
MissingTraversalTargetResolvingStrategy missingTraversalTargetResolvingStrategy
) {
if (elements.size() == 0) {
return null;
}
if (elements.size() > 1) {
throw GenericGraphOgmDeserializerException.becauseThereIsMultipleGraphBranchesButMappingIsNotForList();
}
elements = this.ensureElementsAreNodes(elements, lastGraphDescription);
var rootElement = elements.get(0);
if (!this.serializationTypeProvider.existsSerializationTypeForNode(rootElement)) {
throw GenericGraphOgmDeserializerException.becauseNodeTypeIsNotSupported(
rootElement.getType());
}
var serializationType = this.serializationTypeProvider.getSerializationType(rootElement);
var objectGraphMapping =
(ObjectObjectGraphMapping) this.mappingProvider.provideGraphMapping(serializationType);
var objectMap = (Map<String, Object>) this.genericDeserializer.resolveInternally(
elements,
new NullGraphDescription(),
objectGraphMapping,
contextualGraph,
missingTraversalTargetResolvingStrategy
);
objectMap.put(
AbstractSerializableObject.NAME_OF_FIELD_WITH_SERIALIZATION_TYPE,
serializationType
);
return objectMap;
}
@Override
public boolean supports(
ObjectGraphMapping objectGraphMapping,
List<TraversableGraphElement> elements
) {
return objectGraphMapping instanceof InterfaceObjectGraphMapping;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer/specific/LeafGraphToObjectDeserializer.java | package ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.specific;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.GenericGraphToObjectDeserializer;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.MissingTraversalTargetResolvingStrategy;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphReader.GraphReader;
import ai.stapi.graphoperations.objectGraphLanguage.LeafObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import ai.stapi.graphoperations.serializationTypeProvider.GenericSerializationTypeByNodeProvider;
import java.util.List;
public class LeafGraphToObjectDeserializer extends AbstractSpecificGraphToObjectDeserializer {
public LeafGraphToObjectDeserializer(
GraphReader graphReader,
GenericGraphToObjectDeserializer genericDeserializer,
GenericSerializationTypeByNodeProvider serializationTypeProvider,
GenericGraphMappingProvider mappingProvider
) {
super(graphReader, genericDeserializer, serializationTypeProvider, mappingProvider);
}
@Override
public Object deserialize(
List<TraversableGraphElement> elements,
GraphDescription lastGraphDescription,
ObjectGraphMapping graphMapping,
InMemoryGraphRepository contextualGraph,
MissingTraversalTargetResolvingStrategy missingTraversalTargetResolvingStrategy
) {
var leafMapping = (LeafObjectGraphMapping) graphMapping;
return this.traverseSingleGraphBranchToValue(
elements.get(0).getId(),
elements.get(0).getType(),
leafMapping.getGraphDescription(),
contextualGraph,
missingTraversalTargetResolvingStrategy
);
}
@Override
public boolean supports(
ObjectGraphMapping objectGraphMapping,
List<TraversableGraphElement> elements
) {
return objectGraphMapping instanceof LeafObjectGraphMapping;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer/specific/ListGraphToObjectDeserializer.java | package ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.specific;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.GenericGraphToObjectDeserializer;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.MissingTraversalTargetResolvingStrategy;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ListAttributeDescription;
import ai.stapi.graphoperations.graphReader.GraphReader;
import ai.stapi.graphoperations.objectGraphLanguage.LeafObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ListObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import ai.stapi.graphoperations.serializationTypeProvider.GenericSerializationTypeByNodeProvider;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class ListGraphToObjectDeserializer extends AbstractSpecificGraphToObjectDeserializer {
public ListGraphToObjectDeserializer(
GraphReader graphReader,
GenericGraphToObjectDeserializer genericDeserializer,
GenericSerializationTypeByNodeProvider serializationTypeProvider,
GenericGraphMappingProvider mappingProvider
) {
super(graphReader, genericDeserializer, serializationTypeProvider, mappingProvider);
}
@Override
public Object deserialize(
List<TraversableGraphElement> elements,
GraphDescription lastGraphDescription,
ObjectGraphMapping graphMapping,
InMemoryGraphRepository contextualGraph,
MissingTraversalTargetResolvingStrategy missingTraversalTargetResolvingStrategy
) {
var listMapping = (ListObjectGraphMapping) graphMapping;
if (elements.isEmpty()) {
return new ArrayList<>();
}
if (listMapping.getChildObjectGraphMapping() instanceof LeafObjectGraphMapping) {
var values = elements.stream().map(element -> this.traverseSingleGraphBranchToValue(
element.getId(),
element.getType(),
listMapping.getGraphDescription(),
contextualGraph,
missingTraversalTargetResolvingStrategy
)
).collect(Collectors.toList());
if (listMapping.getGraphDescription() instanceof ListAttributeDescription) {
return values.stream()
.filter(List.class::isInstance)
.map(List.class::cast)
.flatMap(List::stream)
.collect(Collectors.toList());
}
return values;
}
return elements.stream().map(element -> this.traverseMultipleGraphBranch(
element.getId(),
element.getType(),
listMapping.getGraphDescription(),
contextualGraph
)
).flatMap(List::stream).map(element -> this.genericDeserializer.resolveInternally(
List.of(element),
this.updateLastGraphDescription(
lastGraphDescription,
listMapping.getGraphDescription()
),
listMapping.getChildObjectGraphMapping(),
contextualGraph,
missingTraversalTargetResolvingStrategy
)
).toList();
}
@Override
public boolean supports(
ObjectGraphMapping objectGraphMapping,
List<TraversableGraphElement> elements
) {
return objectGraphMapping instanceof ListObjectGraphMapping;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer/specific/MapGraphToObjectDeserializer.java | package ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.specific;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.GenericGraphToObjectDeserializer;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.MissingTraversalTargetResolvingStrategy;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphReader.GraphReader;
import ai.stapi.graphoperations.objectGraphLanguage.MapObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import ai.stapi.graphoperations.serializationTypeProvider.GenericSerializationTypeByNodeProvider;
import java.util.HashMap;
import java.util.List;
public class MapGraphToObjectDeserializer extends AbstractSpecificGraphToObjectDeserializer {
public MapGraphToObjectDeserializer(
GraphReader graphReader,
GenericGraphToObjectDeserializer genericDeserializer,
GenericSerializationTypeByNodeProvider serializationTypeProvider,
GenericGraphMappingProvider mappingProvider
) {
super(graphReader, genericDeserializer, serializationTypeProvider, mappingProvider);
}
@Override
public Object deserialize(
List<TraversableGraphElement> elements,
GraphDescription lastGraphDescription,
ObjectGraphMapping graphMapping,
InMemoryGraphRepository contextualGraph,
MissingTraversalTargetResolvingStrategy missingTraversalTargetResolvingStrategy
) {
var mapMapping = (MapObjectGraphMapping) graphMapping;
var map = new HashMap<>();
elements.stream()
.map(element -> this.traverseMultipleGraphBranch(
element.getId(),
element.getType(),
mapMapping.getGraphDescription(),
contextualGraph
)
).flatMap(List::stream)
.forEach(
element -> map.put(
this.genericDeserializer.resolveInternally(
List.of(element),
this.updateLastGraphDescription(
lastGraphDescription,
mapMapping.getGraphDescription()
),
mapMapping.getKeyObjectGraphMapping(),
contextualGraph,
missingTraversalTargetResolvingStrategy
),
this.genericDeserializer.resolveInternally(
List.of(element),
this.updateLastGraphDescription(
lastGraphDescription,
mapMapping.getGraphDescription()
),
mapMapping.getValueObjectGraphMapping(),
contextualGraph,
missingTraversalTargetResolvingStrategy
)
)
);
return map;
}
@Override
public boolean supports(
ObjectGraphMapping objectGraphMapping,
List<TraversableGraphElement> elements
) {
return objectGraphMapping instanceof MapObjectGraphMapping;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer/specific/ObjectGraphToObjectDeserializer.java | package ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.specific;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.GenericGraphToObjectDeserializer;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.MissingTraversalTargetResolvingStrategy;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.exception.GenericGraphOgmDeserializerException;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.specific.exception.SpecificGraphOgmDeserializerException;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphReader.GraphReader;
import ai.stapi.graphoperations.graphReader.mappingPartReadResolvers.exception.GraphDescriptionReadResolverException;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectObjectGraphMapping;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import ai.stapi.graphoperations.serializationTypeProvider.GenericSerializationTypeByNodeProvider;
import java.util.HashMap;
import java.util.List;
public class ObjectGraphToObjectDeserializer extends AbstractSpecificGraphToObjectDeserializer {
public ObjectGraphToObjectDeserializer(
GraphReader graphReader,
GenericGraphToObjectDeserializer genericDeserializer,
GenericSerializationTypeByNodeProvider serializationTypeProvider,
GenericGraphMappingProvider mappingProvider
) {
super(graphReader, genericDeserializer, serializationTypeProvider, mappingProvider);
}
@Override
public Object deserialize(
List<TraversableGraphElement> elements,
GraphDescription lastGraphDescription,
ObjectGraphMapping graphMapping,
InMemoryGraphRepository contextualGraph,
MissingTraversalTargetResolvingStrategy missingTraversalTargetResolvingStrategy
) {
if (elements.size() == 0) {
return null;
}
if (elements.size() > 1) {
throw SpecificGraphOgmDeserializerException.becauseThereIsMultipleGraphBranches(
graphMapping,
elements
);
}
elements = this.ensureElementsAreNodes(elements, lastGraphDescription);
var objectGraphMapping = (ObjectObjectGraphMapping) graphMapping;
var map = new HashMap<String, Object>();
var traversedObject = this.traverseSingleGraphBranch(
elements.get(0).getId(),
elements.get(0).getType(),
graphMapping.getGraphDescription(),
contextualGraph
);
objectGraphMapping.getFields().forEach(
(fieldName, fieldDefinition) -> {
var traversedField = this.traverseMultipleGraphBranch(
traversedObject.getId(),
traversedObject.getType(),
fieldDefinition.getRelation(),
contextualGraph
);
if (
missingTraversalTargetResolvingStrategy.equals(
MissingTraversalTargetResolvingStrategy.LENIENT
)
) {
try {
var object = this.genericDeserializer.resolveInternally(
traversedField,
this.updateLastGraphDescription(
lastGraphDescription,
(GraphDescription) fieldDefinition.getRelation()
),
fieldDefinition.getFieldObjectGraphMapping(),
contextualGraph,
missingTraversalTargetResolvingStrategy
);
map.put(fieldName, object);
} catch (GraphDescriptionReadResolverException |
GenericGraphOgmDeserializerException exception) {
map.put(fieldName, null);
}
} else {
var object = this.genericDeserializer.resolveInternally(
traversedField,
this.updateLastGraphDescription(
lastGraphDescription,
(GraphDescription) fieldDefinition.getRelation()
),
fieldDefinition.getFieldObjectGraphMapping(),
contextualGraph,
missingTraversalTargetResolvingStrategy
);
map.put(fieldName, object);
}
}
);
return map;
}
@Override
public boolean supports(
ObjectGraphMapping objectGraphMapping,
List<TraversableGraphElement> elements
) {
return objectGraphMapping instanceof ObjectObjectGraphMapping;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer/specific/SpecificGraphToObjectDeserializer.java | package ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.specific;
import ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.MissingTraversalTargetResolvingStrategy;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import java.util.List;
public interface SpecificGraphToObjectDeserializer {
Object deserialize(
List<TraversableGraphElement> elements,
GraphDescription lastGraphDescription,
ObjectGraphMapping graphMapping,
InMemoryGraphRepository contextualGraph,
MissingTraversalTargetResolvingStrategy missingTraversalTargetResolvingStrategy
);
default Object deserialize(
List<TraversableGraphElement> elements,
GraphDescription lastGraphDescription,
ObjectGraphMapping graphMapping,
InMemoryGraphRepository contextualGraph
) {
return this.deserialize(
elements,
lastGraphDescription,
graphMapping,
contextualGraph,
MissingTraversalTargetResolvingStrategy.STRICT
);
}
;
boolean supports(
ObjectGraphMapping objectGraphMapping,
List<TraversableGraphElement> elements
);
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphDeserializers/ogmDeserializer/specific/exception/SpecificGraphOgmDeserializerException.java | package ai.stapi.graphoperations.graphDeserializers.ogmDeserializer.specific.exception;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.graphReader.exception.GraphReaderException;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectObjectGraphMapping;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
public class SpecificGraphOgmDeserializerException extends RuntimeException {
private SpecificGraphOgmDeserializerException(String message) {
super(message);
}
public static SpecificGraphOgmDeserializerException becauseThereIsMultipleGraphBranches(
ObjectGraphMapping objectGraphMapping,
List<TraversableGraphElement> elements
) {
return new SpecificGraphOgmDeserializerException(
"Traversing graph led to multiple branches. That is not allowed for "
+ ObjectGraphMapping.class.getSimpleName()
+ " of type '" + objectGraphMapping.getClass().getSimpleName() + "'."
+ System.lineSeparator()
+ " Given elements: "
+ StringUtils.join(elements.stream().map(TraversableGraphElement::getType), ", ")
);
}
public static SpecificGraphOgmDeserializerException becauseGraphTraversingLedToMultipleBranches(
String elementType) {
return new SpecificGraphOgmDeserializerException(
GraphDescription.class.getSimpleName()
+ " inside " + ObjectObjectGraphMapping.class.getSimpleName()
+ " led from element of type '" + elementType
+ "' to multiple graph branches and that is not allowed."
);
}
public static SpecificGraphOgmDeserializerException becauseGraphReadingAccordingToOgmFailed(
String currentElementType,
PositiveGraphDescription declaration,
GraphReaderException exception
) {
return new SpecificGraphOgmDeserializerException(
"Traversing graph from element of type '" + currentElementType
+ "' using " + declaration.getClass().getSimpleName()
+ " failed. Ogm doesn't correspond to the actual graph structure saved. "
+ System.lineSeparator()
+ "Cause: " + exception.getMessage()
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/AbstractGraphDeclaration.java | package ai.stapi.graphoperations.graphLanguage;
import ai.stapi.graphoperations.declaration.AbstractDeclaration;
abstract public class AbstractGraphDeclaration extends AbstractDeclaration
implements GraphDeclaration {
public static final String DECLARATION_TYPE = "GraphDeclaration";
protected AbstractGraphDeclaration() {
}
protected AbstractGraphDeclaration(String serializationType) {
super(serializationType);
}
@Override
public String getDeclarationType() {
return DECLARATION_TYPE;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/GraphBaseTypes.java | package ai.stapi.graphoperations.graphLanguage;
public class GraphBaseTypes {
public static final String NODE_TYPE = "node";
public static final String EDGE_TYPE = "edge";
public static final String VALUE_TYPE = "value";
public static final String ATTRIBUTE_TYPE = "attribute";
public static final String CONSTANT_TYPE = "constant";
public static final String NULL_TYPE = "null";
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/GraphDeclaration.java | package ai.stapi.graphoperations.graphLanguage;
import ai.stapi.graphoperations.declaration.Declaration;
public interface GraphDeclaration extends Declaration {
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/classnameprovider/GraphDescriptionClassNameProvider.java | package ai.stapi.graphoperations.graphLanguage.classnameprovider;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AllAttributesDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.BooleanAttributeValueDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ConstantDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.IngoingEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.IntegerAttributeValueDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.LeafAttributeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ListAttributeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.OutgoingEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.SetAttributeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.StringAttributeValueDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.AttributeQueryDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.IngoingEdgeQueryDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.NodeQueryGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.OutgoingEdgeQueryDescription;
import ai.stapi.serialization.classNameProvider.specific.AbstractSerializableObjectClassNameProvider;
import java.util.HashMap;
import java.util.Map;
public class GraphDescriptionClassNameProvider extends AbstractSerializableObjectClassNameProvider {
@Override
protected Map<String, Class<?>> getClassMap() {
var map = new HashMap<String, Class<?>>();
map.put(NodeDescription.SERIALIZATION_TYPE, NodeDescription.class);
map.put(OutgoingEdgeDescription.SERIALIZATION_TYPE, OutgoingEdgeDescription.class);
map.put(IngoingEdgeDescription.SERIALIZATION_TYPE, IngoingEdgeDescription.class);
map.put(StringAttributeValueDescription.SERIALIZATION_TYPE, StringAttributeValueDescription.class);
map.put(IntegerAttributeValueDescription.SERIALIZATION_TYPE, IntegerAttributeValueDescription.class);
map.put(BooleanAttributeValueDescription.SERIALIZATION_TYPE, BooleanAttributeValueDescription.class);
map.put(UuidIdentityDescription.SERIALIZATION_TYPE, UuidIdentityDescription.class);
map.put(ConstantDescription.SERIALIZATION_TYPE, ConstantDescription.class);
map.put(NullGraphDescription.SERIALIZATION_TYPE, NullGraphDescription.class);
map.put(NodeQueryGraphDescription.SERIALIZATION_TYPE, NodeQueryGraphDescription.class);
map.put(OutgoingEdgeQueryDescription.SERIALIZATION_TYPE, OutgoingEdgeQueryDescription.class);
map.put(IngoingEdgeQueryDescription.SERIALIZATION_TYPE, IngoingEdgeQueryDescription.class);
map.put(AllAttributesDescription.SERIALIZATION_TYPE, AllAttributesDescription.class);
map.put(LeafAttributeDescription.SERIALIZATION_TYPE, LeafAttributeDescription.class);
map.put(ListAttributeDescription.SERIALIZATION_TYPE, ListAttributeDescription.class);
map.put(SetAttributeDescription.SERIALIZATION_TYPE, SetAttributeDescription.class);
map.put(AttributeQueryDescription.SERIALIZATION_TYPE, AttributeQueryDescription.class);
return map;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/AbstractGraphDescription.java | package ai.stapi.graphoperations.graphLanguage.graphDescription;
import ai.stapi.graphoperations.graphLanguage.AbstractGraphDeclaration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public abstract class AbstractGraphDescription extends AbstractGraphDeclaration
implements GraphDescription {
protected List<GraphDescription> childGraphDescriptions;
protected String traversingType;
protected AbstractGraphDescription() {
}
protected AbstractGraphDescription(
String deserializationType,
String traversingType,
List<GraphDescription> childGraphDescriptions
) {
super(deserializationType);
this.traversingType = traversingType;
this.childGraphDescriptions = childGraphDescriptions;
}
protected AbstractGraphDescription(
String deserializationType,
String traversingType,
GraphDescription... childGraphDescriptions
) {
super(deserializationType);
this.traversingType = traversingType;
this.childGraphDescriptions =
Arrays.stream(childGraphDescriptions).collect(Collectors.toCollection(ArrayList::new));
}
@Override
public String getDeclarationType() {
return GraphDescription.DECLARATION_TYPE;
}
@Override
public String getGraphTraversingType() {
return traversingType;
}
@Override
public List<GraphDescription> getChildGraphDescriptions() {
return this.childGraphDescriptions;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/GraphDescription.java | package ai.stapi.graphoperations.graphLanguage.graphDescription;
import ai.stapi.graphoperations.graphLanguage.GraphDeclaration;
import java.util.List;
public interface GraphDescription extends GraphDeclaration {
String INTERFACE_UUID = "16155223-9c61-4138-a8f2-16fa555f7c61";
String DECLARATION_TYPE = "GraphDescription";
GraphDescriptionParameters getParameters();
String getGraphTraversingType();
List<GraphDescription> getChildGraphDescriptions();
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/GraphDescriptionParameters.java | package ai.stapi.graphoperations.graphLanguage.graphDescription;
public interface GraphDescriptionParameters {
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/GraphDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.exception.GraphDescriptionBuilderException;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.AbstractAttributeDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.AbstractAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.AbstractPositiveDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.Base64BinaryAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.BooleanAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.CanonicalAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.CodeAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.ConstantSpecificDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.DateAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.DateTimeAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.DecimalAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.EdgeDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.IdAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.InstantAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.IntegerAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.InterfaceDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.LeafAttributeDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.ListAttributeDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.MarkdownAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.NodeDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.NullSpecificDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.OidAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.PositiveIntegerAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.ReferenceDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.SetAttributeDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.StringAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.TimeAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.UnsignedIntegerAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.UriAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.UrlAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.UuidAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.UuidSpecificDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive.XhtmlAttributeValueDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.query.AttributeQueryDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.removal.AbstractRemovalDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.removal.RemovalEdgeDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.removal.RemovalNodeDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractAttributeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.removal.RemovalGraphDescription;
import ai.stapi.graphoperations.graphbuilder.specific.positive.EdgeDirection;
import ai.stapi.utils.Classifier;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class GraphDescriptionBuilder {
private final List<SpecificGraphDescriptionBuilder> immutableSupportingSpecificBuilders;
private SpecificGraphDescriptionBuilder descriptionBuilder;
private List<GraphDescriptionBuilder> childBranches = new ArrayList<>();
private GraphDescriptionBuilder parent;
public GraphDescriptionBuilder() {
this.immutableSupportingSpecificBuilders = List.of(
new UuidSpecificDescriptionBuilder(),
new NodeDescriptionBuilder(),
new EdgeDescriptionBuilder(),
new StringAttributeValueDescriptionBuilder(),
new IntegerAttributeValueDescriptionBuilder(),
new BooleanAttributeValueDescriptionBuilder(),
new InstantAttributeValueDescriptionBuilder(),
new TimeAttributeValueDescriptionBuilder(),
new DateAttributeValueDescriptionBuilder(),
new DateTimeAttributeValueDescriptionBuilder(),
new Base64BinaryAttributeValueDescriptionBuilder(),
new UrlAttributeValueDescriptionBuilder(),
new CodeAttributeValueDescriptionBuilder(),
new UriAttributeValueDescriptionBuilder(),
new CanonicalAttributeValueDescriptionBuilder(),
new MarkdownAttributeValueDescriptionBuilder(),
new IdAttributeValueDescriptionBuilder(),
new OidAttributeValueDescriptionBuilder(),
new UuidAttributeValueDescriptionBuilder(),
new UnsignedIntegerAttributeValueDescriptionBuilder(),
new PositiveIntegerAttributeValueDescriptionBuilder(),
new ConstantSpecificDescriptionBuilder(),
new NullSpecificDescriptionBuilder(),
new RemovalNodeDescriptionBuilder(),
new RemovalEdgeDescriptionBuilder(),
new InterfaceDescriptionBuilder(),
new DecimalAttributeValueDescriptionBuilder(),
new XhtmlAttributeValueDescriptionBuilder(),
new ReferenceDescriptionBuilder(),
new LeafAttributeDescriptionBuilder(),
new ListAttributeDescriptionBuilder(),
new SetAttributeDescriptionBuilder(),
new AttributeQueryDescriptionBuilder()
);
}
private GraphDescriptionBuilder(GraphDescriptionBuilder parent) {
this();
this.parent = parent;
}
public static Stream<GraphDescription> getGraphDescriptionAsStream(
GraphDescription graphDescription
) {
var allGraphDescriptions = new ArrayList<GraphDescription>();
GraphDescriptionBuilder.addAllGraphDescriptionsInComposite(
graphDescription,
allGraphDescriptions
);
return allGraphDescriptions.stream();
}
public static boolean isGraphDescriptionSinglePath(GraphDescription graphDescription) {
var childGraphDescriptions = graphDescription.getChildGraphDescriptions();
if (childGraphDescriptions.size() > 1) {
return false;
}
if (childGraphDescriptions.size() == 1) {
return GraphDescriptionBuilder.isGraphDescriptionSinglePath(childGraphDescriptions.get(0));
}
return true;
}
public static boolean isGraphDescriptionEndingWithAttributeDescription(
GraphDescription graphDescription
) {
var children = graphDescription.getChildGraphDescriptions();
if (children.isEmpty() && graphDescription instanceof AbstractAttributeDescription) {
return true;
}
if (children.isEmpty()) {
return false;
}
return children.stream().allMatch(GraphDescriptionBuilder::isGraphDescriptionEndingWithAttributeDescription);
}
public static boolean isGraphDescriptionEndingWithAttributeOrUuidDescription(
GraphDescription graphDescription
) {
var children = graphDescription.getChildGraphDescriptions();
if (children.isEmpty() && isInstanceOfUuidIdentityOrAttributeDescription(graphDescription)) {
return true;
}
if (children.isEmpty()) {
return false;
}
return children.stream().allMatch(
GraphDescriptionBuilder::isGraphDescriptionEndingWithAttributeOrUuidDescription
);
}
private static void addAllGraphDescriptionsInComposite(
GraphDescription graphDescription,
List<GraphDescription> listOfGraphDescriptions
) {
listOfGraphDescriptions.add(graphDescription);
graphDescription.getChildGraphDescriptions()
.forEach(
child -> GraphDescriptionBuilder.addAllGraphDescriptionsInComposite(
child,
listOfGraphDescriptions
)
);
}
public GraphDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
var supportingBuilder = this.getRepresentingBuilder(graphDescription);
return supportingBuilder.copyWithNewChildren(graphDescription, newChildren);
}
public GraphDescription copyWithNewChildren(
GraphDescription graphDescription,
GraphDescription... newChildren
) {
var supportingBuilder = this.getRepresentingBuilder(graphDescription);
return supportingBuilder.copyWithNewChildren(graphDescription,
Arrays.stream(newChildren).collect(Collectors.toCollection(ArrayList::new)));
}
public GraphDescription addToDeepestDescription(
GraphDescription mainDescription,
List<GraphDescription> childDescriptions
) {
if (!GraphDescriptionBuilder.isGraphDescriptionSinglePath(mainDescription)) {
throw GraphDescriptionBuilderException.becauseToAddToDeepestGraphDescriptionItMustBeSinglePath(
mainDescription
);
}
return this.privateAddToDeepestDescription(mainDescription, childDescriptions);
}
private GraphDescription privateAddToDeepestDescription(
GraphDescription mainDescription,
List<GraphDescription> childDescriptions
) {
var supportingBuilder = this.getRepresentingBuilder(mainDescription);
if (mainDescription.getChildGraphDescriptions().isEmpty()) {
return supportingBuilder.copyWithNewChildren(mainDescription, childDescriptions);
}
return supportingBuilder.copyWithNewChildren(
mainDescription,
List.of(
this.privateAddToDeepestDescription(
mainDescription.getChildGraphDescriptions().get(0),
childDescriptions
)
)
);
}
public GraphDescription filterOutNullDescriptions(GraphDescription graphDescription) {
return new GraphDescriptionBuilder().copyWithNewChildren(
graphDescription,
graphDescription.getChildGraphDescriptions()
.stream()
.flatMap(GraphDescriptionBuilder::filterOutNull)
.toList()
);
}
@NotNull
private static Stream<GraphDescription> filterOutNull(GraphDescription child) {
var builder = new GraphDescriptionBuilder();
if (child instanceof NullGraphDescription) {
return child.getChildGraphDescriptions()
.stream()
.flatMap(GraphDescriptionBuilder::filterOutNull);
}
return Stream.of(builder.filterOutNullDescriptions(child));
}
public GraphDescriptionBuilder addNodeDescription(String nodeType) {
var builder = new NodeDescriptionBuilder().setNodeType(nodeType);
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addOutgoingEdge(String edgeType) {
var builder = new EdgeDescriptionBuilder()
.setDirection(EdgeDirection.OUTGOING)
.setEdgeType(edgeType);
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addIngoingEdge(String edgeType) {
var builder = new EdgeDescriptionBuilder()
.setDirection(EdgeDirection.INGOING)
.setEdgeType(edgeType);
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addAttributeByType(
String attributeStructureType,
String attributeName
) {
var builder = this.immutableSupportingSpecificBuilders.stream()
.filter(AbstractAttributeDescriptionBuilder.class::isInstance)
.map(AbstractAttributeDescriptionBuilder.class::cast)
.filter(bldr -> bldr.getSupportedStructureTypeId().equals(attributeStructureType))
.findAny()
.orElseThrow(() -> new RuntimeException(
"No supporting builder for attribute structure type '" + attributeStructureType + "'."))
.getCopy()
.setAttributeName(attributeName);
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addAttributeValueByType(
String attributeDataType
) {
var builder = this.immutableSupportingSpecificBuilders.stream()
.filter(AbstractAttributeValueDescriptionBuilder.class::isInstance)
.map(AbstractAttributeValueDescriptionBuilder.class::cast)
.filter(bldr -> bldr.getSupportedDataTypeId().equals(attributeDataType))
.findAny()
.orElseThrow(() -> new RuntimeException(
"No supporting builder for attribute value data type '" + attributeDataType + "'."))
.getCopy();
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addQueryAttribute(String attributeName) {
var builder = new AttributeQueryDescriptionBuilder();
builder.setAttributeName(attributeName);
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addLeafAttribute(String attributeName) {
var builder = new LeafAttributeDescriptionBuilder();
builder.setAttributeName(attributeName);
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addListAttribute(String attributeName) {
var builder = new ListAttributeDescriptionBuilder();
builder.setAttributeName(attributeName);
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addSetAttribute(String attributeName) {
var builder = new SetAttributeDescriptionBuilder();
builder.setAttributeName(attributeName);
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addStringAttributeValue() {
var builder = new StringAttributeValueDescriptionBuilder();
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder setParent(GraphDescriptionBuilder parent) {
this.parent = parent;
return this;
}
public GraphDescriptionBuilder addUriAttributeValue() {
var builder = new UriAttributeValueDescriptionBuilder();
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addMarkdownAttributeValue() {
var builder = new MarkdownAttributeValueDescriptionBuilder();
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addCodeAttributeValue() {
var builder = new CodeAttributeValueDescriptionBuilder();
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addDecimalAttributeValue() {
var builder = new DecimalAttributeValueDescriptionBuilder();
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addBooleanAttributeValue() {
var builder = new BooleanAttributeValueDescriptionBuilder();
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addIntegerAttributeValue() {
var builder = new IntegerAttributeValueDescriptionBuilder();
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addUnsignedIntegerAttributeValue() {
var builder = new UnsignedIntegerAttributeValueDescriptionBuilder();
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addInterfaceDescription(String interfaceId) {
var builder = new InterfaceDescriptionBuilder()
.setInterfaceId(interfaceId);
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addUuidDescription() {
var builder = new UuidSpecificDescriptionBuilder();
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addConstantDescription(Object value) {
if (!Classifier.isPrimitiveOrString(value) && !(value instanceof List)) {
throw GraphDescriptionBuilderException.becauseProvidedValueIsNotPrimitiveType(value);
}
var builder = new ConstantSpecificDescriptionBuilder()
.setValue(value);
this.addGraphDescriptionBuilder(builder);
return this;
}
public GraphDescriptionBuilder addRemovalNodeDescription(String nodeType) {
var builder = new RemovalNodeDescriptionBuilder()
.setNodeType(nodeType);
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addRemovalEdgeDescription(String edgeType) {
var builder = new RemovalEdgeDescriptionBuilder()
.setEdgeType(edgeType);
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder addReferenceDescription(String structureSerializationType) {
var builder = new ReferenceDescriptionBuilder()
.setStructureSerializationType(structureSerializationType);
return this.addGraphDescriptionBuilder(builder);
}
public GraphDescriptionBuilder createNewBranch() {
var newBranch = new GraphDescriptionBuilder(this);
this.childBranches.add(newBranch);
return newBranch;
}
public GraphDescriptionBuilder addNewBranch(GraphDescriptionBuilder child) {
child.setParent(this);
this.childBranches.add(child);
return child;
}
public GraphDescriptionBuilder addBuilderCopyOfGraphDescriptionWithNoChildrenToBuilder(
GraphDescription graphDescription
) {
var builder = this.getRepresentingBuilder(graphDescription);
builder.setValues(graphDescription);
return this.addGraphDescriptionBuilder(builder);
}
public SpecificGraphDescriptionBuilder convertToGraphDescriptionBuilderComposite(
GraphDescription graphDescription
) {
var builder = this.getRepresentingBuilder(graphDescription);
builder.setValues(graphDescription);
if (graphDescription.getChildGraphDescriptions().size() > 0) {
var children = graphDescription.getChildGraphDescriptions().stream()
.map(this::convertToGraphDescriptionBuilderComposite)
.collect(Collectors.toCollection(ArrayList::new));
builder.setChildren(children);
}
return builder;
}
public PositiveGraphDescription getOnlyPositiveGraphDescriptions() {
var builderCopy = this.copyBuilder();
this.removeSpecificBuilderChildReferencesToRemovalBuilders(builderCopy);
return (PositiveGraphDescription) builderCopy.build();
}
public List<RemovalGraphDescription> getOnlyRemovalGraphDescriptions() {
List<AbstractRemovalDescriptionBuilder> removalBuilders = new ArrayList<>();
this.getAllRemovalDescriptions(this, removalBuilders);
return removalBuilders.stream()
.map(AbstractRemovalDescriptionBuilder::build)
.collect(Collectors.toCollection(ArrayList::new));
}
public GraphDescriptionBuilder copyBuilder() {
return this.copyBuilder(new GraphDescriptionBuilder());
}
public GraphDescription build() {
var currentBuilder = this;
while (currentBuilder.getParent() != null) {
currentBuilder = currentBuilder.getParent();
}
if (currentBuilder.descriptionBuilder == null) {
throw GraphDescriptionBuilderException.becauseThereAreNoBuilders();
}
return currentBuilder.descriptionBuilder.build();
}
public SpecificGraphDescriptionBuilder getLastDescriptionBuilder() {
if (this.descriptionBuilder != null) {
return this.descriptionBuilder;
}
if (this.parent == null) {
return null;
}
return this.parent.getLastDescriptionBuilder();
}
public SpecificGraphDescriptionBuilder getLastDescriptionBuilderOfType(
Class<? extends SpecificGraphDescriptionBuilder> builderType
) {
if (this.descriptionBuilder != null
&& this.descriptionBuilder.getClass().equals(builderType)) {
return this.descriptionBuilder;
}
if (this.parent == null) {
return null;
}
return this.parent.getLastDescriptionBuilderOfType(builderType);
}
public GraphDescriptionBuilder getLastBranchWithGraphElementBuilder() {
var current = this;
while (!(current.getDescriptionBuilder() instanceof NodeDescriptionBuilder)
&& !(current.getDescriptionBuilder() instanceof EdgeDescriptionBuilder)
&& !(current.getDescriptionBuilder() instanceof RemovalEdgeDescriptionBuilder)
&& !(current.getDescriptionBuilder() instanceof RemovalNodeDescriptionBuilder)
) {
current = current.getParent();
if (current == null) {
throw GraphDescriptionBuilderException.becauseThereAreNoGraphElementsBuilders();
}
}
return current;
}
public GraphDescriptionBuilder getLastBranchWithGraphBuilderOfType(
Class<? extends SpecificGraphDescriptionBuilder> builderType) {
if (this.descriptionBuilder.getClass().equals(builderType)) {
return this;
}
if (parent == null) {
throw GraphDescriptionBuilderException.becauseThereAreNoGraphBuildersWithGivenType(
builderType);
}
return this.parent.getLastBranchWithGraphBuilderOfType(builderType);
}
private void removeSpecificBuilderChildReferencesToRemovalBuilders(
GraphDescriptionBuilder builder) {
var localSpecificBuilder = builder.getDescriptionBuilder();
var positiveChildrenList = localSpecificBuilder.getChildren().stream()
.filter(child -> !(child instanceof AbstractRemovalDescriptionBuilder))
.collect(Collectors.toCollection(ArrayList::new));
localSpecificBuilder.setChildren(positiveChildrenList);
if (localSpecificBuilder instanceof AbstractRemovalDescriptionBuilder) {
if (builder.getParent() == null) {
throw GraphDescriptionBuilderException.becauseFirstGraphDescriptionIsForRemoval(
localSpecificBuilder);
}
builder.getChildBranches()
.forEach(this::removeSpecificBuilderChildReferencesToRemovalBuilders);
return;
}
if (builder.getParent() != null) {
var parentSpecificBuilder = builder.getParent().getDescriptionBuilder();
if (parentSpecificBuilder instanceof AbstractRemovalDescriptionBuilder
&& localSpecificBuilder instanceof AbstractPositiveDescriptionBuilder
&& !(localSpecificBuilder instanceof UuidSpecificDescriptionBuilder)) {
builder.getLastBranchWithGraphBuilderOfType(AbstractPositiveDescriptionBuilder.class)
.getDescriptionBuilder().addChild(localSpecificBuilder);
}
}
builder.getChildBranches().forEach(this::removeSpecificBuilderChildReferencesToRemovalBuilders);
}
private GraphDescriptionBuilder copyBuilder(GraphDescriptionBuilder parentBuilder) {
var graphDescription = this.descriptionBuilder.build();
var newParent =
parentBuilder.addBuilderCopyOfGraphDescriptionWithNoChildrenToBuilder(graphDescription);
this.childBranches.forEach(
child -> child.copyBuilder(newParent)
);
return parentBuilder;
}
private SpecificGraphDescriptionBuilder getRepresentingBuilder(
GraphDescription graphDescription) {
var representingBuilder = this.immutableSupportingSpecificBuilders.stream()
.filter(builder -> builder.represents(graphDescription))
.collect(Collectors.toCollection(ArrayList::new));
switch (representingBuilder.size()) {
case 0 -> throw GraphDescriptionBuilderException.becauseDescriptionTypeIsNotSupported(
graphDescription);
case 1 -> {
return representingBuilder.get(0).getCopy();
}
default -> throw GraphDescriptionBuilderException.becauseDescriptionTypeIsSupportedByMultipleBuilders(
graphDescription);
}
}
private void getAllRemovalDescriptions(GraphDescriptionBuilder builder,
List<AbstractRemovalDescriptionBuilder> builders) {
if (builder.descriptionBuilder instanceof AbstractRemovalDescriptionBuilder removalDescriptionBuilder) {
builders.add(removalDescriptionBuilder);
}
builder.getChildBranches().forEach(
child -> this.getAllRemovalDescriptions(child, builders)
);
}
private GraphDescriptionBuilder addGraphDescriptionBuilder(
SpecificGraphDescriptionBuilder builder
) {
var lastBuilder = this.getLastDescriptionBuilder();
if (lastBuilder != null) {
lastBuilder.addChild(builder);
}
if (this.descriptionBuilder == null) {
this.descriptionBuilder = builder;
return this;
} else {
var newBranch = this.createNewBranch();
newBranch.descriptionBuilder = builder;
return newBranch;
}
}
public List<GraphDescriptionBuilder> getChildBranches() {
return childBranches;
}
public GraphDescriptionBuilder getParent() {
return parent;
}
public SpecificGraphDescriptionBuilder getDescriptionBuilder() {
return descriptionBuilder;
}
private static boolean isInstanceOfUuidIdentityOrAttributeDescription(GraphDescription graphDescription) {
if (graphDescription instanceof AbstractAttributeDescription) {
return true;
}
return graphDescription instanceof UuidIdentityDescription;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/GraphDescriptionBuilderResult.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.removal.RemovalGraphDescription;
import java.util.List;
public class GraphDescriptionBuilderResult {
private final List<RemovalGraphDescription> removalGraphDescriptions;
private final PositiveGraphDescription positiveGraphDescription;
private final GraphDescription graphDescription;
public GraphDescriptionBuilderResult(
List<RemovalGraphDescription> removalGraphDescriptions,
PositiveGraphDescription positiveGraphDescription,
GraphDescription graphDescription
) {
this.removalGraphDescriptions = removalGraphDescriptions;
this.positiveGraphDescription = positiveGraphDescription;
this.graphDescription = graphDescription;
}
public PositiveGraphDescription getPositiveGraphDescription() {
return positiveGraphDescription;
}
public GraphDescription getGraphDescription() {
return graphDescription;
}
public List<RemovalGraphDescription> getRemovalGraphDescriptions() {
return removalGraphDescriptions;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/exception/GraphDescriptionBuilderException.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.exception;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.removal.AbstractRemovalDescriptionBuilder;
import ai.stapi.graphoperations.graphbuilder.specific.positive.EdgeDirection;
import ai.stapi.utils.Stringifier;
public class GraphDescriptionBuilderException extends RuntimeException {
private GraphDescriptionBuilderException(String message) {
super(message);
}
public static GraphDescriptionBuilderException becauseEdgeDirectionIsNotSupported(
EdgeDirection direction) {
return new GraphDescriptionBuilderException(
"Edge direction '" + direction.name() + "' is not supported by the builder.");
}
public static GraphDescriptionBuilderException becauseDescriptionTypeIsNotSupported(
GraphDescription graphDescription) {
return new GraphDescriptionBuilderException(
"Graph Description of type '"
+ graphDescription.getClass().getSimpleName()
+ "' is not supported by the builder here."
);
}
public static GraphDescriptionBuilderException becauseProvidedValueIsNotPrimitiveType(
Object value) {
throw new GraphDescriptionBuilderException(
"Provided value is not of primitive type." +
System.lineSeparator() +
"Value: " +
System.lineSeparator() +
Stringifier.convertToString(value)
);
}
public static GraphDescriptionBuilderException becauseValueTypeIsNotSupported(Object value) {
return new GraphDescriptionBuilderException(
"Attribute value of type '" + value.getClass().getSimpleName() + "' is not supported.");
}
public static GraphDescriptionBuilderException becauseDescriptionTypeIsSupportedByMultipleBuilders(
GraphDescription graphDescription) {
return new GraphDescriptionBuilderException(
"Graph Description '"
+ graphDescription.getClass().getSimpleName()
+ "' is supported by multiple builders."
);
}
public static GraphDescriptionBuilderException becauseThereAreNoBuilders() {
return new GraphDescriptionBuilderException(
"There are no specific builders inside the builder.");
}
public static GraphDescriptionBuilderException becauseThereAreNoGraphElementsBuilders() {
return new GraphDescriptionBuilderException(
"There are no node or edge builders in this or parent builder branches."
);
}
public static GraphDescriptionBuilderException becauseThereAreNoGraphBuildersWithGivenType(
Class<? extends SpecificGraphDescriptionBuilder> builderType) {
return new GraphDescriptionBuilderException(
"There are no builders with "
+ SpecificGraphDescriptionBuilder.class.getSimpleName()
+ " of type '"
+ builderType.getSimpleName()
+ "'."
);
}
public static GraphDescriptionBuilderException becauseFirstGraphDescriptionIsForRemoval(
SpecificGraphDescriptionBuilder localSpecificBuilder) {
return new GraphDescriptionBuilderException(
"First builder '"
+ localSpecificBuilder.getClass().getSimpleName()
+ "' inherits '"
+ AbstractRemovalDescriptionBuilder.class.getSimpleName()
+ "' and that is not allowed when calling 'getOnlyPositiveGraphDescriptions()'."
);
}
public static GraphDescriptionBuilderException becauseToAddToDeepestGraphDescriptionItMustBeSinglePath(
GraphDescription mainGraphDescription
) {
return new GraphDescriptionBuilderException(
String.format(
"Cannot add child descriptions to composite graph description to the end." +
"Main graph description has to be single path.%nInvalid main description: %s",
Stringifier.convertToString(mainGraphDescription)
)
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/AbstractSpecificDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public abstract class AbstractSpecificDescriptionBuilder
implements SpecificGraphDescriptionBuilder {
private List<SpecificGraphDescriptionBuilder> children = new ArrayList<>();
public List<SpecificGraphDescriptionBuilder> getChildren() {
return children;
}
public SpecificGraphDescriptionBuilder addChild(SpecificGraphDescriptionBuilder child) {
this.children.add(child);
return this;
}
@Override
public SpecificGraphDescriptionBuilder setChildren(
List<SpecificGraphDescriptionBuilder> children) {
this.children = new ArrayList<>(children);
return this;
}
@Override
public SpecificGraphDescriptionBuilder setChildren(SpecificGraphDescriptionBuilder... children) {
this.children = Arrays.stream(children).collect(Collectors.toCollection(ArrayList::new));
return this;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/SpecificGraphDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import java.util.List;
public interface SpecificGraphDescriptionBuilder {
SpecificGraphDescriptionBuilder addChild(SpecificGraphDescriptionBuilder child);
SpecificGraphDescriptionBuilder setValues(GraphDescription graphDescription);
boolean represents(GraphDescription graphDescription);
GraphDescription build();
SpecificGraphDescriptionBuilder getCopy();
GraphDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
);
List<SpecificGraphDescriptionBuilder> getChildren();
SpecificGraphDescriptionBuilder setChildren(List<SpecificGraphDescriptionBuilder> children);
SpecificGraphDescriptionBuilder setChildren(SpecificGraphDescriptionBuilder... children);
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/AbstractAttributeDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AttributeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public abstract class AbstractAttributeDescriptionBuilder
extends AbstractPositiveDescriptionBuilder {
private String attributeName;
protected abstract PositiveGraphDescription buildAttributeDescription(
AttributeDescriptionParameters parameters,
List<GraphDescription> children
);
public abstract String getSupportedStructureTypeId();
@Override
public abstract boolean represents(GraphDescription graphDescription);
@Override
public abstract PositiveGraphDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
);
@Override
public abstract AbstractAttributeDescriptionBuilder getCopy();
@Override
public PositiveGraphDescription build() {
var children = this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::build)
.collect(Collectors.toCollection(ArrayList::new));
return this.buildAttributeDescription(
new AttributeDescriptionParameters(attributeName),
children
);
}
@Override
public AbstractPositiveDescriptionBuilder setValues(GraphDescription graphDescription) {
var params = (AttributeDescriptionParameters) graphDescription.getParameters();
this.setAttributeName(params.getAttributeName());
return this;
}
public AbstractAttributeDescriptionBuilder setAttributeName(String attributeName) {
this.attributeName = attributeName;
return this;
}
public String getAttributeName() {
return attributeName;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/AbstractAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public abstract class AbstractAttributeValueDescriptionBuilder
extends AbstractPositiveDescriptionBuilder {
protected abstract PositiveGraphDescription buildAttributeDescription(
List<GraphDescription> children
);
public abstract String getSupportedDataTypeId();
@Override
public abstract boolean represents(GraphDescription graphDescription);
@Override
public abstract PositiveGraphDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
);
@Override
public abstract AbstractAttributeValueDescriptionBuilder getCopy();
@Override
public PositiveGraphDescription build() {
var children = this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::build)
.collect(Collectors.toCollection(ArrayList::new));
return this.buildAttributeDescription(children);
}
@Override
public AbstractPositiveDescriptionBuilder setValues(GraphDescription graphDescription) {
return this;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/AbstractPositiveDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.AbstractSpecificDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import java.util.List;
public abstract class AbstractPositiveDescriptionBuilder
extends AbstractSpecificDescriptionBuilder {
@Override
public abstract PositiveGraphDescription build();
@Override
public abstract AbstractPositiveDescriptionBuilder setValues(GraphDescription graphDescription);
@Override
public abstract PositiveGraphDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
);
@Override
public abstract AbstractPositiveDescriptionBuilder getCopy();
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/Base64BinaryAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.attributeValue.Base64BinaryAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.Base64BinaryAttributeValueDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class Base64BinaryAttributeValueDescriptionBuilder
extends AbstractAttributeValueDescriptionBuilder {
@Override
protected Base64BinaryAttributeValueDescription buildAttributeDescription(
List<GraphDescription> children
) {
return new Base64BinaryAttributeValueDescription(children);
}
@Override
public String getSupportedDataTypeId() {
return Base64BinaryAttributeValue.SERIALIZATION_TYPE;
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof Base64BinaryAttributeValueDescription;
}
@Override
public Base64BinaryAttributeValueDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new Base64BinaryAttributeValueDescription(newChildren);
}
@Override
public Base64BinaryAttributeValueDescriptionBuilder getCopy() {
var builder = new Base64BinaryAttributeValueDescriptionBuilder();
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/BooleanAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.attributeValue.BooleanAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.BooleanAttributeValueDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class BooleanAttributeValueDescriptionBuilder
extends AbstractAttributeValueDescriptionBuilder {
@Override
protected BooleanAttributeValueDescription buildAttributeDescription(
List<GraphDescription> children
) {
return new BooleanAttributeValueDescription(children);
}
@Override
public String getSupportedDataTypeId() {
return BooleanAttributeValue.SERIALIZATION_TYPE;
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof BooleanAttributeValueDescription;
}
@Override
public BooleanAttributeValueDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new BooleanAttributeValueDescription(newChildren);
}
@Override
public BooleanAttributeValueDescriptionBuilder getCopy() {
var builder = new BooleanAttributeValueDescriptionBuilder();
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/CanonicalAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.attributeValue.CanonicalAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.CanonicalAttributeValueDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class CanonicalAttributeValueDescriptionBuilder
extends AbstractAttributeValueDescriptionBuilder {
@Override
protected CanonicalAttributeValueDescription buildAttributeDescription(
List<GraphDescription> children
) {
return new CanonicalAttributeValueDescription(children);
}
@Override
public String getSupportedDataTypeId() {
return CanonicalAttributeValue.SERIALIZATION_TYPE;
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof CanonicalAttributeValueDescription;
}
@Override
public CanonicalAttributeValueDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new CanonicalAttributeValueDescription(newChildren);
}
@Override
public CanonicalAttributeValueDescriptionBuilder getCopy() {
var builder = new CanonicalAttributeValueDescriptionBuilder();
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/CodeAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.attributeValue.CodeAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.CodeAttributeValueDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class CodeAttributeValueDescriptionBuilder extends AbstractAttributeValueDescriptionBuilder {
@Override
protected CodeAttributeValueDescription buildAttributeDescription(
List<GraphDescription> children
) {
return new CodeAttributeValueDescription(children);
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof CodeAttributeValueDescription;
}
@Override
public String getSupportedDataTypeId() {
return CodeAttributeValue.SERIALIZATION_TYPE;
}
@Override
public CodeAttributeValueDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new CodeAttributeValueDescription(newChildren);
}
@Override
public CodeAttributeValueDescriptionBuilder getCopy() {
var builder = new CodeAttributeValueDescriptionBuilder();
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/ConstantSpecificDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ConstantDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ConstantDescriptionParameters;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class ConstantSpecificDescriptionBuilder extends AbstractPositiveDescriptionBuilder {
private Object value;
@Override
public ConstantDescription build() {
return new ConstantDescription(new ConstantDescriptionParameters(value));
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof ConstantDescription;
}
@Override
public ConstantSpecificDescriptionBuilder setValues(GraphDescription graphDescription) {
var parameters = (ConstantDescriptionParameters) graphDescription.getParameters();
this.value = parameters.getValue();
return this;
}
@Override
public ConstantDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
var parameters = (ConstantDescriptionParameters) graphDescription;
return new ConstantDescription(new ConstantDescriptionParameters(parameters.getValue()));
}
@Override
public ConstantSpecificDescriptionBuilder getCopy() {
var builder = new ConstantSpecificDescriptionBuilder();
builder.setValue(this.value)
.setChildren(
this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
public ConstantSpecificDescriptionBuilder setValue(Object value) {
this.value = value;
return this;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/DateAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.attributeValue.DateAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.DateAttributeValueDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class DateAttributeValueDescriptionBuilder extends AbstractAttributeValueDescriptionBuilder {
@Override
protected DateAttributeValueDescription buildAttributeDescription(
List<GraphDescription> children
) {
return new DateAttributeValueDescription(children);
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof DateAttributeValueDescription;
}
@Override
public DateAttributeValueDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new DateAttributeValueDescription(newChildren);
}
@Override
public String getSupportedDataTypeId() {
return DateAttributeValue.SERIALIZATION_TYPE;
}
@Override
public DateAttributeValueDescriptionBuilder getCopy() {
var builder = new DateAttributeValueDescriptionBuilder();
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/DateTimeAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.attributeValue.DateTimeAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.DateTimeAttributeValueDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class DateTimeAttributeValueDescriptionBuilder
extends AbstractAttributeValueDescriptionBuilder {
@Override
protected DateTimeAttributeValueDescription buildAttributeDescription(
List<GraphDescription> children
) {
return new DateTimeAttributeValueDescription(children);
}
@Override
public String getSupportedDataTypeId() {
return DateTimeAttributeValue.SERIALIZATION_TYPE;
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof DateTimeAttributeValueDescription;
}
@Override
public DateTimeAttributeValueDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new DateTimeAttributeValueDescription(newChildren);
}
@Override
public DateTimeAttributeValueDescriptionBuilder getCopy() {
var builder = new DateTimeAttributeValueDescriptionBuilder();
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/DecimalAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.attributeValue.DecimalAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AttributeValueDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.DecimalAttributeValueDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class DecimalAttributeValueDescriptionBuilder
extends AbstractAttributeValueDescriptionBuilder {
@Override
protected DecimalAttributeValueDescription buildAttributeDescription(
List<GraphDescription> children
) {
return new DecimalAttributeValueDescription(children);
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof DecimalAttributeValueDescription;
}
@Override
public String getSupportedDataTypeId() {
return DecimalAttributeValue.SERIALIZATION_TYPE;
}
@Override
public DecimalAttributeValueDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
var parameters = (AttributeValueDescriptionParameters) graphDescription.getParameters();
return new DecimalAttributeValueDescription(newChildren);
}
@Override
public DecimalAttributeValueDescriptionBuilder getCopy() {
var builder = new DecimalAttributeValueDescriptionBuilder();
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/EdgeDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.exception.GraphDescriptionBuilderException;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.EdgeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.IngoingEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.OutgoingEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.IngoingEdgeQueryDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.OutgoingEdgeQueryDescription;
import ai.stapi.graphoperations.graphbuilder.specific.positive.EdgeDirection;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class EdgeDescriptionBuilder extends AbstractPositiveDescriptionBuilder {
private EdgeDirection direction;
private String edgeType;
@Override
public AbstractEdgeDescription build() {
var children = this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::build)
.collect(Collectors.toCollection(ArrayList::new));
if (direction.equals(EdgeDirection.INGOING)) {
return new IngoingEdgeDescription(new EdgeDescriptionParameters(edgeType), children);
} else if (direction.equals(EdgeDirection.OUTGOING)) {
return new OutgoingEdgeDescription(new EdgeDescriptionParameters(edgeType), children);
} else {
throw GraphDescriptionBuilderException.becauseEdgeDirectionIsNotSupported(direction);
}
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof AbstractEdgeDescription;
}
@Override
public EdgeDescriptionBuilder setValues(GraphDescription graphDescription) {
var parameters = (EdgeDescriptionParameters) graphDescription.getParameters();
this.edgeType = parameters.getEdgeType();
if (graphDescription instanceof OutgoingEdgeDescription) {
this.direction = EdgeDirection.OUTGOING;
} else if (graphDescription instanceof IngoingEdgeDescription) {
this.direction = EdgeDirection.INGOING;
} else {
throw GraphDescriptionBuilderException.becauseDescriptionTypeIsNotSupported(graphDescription);
}
return this;
}
@Override
public AbstractEdgeDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
if (graphDescription instanceof OutgoingEdgeDescription outgoingEdgeDescription) {
return new OutgoingEdgeDescription(
(EdgeDescriptionParameters) outgoingEdgeDescription.getParameters(), newChildren);
}
if (graphDescription instanceof IngoingEdgeDescription ingoingEdgeDescription) {
return new IngoingEdgeDescription(
(EdgeDescriptionParameters) ingoingEdgeDescription.getParameters(), newChildren);
}
if (graphDescription instanceof OutgoingEdgeQueryDescription outgoingEdgeQueryDescription) {
return new OutgoingEdgeQueryDescription(
(EdgeDescriptionParameters) outgoingEdgeQueryDescription.getParameters(),
outgoingEdgeQueryDescription.getSearchQueryParameters(), newChildren
);
}
if (graphDescription instanceof IngoingEdgeQueryDescription ingoingEdgeQueryDescription) {
return new IngoingEdgeQueryDescription(
(EdgeDescriptionParameters) ingoingEdgeQueryDescription.getParameters(),
ingoingEdgeQueryDescription.getSearchQueryParameters(), newChildren
);
}
throw GraphDescriptionBuilderException.becauseDescriptionTypeIsNotSupported(graphDescription);
}
@Override
public EdgeDescriptionBuilder getCopy() {
var builder = new EdgeDescriptionBuilder();
var children = this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new));
builder.setDirection(this.direction)
.setEdgeType(this.edgeType)
.setChildren(children);
return builder;
}
public EdgeDirection getDirection() {
return direction;
}
public EdgeDescriptionBuilder setDirection(EdgeDirection direction) {
this.direction = direction;
return this;
}
public String getEdgeType() {
return edgeType;
}
public EdgeDescriptionBuilder setEdgeType(String edgeType) {
this.edgeType = edgeType;
return this;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/IdAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.attributeValue.IdAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.IdAttributeValueDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class IdAttributeValueDescriptionBuilder extends AbstractAttributeValueDescriptionBuilder {
@Override
protected IdAttributeValueDescription buildAttributeDescription(
List<GraphDescription> children
) {
return new IdAttributeValueDescription(children);
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof IdAttributeValueDescription;
}
@Override
public String getSupportedDataTypeId() {
return IdAttributeValue.SERIALIZATION_TYPE;
}
@Override
public IdAttributeValueDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new IdAttributeValueDescription(newChildren);
}
@Override
public IdAttributeValueDescriptionBuilder getCopy() {
var builder = new IdAttributeValueDescriptionBuilder();
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/InstantAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.attributeValue.InstantAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.InstantAttributeValueDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class InstantAttributeValueDescriptionBuilder
extends AbstractAttributeValueDescriptionBuilder {
@Override
protected InstantAttributeValueDescription buildAttributeDescription(
List<GraphDescription> children
) {
return new InstantAttributeValueDescription(children);
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof InstantAttributeValueDescription;
}
@Override
public String getSupportedDataTypeId() {
return InstantAttributeValue.SERIALIZATION_TYPE;
}
@Override
public InstantAttributeValueDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new InstantAttributeValueDescription(newChildren);
}
@Override
public InstantAttributeValueDescriptionBuilder getCopy() {
var builder = new InstantAttributeValueDescriptionBuilder();
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/IntegerAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.attributeValue.IntegerAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.IntegerAttributeValueDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class IntegerAttributeValueDescriptionBuilder
extends AbstractAttributeValueDescriptionBuilder {
@Override
protected IntegerAttributeValueDescription buildAttributeDescription(
List<GraphDescription> children
) {
return new IntegerAttributeValueDescription(children);
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof IntegerAttributeValueDescription;
}
@Override
public String getSupportedDataTypeId() {
return IntegerAttributeValue.SERIALIZATION_TYPE;
}
@Override
public IntegerAttributeValueDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new IntegerAttributeValueDescription(newChildren);
}
@Override
public IntegerAttributeValueDescriptionBuilder getCopy() {
var builder = new IntegerAttributeValueDescriptionBuilder();
builder.setChildren(
this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/InterfaceDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.InterfaceGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.InterfaceGraphDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class InterfaceDescriptionBuilder extends AbstractPositiveDescriptionBuilder {
private String interfaceId;
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof InterfaceGraphDescription;
}
@Override
public PositiveGraphDescription build() {
var children = this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::build)
.collect(Collectors.toCollection(ArrayList::new));
return new InterfaceGraphDescription(new InterfaceGraphDescriptionParameters(this.interfaceId),
children);
}
@Override
public AbstractPositiveDescriptionBuilder setValues(GraphDescription graphDescription) {
var params = (InterfaceGraphDescriptionParameters) graphDescription.getParameters();
this.interfaceId = params.getInterfaceId();
return this;
}
@Override
public PositiveGraphDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
var parameters = (InterfaceGraphDescriptionParameters) graphDescription.getParameters();
return new InterfaceGraphDescription(
new InterfaceGraphDescriptionParameters(parameters.getInterfaceId()),
newChildren
);
}
@Override
public AbstractPositiveDescriptionBuilder getCopy() {
var builder = new InterfaceDescriptionBuilder();
builder.setInterfaceId(this.interfaceId)
.setChildren(
this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
public AbstractPositiveDescriptionBuilder setInterfaceId(String interfaceId) {
this.interfaceId = interfaceId;
return this;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/LeafAttributeDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.LeafAttribute;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AttributeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.LeafAttributeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class LeafAttributeDescriptionBuilder extends AbstractAttributeDescriptionBuilder {
@Override
protected PositiveGraphDescription buildAttributeDescription(
AttributeDescriptionParameters parameters,
List<GraphDescription> children
) {
return new LeafAttributeDescription(parameters, children);
}
@Override
public String getSupportedStructureTypeId() {
return LeafAttribute.DATA_STRUCTURE_TYPE;
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof LeafAttributeDescription;
}
@Override
public PositiveGraphDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
var param = (AttributeDescriptionParameters) graphDescription.getParameters();
return new LeafAttributeDescription(param, newChildren);
}
@Override
public AbstractAttributeDescriptionBuilder getCopy() {
var builder = new LeafAttributeDescriptionBuilder();
builder.setAttributeName(this.getAttributeName());
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/ListAttributeDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.ListAttribute;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AttributeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ListAttributeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class ListAttributeDescriptionBuilder extends AbstractAttributeDescriptionBuilder {
@Override
protected PositiveGraphDescription buildAttributeDescription(
AttributeDescriptionParameters parameters,
List<GraphDescription> children
) {
return new ListAttributeDescription(parameters, children);
}
@Override
public String getSupportedStructureTypeId() {
return ListAttribute.DATA_STRUCTURE_TYPE;
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof ListAttributeDescription;
}
@Override
public PositiveGraphDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
var param = (AttributeDescriptionParameters) graphDescription.getParameters();
return new ListAttributeDescription(param, newChildren);
}
@Override
public AbstractAttributeDescriptionBuilder getCopy() {
var builder = new ListAttributeDescriptionBuilder();
builder.setAttributeName(this.getAttributeName());
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/MarkdownAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.attributeValue.MarkdownAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.MarkdownAttributeValueDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class MarkdownAttributeValueDescriptionBuilder
extends AbstractAttributeValueDescriptionBuilder {
@Override
protected MarkdownAttributeValueDescription buildAttributeDescription(
List<GraphDescription> children
) {
return new MarkdownAttributeValueDescription(children);
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof MarkdownAttributeValueDescription;
}
@Override
public String getSupportedDataTypeId() {
return MarkdownAttributeValue.SERIALIZATION_TYPE;
}
@Override
public MarkdownAttributeValueDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new MarkdownAttributeValueDescription(newChildren);
}
@Override
public MarkdownAttributeValueDescriptionBuilder getCopy() {
var builder = new MarkdownAttributeValueDescriptionBuilder();
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/NodeDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractNodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.NodeQueryGraphDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class NodeDescriptionBuilder extends AbstractPositiveDescriptionBuilder {
private String nodeType;
@Override
public NodeDescriptionBuilder getCopy() {
var builder = new NodeDescriptionBuilder();
builder.setNodeType(this.nodeType)
.setChildren(
this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
@Override
public NodeDescription build() {
var children = this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::build)
.collect(Collectors.toCollection(ArrayList::new));
return new NodeDescription(new NodeDescriptionParameters(nodeType), children);
}
@Override
public AbstractNodeDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
if (graphDescription instanceof NodeQueryGraphDescription nodeQueryGraphDescription) {
return new NodeQueryGraphDescription(
(NodeDescriptionParameters) graphDescription.getParameters(),
nodeQueryGraphDescription.getSearchQueryParameters(), newChildren
);
} else {
return new NodeDescription((NodeDescriptionParameters) graphDescription.getParameters(),
newChildren);
}
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof AbstractNodeDescription;
}
@Override
public NodeDescriptionBuilder setValues(GraphDescription graphDescription) {
var parameters = (NodeDescriptionParameters) graphDescription.getParameters();
this.nodeType = parameters.getNodeType();
return this;
}
public String getNodeType() {
return nodeType;
}
public NodeDescriptionBuilder setNodeType(String nodeType) {
this.nodeType = nodeType;
return this;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/NullSpecificDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import java.util.List;
public class NullSpecificDescriptionBuilder extends AbstractPositiveDescriptionBuilder {
@Override
public NullGraphDescription build() {
return new NullGraphDescription();
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof NullGraphDescription;
}
@Override
public NullSpecificDescriptionBuilder setValues(GraphDescription graphDescription) {
return new NullSpecificDescriptionBuilder();
}
@Override
public NullGraphDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new NullGraphDescription(newChildren);
}
@Override
public NullSpecificDescriptionBuilder getCopy() {
return new NullSpecificDescriptionBuilder();
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/OidAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.attributeValue.OidAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.OidAttributeValueDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class OidAttributeValueDescriptionBuilder extends AbstractAttributeValueDescriptionBuilder {
@Override
protected OidAttributeValueDescription buildAttributeDescription(
List<GraphDescription> children
) {
return new OidAttributeValueDescription(children);
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof OidAttributeValueDescription;
}
@Override
public String getSupportedDataTypeId() {
return OidAttributeValue.SERIALIZATION_TYPE;
}
@Override
public OidAttributeValueDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new OidAttributeValueDescription(newChildren);
}
@Override
public OidAttributeValueDescriptionBuilder getCopy() {
var builder = new OidAttributeValueDescriptionBuilder();
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/PositiveIntegerAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.attributeValue.PositiveIntegerAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveIntegerAttributeValueDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class PositiveIntegerAttributeValueDescriptionBuilder
extends AbstractAttributeValueDescriptionBuilder {
@Override
protected PositiveIntegerAttributeValueDescription buildAttributeDescription(
List<GraphDescription> children
) {
return new PositiveIntegerAttributeValueDescription(children);
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof PositiveIntegerAttributeValueDescription;
}
@Override
public PositiveIntegerAttributeValueDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new PositiveIntegerAttributeValueDescription(newChildren);
}
@Override
public String getSupportedDataTypeId() {
return PositiveIntegerAttributeValue.SERIALIZATION_TYPE;
}
@Override
public PositiveIntegerAttributeValueDescriptionBuilder getCopy() {
var builder = new PositiveIntegerAttributeValueDescriptionBuilder();
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/ReferenceDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ReferenceGraphDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class ReferenceDescriptionBuilder extends AbstractPositiveDescriptionBuilder {
private String structureSerializationType;
@Override
public ReferenceDescriptionBuilder getCopy() {
var builder = new ReferenceDescriptionBuilder();
builder.setStructureSerializationType(this.structureSerializationType)
.setChildren(
this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
@Override
public ReferenceGraphDescription build() {
var children = this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::build)
.collect(Collectors.toCollection(ArrayList::new));
return new ReferenceGraphDescription(
new NodeDescriptionParameters(structureSerializationType),
children
);
}
@Override
public ReferenceGraphDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new ReferenceGraphDescription(
(NodeDescriptionParameters) graphDescription.getParameters(),
graphDescription.getChildGraphDescriptions()
);
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof ReferenceGraphDescription;
}
@Override
public ReferenceDescriptionBuilder setValues(GraphDescription graphDescription) {
var parameters = (NodeDescriptionParameters) graphDescription.getParameters();
this.structureSerializationType = parameters.getNodeType();
return this;
}
public ReferenceDescriptionBuilder setStructureSerializationType(String serializationType) {
this.structureSerializationType = serializationType;
return this;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/SetAttributeDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.SetAttribute;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AttributeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.SetAttributeDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class SetAttributeDescriptionBuilder extends AbstractAttributeDescriptionBuilder {
@Override
protected PositiveGraphDescription buildAttributeDescription(
AttributeDescriptionParameters parameters,
List<GraphDescription> children
) {
return new SetAttributeDescription(parameters, children);
}
@Override
public String getSupportedStructureTypeId() {
return SetAttribute.DATA_STRUCTURE_TYPE;
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof SetAttributeDescription;
}
@Override
public PositiveGraphDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
var param = (AttributeDescriptionParameters) graphDescription.getParameters();
return new SetAttributeDescription(param, newChildren);
}
@Override
public AbstractAttributeDescriptionBuilder getCopy() {
var builder = new SetAttributeDescriptionBuilder();
builder.setAttributeName(this.getAttributeName());
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/StringAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.attributeValue.StringAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.StringAttributeValueDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class StringAttributeValueDescriptionBuilder
extends AbstractAttributeValueDescriptionBuilder {
@Override
protected StringAttributeValueDescription buildAttributeDescription(
List<GraphDescription> children
) {
return new StringAttributeValueDescription(children);
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof StringAttributeValueDescription;
}
@Override
public StringAttributeValueDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new StringAttributeValueDescription(newChildren);
}
@Override
public String getSupportedDataTypeId() {
return StringAttributeValue.SERIALIZATION_TYPE;
}
@Override
public StringAttributeValueDescriptionBuilder getCopy() {
var builder = new StringAttributeValueDescriptionBuilder();
builder.setChildren(
this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new))
);
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/TimeAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.attributeValue.TimeAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.TimeAttributeValueDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class TimeAttributeValueDescriptionBuilder extends AbstractAttributeValueDescriptionBuilder {
@Override
protected TimeAttributeValueDescription buildAttributeDescription(
List<GraphDescription> children
) {
return new TimeAttributeValueDescription(children);
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof TimeAttributeValueDescription;
}
@Override
public String getSupportedDataTypeId() {
return TimeAttributeValue.SERIALIZATION_TYPE;
}
@Override
public TimeAttributeValueDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new TimeAttributeValueDescription(newChildren);
}
@Override
public TimeAttributeValueDescriptionBuilder getCopy() {
var builder = new TimeAttributeValueDescriptionBuilder();
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/UnsignedIntegerAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.attributeValue.UnsignedIntegerAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UnsignedIntegerAttributeValueDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class UnsignedIntegerAttributeValueDescriptionBuilder
extends AbstractAttributeValueDescriptionBuilder {
@Override
protected UnsignedIntegerAttributeValueDescription buildAttributeDescription(
List<GraphDescription> children
) {
return new UnsignedIntegerAttributeValueDescription(children);
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof UnsignedIntegerAttributeValueDescription;
}
@Override
public UnsignedIntegerAttributeValueDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new UnsignedIntegerAttributeValueDescription(newChildren);
}
@Override
public String getSupportedDataTypeId() {
return UnsignedIntegerAttributeValue.SERIALIZATION_TYPE;
}
@Override
public UnsignedIntegerAttributeValueDescriptionBuilder getCopy() {
var builder = new UnsignedIntegerAttributeValueDescriptionBuilder();
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLanguage/graphDescription/graphDescriptionBuilder/specificDescriptionBuilders/positive/UriAttributeValueDescriptionBuilder.java | package ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.positive;
import ai.stapi.graph.attribute.attributeValue.UriAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.specificDescriptionBuilders.SpecificGraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UriAttributeValueDescription;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class UriAttributeValueDescriptionBuilder extends AbstractAttributeValueDescriptionBuilder {
@Override
protected UriAttributeValueDescription buildAttributeDescription(
List<GraphDescription> children
) {
return new UriAttributeValueDescription(children);
}
@Override
public boolean represents(GraphDescription graphDescription) {
return graphDescription instanceof UriAttributeValueDescription;
}
@Override
public String getSupportedDataTypeId() {
return UriAttributeValue.SERIALIZATION_TYPE;
}
@Override
public UriAttributeValueDescription copyWithNewChildren(
GraphDescription graphDescription,
List<GraphDescription> newChildren
) {
return new UriAttributeValueDescription(newChildren);
}
@Override
public UriAttributeValueDescriptionBuilder getCopy() {
var builder = new UriAttributeValueDescriptionBuilder();
builder.setChildren(this.getChildren().stream()
.map(SpecificGraphDescriptionBuilder::getCopy)
.collect(Collectors.toCollection(ArrayList::new)));
return builder;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.