index int64 | repo_id string | file_path string | content string |
|---|---|---|---|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter/exceptions/SpecificGraphWriterException.java | package ai.stapi.graphoperations.graphWriter.exceptions;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.graphWriter.specific.AttributeGraphWriter;
public class SpecificGraphWriterException extends RuntimeException {
private SpecificGraphWriterException(String message) {
super(message);
}
public static SpecificGraphWriterException becauseGivenEdgeDirectionIsNotSupported(
GraphDescription graphDescription) {
return new SpecificGraphWriterException(
"Given edge direction '"
+ graphDescription.getClass().getSimpleName()
+ "' is not supported."
);
}
public static GenericGraphWriterException becauseEdgeCanNotBeFirstElementInGraph() {
return new GenericGraphWriterException("Graph can not start with edge.");
}
public static SpecificGraphWriterException becauseAttributeDescriptionDoesNotContainValue(
GraphDescription graphDescription) {
return new SpecificGraphWriterException(
"Provided attribute description '"
+ graphDescription.getClass().getSimpleName()
+ "' does not contain value."
);
}
public static SpecificGraphWriterException becauseAttributeTypeIsNotSupported(
GraphDescription graphDescription) {
return new SpecificGraphWriterException(
"Provided attribute description '"
+ graphDescription.getClass().getSimpleName()
+ "' is not recognized by '" + AttributeGraphWriter.class.getSimpleName()
+ "'. Add it to 'getAttributeValue' method."
);
}
public static SpecificGraphWriterException becauseProvidedConstantIsNotUuid(Object value) {
return new SpecificGraphWriterException(
"Provided constant is not of type UUID. Provided constant: '" + value + "'."
);
}
public static SpecificGraphWriterException becauseProvidedAttributeValueDoesNotContainAnyConstantDescription(
GraphDescription graphDescription) {
return new SpecificGraphWriterException(
"'" + graphDescription.getClass().getSimpleName()
+ "' does not contain any constant description among it's children."
);
}
public static SpecificGraphWriterException becauseRemovalDescriptionDoesNotHaveUuidDescriptionAsChild(
GraphDescription graphDescription
) {
return new SpecificGraphWriterException(
"Removal description '"
+ graphDescription.getClass().getSimpleName()
+ "' does not contain any '"
+ UuidIdentityDescription.class.getSimpleName()
+ "' as child ,and that is not allowed."
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter/specific/AttributeGraphWriter.java | package ai.stapi.graphoperations.graphWriter.specific;
import ai.stapi.graph.attribute.attributeFactory.AttributeValueFactoryInput;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractAttributeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractAttributeValueDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AttributeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ConstantDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ConstantDescriptionParameters;
import ai.stapi.graphoperations.graphWriter.SpecificGraphWriter;
import ai.stapi.graphoperations.graphWriter.exceptions.SpecificGraphWriterException;
import ai.stapi.graphoperations.graphbuilder.GraphBuilder;
public class AttributeGraphWriter implements SpecificGraphWriter {
@Override
public GraphBuilder write(
GraphDescription graphDescription,
GraphBuilder builder
) {
if (!(graphDescription instanceof AbstractAttributeDescription attributeDescription)) {
throw new RuntimeException("Should not ever happen, because of supports.");
}
var parameters = (AttributeDescriptionParameters) attributeDescription.getParameters();
var attributeBuilder = builder.addAttributeToLastElement();
attributeBuilder
.setAttributeName(parameters.getAttributeName())
.setAttributeStructureType(attributeDescription.getDescribedAttributeStructureType());
var attributeValuesDescriptions = attributeDescription.getChildGraphDescriptions()
.stream()
.filter(AbstractAttributeValueDescription.class::isInstance)
.map(AbstractAttributeValueDescription.class::cast)
.toList();
attributeValuesDescriptions.forEach(valueDescription -> {
var constant = valueDescription.getChildGraphDescriptions().stream()
.filter(ConstantDescription.class::isInstance)
.findAny()
.orElseThrow(
() -> SpecificGraphWriterException.becauseProvidedAttributeValueDoesNotContainAnyConstantDescription(
valueDescription
)
);
var constantParameters = (ConstantDescriptionParameters) constant.getParameters();
var value = constantParameters.getValue();
attributeBuilder.addAttributeValue(
new AttributeValueFactoryInput(
value,
valueDescription.getDescribedAttributeDataTypeId()
)
);
});
return builder;
}
@Override
public boolean supports(GraphDescription graphDescription) {
return graphDescription instanceof AbstractAttributeDescription;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter/specific/AttributeValueSpecificGraphWriter.java | package ai.stapi.graphoperations.graphWriter.specific;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractAttributeValueDescription;
import ai.stapi.graphoperations.graphWriter.SpecificGraphWriter;
import ai.stapi.graphoperations.graphbuilder.GraphBuilder;
public class AttributeValueSpecificGraphWriter implements SpecificGraphWriter {
@Override
public GraphBuilder write(
GraphDescription graphDescription,
GraphBuilder builder
) {
return builder;
}
@Override
public boolean supports(GraphDescription graphDescription) {
return graphDescription instanceof AbstractAttributeValueDescription;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter/specific/ConstantSpecificGraphWriter.java | package ai.stapi.graphoperations.graphWriter.specific;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ConstantDescription;
import ai.stapi.graphoperations.graphWriter.SpecificGraphWriter;
import ai.stapi.graphoperations.graphbuilder.GraphBuilder;
public class ConstantSpecificGraphWriter implements SpecificGraphWriter {
@Override
public GraphBuilder write(
GraphDescription graphDescription,
GraphBuilder builder
) {
return builder;
}
@Override
public boolean supports(GraphDescription graphDescription) {
return graphDescription instanceof ConstantDescription;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter/specific/EdgeGraphWriter.java | package ai.stapi.graphoperations.graphWriter.specific;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
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.graphWriter.SpecificGraphWriter;
import ai.stapi.graphoperations.graphbuilder.GraphBuilder;
import ai.stapi.graphoperations.graphWriter.exceptions.SpecificGraphWriterException;
import ai.stapi.graphoperations.graphbuilder.specific.positive.EdgeDirection;
import ai.stapi.identity.UniversallyUniqueIdentifier;
public class EdgeGraphWriter implements SpecificGraphWriter {
@Override
public GraphBuilder write(
GraphDescription graphDescription,
GraphBuilder builder
) {
EdgeDirection direction;
if (graphDescription instanceof IngoingEdgeDescription) {
direction = EdgeDirection.INGOING;
} else if (graphDescription instanceof OutgoingEdgeDescription) {
direction = EdgeDirection.OUTGOING;
} else {
throw SpecificGraphWriterException.becauseGivenEdgeDirectionIsNotSupported(graphDescription);
}
var parameters = (EdgeDescriptionParameters) graphDescription.getParameters();
builder.addEdge().setEdgeDirection(direction).setId(UniversallyUniqueIdentifier.randomUUID())
.setType(parameters.getEdgeType());
return builder;
}
@Override
public boolean supports(GraphDescription graphDescription) {
return graphDescription instanceof IngoingEdgeDescription
|| graphDescription instanceof OutgoingEdgeDescription;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter/specific/NodeGraphWriter.java | package ai.stapi.graphoperations.graphWriter.specific;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescriptionParameters;
import ai.stapi.graphoperations.graphWriter.SpecificGraphWriter;
import ai.stapi.graphoperations.graphbuilder.GraphBuilder;
import ai.stapi.identity.UniversallyUniqueIdentifier;
public class NodeGraphWriter implements SpecificGraphWriter {
@Override
public GraphBuilder write(
GraphDescription graphDescription,
GraphBuilder builder
) {
var parameters = (NodeDescriptionParameters) graphDescription.getParameters();
builder.addNode()
.setId(UniversallyUniqueIdentifier.randomUUID())
.setType(parameters.getNodeType());
return builder;
}
@Override
public boolean supports(GraphDescription graphDescription) {
return graphDescription instanceof NodeDescription;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter/specific/RemovalEdgeGraphWriter.java | package ai.stapi.graphoperations.graphWriter.specific;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ConstantDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ConstantDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.removal.RemovalEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.removal.RemovalEdgeDescriptionParameters;
import ai.stapi.graphoperations.graphWriter.SpecificGraphWriter;
import ai.stapi.graphoperations.graphWriter.exceptions.SpecificGraphWriterException;
import ai.stapi.graphoperations.graphbuilder.GraphBuilder;
import ai.stapi.identity.UniqueIdentifier;
public class RemovalEdgeGraphWriter implements SpecificGraphWriter {
@Override
public GraphBuilder write(
GraphDescription graphDescription,
GraphBuilder builder
) {
var parameters = (RemovalEdgeDescriptionParameters) graphDescription.getParameters();
var uuidDescription = graphDescription.getChildGraphDescriptions().stream()
.filter(child -> child instanceof UuidIdentityDescription)
.findAny()
.orElseThrow(
() -> SpecificGraphWriterException.becauseRemovalDescriptionDoesNotHaveUuidDescriptionAsChild(
graphDescription));
var constantDescription = uuidDescription.getChildGraphDescriptions().stream()
.filter(child -> child instanceof ConstantDescription)
.findAny()
.orElseThrow(
() -> SpecificGraphWriterException.becauseAttributeDescriptionDoesNotContainValue(
uuidDescription));
var constantParameters = (ConstantDescriptionParameters) constantDescription.getParameters();
try {
var uuid = new UniqueIdentifier(constantParameters.getValue().toString());
builder.addEdgeForRemoval()
.setType(parameters.getEdgeType())
.setId(uuid);
return builder;
} catch (RuntimeException error) {
throw SpecificGraphWriterException.becauseProvidedConstantIsNotUuid(
constantParameters.getValue().toString());
}
}
@Override
public boolean supports(GraphDescription graphDescription) {
return graphDescription instanceof RemovalEdgeDescription;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter/specific/RemovalNodeGraphWriter.java | package ai.stapi.graphoperations.graphWriter.specific;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ConstantDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ConstantDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.removal.RemovalNodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.removal.RemovalNodeDescriptionParameters;
import ai.stapi.graphoperations.graphWriter.SpecificGraphWriter;
import ai.stapi.graphoperations.graphWriter.exceptions.SpecificGraphWriterException;
import ai.stapi.graphoperations.graphbuilder.GraphBuilder;
import ai.stapi.identity.UniqueIdentifier;
public class RemovalNodeGraphWriter implements SpecificGraphWriter {
@Override
public GraphBuilder write(
GraphDescription graphDescription,
GraphBuilder builder
) {
var parameters = (RemovalNodeDescriptionParameters) graphDescription.getParameters();
var uuidDescription = graphDescription.getChildGraphDescriptions().stream()
.filter(child -> child instanceof UuidIdentityDescription)
.findAny()
.orElseThrow(
() -> SpecificGraphWriterException.becauseRemovalDescriptionDoesNotHaveUuidDescriptionAsChild(
graphDescription));
var constantDescription = uuidDescription.getChildGraphDescriptions().stream()
.filter(child -> child instanceof ConstantDescription)
.findAny()
.orElseThrow(
() -> SpecificGraphWriterException.becauseAttributeDescriptionDoesNotContainValue(
uuidDescription));
var constantParameters = (ConstantDescriptionParameters) constantDescription.getParameters();
try {
var uuid = new UniqueIdentifier(constantParameters.getValue().toString());
builder.addNodeForRemoval()
.setType(parameters.getNodeType())
.setId(uuid);
return builder;
} catch (RuntimeException error) {
throw SpecificGraphWriterException.becauseProvidedConstantIsNotUuid(
constantParameters.getValue().toString());
}
}
@Override
public boolean supports(GraphDescription graphDescription) {
return graphDescription instanceof RemovalNodeDescription;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphWriter/specific/UuidGraphWriter.java | package ai.stapi.graphoperations.graphWriter.specific;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ConstantDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ConstantDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.graphWriter.SpecificGraphWriter;
import ai.stapi.graphoperations.graphWriter.exceptions.SpecificGraphWriterException;
import ai.stapi.graphoperations.graphbuilder.GraphBuilder;
import ai.stapi.identity.UniqueIdentifier;
public class UuidGraphWriter implements SpecificGraphWriter {
@Override
public GraphBuilder write(
GraphDescription graphDescription,
GraphBuilder builder
) {
var constant = graphDescription.getChildGraphDescriptions().stream()
.filter(child -> child instanceof ConstantDescription)
.findAny()
.orElseThrow(
() -> SpecificGraphWriterException.becauseAttributeDescriptionDoesNotContainValue(
graphDescription));
var constantParameters = (ConstantDescriptionParameters) constant.getParameters();
try {
var uuid = new UniqueIdentifier(constantParameters.getValue().toString());
builder.setIdToLastElement(uuid);
return builder;
} catch (RuntimeException error) {
throw SpecificGraphWriterException.becauseProvidedConstantIsNotUuid(
constantParameters.getValue().toString());
}
}
@Override
public boolean supports(GraphDescription graphDescription) {
return graphDescription instanceof UuidIdentityDescription;
}
}
|
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/graphbuilder/GraphBuilder.java | package ai.stapi.graphoperations.graphbuilder;
import ai.stapi.graphoperations.graphbuilder.exception.GraphBuilderException;
import ai.stapi.graphoperations.graphbuilder.specific.positive.AttributeBuilder;
import ai.stapi.graphoperations.graphbuilder.specific.positive.EdgeBuilder;
import ai.stapi.graphoperations.graphbuilder.specific.positive.EdgeBuilderWithSettableNodes;
import ai.stapi.graphoperations.graphbuilder.specific.positive.EdgeDirection;
import ai.stapi.graphoperations.graphbuilder.specific.positive.GraphElementBuilder;
import ai.stapi.graphoperations.graphbuilder.specific.positive.NodeBuilder;
import ai.stapi.graphoperations.graphbuilder.specific.removal.GraphElementForRemovalBuilder;
import ai.stapi.graphoperations.graphbuilder.specific.removal.RemovalEdgeBuilder;
import ai.stapi.graphoperations.graphbuilder.specific.removal.RemovalNodeBuilder;
import ai.stapi.graph.attribute.attributeFactory.GenericAttributeFactory;
import ai.stapi.graph.graphElementForRemoval.GraphElementForRemoval;
import ai.stapi.graph.Graph;
import ai.stapi.identity.UniqueIdentifier;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import org.jetbrains.annotations.Nullable;
public class GraphBuilder {
private final List<GraphElementForRemovalBuilder> graphElementsForRemoval = new ArrayList<>();
private final List<GraphBuilder> childGraphBranches = new ArrayList<>();
private GraphBuilder parentGraph;
private List<GraphElementBuilder> graphElements = new ArrayList<>();
public GraphBuilder(GraphBuilder parent) {
this.parentGraph = parent;
}
public GraphBuilder() {
}
public NodeBuilder addNode() {
var previousElement = this.getPreviousElementBuilder();
if (previousElement instanceof NodeBuilder nodeBuilder) {
throw GraphBuilderException.becauseThereCanNotBeTwoNodesAfterEachOther(nodeBuilder);
}
var nodeBuilder = new NodeBuilder();
if (previousElement instanceof EdgeBuilderWithSettableNodes edgeBuilder) {
if (edgeBuilder.getEdgeDirection().equals(EdgeDirection.OUTGOING)) {
edgeBuilder.setNodeTo(nodeBuilder);
} else if (edgeBuilder.getEdgeDirection().equals(EdgeDirection.INGOING)) {
edgeBuilder.setNodeFrom(nodeBuilder);
}
}
this.graphElements.add(nodeBuilder);
return nodeBuilder;
}
public EdgeBuilder addEdge() {
var previousElement = this.getPreviousElementBuilder();
if (previousElement instanceof EdgeBuilder) {
throw GraphBuilderException.becauseThereCanNotBeTwoEdgesAfterEachOther();
}
if (previousElement == null) {
throw GraphBuilderException.becauseGraphCanNotHaveEdgeAsFirstElement();
}
var edgeBuilder = new EdgeBuilderWithSettableNodes();
if (previousElement instanceof NodeBuilder nodeBuilder) {
edgeBuilder.setPrecedingNode(nodeBuilder);
} else {
throw GraphBuilderException.becauseEdgeHasToBePrecededByNode();
}
this.graphElements.add(edgeBuilder);
return edgeBuilder;
}
public RemovalNodeBuilder addNodeForRemoval() {
var builder = new RemovalNodeBuilder();
this.graphElementsForRemoval.add(builder);
return builder;
}
public RemovalEdgeBuilder addEdgeForRemoval() {
var builder = new RemovalEdgeBuilder();
this.graphElementsForRemoval.add(builder);
return builder;
}
public AttributeBuilder addAttributeToLastElement() {
var element = this.getPreviousElementBuilder();
if (element == null) {
throw GraphBuilderException.becauseThereAreNoElementsAbleToContainAttribute();
}
return element.addAttribute();
}
public void setIdToLastElement(UniqueIdentifier id) {
var element = this.getPreviousElementBuilder();
if (element == null) {
throw GraphBuilderException.becauseThereAreNoElements();
}
element.setId(id);
}
@Nullable
public GraphElementBuilder getLastGraphElement() {
if (this.graphElements.isEmpty()) {
return null;
}
return this.graphElements.get(this.graphElements.size() - 1);
}
@Nullable
public GraphElementBuilder getFirstGraphElement() {
if (this.graphElements.isEmpty()) {
return null;
}
return this.graphElements.get(0);
}
public GraphBuilder createNewBranch() {
var childBuilder = new GraphBuilder(this);
this.childGraphBranches.add(childBuilder);
return childBuilder;
}
public void dropIncompleteEdges() {
this.childGraphBranches.forEach(GraphBuilder::dropIncompleteEdges);
this.graphElements = this.graphElements.stream().filter(elementBuilder -> {
if (elementBuilder instanceof EdgeBuilder edgeBuilder) {
return edgeBuilder.isComplete();
} else {
return true;
}
}).toList();
}
public Graph build(GenericAttributeFactory attributeFactory) {
var childGraph =
this.childGraphBranches.stream().map(builder -> builder.build(attributeFactory)).reduce(
Graph::merge).orElse(new Graph());
var rootGraph = this.graphElements.stream()
.map(graphElementBuilder -> graphElementBuilder.buildToGraph(attributeFactory))
.reduce(Graph::merge).orElse(new Graph());
return rootGraph.merge(childGraph);
}
public List<GraphElementForRemoval> buildElementsForRemoval() {
var localElements =
this.graphElementsForRemoval.stream().map(GraphElementForRemovalBuilder::build)
.collect(Collectors.toList());
var childElements = this.childGraphBranches.stream().map(GraphBuilder::buildElementsForRemoval)
.flatMap(List::stream).toList();
localElements.addAll(childElements);
return localElements;
}
@Nullable
private GraphElementBuilder getPreviousElementBuilder() {
var previousElementBuilder = this.getLastGraphElement();
if (previousElementBuilder != null) {
return previousElementBuilder;
}
var parent = this.getFirstParentGraphWithElements();
if (parent == null) {
return null;
}
return parent.getLastGraphElement();
}
@Nullable
private GraphBuilder getFirstParentGraphWithElements() {
var parent = this.parentGraph;
while (parent != null) {
if (!parent.graphElements.isEmpty()) {
return parent;
}
parent = parent.parentGraph;
}
return null;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/exception/GraphBuilderException.java | package ai.stapi.graphoperations.graphbuilder.exception;
import ai.stapi.graphoperations.graphbuilder.specific.positive.NodeBuilder;
import ai.stapi.graphoperations.graphbuilder.specific.positive.GraphElementBuilder;
public class GraphBuilderException extends RuntimeException {
private GraphBuilderException(String message) {
super(message);
}
public static GraphBuilderException becauseAttributeValueTypeIsNotSupported(Object value) {
return new GraphBuilderException(
"Attribute value of type '" + value.toString() + "' is not supported.");
}
public static GraphBuilderException becauseAttributeBuilderIsNotComplete() {
return new GraphBuilderException("Attribute builder is not complete.");
}
public static GraphBuilderException becauseNodeIsMissingIdOrType() {
return new GraphBuilderException("Node is missing id or type.");
}
public static GraphBuilderException becauseEdgeIsNotCompleted() {
return new GraphBuilderException(
"Edge was not complete. It is missing either id, type or direction.");
}
public static GraphBuilderException becauseNodeFromOnEdgeIsNotComplete() {
return new GraphBuilderException("Node FROM on edge is not complete.");
}
public static GraphBuilderException becauseNodeToOnEdgeIsNotComplete() {
return new GraphBuilderException("Node TO on edge is not complete.");
}
public static GraphBuilderException becauseGraphCanNotHaveEdgeAsFirstElement() {
return new GraphBuilderException("Graph can not have edge as first element.");
}
public static GraphBuilderException becauseGraphCanNotHaveEdgeAsLastElement() {
return new GraphBuilderException("Graph can not have edge as last element.");
}
public static GraphBuilderException becauseOfUnexpectedEdgeNeighbor(
GraphElementBuilder elementBuilder) {
return new GraphBuilderException(
"Because there was unexpected edge neighbor: '"
+ (elementBuilder == null ? "null'."
: elementBuilder.getClass().getSimpleName() + "'."));
}
public static GraphBuilderException becauseThereCanNotBeTwoNodesAfterEachOther(
NodeBuilder previousNode) {
return new GraphBuilderException(
"There can not be two nodes after each other. Previous node type: '"
+ previousNode.getType() + "'."
);
}
public static GraphBuilderException becauseThereCanNotBeTwoEdgesAfterEachOther() {
return new GraphBuilderException("There can not be two edges after each other.");
}
public static GraphBuilderException becauseEdgeHasToBePrecededByNode() {
return new GraphBuilderException("Edge has to be preceded by node.");
}
public static GraphBuilderException becauseThereAreNoElementsAbleToContainAttribute() {
return new GraphBuilderException("There are no elements able to contain attributes.");
}
public static GraphBuilderException becauseThereAreNoAttributesOnElement() {
return new GraphBuilderException("There are no attributes on element.");
}
public static GraphBuilderException becauseThereAreNoElements() {
return new GraphBuilderException("There are no elements inside builder.");
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific/positive/AttributeBuilder.java | package ai.stapi.graphoperations.graphbuilder.specific.positive;
import ai.stapi.graph.attribute.Attribute;
import ai.stapi.graph.attribute.attributeFactory.AttributeValueFactoryInput;
import ai.stapi.graph.attribute.attributeFactory.GenericAttributeFactory;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class AttributeBuilder {
private String attributeName;
private String structureType;
private List<AttributeValueFactoryInput> attributeValues;
public AttributeBuilder() {
this.attributeValues = new ArrayList<>();
}
public AttributeBuilder setAttributeName(String attributeName) {
this.attributeName = attributeName;
return this;
}
public AttributeBuilder addAttributeValue(AttributeValueFactoryInput attributeValue) {
this.attributeValues.add(attributeValue);
return this;
}
public AttributeBuilder setAttributeStructureType(String structureType) {
this.structureType = structureType;
return this;
}
public boolean isComplete() {
return this.attributeName != null && this.attributeValues != null
&& this.structureType != null;
}
public Attribute<?> build(GenericAttributeFactory attributeFactory) {
return attributeFactory.create(
this.attributeName,
this.structureType,
this.attributeValues,
new HashMap<>()
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific/positive/EdgeBuilder.java | package ai.stapi.graphoperations.graphbuilder.specific.positive;
public interface EdgeBuilder extends GraphElementBuilder {
EdgeDirection getEdgeDirection();
EdgeBuilder setEdgeDirection(EdgeDirection edgeDirection);
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific/positive/EdgeBuilderWithSettableNodes.java | package ai.stapi.graphoperations.graphbuilder.specific.positive;
import ai.stapi.graphoperations.graphbuilder.exception.GraphBuilderException;
import ai.stapi.graph.attribute.Attribute;
import ai.stapi.graph.attribute.attributeFactory.GenericAttributeFactory;
import ai.stapi.graph.Graph;
import ai.stapi.graph.graphelements.Edge;
import ai.stapi.graph.graphelements.Node;
import ai.stapi.identity.UniqueIdentifier;
import java.util.ArrayList;
import java.util.List;
public class EdgeBuilderWithSettableNodes implements EdgeBuilder {
private final List<AttributeBuilder> attributes = new ArrayList<>();
private NodeBuilder precedingNode;
private NodeBuilder nodeFrom;
private NodeBuilder nodeTo;
private EdgeDirection edgeDirection;
private UniqueIdentifier id;
private String type;
@Override
public EdgeBuilder setId(UniqueIdentifier id) {
this.id = id;
return this;
}
@Override
public EdgeBuilder setType(String type) {
this.type = type;
return this;
}
@Override
public AttributeBuilder addAttribute() {
var attributeBuilder = new AttributeBuilder();
attributes.add(attributeBuilder);
return attributeBuilder;
}
@Override
public AttributeBuilder getLastAttribute() {
if (this.attributes.size() == 0) {
throw GraphBuilderException.becauseThereAreNoAttributesOnElement();
}
return this.attributes.get(attributes.size() - 1);
}
@Override
public boolean isComplete() {
return this.id != null
&& this.type != null
&& this.edgeDirection != null
&& this.nodeTo != null
&& this.nodeFrom != null
&& this.nodeFrom.isComplete()
&& this.nodeTo.isComplete();
}
@Override
public Edge build(GenericAttributeFactory attributeFactory) {
if (this.nodeTo == null) {
throw GraphBuilderException.becauseGraphCanNotHaveEdgeAsLastElement();
}
if (!this.isComplete()) {
throw GraphBuilderException.becauseEdgeIsNotCompleted();
}
if (!this.nodeFrom.isComplete()) {
throw GraphBuilderException.becauseNodeFromOnEdgeIsNotComplete();
}
if (!this.nodeTo.isComplete()) {
throw GraphBuilderException.becauseNodeToOnEdgeIsNotComplete();
}
var nodeFrom = this.nodeFrom.build(attributeFactory);
var nodeTo = this.nodeTo.build(attributeFactory);
var edge = new Edge(this.id, nodeFrom, this.type, nodeTo);
for (AttributeBuilder attributeBuilder : this.attributes) {
Attribute<?> build = attributeBuilder.build(attributeFactory);
edge = edge.add(build);
}
return edge;
}
@Override
public Graph buildToGraph(GenericAttributeFactory attributeFactory) {
Edge edge = this.build(attributeFactory);
Node nodeFrom = this.nodeFrom.build(attributeFactory);
Node nodeTo = this.nodeTo.build(attributeFactory);
return new Graph(
nodeFrom,
nodeTo,
edge
);
}
public EdgeBuilderWithSettableNodes setPrecedingNode(NodeBuilder nodeBuilder) {
this.precedingNode = nodeBuilder;
return this;
}
public EdgeBuilderWithSettableNodes setNodeFrom(NodeBuilder nodeFrom) {
this.nodeFrom = nodeFrom;
return this;
}
public EdgeBuilderWithSettableNodes setNodeTo(NodeBuilder nodeTo) {
this.nodeTo = nodeTo;
return this;
}
@Override
public EdgeBuilder setEdgeDirection(EdgeDirection edgeDirection) {
if (precedingNode == null) {
throw GraphBuilderException.becauseEdgeHasToBePrecededByNode();
}
this.edgeDirection = edgeDirection;
if (edgeDirection.equals(EdgeDirection.INGOING)) {
this.nodeTo = this.precedingNode;
} else if (edgeDirection.equals(EdgeDirection.OUTGOING)) {
this.nodeFrom = this.precedingNode;
}
return this;
}
@Override
public EdgeDirection getEdgeDirection() {
return edgeDirection;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific/positive/EdgeDirection.java | package ai.stapi.graphoperations.graphbuilder.specific.positive;
public enum EdgeDirection {
INGOING,
OUTGOING
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific/positive/GraphElementBuilder.java | package ai.stapi.graphoperations.graphbuilder.specific.positive;
import ai.stapi.graph.attribute.attributeFactory.GenericAttributeFactory;
import ai.stapi.graph.Graph;
import ai.stapi.graph.graphelements.GraphElement;
import ai.stapi.identity.UniqueIdentifier;
public interface GraphElementBuilder {
GraphElementBuilder setId(UniqueIdentifier id);
GraphElementBuilder setType(String type);
AttributeBuilder addAttribute();
AttributeBuilder getLastAttribute();
boolean isComplete();
GraphElement build(GenericAttributeFactory attributeFactory);
Graph buildToGraph(GenericAttributeFactory attributeFactory);
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific/positive/NodeBuilder.java | package ai.stapi.graphoperations.graphbuilder.specific.positive;
import ai.stapi.graphoperations.graphbuilder.exception.GraphBuilderException;
import ai.stapi.graph.attribute.Attribute;
import ai.stapi.graph.attribute.attributeFactory.GenericAttributeFactory;
import ai.stapi.graph.Graph;
import ai.stapi.graph.graphelements.Node;
import ai.stapi.identity.UniqueIdentifier;
import java.util.ArrayList;
import java.util.List;
public class NodeBuilder implements GraphElementBuilder {
private final List<AttributeBuilder> attributes = new ArrayList<>();
private UniqueIdentifier id;
private String type;
@Override
public NodeBuilder setId(UniqueIdentifier id) {
this.id = id;
return this;
}
public NodeBuilder setId(String id) {
this.id = new UniqueIdentifier(id);
return this;
}
@Override
public AttributeBuilder addAttribute() {
var attributeBuilder = new AttributeBuilder();
attributes.add(attributeBuilder);
return attributeBuilder;
}
@Override
public AttributeBuilder getLastAttribute() {
if (this.attributes.size() == 0) {
throw GraphBuilderException.becauseThereAreNoAttributesOnElement();
}
return this.attributes.get(attributes.size() - 1);
}
@Override
public boolean isComplete() {
return this.id != null && this.type != null;
}
@Override
public Node build(GenericAttributeFactory attributeFactory) {
if (!this.isComplete()) {
throw GraphBuilderException.becauseNodeIsMissingIdOrType();
}
var node = new Node(this.id, this.type);
for (AttributeBuilder builder : this.attributes) {
Attribute<?> attribute = builder.build(attributeFactory);
node = node.add(attribute);
}
return node;
}
@Override
public Graph buildToGraph(GenericAttributeFactory attributeFactory) {
return new Graph(this.build(attributeFactory));
}
public String getType() {
return type;
}
@Override
public NodeBuilder setType(String type) {
this.type = type;
return this;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific/removal/GraphElementForRemovalBuilder.java | package ai.stapi.graphoperations.graphbuilder.specific.removal;
import ai.stapi.graph.graphElementForRemoval.GraphElementForRemoval;
import ai.stapi.identity.UniqueIdentifier;
public interface GraphElementForRemovalBuilder {
GraphElementForRemovalBuilder setId(UniqueIdentifier id);
GraphElementForRemovalBuilder setType(String type);
boolean isComplete();
GraphElementForRemoval build();
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific/removal/RemovalEdgeBuilder.java | package ai.stapi.graphoperations.graphbuilder.specific.removal;
import ai.stapi.graphoperations.graphbuilder.exception.GraphBuilderException;
import ai.stapi.graph.graphElementForRemoval.EdgeForRemoval;
import ai.stapi.identity.UniqueIdentifier;
public class RemovalEdgeBuilder implements GraphElementForRemovalBuilder {
private UniqueIdentifier id;
private String type;
@Override
public RemovalEdgeBuilder setId(UniqueIdentifier id) {
this.id = id;
return this;
}
public RemovalEdgeBuilder setId(String id) {
this.id = new UniqueIdentifier(id);
return this;
}
@Override
public RemovalEdgeBuilder setType(String type) {
this.type = type;
return this;
}
@Override
public boolean isComplete() {
return this.id != null && this.type != null;
}
@Override
public EdgeForRemoval build() {
if (!this.isComplete()) {
throw GraphBuilderException.becauseNodeIsMissingIdOrType();
}
return new EdgeForRemoval(this.id, this.type);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphbuilder/specific/removal/RemovalNodeBuilder.java | package ai.stapi.graphoperations.graphbuilder.specific.removal;
import ai.stapi.graphoperations.graphbuilder.exception.GraphBuilderException;
import ai.stapi.graph.graphElementForRemoval.NodeForRemoval;
import ai.stapi.identity.UniqueIdentifier;
public class RemovalNodeBuilder implements GraphElementForRemovalBuilder {
private UniqueIdentifier id;
private String type;
@Override
public RemovalNodeBuilder setId(UniqueIdentifier id) {
this.id = id;
return this;
}
public RemovalNodeBuilder setId(String id) {
this.id = new UniqueIdentifier(id);
return this;
}
@Override
public RemovalNodeBuilder setType(String type) {
this.type = type;
return this;
}
@Override
public boolean isComplete() {
return this.id != null && this.type != null;
}
@Override
public NodeForRemoval build() {
if (!this.isComplete()) {
throw GraphBuilderException.becauseNodeIsMissingIdOrType();
}
return new NodeForRemoval(this.id, this.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/objectGraphLanguage/AbstractObjectGraphMapping.java | package ai.stapi.graphoperations.objectGraphLanguage;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.declaration.AbstractDeclaration;
public abstract class AbstractObjectGraphMapping extends AbstractDeclaration
implements ObjectGraphMapping {
public static final String DECLARATION_TYPE = "ObjectGraphMapping";
protected GraphDescription graphDescription;
protected AbstractObjectGraphMapping() {
}
public AbstractObjectGraphMapping(
GraphDescription graphDescription,
String deserializationType
) {
super(deserializationType);
this.graphDescription = graphDescription;
}
public AbstractObjectGraphMapping(String deserializationType) {
super(deserializationType);
}
@Override
public GraphDescription getGraphDescription() {
return graphDescription;
}
@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/objectGraphLanguage/InterfaceObjectGraphMapping.java | package ai.stapi.graphoperations.objectGraphLanguage;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
public class InterfaceObjectGraphMapping extends AbstractObjectGraphMapping {
public static final String SERIALIZATION_TYPE = "InterfaceObjectGraphMapping";
private String interfaceUuid;
public InterfaceObjectGraphMapping() {
super(SERIALIZATION_TYPE);
}
public InterfaceObjectGraphMapping(
String interfaceUuid,
GraphDescription graphDescription
) {
super(
graphDescription,
SERIALIZATION_TYPE
);
this.interfaceUuid = interfaceUuid;
}
public String getInterfaceUuid() {
return interfaceUuid;
}
}
|
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/objectGraphLanguage/LeafObjectGraphMapping.java | package ai.stapi.graphoperations.objectGraphLanguage;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
public class LeafObjectGraphMapping extends AbstractObjectGraphMapping {
public static final String SERIALIZATION_TYPE = "LeafObjectGraphMapping";
private LeafObjectGraphMapping() {
}
public LeafObjectGraphMapping(GraphDescription graphDescription) {
super(
graphDescription,
SERIALIZATION_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/objectGraphLanguage/ListObjectGraphMapping.java | package ai.stapi.graphoperations.objectGraphLanguage;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
public class ListObjectGraphMapping extends AbstractObjectGraphMapping {
public static final String SERIALIZATION_TYPE = "ListObjectGraphMapping";
private ObjectGraphMapping childObjectGraphMapping;
private ListObjectGraphMapping() {
}
public ListObjectGraphMapping(
GraphDescription graphDescription,
ObjectGraphMapping childObjectGraphMapping
) {
super(
graphDescription,
SERIALIZATION_TYPE
);
this.childObjectGraphMapping = childObjectGraphMapping;
}
public ObjectGraphMapping getChildObjectGraphMapping() {
return childObjectGraphMapping;
}
}
|
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/objectGraphLanguage/MapObjectGraphMapping.java | package ai.stapi.graphoperations.objectGraphLanguage;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
public class MapObjectGraphMapping extends AbstractObjectGraphMapping {
public static final String SERIALIZATION_TYPE = "MapObjectGraphMapping";
private ObjectGraphMapping keyObjectGraphMapping;
private ObjectGraphMapping valueObjectGraphMapping;
private MapObjectGraphMapping() {
}
public MapObjectGraphMapping(
GraphDescription graphDescription,
ObjectGraphMapping keyObjectGraphMapping,
ObjectGraphMapping valueObjectGraphMapping
) {
super(graphDescription, SERIALIZATION_TYPE);
this.keyObjectGraphMapping = keyObjectGraphMapping;
this.valueObjectGraphMapping = valueObjectGraphMapping;
}
public ObjectGraphMapping getKeyObjectGraphMapping() {
return keyObjectGraphMapping;
}
public ObjectGraphMapping getValueObjectGraphMapping() {
return valueObjectGraphMapping;
}
}
|
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/objectGraphLanguage/ObjectFieldDefinition.java | package ai.stapi.graphoperations.objectGraphLanguage;
import ai.stapi.graphoperations.declaration.Declaration;
import ai.stapi.serialization.AbstractSerializableObject;
public class ObjectFieldDefinition extends AbstractSerializableObject {
public static final String SERIALIZATION_TYPE = "ObjectFieldDefinition";
private Declaration relation;
private ObjectGraphMapping fieldObjectGraphMapping;
private ObjectFieldDefinition() {
}
public ObjectFieldDefinition(
Declaration relation,
ObjectGraphMapping fieldObjectGraphMapping
) {
super(SERIALIZATION_TYPE);
this.fieldObjectGraphMapping = fieldObjectGraphMapping;
this.relation = relation;
}
public ObjectFieldDefinition(
Declaration relation,
ObjectGraphMapping fieldObjectGraphMapping,
String serializationType
) {
super(serializationType);
this.fieldObjectGraphMapping = fieldObjectGraphMapping;
this.relation = relation;
}
public ObjectGraphMapping getFieldObjectGraphMapping() {
return fieldObjectGraphMapping;
}
public Declaration getRelation() {
return relation;
}
}
|
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/objectGraphLanguage/ObjectGraphMapping.java | package ai.stapi.graphoperations.objectGraphLanguage;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.declaration.Declaration;
public interface ObjectGraphMapping extends Declaration {
String INTERFACE_UUID = "1eb45324-8162-44c5-ae87-104318446aed";
GraphDescription getGraphDescription();
}
|
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/objectGraphLanguage/ObjectObjectGraphMapping.java | package ai.stapi.graphoperations.objectGraphLanguage;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import java.util.Map;
public class ObjectObjectGraphMapping extends AbstractObjectGraphMapping {
public static final String SERIALIZATION_TYPE = "ObjectObjectGraphMapping";
private Map<String, ObjectFieldDefinition> fields;
private ObjectObjectGraphMapping() {
}
public ObjectObjectGraphMapping(
GraphDescription graphDescription,
Map<String, ObjectFieldDefinition> fields
) {
super(
graphDescription,
SERIALIZATION_TYPE
);
this.fields = fields;
}
public ObjectObjectGraphMapping(
GraphDescription graphDescription,
Map<String, ObjectFieldDefinition> fields,
String serializationType
) {
super(
graphDescription,
serializationType
);
this.fields = fields;
}
public Map<String, ObjectFieldDefinition> getFields() {
return fields;
}
}
|
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/objectGraphLanguage/ReferenceObjectGraphMapping.java | package ai.stapi.graphoperations.objectGraphLanguage;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
public class ReferenceObjectGraphMapping extends AbstractObjectGraphMapping {
public static final String SERIALIZATION_TYPE = "ReferenceObjectGraphMapping";
private String referencedSerializationType;
protected ReferenceObjectGraphMapping() {
super();
}
public ReferenceObjectGraphMapping(
GraphDescription graphDescription,
String referencedSerializationType
) {
super(graphDescription, SERIALIZATION_TYPE);
this.referencedSerializationType = referencedSerializationType;
}
public ReferenceObjectGraphMapping(String referencedSerializationType) {
super(SERIALIZATION_TYPE);
this.referencedSerializationType = referencedSerializationType;
}
public String getReferencedSerializationType() {
return referencedSerializationType;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/classnameprovider/ObjectGraphMappingClassNameProvider.java | package ai.stapi.graphoperations.objectGraphLanguage.classnameprovider;
import ai.stapi.graphoperations.objectGraphLanguage.InterfaceObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.LeafObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ListObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.MapObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectFieldDefinition;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ReferenceObjectGraphMapping;
import ai.stapi.serialization.classNameProvider.specific.AbstractSerializableObjectClassNameProvider;
import java.util.Map;
public class ObjectGraphMappingClassNameProvider extends AbstractSerializableObjectClassNameProvider {
@Override
protected Map<String, Class<?>> getClassMap() {
return Map.of(
ObjectObjectGraphMapping.SERIALIZATION_TYPE, ObjectObjectGraphMapping.class,
InterfaceObjectGraphMapping.SERIALIZATION_TYPE, InterfaceObjectGraphMapping.class,
LeafObjectGraphMapping.SERIALIZATION_TYPE, LeafObjectGraphMapping.class,
ListObjectGraphMapping.SERIALIZATION_TYPE, ListObjectGraphMapping.class,
MapObjectGraphMapping.SERIALIZATION_TYPE, MapObjectGraphMapping.class,
ReferenceObjectGraphMapping.SERIALIZATION_TYPE, ReferenceObjectGraphMapping.class,
ObjectFieldDefinition.SERIALIZATION_TYPE, ObjectFieldDefinition.class
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder/GenericOGMBuilder.java | package ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.*;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.exception.GenericOGMBuilderException;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.SpecificObjectGraphMappingBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.InterfaceGraphMappingBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.LeafGraphMappingBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ListGraphMappingBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.MapGraphMappingBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ReferenceGraphMappingBuilder;
import java.util.ArrayList;
import java.util.List;
public class GenericOGMBuilder {
private final List<SpecificObjectGraphMappingBuilder> supportingBuilders = new ArrayList<>();
public GenericOGMBuilder() {
this.initializeBuilders();
}
private void initializeBuilders() {
this.supportingBuilders.add(new ObjectGraphMappingBuilder());
this.supportingBuilders.add(new ListGraphMappingBuilder());
this.supportingBuilders.add(new MapGraphMappingBuilder());
this.supportingBuilders.add(new LeafGraphMappingBuilder());
this.supportingBuilders.add(new InterfaceGraphMappingBuilder());
this.supportingBuilders.add(new ReferenceGraphMappingBuilder());
}
public static GraphDescription getCompositeGraphDescriptionFromOgm(ObjectGraphMapping objectGraphMapping) {
var newChildren = new ArrayList<GraphDescription>();
if (objectGraphMapping instanceof ListObjectGraphMapping list) {
newChildren.add(GenericOGMBuilder.getCompositeGraphDescriptionFromOgm(list.getChildObjectGraphMapping()));
} else if (objectGraphMapping instanceof MapObjectGraphMapping map) {
newChildren.add(GenericOGMBuilder.getCompositeGraphDescriptionFromOgm(map.getValueObjectGraphMapping()));
} else if (objectGraphMapping instanceof ObjectObjectGraphMapping object) {
object.getFields().values()
.stream()
.map(field -> {
var newChild = GenericOGMBuilder.getCompositeGraphDescriptionFromOgm(field.getFieldObjectGraphMapping());
if (field.getRelation() instanceof GraphDescription relationDescription) {
return new GraphDescriptionBuilder().addToDeepestDescription(
relationDescription,
List.of(newChild)
);
}
return newChild;
}).forEach(newChildren::add);
}
return new GraphDescriptionBuilder().addToDeepestDescription(
objectGraphMapping.getGraphDescription(),
newChildren
);
}
public ObjectGraphMappingBuilder createNewObjectGraphMapping() {
return new ObjectGraphMappingBuilder();
}
public SpecificObjectGraphMappingBuilder copyGraphMappingAsBuilder(
ObjectGraphMapping objectGraphMapping
) {
var builder = this.getSupportingBuilder(objectGraphMapping);
return builder.copyObjectGraphMappingAsBuilder(objectGraphMapping, this);
}
public SpecificObjectGraphMappingBuilder getSupportingBuilder(
ObjectGraphMapping objectGraphMapping) {
var supportingBuilder = this.supportingBuilders.stream()
.filter(builder -> builder.supports(objectGraphMapping))
.findAny()
.orElseThrow(
() -> GenericOGMBuilderException.becauseThereIsNoSupportingBuilder(objectGraphMapping));
return supportingBuilder.getEmptyCopy();
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder/exception/GenericOGMBuilderException.java | package ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.exception;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
public class GenericOGMBuilderException extends RuntimeException {
private GenericOGMBuilderException(String message) {
super(message);
}
public static GenericOGMBuilderException becauseThereIsNoSupportingBuilder(
ObjectGraphMapping objectGraphMapping) {
return new GenericOGMBuilderException(
"There is no supporting builder for "
+ ObjectGraphMapping.class.getSimpleName()
+ " of type '" + objectGraphMapping.getClass().getSimpleName() + "'."
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder/specific/SpecificObjectGraphMappingBuilder.java | package ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.GenericOGMBuilder;
public interface SpecificObjectGraphMappingBuilder {
ObjectGraphMapping build();
SpecificObjectGraphMappingBuilder getEmptyCopy();
boolean supports(ObjectGraphMapping objectGraphMapping);
SpecificObjectGraphMappingBuilder copyObjectGraphMappingAsBuilder(
ObjectGraphMapping objectGraphMapping,
GenericOGMBuilder genericBuilder
);
GraphDescription getGraphDescription();
void setNewGraphDescription(GraphDescription graphDescription);
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder/specific/ogm/InterfaceGraphMappingBuilder.java | package ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.objectGraphLanguage.InterfaceObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.GenericOGMBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.SpecificObjectGraphMappingBuilder;
import java.util.UUID;
public class InterfaceGraphMappingBuilder implements SpecificObjectGraphMappingBuilder {
private String uuid;
private GraphDescription graphDescription;
public InterfaceGraphMappingBuilder setUuid(String uuid) {
this.uuid = uuid;
return this;
}
public InterfaceGraphMappingBuilder setUuid(UUID uuid) {
this.uuid = uuid.toString();
return this;
}
public ObjectGraphMapping build() {
var graphDescription = this.graphDescription;
if (this.graphDescription == null) {
graphDescription = new NullGraphDescription();
}
return new InterfaceObjectGraphMapping(this.uuid, graphDescription);
}
@Override
public SpecificObjectGraphMappingBuilder getEmptyCopy() {
return new InterfaceGraphMappingBuilder();
}
@Override
public boolean supports(ObjectGraphMapping objectGraphMapping) {
return objectGraphMapping instanceof InterfaceObjectGraphMapping;
}
@Override
public GraphDescription getGraphDescription() {
return this.graphDescription;
}
public InterfaceGraphMappingBuilder setGraphDescription(
GraphDescriptionBuilder graphDescription) {
this.graphDescription = graphDescription.build();
return this;
}
public InterfaceGraphMappingBuilder setGraphDescription(GraphDescription graphDescription) {
this.graphDescription = graphDescription;
return this;
}
@Override
public void setNewGraphDescription(GraphDescription graphDescription) {
this.graphDescription = graphDescription;
}
@Override
public SpecificObjectGraphMappingBuilder copyObjectGraphMappingAsBuilder(
ObjectGraphMapping objectGraphMapping,
GenericOGMBuilder genericBuilder
) {
var interfaceMapping = (InterfaceObjectGraphMapping) objectGraphMapping;
var copy = new InterfaceGraphMappingBuilder();
copy.setUuid(interfaceMapping.getInterfaceUuid());
copy.setGraphDescription(objectGraphMapping.getGraphDescription());
return copy;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder/specific/ogm/LeafGraphMappingBuilder.java | package ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.objectGraphLanguage.LeafObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.GenericOGMBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.SpecificObjectGraphMappingBuilder;
public class LeafGraphMappingBuilder implements SpecificObjectGraphMappingBuilder {
private GraphDescription graphDescription;
public ObjectGraphMapping build() {
if (this.graphDescription == null) {
this.graphDescription = new NullGraphDescription();
}
return new LeafObjectGraphMapping(
this.graphDescription
);
}
@Override
public SpecificObjectGraphMappingBuilder getEmptyCopy() {
return new LeafGraphMappingBuilder();
}
@Override
public GraphDescription getGraphDescription() {
return this.graphDescription;
}
public LeafGraphMappingBuilder setGraphDescription(GraphDescription graphDescription) {
this.graphDescription = graphDescription;
return this;
}
public LeafGraphMappingBuilder setGraphDescription(GraphDescriptionBuilder builder) {
this.graphDescription = builder.build();
return this;
}
@Override
public void setNewGraphDescription(GraphDescription graphDescription) {
this.graphDescription = graphDescription;
}
@Override
public boolean supports(ObjectGraphMapping objectGraphMapping) {
return objectGraphMapping instanceof LeafObjectGraphMapping;
}
@Override
public SpecificObjectGraphMappingBuilder copyObjectGraphMappingAsBuilder(
ObjectGraphMapping objectGraphMapping,
GenericOGMBuilder genericBuilder
) {
var leaf = (LeafObjectGraphMapping) objectGraphMapping;
var leafCopy = new LeafGraphMappingBuilder();
leafCopy.setGraphDescription(leaf.getGraphDescription());
return leafCopy;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder/specific/ogm/ListGraphMappingBuilder.java | package ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.objectGraphLanguage.ListObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.GenericOGMBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.SpecificObjectGraphMappingBuilder;
public class ListGraphMappingBuilder implements SpecificObjectGraphMappingBuilder {
private GraphDescription graphDescription;
private SpecificObjectGraphMappingBuilder child;
public ObjectGraphMappingBuilder addObjectChildDefinition() {
var builder = new ObjectGraphMappingBuilder();
this.child = builder;
return builder;
}
public LeafGraphMappingBuilder addLeafChildDefinition() {
var builder = new LeafGraphMappingBuilder();
this.child = builder;
return builder;
}
public ListGraphMappingBuilder addListChildDefinition() {
var builder = new ListGraphMappingBuilder();
this.child = builder;
return builder;
}
public MapGraphMappingBuilder addMapChildDefinition() {
var builder = new MapGraphMappingBuilder();
this.child = builder;
return builder;
}
public InterfaceGraphMappingBuilder addInterfaceChildDefinition() {
var builder = new InterfaceGraphMappingBuilder();
this.child = builder;
return builder;
}
public ReferenceGraphMappingBuilder addReferenceChildDefinition() {
var builder = new ReferenceGraphMappingBuilder();
this.child = builder;
return builder;
}
public ObjectGraphMapping build() {
if (this.graphDescription == null) {
this.graphDescription = new NullGraphDescription();
}
return new ListObjectGraphMapping(
this.graphDescription,
this.child.build()
);
}
@Override
public SpecificObjectGraphMappingBuilder getEmptyCopy() {
return new ListGraphMappingBuilder();
}
@Override
public boolean supports(ObjectGraphMapping objectGraphMapping) {
return objectGraphMapping instanceof ListObjectGraphMapping;
}
@Override
public GraphDescription getGraphDescription() {
return this.graphDescription;
}
public ListGraphMappingBuilder setGraphDescription(GraphDescription graphDescription) {
this.graphDescription = graphDescription;
return this;
}
public ListGraphMappingBuilder setGraphDescription(GraphDescriptionBuilder builder) {
this.graphDescription = builder.build();
return this;
}
@Override
public void setNewGraphDescription(GraphDescription graphDescription) {
this.graphDescription = graphDescription;
}
@Override
public SpecificObjectGraphMappingBuilder copyObjectGraphMappingAsBuilder(
ObjectGraphMapping objectGraphMapping,
GenericOGMBuilder genericBuilder
) {
var listMapping = (ListObjectGraphMapping) objectGraphMapping;
var builder = new ListGraphMappingBuilder();
builder.setGraphDescription(listMapping.getGraphDescription());
builder.setChildDefinition(
genericBuilder.copyGraphMappingAsBuilder(listMapping.getChildObjectGraphMapping()));
return builder;
}
public SpecificObjectGraphMappingBuilder setChildDefinition(
SpecificObjectGraphMappingBuilder builder) {
this.child = builder;
return builder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder/specific/ogm/MapGraphMappingBuilder.java | package ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.objectGraphLanguage.MapObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.GenericOGMBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.SpecificObjectGraphMappingBuilder;
public class MapGraphMappingBuilder implements SpecificObjectGraphMappingBuilder {
private GraphDescription graphDescription;
private SpecificObjectGraphMappingBuilder keyObjectGraphMapping;
private SpecificObjectGraphMappingBuilder valueObjectGraphMapping;
public ObjectGraphMappingBuilder addObjectObjectValueMapping() {
var builder = new ObjectGraphMappingBuilder();
this.valueObjectGraphMapping = builder;
return builder;
}
public ReferenceGraphMappingBuilder addReferenceValueMapping() {
var builder = new ReferenceGraphMappingBuilder();
this.valueObjectGraphMapping = builder;
return builder;
}
public ObjectGraphMappingBuilder addObjectObjectKeyMapping() {
var builder = new ObjectGraphMappingBuilder();
this.keyObjectGraphMapping = builder;
return builder;
}
public InterfaceGraphMappingBuilder addInterfaceObjectValueMapping() {
var builder = new InterfaceGraphMappingBuilder();
this.valueObjectGraphMapping = builder;
return builder;
}
public InterfaceGraphMappingBuilder addInterfaceObjectKeyMapping() {
var builder = new InterfaceGraphMappingBuilder();
this.keyObjectGraphMapping = builder;
return builder;
}
public ReferenceGraphMappingBuilder addReferenceKeyMapping() {
var builder = new ReferenceGraphMappingBuilder();
this.keyObjectGraphMapping = builder;
return builder;
}
public LeafGraphMappingBuilder addLeafValueMapping() {
var builder = new LeafGraphMappingBuilder();
this.valueObjectGraphMapping = builder;
return builder;
}
public LeafGraphMappingBuilder addLeafKeyMapping() {
var builder = new LeafGraphMappingBuilder();
this.keyObjectGraphMapping = builder;
return builder;
}
public ListGraphMappingBuilder addListValueMapping() {
var builder = new ListGraphMappingBuilder();
this.valueObjectGraphMapping = builder;
return builder;
}
public ListGraphMappingBuilder addListKeyMapping() {
var builder = new ListGraphMappingBuilder();
this.keyObjectGraphMapping = builder;
return builder;
}
public MapGraphMappingBuilder addMapValueMapping() {
var builder = new MapGraphMappingBuilder();
this.valueObjectGraphMapping = builder;
return builder;
}
public MapGraphMappingBuilder addMapKeyMapping() {
var builder = new MapGraphMappingBuilder();
this.keyObjectGraphMapping = builder;
return builder;
}
public ObjectGraphMapping build() {
if (this.graphDescription == null) {
this.graphDescription = new NullGraphDescription();
}
return new MapObjectGraphMapping(
this.graphDescription,
this.keyObjectGraphMapping.build(),
this.valueObjectGraphMapping.build()
);
}
@Override
public SpecificObjectGraphMappingBuilder getEmptyCopy() {
return new MapGraphMappingBuilder();
}
@Override
public boolean supports(ObjectGraphMapping objectGraphMapping) {
return objectGraphMapping instanceof MapObjectGraphMapping;
}
@Override
public SpecificObjectGraphMappingBuilder copyObjectGraphMappingAsBuilder(
ObjectGraphMapping objectGraphMapping,
GenericOGMBuilder genericBuilder
) {
var mapMapping = (MapObjectGraphMapping) objectGraphMapping;
var copy = new MapGraphMappingBuilder();
copy.setGraphDescription(mapMapping.getGraphDescription());
copy.setObjectKeyMapping(
genericBuilder.copyGraphMappingAsBuilder(mapMapping.getKeyObjectGraphMapping()));
copy.setObjectValueMapping(
genericBuilder.copyGraphMappingAsBuilder(mapMapping.getValueObjectGraphMapping()));
return copy;
}
@Override
public GraphDescription getGraphDescription() {
return this.graphDescription;
}
public MapGraphMappingBuilder setGraphDescription(GraphDescription graphDescription) {
this.graphDescription = graphDescription;
return this;
}
public MapGraphMappingBuilder setGraphDescription(GraphDescriptionBuilder builder) {
this.graphDescription = builder.build();
return this;
}
@Override
public void setNewGraphDescription(GraphDescription graphDescription) {
this.graphDescription = graphDescription;
}
private SpecificObjectGraphMappingBuilder setObjectValueMapping(
SpecificObjectGraphMappingBuilder objectGraphMappingBuilder) {
this.valueObjectGraphMapping = objectGraphMappingBuilder;
return objectGraphMappingBuilder;
}
private SpecificObjectGraphMappingBuilder setObjectKeyMapping(
SpecificObjectGraphMappingBuilder objectGraphMappingBuilder) {
this.keyObjectGraphMapping = objectGraphMappingBuilder;
return objectGraphMappingBuilder;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder/specific/ogm/ObjectFieldDefinitionBuilder.java | package ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectFieldDefinition;
import ai.stapi.graphoperations.declaration.Declaration;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.SpecificObjectGraphMappingBuilder;
public class ObjectFieldDefinitionBuilder {
private Declaration declaration;
private SpecificObjectGraphMappingBuilder child;
public ObjectFieldDefinitionBuilder setRelation(Declaration declaration) {
this.declaration = declaration;
return this;
}
public ObjectFieldDefinitionBuilder setRelation(GraphDescriptionBuilder builder) {
this.declaration = builder.build();
return this;
}
public ObjectGraphMappingBuilder addObjectAsObjectFieldMapping() {
var builder = new ObjectGraphMappingBuilder();
this.child = builder;
return builder;
}
public LeafGraphMappingBuilder addLeafAsObjectFieldMapping() {
var builder = new LeafGraphMappingBuilder();
this.child = builder;
return builder;
}
public ListGraphMappingBuilder addListAsObjectFieldMapping() {
var builder = new ListGraphMappingBuilder();
this.child = builder;
return builder;
}
public MapGraphMappingBuilder addMapAsObjectFieldMapping() {
var builder = new MapGraphMappingBuilder();
this.child = builder;
return builder;
}
public InterfaceGraphMappingBuilder addInterfaceAsObjectFieldMapping() {
var builder = new InterfaceGraphMappingBuilder();
this.child = builder;
return builder;
}
public ReferenceGraphMappingBuilder addReferenceOgm() {
var builder = new ReferenceGraphMappingBuilder();
this.child = builder;
return builder;
}
public <T extends SpecificObjectGraphMappingBuilder> T setOgmBuilder(T ogmBuilder) {
this.child = ogmBuilder;
return ogmBuilder;
}
public SpecificObjectGraphMappingBuilder setChild(
SpecificObjectGraphMappingBuilder childBuilder
) {
this.child = childBuilder;
return childBuilder;
}
public ObjectFieldDefinition build() {
if (this.declaration == null) {
this.declaration = new NullGraphDescription();
}
return new ObjectFieldDefinition(
this.declaration,
this.child.build()
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder/specific/ogm/ObjectGraphMappingBuilder.java | package ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectFieldDefinition;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.GenericOGMBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.SpecificObjectGraphMappingBuilder;
import java.util.HashMap;
import java.util.Map;
public class ObjectGraphMappingBuilder implements SpecificObjectGraphMappingBuilder {
private final Map<String, ObjectFieldDefinitionBuilder> fields = new HashMap<>();
private GraphDescription graphDescription;
public ObjectFieldDefinitionBuilder addField(String fieldName) {
var newField = new ObjectFieldDefinitionBuilder();
this.fields.put(fieldName, newField);
return newField;
}
public ObjectFieldDefinitionBuilder addField(String fieldName,
ObjectFieldDefinitionBuilder fieldBuilder) {
this.fields.put(fieldName, fieldBuilder);
return fieldBuilder;
}
@Override
public void setNewGraphDescription(GraphDescription graphDescription) {
this.graphDescription = graphDescription;
}
public ObjectGraphMapping build() {
if (this.graphDescription == null) {
this.graphDescription = new NullGraphDescription();
}
var resolvedFields = new HashMap<String, ObjectFieldDefinition>();
this.fields.forEach(
(key, value) -> resolvedFields.put(key, value.build())
);
return new ObjectObjectGraphMapping(
this.graphDescription,
resolvedFields
);
}
@Override
public SpecificObjectGraphMappingBuilder getEmptyCopy() {
return new ObjectGraphMappingBuilder();
}
@Override
public boolean supports(ObjectGraphMapping objectGraphMapping) {
return objectGraphMapping instanceof ObjectObjectGraphMapping;
}
@Override
public SpecificObjectGraphMappingBuilder copyObjectGraphMappingAsBuilder(
ObjectGraphMapping objectGraphMapping, GenericOGMBuilder genericBuilder) {
var objectMapping = (ObjectObjectGraphMapping) objectGraphMapping;
var builder = new ObjectGraphMappingBuilder();
builder.setGraphDescription(objectGraphMapping.getGraphDescription());
objectMapping.getFields().forEach(
(key, value) -> {
var copiedField = new ObjectFieldDefinitionBuilder();
copiedField.setRelation(value.getRelation());
copiedField.setChild(
genericBuilder.copyGraphMappingAsBuilder(value.getFieldObjectGraphMapping()));
builder.addField(key, copiedField);
}
);
return builder;
}
@Override
public GraphDescription getGraphDescription() {
return this.graphDescription;
}
public ObjectGraphMappingBuilder setGraphDescription(GraphDescription graphDescription) {
this.graphDescription = graphDescription;
return this;
}
public ObjectGraphMappingBuilder setGraphDescription(GraphDescriptionBuilder builder) {
this.graphDescription = builder.build();
return this;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphLanguage/objectGraphMappingBuilder/specific/ogm/ReferenceGraphMappingBuilder.java | package ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ReferenceObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.GenericOGMBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.SpecificObjectGraphMappingBuilder;
public class ReferenceGraphMappingBuilder implements SpecificObjectGraphMappingBuilder {
private String referencedSerializationType;
private GraphDescription graphDescription;
public ObjectGraphMapping build() {
var graphDescription = this.graphDescription;
if (this.graphDescription == null) {
graphDescription = new NullGraphDescription();
}
return new ReferenceObjectGraphMapping(graphDescription, referencedSerializationType);
}
@Override
public SpecificObjectGraphMappingBuilder getEmptyCopy() {
return new ReferenceGraphMappingBuilder();
}
@Override
public boolean supports(ObjectGraphMapping objectGraphMapping) {
return objectGraphMapping instanceof ReferenceObjectGraphMapping;
}
@Override
public GraphDescription getGraphDescription() {
return this.graphDescription;
}
public ReferenceGraphMappingBuilder setGraphDescription(
GraphDescriptionBuilder graphDescription) {
this.graphDescription = graphDescription.build();
return this;
}
public ReferenceGraphMappingBuilder setGraphDescription(GraphDescription graphDescription) {
this.graphDescription = graphDescription;
return this;
}
@Override
public void setNewGraphDescription(GraphDescription graphDescription) {
this.graphDescription = graphDescription;
}
@Override
public SpecificObjectGraphMappingBuilder copyObjectGraphMappingAsBuilder(
ObjectGraphMapping objectGraphMapping,
GenericOGMBuilder genericBuilder
) {
var referenceMapping = (ReferenceObjectGraphMapping) objectGraphMapping;
var copy = new ReferenceGraphMappingBuilder();
copy.setReferencedSerializationType(referenceMapping.getReferencedSerializationType());
copy.setGraphDescription(referenceMapping.getGraphDescription());
return copy;
}
public String getReferencedSerializationType() {
return referencedSerializationType;
}
public ReferenceGraphMappingBuilder setReferencedSerializationType(
String referencedSerializationType) {
this.referencedSerializationType = referencedSerializationType;
return this;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/infrastructure | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/infrastructure/structureSchema/StructureSchemaInterfaceSpecificObjectGraphMapperFixStrategy.java | package ai.stapi.graphoperations.objectGraphMapper.infrastructure.structureSchema;
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.NullGraphDescription;
import ai.stapi.graphoperations.objectGraphMapper.model.specific.InterfaceSpecificObjectGraphMapperFixStrategy;
import ai.stapi.graphoperations.objectGraphMapper.model.specific.exceptions.CannotFixInterfaceObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.InterfaceObjectGraphMapping;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.BoxedPrimitiveStructureType;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaProvider;
import ai.stapi.schema.structureSchemaProvider.exception.CannotProvideStructureSchema;
import java.util.Map;
public class StructureSchemaInterfaceSpecificObjectGraphMapperFixStrategy
implements InterfaceSpecificObjectGraphMapperFixStrategy {
private final StructureSchemaProvider structureSchemaProvider;
public StructureSchemaInterfaceSpecificObjectGraphMapperFixStrategy(
StructureSchemaProvider structureSchemaProvider
) {
this.structureSchemaProvider = structureSchemaProvider;
}
@Override
public InterfaceObjectGraphMapping fix(
InterfaceObjectGraphMapping interfaceObjectGraphMapping,
Map.Entry<String, Object> fieldEntry,
GraphDescriptionBuilder builder,
String serializationType
) {
if (!this.structureSchemaProvider.provideSchema().containsDefinition(serializationType)) {
return interfaceObjectGraphMapping;
}
AbstractStructureType structure = null;
try {
structure = this.structureSchemaProvider.provideSpecific(serializationType);
} catch (CannotProvideStructureSchema e) {
throw new CannotFixInterfaceObjectGraphMapping(serializationType, e);
}
if (structure instanceof BoxedPrimitiveStructureType) {
if (interfaceObjectGraphMapping.getGraphDescription() instanceof AbstractEdgeDescription) {
GraphDescription graphDescription = new NullGraphDescription();
if (
!interfaceObjectGraphMapping
.getGraphDescription()
.getChildGraphDescriptions()
.isEmpty()
) {
graphDescription = interfaceObjectGraphMapping
.getGraphDescription()
.getChildGraphDescriptions()
.get(0);
}
return new InterfaceObjectGraphMapping(
interfaceObjectGraphMapping.getInterfaceUuid(),
graphDescription
);
}
}
return interfaceObjectGraphMapping;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model/GenericObjectGraphMapper.java | package ai.stapi.graphoperations.objectGraphMapper.model;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphWriter.GenericGraphWriter;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphMapper.model.exceptions.ObjectGraphMapperException;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import ai.stapi.serialization.SerializableObject;
import java.util.List;
import java.util.Map;
public class GenericObjectGraphMapper {
private final List<SpecificObjectGraphMapper> specificObjectGraphMappers;
private final GenericGraphWriter writer;
private final GenericGraphMappingProvider mappingProvider;
public GenericObjectGraphMapper(
List<SpecificObjectGraphMapper> specificObjectGraphMappers,
GenericGraphWriter writer,
GenericGraphMappingProvider mappingProvider
) {
this.specificObjectGraphMappers = specificObjectGraphMappers;
this.writer = writer;
this.mappingProvider = mappingProvider;
}
public GraphMappingResult mapToGraph(
ObjectGraphMapping objectGraphMapping,
Object object
) {
return this.mapToGraph(objectGraphMapping, object, MissingFieldResolvingStrategy.STRICT);
}
public GraphMappingResult mapToGraph(
ObjectGraphMapping objectGraphMapping,
Object object,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
if (object == null) {
throw ObjectGraphMapperException.becausegivenObjectIsNull(objectGraphMapping);
}
if (!(objectGraphMapping instanceof ObjectObjectGraphMapping)) {
throw ObjectGraphMapperException.becauseFirstObjectGraphMappingIsNotObject(
objectGraphMapping);
}
var builder = new GraphDescriptionBuilder();
this.resolveInternally(
objectGraphMapping,
Map.entry("", object),
builder,
missingFieldResolvingStrategy
);
var graph = this.writer.createGraph(
builder.getOnlyPositiveGraphDescriptions()
);
var elementsForRemoval = this.writer.createElementsForRemoval(
builder.getOnlyRemovalGraphDescriptions()
);
return new GraphMappingResult(graph, elementsForRemoval);
}
public GraphMappingResult mapToGraph(SerializableObject object) {
return this.mapToGraph(object, MissingFieldResolvingStrategy.STRICT);
}
public GraphMappingResult mapToGraph(
SerializableObject object,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
var objectGraphMapping = this.mappingProvider.provideGraphMapping(object.getSerializationType());
return this.mapToGraph(objectGraphMapping, object, missingFieldResolvingStrategy);
}
public GraphMappingResult mapToGraph(
Object object,
String serializationType,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
var objectGraphMapping = this.mappingProvider.provideGraphMapping(serializationType);
return this.mapToGraph(objectGraphMapping, object, missingFieldResolvingStrategy);
}
public void resolveInternally(
ObjectGraphMapping graphMapping,
Map.Entry<String, Object> fieldEntry,
GraphDescriptionBuilder builder,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
var supportingResolver = this.getSupportingSpecificMapper(graphMapping);
supportingResolver.createGraphDescriptionWithValues(
graphMapping,
fieldEntry,
builder,
missingFieldResolvingStrategy
);
}
private SpecificObjectGraphMapper getSupportingSpecificMapper(
ObjectGraphMapping objectGraphMapping) {
var supportingGraphWriters = this.specificObjectGraphMappers.stream()
.filter(
specificObjectGraphMapper -> specificObjectGraphMapper.supports(objectGraphMapping));
var listOfSupportingResolvers = supportingGraphWriters.toList();
if (listOfSupportingResolvers.size() == 0) {
throw ObjectGraphMapperException.becauseNoSupportingSpecificResolverForGivenDeclaration(
objectGraphMapping);
}
if (listOfSupportingResolvers.size() > 1) {
throw ObjectGraphMapperException.becauseMoreThanOneSpecificResolverForGivenDeclaration(
objectGraphMapping,
listOfSupportingResolvers
);
}
return listOfSupportingResolvers.get(0);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model/GraphMappingResult.java | package ai.stapi.graphoperations.objectGraphMapper.model;
import ai.stapi.graph.graphElementForRemoval.GraphElementForRemoval;
import ai.stapi.graph.Graph;
import java.util.ArrayList;
import java.util.List;
public class GraphMappingResult {
private final List<GraphElementForRemoval> elementForRemoval;
private final Graph graph;
public GraphMappingResult(
Graph graph,
List<GraphElementForRemoval> elementForRemoval
) {
this.elementForRemoval = elementForRemoval;
this.graph = graph;
}
public List<GraphElementForRemoval> getElementForRemoval() {
return elementForRemoval;
}
public Graph getGraph() {
return graph;
}
public GraphMappingResult merge(GraphMappingResult anotherMappingResult) {
var mergedList = new ArrayList<>(this.elementForRemoval);
mergedList.addAll(anotherMappingResult.elementForRemoval);
return new GraphMappingResult(
this.getGraph().merge(anotherMappingResult.graph),
mergedList
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model/MissingFieldResolvingStrategy.java | package ai.stapi.graphoperations.objectGraphMapper.model;
public enum MissingFieldResolvingStrategy {
STRICT,
LENIENT
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model/SpecificObjectGraphMapper.java | package ai.stapi.graphoperations.objectGraphMapper.model;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import java.util.Map;
public interface SpecificObjectGraphMapper {
GraphDescriptionBuilder createGraphDescriptionWithValues(
ObjectGraphMapping objectGraphMapping,
Map.Entry<String, Object> fieldEntry,
GraphDescriptionBuilder builder,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
);
boolean supports(ObjectGraphMapping objectGraphMapping);
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model/exceptions/ObjectGraphMapperException.java | package ai.stapi.graphoperations.objectGraphMapper.model.exceptions;
import ai.stapi.graphoperations.objectGraphMapper.model.GenericObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.SpecificObjectGraphMapper;
import ai.stapi.graphoperations.declaration.Declaration;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectObjectGraphMapping;
import ai.stapi.utils.LineFormatter;
import java.util.List;
import java.util.stream.Collectors;
public class ObjectGraphMapperException extends RuntimeException {
public ObjectGraphMapperException(String format) {
super(format);
}
public static ObjectGraphMapperException becausegivenObjectIsNull(
ObjectGraphMapping objectGraphMapping
) {
return new ObjectGraphMapperException(
String.format(
"Given object to be mapped to graph should not be null. But it is."
+ LineFormatter.createNewLine() +
"Given Graph Object Mapping:" + LineFormatter.createNewLine() +
"\"%s\"",
objectGraphMapping.getClass().getSimpleName()
)
);
}
public static ObjectGraphMapperException becauseNoSupportingSpecificResolverForGivenDeclaration(
Declaration declaration) {
return new ObjectGraphMapperException(
String.format(
"There is no supporting \"%s\" for declaration \"%s\".",
GenericObjectGraphMapper.class.getSimpleName(),
declaration.getClass().getSimpleName()
)
);
}
public static ObjectGraphMapperException becauseMoreThanOneSpecificResolverForGivenDeclaration(
Declaration declaration,
List<SpecificObjectGraphMapper> supportingSpecificGraphWriters
) {
return new ObjectGraphMapperException(
String.format(
"There is more than one supporting \"%s\" " + LineFormatter.createNewLine() +
"for declaration \"%s\". " + LineFormatter.createNewLine() +
"Supporting: " + LineFormatter.createNewLine() +
"\"%s\"",
GenericObjectGraphMapper.class.getSimpleName(),
declaration.getClass().getSimpleName(),
supportingSpecificGraphWriters.stream()
.map(supportingSpecificGraphWriter -> supportingSpecificGraphWriter.getClass()
.getSimpleName())
.collect(Collectors.joining(LineFormatter.createNewLine()))
)
);
}
public static ObjectGraphMapperException becauseFirstObjectGraphMappingIsNotObject(
ObjectGraphMapping objectGraphMapping) {
return new ObjectGraphMapperException(
String.format(
"First Object Graph Mapping should be of type \"%s\" " + LineFormatter.createNewLine() +
"but is \"%s\". " + LineFormatter.createNewLine(),
ObjectObjectGraphMapping.class.getSimpleName(),
objectGraphMapping == null
? "null"
: objectGraphMapping.getClass().getSimpleName()
)
);
}
public static ObjectGraphMapperException becauseResolverCanNotResolveEntityIdentifier(
SpecificObjectGraphMapper supportingResolver) {
return new ObjectGraphMapperException(
"Specific Object Graph Mapper of type '"
+ supportingResolver.getClass().getSimpleName()
+ "' can not resolve Entity Identifier."
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model/specific/AbstractSpecificObjectGraphMapper.java | package ai.stapi.graphoperations.objectGraphMapper.model.specific;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ConstantDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.objectGraphMapper.model.GenericObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import ai.stapi.graphoperations.objectGraphMapper.model.SpecificObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.specific.exceptions.SpecificObjectGraphMapperException;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import java.util.Map;
public abstract class AbstractSpecificObjectGraphMapper implements SpecificObjectGraphMapper {
protected final GenericObjectGraphMapper genericGraphMapper;
protected final ObjectMapper jsonObjectMapper;
public AbstractSpecificObjectGraphMapper(GenericObjectGraphMapper genericGraphMapper) {
this.genericGraphMapper = genericGraphMapper;
this.jsonObjectMapper = new ObjectMapper();
this.jsonObjectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
}
@Override
public abstract GraphDescriptionBuilder createGraphDescriptionWithValues(
ObjectGraphMapping objectGraphMapping,
Map.Entry<String, Object> fieldEntry,
GraphDescriptionBuilder builder,
MissingFieldResolvingStrategy missingFieldResolvingStrategy);
@Override
public abstract boolean supports(ObjectGraphMapping objectGraphMapping);
protected GraphDescriptionBuilder addGraphDescriptionCompositeToBuilder(
GraphDescription graphDescription,
GraphDescriptionBuilder rootBuilderBranch
) {
if (graphDescription instanceof NullGraphDescription) {
return rootBuilderBranch;
}
var newBranch =
rootBuilderBranch.addBuilderCopyOfGraphDescriptionWithNoChildrenToBuilder(graphDescription);
this.ensureGraphDescriptionChildrenAreValid(graphDescription);
for (GraphDescription child : graphDescription.getChildGraphDescriptions()) {
newBranch = this.addGraphDescriptionCompositeToBuilder(child, newBranch);
}
return newBranch;
}
private void ensureGraphDescriptionChildrenAreValid(GraphDescription graphDescription) {
var nonConstantChildren = graphDescription.getChildGraphDescriptions().stream()
.filter(child -> (!(child instanceof ConstantDescription)))
.toList();
if (nonConstantChildren.size() > 1) {
throw SpecificObjectGraphMapperException.becauseGraphDescriptionHasMultipleNonConstantChildren(
graphDescription, nonConstantChildren.size());
}
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model/specific/InterfaceSpecificObjectGraphMapper.java | package ai.stapi.graphoperations.objectGraphMapper.model.specific;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.objectGraphLanguage.InterfaceObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphMapper.model.GenericObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import ai.stapi.graphoperations.objectGraphMapper.model.specific.exceptions.SpecificObjectGraphMapperException;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import ai.stapi.serialization.AbstractSerializableObject;
import ai.stapi.serialization.SerializableObject;
import java.util.Map;
import org.jetbrains.annotations.Nullable;
public class InterfaceSpecificObjectGraphMapper extends AbstractSpecificObjectGraphMapper {
private final GenericGraphMappingProvider mappingProvider;
@Nullable
private final InterfaceSpecificObjectGraphMapperFixStrategy interfaceSpecificObjectGraphMapperFixStrategy;
public InterfaceSpecificObjectGraphMapper(
GenericObjectGraphMapper genericGraphMapper,
GenericGraphMappingProvider mappingProvider,
@Nullable InterfaceSpecificObjectGraphMapperFixStrategy interfaceSpecificObjectGraphMapperFixStrategy
) {
super(genericGraphMapper);
this.mappingProvider = mappingProvider;
this.interfaceSpecificObjectGraphMapperFixStrategy = interfaceSpecificObjectGraphMapperFixStrategy;
}
@Override
public GraphDescriptionBuilder createGraphDescriptionWithValues(
ObjectGraphMapping objectGraphMapping,
Map.Entry<String, Object> fieldEntry,
GraphDescriptionBuilder builder,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
String serializationType;
if (fieldEntry.getValue() instanceof Map map) {
serializationType = this.getSerializationTypeFromMap(map);
} else if (fieldEntry.getValue() instanceof SerializableObject serializableObject) {
serializationType = serializableObject.getSerializationType();
} else {
throw SpecificObjectGraphMapperException.becauseActualEntityBehindInterfaceIsNotObject(
fieldEntry.getValue()
);
}
if (this.isNullDeclaration(serializationType)) {
return builder;
}
if (serializationType.isBlank()) {
throw SpecificObjectGraphMapperException.becauseSerializationTypeWasNotFound(
fieldEntry.getKey(),
fieldEntry.getValue()
);
}
var mappingDefinition = this.mappingProvider.provideGraphMapping(
serializationType,
fieldEntry.getKey()
);
var interfaceObjectGraphMapping = (InterfaceObjectGraphMapping) objectGraphMapping;
if (this.interfaceSpecificObjectGraphMapperFixStrategy != null) {
interfaceObjectGraphMapping = this.interfaceSpecificObjectGraphMapperFixStrategy.fix(
interfaceObjectGraphMapping,
fieldEntry,
builder,
serializationType
);
}
var resolvedBuilder = this.addGraphDescriptionCompositeToBuilder(
interfaceObjectGraphMapping.getGraphDescription(),
builder
);
this.genericGraphMapper.resolveInternally(
mappingDefinition,
fieldEntry,
resolvedBuilder,
missingFieldResolvingStrategy
);
return resolvedBuilder;
}
private String getSerializationTypeFromMap(Map map) {
return (String) map.getOrDefault(
AbstractSerializableObject.NAME_OF_FIELD_WITH_SERIALIZATION_TYPE,
""
);
}
@Override
public boolean supports(ObjectGraphMapping objectGraphMapping) {
return objectGraphMapping instanceof InterfaceObjectGraphMapping;
}
private boolean isNullDeclaration(String serializationType) {
return serializationType.equals(NullGraphDescription.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model/specific/InterfaceSpecificObjectGraphMapperFixStrategy.java | package ai.stapi.graphoperations.objectGraphMapper.model.specific;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.InterfaceObjectGraphMapping;
import java.util.Map;
public interface InterfaceSpecificObjectGraphMapperFixStrategy {
InterfaceObjectGraphMapping fix(
InterfaceObjectGraphMapping interfaceObjectGraphMapping,
Map.Entry<String, Object> fieldEntry,
GraphDescriptionBuilder builder,
String serializationType
);
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model/specific/LeafSpecificObjectGraphMapper.java | package ai.stapi.graphoperations.objectGraphMapper.model.specific;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.LeafObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphMapper.model.specific.exceptions.SpecificObjectGraphMapperException;
import ai.stapi.graphoperations.objectGraphMapper.model.GenericObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import ai.stapi.utils.Classifier;
import java.util.Map;
public class LeafSpecificObjectGraphMapper extends AbstractSpecificObjectGraphMapper {
public LeafSpecificObjectGraphMapper(GenericObjectGraphMapper genericGraphMapper) {
super(genericGraphMapper);
}
@Override
public GraphDescriptionBuilder createGraphDescriptionWithValues(
ObjectGraphMapping objectGraphMapping,
Map.Entry<String, Object> fieldEntry,
GraphDescriptionBuilder builder,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
if (!Classifier.isPrimitiveOrString(fieldEntry.getValue())) {
throw SpecificObjectGraphMapperException.becauseProvidedValueIsNotPrimitiveType(
fieldEntry.getKey(),
fieldEntry.getValue()
);
}
var leafMapping = (LeafObjectGraphMapping) objectGraphMapping;
var leafFinishedBranch = this.addGraphDescriptionCompositeToBuilder(
leafMapping.getGraphDescription(),
builder
);
leafFinishedBranch.addConstantDescription(fieldEntry.getValue());
return leafFinishedBranch;
}
@Override
public boolean supports(ObjectGraphMapping objectGraphMapping) {
return objectGraphMapping instanceof LeafObjectGraphMapping;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model/specific/ListSpecificObjectGraphMapper.java | package ai.stapi.graphoperations.objectGraphMapper.model.specific;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractAttributeValueDescription;
import ai.stapi.graphoperations.objectGraphLanguage.LeafObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ListObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphMapper.model.specific.exceptions.SpecificObjectGraphMapperException;
import com.fasterxml.jackson.core.type.TypeReference;
import ai.stapi.graphoperations.objectGraphMapper.model.GenericObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import java.util.List;
import java.util.Map;
public class ListSpecificObjectGraphMapper extends AbstractSpecificObjectGraphMapper {
public ListSpecificObjectGraphMapper(GenericObjectGraphMapper genericGraphMapper) {
super(genericGraphMapper);
}
@Override
public GraphDescriptionBuilder createGraphDescriptionWithValues(
ObjectGraphMapping objectGraphMapping,
Map.Entry<String, Object> fieldEntry,
GraphDescriptionBuilder builder,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
var listMapping = (ListObjectGraphMapping) objectGraphMapping;
var objectList = this.convertObjectIntoList(fieldEntry.getValue(), fieldEntry.getKey());
var childObjectGraphMapping = listMapping.getChildObjectGraphMapping();
if (childObjectGraphMapping instanceof LeafObjectGraphMapping leafObjectGraphMapping) {
var resolvedListBuilderBranch = this.addGraphDescriptionCompositeToBuilder(
listMapping.getGraphDescription(),
builder
);
var childDescription = leafObjectGraphMapping.getGraphDescription();
if (childDescription instanceof AbstractAttributeValueDescription) {
objectList.forEach(value -> {
var leafFinishedBranch = this.addGraphDescriptionCompositeToBuilder(
childDescription,
resolvedListBuilderBranch
);
leafFinishedBranch.addConstantDescription(value);
});
return resolvedListBuilderBranch;
}
}
objectList.forEach(listObject -> {
var resolvedListBuilderBranch = this.addGraphDescriptionCompositeToBuilder(
listMapping.getGraphDescription(),
builder
);
this.genericGraphMapper.resolveInternally(
childObjectGraphMapping,
Map.entry("", listObject),
resolvedListBuilderBranch,
missingFieldResolvingStrategy
);
});
return builder;
}
private List<Object> convertObjectIntoList(Object object, String fieldName) {
try {
return this.jsonObjectMapper.convertValue(object, new TypeReference<>() {
});
} catch (IllegalArgumentException error) {
throw SpecificObjectGraphMapperException.becauseObjectCouldNotBeConverted(
this,
fieldName,
object,
error
);
}
}
@Override
public boolean supports(ObjectGraphMapping objectGraphMapping) {
return objectGraphMapping instanceof ListObjectGraphMapping;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model/specific/MapSpecificObjectGraphMapper.java | package ai.stapi.graphoperations.objectGraphMapper.model.specific;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.objectGraphMapper.model.GenericObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import ai.stapi.graphoperations.objectGraphMapper.model.specific.exceptions.SpecificObjectGraphMapperException;
import ai.stapi.graphoperations.objectGraphLanguage.MapObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import com.fasterxml.jackson.core.type.TypeReference;
import java.util.Map;
public class MapSpecificObjectGraphMapper extends AbstractSpecificObjectGraphMapper {
public MapSpecificObjectGraphMapper(GenericObjectGraphMapper genericGraphMapper) {
super(genericGraphMapper);
}
@Override
public GraphDescriptionBuilder createGraphDescriptionWithValues(
ObjectGraphMapping objectGraphMapping,
Map.Entry<String, Object> fieldEntry,
GraphDescriptionBuilder builder,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
var mapMapping = (MapObjectGraphMapping) objectGraphMapping;
var objectMap = this.convertObjectToMap(fieldEntry.getValue(), fieldEntry.getKey());
objectMap.forEach(
(key, value) -> {
var resolvedMapBuilderBranch = this.addGraphDescriptionCompositeToBuilder(
mapMapping.getGraphDescription(),
builder
);
this.genericGraphMapper.resolveInternally(
mapMapping.getKeyObjectGraphMapping(),
Map.entry("", key),
resolvedMapBuilderBranch,
missingFieldResolvingStrategy
);
this.genericGraphMapper.resolveInternally(
mapMapping.getValueObjectGraphMapping(),
Map.entry("", value),
resolvedMapBuilderBranch,
missingFieldResolvingStrategy
);
}
);
return builder;
}
private Map<String, Object> convertObjectToMap(Object object, String fieldName) {
try {
return this.jsonObjectMapper.convertValue(object, new TypeReference<>() {
});
} catch (IllegalArgumentException error) {
throw SpecificObjectGraphMapperException.becauseObjectCouldNotBeConverted(this,
fieldName,
object,
error);
}
}
@Override
public boolean supports(ObjectGraphMapping objectGraphMapping) {
return objectGraphMapping instanceof MapObjectGraphMapping;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model/specific/ObjectSpecificObjectGraphMapper.java | package ai.stapi.graphoperations.objectGraphMapper.model.specific;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.objectGraphMapper.model.GenericObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import ai.stapi.graphoperations.objectGraphMapper.model.specific.exceptions.SpecificObjectGraphMapperException;
import ai.stapi.graphoperations.objectLanguage.EntityIdentifier;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectFieldDefinition;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.GenericOGMBuilder;
import com.fasterxml.jackson.core.type.TypeReference;
import java.util.Map;
import java.util.Optional;
public class ObjectSpecificObjectGraphMapper extends AbstractSpecificObjectGraphMapper {
public ObjectSpecificObjectGraphMapper(GenericObjectGraphMapper genericGraphMapper) {
super(genericGraphMapper);
}
@Override
public GraphDescriptionBuilder createGraphDescriptionWithValues(
ObjectGraphMapping objectGraphMapping,
Map.Entry<String, Object> fieldEntry,
GraphDescriptionBuilder builder,
MissingFieldResolvingStrategy resolvingStrategy
) {
var objectMapping = (ObjectObjectGraphMapping) objectGraphMapping;
var dtoObjectFields = this.convertObjectToFieldMap(fieldEntry.getValue(), fieldEntry.getKey());
if (this.isObjectMissingAnyOfDefinedFields(dtoObjectFields, objectMapping.getFields(),
resolvingStrategy)) {
throw SpecificObjectGraphMapperException.becauseProvidedObjectDoesNotContainFieldWithGivenName(
fieldEntry.getValue(),
objectMapping.getFields().keySet().stream()
.filter(key -> !dtoObjectFields.containsKey(key))
.findAny()
.orElseThrow(),
objectMapping.getFields()
);
}
var identifyingField =
this.getEntityIdentifyingField(objectMapping, dtoObjectFields, resolvingStrategy);
if (identifyingField.isPresent()) {
if (builder.getDescriptionBuilder() != null) {
builder = builder.createNewBranch();
}
this.resolveIdentifyingField(
identifyingField.get().getValue().getFieldObjectGraphMapping(),
dtoObjectFields.get(identifyingField.get().getKey()),
identifyingField.get().getKey(),
builder,
resolvingStrategy
);
}
var finishedObjectBuilderBranch = this.addGraphDescriptionCompositeToBuilder(
objectMapping.getGraphDescription(),
builder
);
var lastFinishedGraphElementBranch =
finishedObjectBuilderBranch.getLastBranchWithGraphElementBuilder();
objectMapping.getFields().forEach(
(key, field) -> {
if (resolvingStrategy.equals(MissingFieldResolvingStrategy.LENIENT) &&
(!dtoObjectFields.containsKey(key) || dtoObjectFields.get(key) == null)
) {
return;
}
if (!(field.getRelation() instanceof EntityIdentifier)) {
var newField = this.copyFieldAndPushDeclarationToChild(field);
this.genericGraphMapper.resolveInternally(
newField.getFieldObjectGraphMapping(),
Map.entry(key, dtoObjectFields.get(key)),
lastFinishedGraphElementBranch,
resolvingStrategy
);
}
}
);
return builder;
}
@Override
public boolean supports(ObjectGraphMapping objectGraphMapping) {
return objectGraphMapping instanceof ObjectObjectGraphMapping;
}
private void resolveIdentifyingField(
ObjectGraphMapping graphMapping,
Object object,
String parentFieldName,
GraphDescriptionBuilder builder,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
if (graphMapping instanceof ObjectObjectGraphMapping objectGraphMapping) {
this.resolveObjectAsEntityIdentifier(
objectGraphMapping,
object,
parentFieldName,
builder,
missingFieldResolvingStrategy
);
} else {
this.genericGraphMapper.resolveInternally(
graphMapping,
Map.entry(parentFieldName, object),
builder,
missingFieldResolvingStrategy
);
}
}
private void resolveObjectAsEntityIdentifier(
ObjectObjectGraphMapping objectGraphMapping,
Object object,
String parentFieldName,
GraphDescriptionBuilder builder,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
var dtoObjectMap = this.convertObjectToFieldMap(object, parentFieldName);
var identifyingField = this.getEntityIdentifyingField(objectGraphMapping, dtoObjectMap,
missingFieldResolvingStrategy);
if (identifyingField.isEmpty()) {
throw SpecificObjectGraphMapperException.becauseThereIsNoIdentifyingFieldOnObject(
parentFieldName);
}
builder = this.addGraphDescriptionCompositeToBuilder(objectGraphMapping.getGraphDescription(),
builder);
var objectIdentifyingField = dtoObjectMap.get(identifyingField.get().getKey());
this.resolveIdentifyingField(
identifyingField.get().getValue().getFieldObjectGraphMapping(),
objectIdentifyingField,
identifyingField.get().getKey(),
builder,
missingFieldResolvingStrategy
);
}
private Optional<Map.Entry<String, ObjectFieldDefinition>> getEntityIdentifyingField(
ObjectObjectGraphMapping objectGraphMapping,
Map<String, Object> dtoObjectMap,
MissingFieldResolvingStrategy resolvingStrategy
) {
var fieldEntries = objectGraphMapping.getFields().entrySet().stream()
.filter(entry -> entry.getValue().getRelation() instanceof EntityIdentifier)
.toList();
if (fieldEntries.size() > 1) {
throw SpecificObjectGraphMapperException.becauseThereAreMultipleIdentifyingFieldsOnObject();
}
if (fieldEntries.isEmpty()) {
return Optional.empty();
}
if (resolvingStrategy.equals(MissingFieldResolvingStrategy.LENIENT)
&& (!dtoObjectMap.containsKey(fieldEntries.get(0).getKey()))) {
return Optional.empty();
}
return Optional.of(fieldEntries.get(0));
}
private Map<String, Object> convertObjectToFieldMap(Object object, String fieldName) {
try {
return this.jsonObjectMapper.convertValue(
object,
new TypeReference<>() {
}
);
} catch (IllegalArgumentException error) {
throw SpecificObjectGraphMapperException.becauseObjectCouldNotBeConverted(this, fieldName,
object, error);
}
}
private boolean isObjectMissingAnyOfDefinedFields(
Map<String, Object> objectFieldMap,
Map<String, ObjectFieldDefinition> mappingFieldDefinition,
MissingFieldResolvingStrategy strategy
) {
if (strategy.equals(MissingFieldResolvingStrategy.LENIENT)) {
return false;
}
return mappingFieldDefinition.keySet().stream()
.anyMatch(key -> !objectFieldMap.containsKey(key));
}
private ObjectFieldDefinition copyFieldAndPushDeclarationToChild(
ObjectFieldDefinition fieldDefinition) {
if (!(fieldDefinition.getRelation() instanceof GraphDescription)) {
return fieldDefinition;
}
if (fieldDefinition.getRelation() instanceof NullGraphDescription) {
return fieldDefinition;
}
var builder = new GraphDescriptionBuilder();
var childDescription = fieldDefinition.getFieldObjectGraphMapping().getGraphDescription();
var combinedDescription = builder.copyWithNewChildren(
(GraphDescription) fieldDefinition.getRelation(),
childDescription
);
var genericBuilder = new GenericOGMBuilder();
var newChild = genericBuilder.copyGraphMappingAsBuilder(
fieldDefinition.getFieldObjectGraphMapping()
);
newChild.setNewGraphDescription(combinedDescription);
return new ObjectFieldDefinition(new NullGraphDescription(), newChild.build());
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model/specific/ReferenceSpecificObjectGraphMapper.java | package ai.stapi.graphoperations.objectGraphMapper.model.specific;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.objectGraphMapper.model.GenericObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ReferenceObjectGraphMapping;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import java.util.Map;
public class ReferenceSpecificObjectGraphMapper extends AbstractSpecificObjectGraphMapper {
private final GenericGraphMappingProvider genericGraphMappingProvider;
public ReferenceSpecificObjectGraphMapper(
GenericObjectGraphMapper genericGraphMapper,
GenericGraphMappingProvider genericGraphMappingProvider
) {
super(genericGraphMapper);
this.genericGraphMappingProvider = genericGraphMappingProvider;
}
@Override
public GraphDescriptionBuilder createGraphDescriptionWithValues(
ObjectGraphMapping objectGraphMapping,
Map.Entry<String, Object> fieldEntry,
GraphDescriptionBuilder builder,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
var referenceOgm = (ReferenceObjectGraphMapping) objectGraphMapping;
var fetchedOgm = genericGraphMappingProvider.provideGraphMapping(
referenceOgm.getReferencedSerializationType(),
fieldEntry.getKey()
);
var graphDescription = referenceOgm.getGraphDescription();
var resolvedBranch = this.addGraphDescriptionCompositeToBuilder(graphDescription, builder);
this.genericGraphMapper.resolveInternally(
fetchedOgm,
fieldEntry,
resolvedBranch,
missingFieldResolvingStrategy
);
return builder;
}
@Override
public boolean supports(ObjectGraphMapping objectGraphMapping) {
return objectGraphMapping instanceof ReferenceObjectGraphMapping;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model/specific/exceptions/CannotFixInterfaceObjectGraphMapping.java | package ai.stapi.graphoperations.objectGraphMapper.model.specific.exceptions;
public class CannotFixInterfaceObjectGraphMapping extends RuntimeException {
public CannotFixInterfaceObjectGraphMapping(String serializationType, Throwable cause) {
super(
String.format(
"Cannot fix Interface OGM, because provided Object contains serializationType '%s'," +
" which does not have Structure Schema.",
serializationType
),
cause
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectGraphMapper/model/specific/exceptions/SpecificObjectGraphMapperException.java | package ai.stapi.graphoperations.objectGraphMapper.model.specific.exceptions;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.objectGraphMapper.model.SpecificObjectGraphMapper;
import ai.stapi.graphoperations.objectLanguage.EntityIdentifier;
import ai.stapi.graphoperations.objectGraphLanguage.InterfaceObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectFieldDefinition;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import ai.stapi.graphoperations.declaration.Declaration;
import ai.stapi.serialization.AbstractSerializableObject;
import ai.stapi.serialization.SerializableObject;
import ai.stapi.utils.Stringifier;
import java.util.Map;
public class SpecificObjectGraphMapperException extends RuntimeException {
private SpecificObjectGraphMapperException(String message) {
super(message);
}
public static SpecificObjectGraphMapperException becauseGraphDescriptionHasMultipleNonConstantChildren(
GraphDescription graphDescription,
Integer childrenCount
) {
return new SpecificObjectGraphMapperException(
"Each " + GraphDescription.class.getSimpleName()
+ " inside " + ObjectGraphMapping.class.getSimpleName()
+ " is allowed to have only one non-constant child. Provided "
+ GraphDescription.class.getSimpleName() + " of type '"
+ graphDescription.getClass().getSimpleName()
+ "' contains " + childrenCount + "."
);
}
public static SpecificObjectGraphMapperException becauseSerializationTypeWasNotFound(
String fieldName,
Object object
) {
try {
var objectMap = new ObjectMapper().writerWithDefaultPrettyPrinter()
.writeValueAsString(object);
return new SpecificObjectGraphMapperException(
"Serialization type of object on field '" +
fieldName +
"' could not be determined." +
System.lineSeparator() +
"Problematic object: " +
System.lineSeparator() +
objectMap
);
} catch (JsonProcessingException e) {
throw new SpecificObjectGraphMapperException(
"Serialization type of object on field '" +
fieldName +
"' could not be determined."
);
}
}
public static SpecificObjectGraphMapperException becauseFieldDoesNotContainGraphDescription(
String fieldName,
Declaration declaration
) {
return new SpecificObjectGraphMapperException(
"Declaration inside field '" + fieldName + "' was of unexpected type. Expected: '"
+ GraphDescription.class.getSimpleName()
+ "', Actual: '"
+ declaration.getClass().getSimpleName()
+ "'."
);
}
public static SpecificObjectGraphMapperException becauseThereAreMultipleIdentifyingFieldsOnObject() {
return new SpecificObjectGraphMapperException(
"There are multiple fields containing '" + EntityIdentifier.class.getSimpleName()
+ "' on object. That is not allowed."
);
}
public static SpecificObjectGraphMapperException becauseProvidedValueIsNotPrimitiveType(
String fieldName,
Object value
) {
return new SpecificObjectGraphMapperException(
"Cannot create attribute with value other than primitive." +
System.lineSeparator() +
"Field: " +
fieldName +
System.lineSeparator() +
"Value: " +
System.lineSeparator() +
Stringifier.convertToString(value)
);
}
public static SpecificObjectGraphMapperException becauseThereIsNoIdentifyingFieldOnObject(
String parentObjectFieldName) {
return new SpecificObjectGraphMapperException(
"There is no " + ObjectFieldDefinition.class.getSimpleName()
+ " containing '"
+ EntityIdentifier.class.getSimpleName()
+ "' on object inside private field '"
+ parentObjectFieldName + "'."
);
}
public static SpecificObjectGraphMapperException becauseObjectCouldNotBeConverted(
SpecificObjectGraphMapper graphMapper,
String fieldName,
Object object,
RuntimeException error
) {
return new SpecificObjectGraphMapperException(
"Provided object from field '" + fieldName + "' could not be converted by '"
+ graphMapper.getClass().getSimpleName()
+ "'. Object probably doesn't correspond to "
+ ObjectGraphMapping.class.getSimpleName() + " definition attached to it."
+ System.lineSeparator()
+ "Cause: " + error.getMessage()
+ System.lineSeparator()
+ "Provided object: " + Stringifier.convertToString(object)
);
}
public static SpecificObjectGraphMapperException becauseProvidedObjectDoesNotContainFieldWithGivenName(
Object object,
String fieldName,
Map<String, ObjectFieldDefinition> fields
) {
String stringObject = null;
try {
stringObject = new ObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(object);
} catch (JsonProcessingException e) {
stringObject = "[unable to deserialize]";
}
return new SpecificObjectGraphMapperException(
String.format(
"Provided object:\n%s\n does not contain field with name:\n%s\nAll required:\n%s",
stringObject,
fieldName,
String.join(
",",
fields.keySet()
)
)
);
}
public static SpecificObjectGraphMapperException becauseObjectIsNotSerializable(
RuntimeException error) {
return new SpecificObjectGraphMapperException(
"Object described by '" + InterfaceObjectGraphMapping.class.getSimpleName()
+ "' does not inherit '" + AbstractSerializableObject.class.getSimpleName()
+ "' or can not be serialize."
+ System.lineSeparator() + "Cause :" + error.getMessage()
);
}
public static SpecificObjectGraphMapperException becauseObjectIsNotSerializable() {
return new SpecificObjectGraphMapperException(
"Object described by '" + InterfaceObjectGraphMapping.class.getSimpleName()
+ "' does not inherit '" + AbstractSerializableObject.class.getSimpleName() + "'."
);
}
public static SpecificObjectGraphMapperException becauseActualEntityBehindInterfaceIsNotObject(
Object object) {
return new SpecificObjectGraphMapperException(
"Interface implementation can not be of type '"
+ object.getClass().getSimpleName()
+ "'. It has to be object and implement interface '"
+ SerializableObject.class.getSimpleName() + "'."
);
}
public static SpecificObjectGraphMapperException becauseProvidedObjectMapDoesNotContainTypeField() {
return new SpecificObjectGraphMapperException(
"Provided object map does not contain field '"
+ AbstractSerializableObject.NAME_OF_FIELD_WITH_SERIALIZATION_TYPE
+ "' with type information."
);
}
}
|
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/objectLanguage/AbstractObjectDeclaration.java | package ai.stapi.graphoperations.objectLanguage;
import ai.stapi.graphoperations.declaration.AbstractDeclaration;
abstract public class AbstractObjectDeclaration extends AbstractDeclaration
implements ObjectDeclaration {
protected AbstractObjectDeclaration() {
}
protected AbstractObjectDeclaration(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/objectLanguage/EntityIdentifier.java | package ai.stapi.graphoperations.objectLanguage;
public class EntityIdentifier extends AbstractObjectDeclaration {
public static final String SERIALIZATION_TYPE = "6a1a15dd-4aba-4c20-b883-2836d3e4cbd6";
public EntityIdentifier() {
super(SERIALIZATION_TYPE);
}
@Override
public String getSerializationType() {
return SERIALIZATION_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/objectLanguage/ObjectDeclaration.java | package ai.stapi.graphoperations.objectLanguage;
import ai.stapi.graphoperations.declaration.Declaration;
public interface ObjectDeclaration extends Declaration {
String DECLARATION_TYPE = "ObjectDeclaration";
}
|
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/objectLanguage/TypeIdentifier.java | package ai.stapi.graphoperations.objectLanguage;
public class TypeIdentifier extends AbstractObjectDeclaration {
public static final String SERIALIZATION_TYPE = "c32ab0d2-03f5-4095-a873-3745704f81bf";
@Override
public String getSerializationType() {
return SERIALIZATION_TYPE;
}
@Override
public String getDeclarationType() {
return DECLARATION_TYPE;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectLanguage | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/objectLanguage/classnameprovider/ObjectLanguageClassNameProvider.java | package ai.stapi.graphoperations.objectLanguage.classnameprovider;
import ai.stapi.graphoperations.objectLanguage.EntityIdentifier;
import ai.stapi.serialization.classNameProvider.specific.AbstractSerializableObjectClassNameProvider;
import java.util.Map;
public class ObjectLanguageClassNameProvider extends AbstractSerializableObjectClassNameProvider {
@Override
protected Map<String, Class<?>> getClassMap() {
return Map.of(
EntityIdentifier.SERIALIZATION_TYPE, EntityIdentifier.class
);
}
}
|
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/ogmProviders/GenericGraphMappingProvider.java | package ai.stapi.graphoperations.ogmProviders;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.ogmProviders.exception.GraphMappingProviderException;
import ai.stapi.graphoperations.ogmProviders.specific.SpecificGraphMappingProvider;
import ai.stapi.graphoperations.ogmProviders.specific.dynamicObjectGraphMappingProvider.DynamicOgmProvider;
import ai.stapi.serialization.AbstractSerializableObject;
import ai.stapi.serialization.SerializableObject;
import java.util.List;
import java.util.Map;
public class GenericGraphMappingProvider {
private final List<SpecificGraphMappingProvider> mappingProviders;
public GenericGraphMappingProvider(
List<SpecificGraphMappingProvider> mappingProviders
) {
this.mappingProviders = mappingProviders;
}
public ObjectGraphMapping provideGraphMapping(Map<String, Object> serializableObjectMap) {
if (!serializableObjectMap.containsKey(
AbstractSerializableObject.NAME_OF_FIELD_WITH_SERIALIZATION_TYPE)) {
throw GraphMappingProviderException.becauseProvidedObjectMapDoesNotContainTypeField();
}
var serializationType = (String) serializableObjectMap.get(
AbstractSerializableObject.NAME_OF_FIELD_WITH_SERIALIZATION_TYPE);
return this.provideGraphMapping(serializationType);
}
public ObjectGraphMapping provideGraphMapping(Map<String, Object> serializableObjectMap,
String fieldName) {
if (!serializableObjectMap.containsKey(
AbstractSerializableObject.NAME_OF_FIELD_WITH_SERIALIZATION_TYPE)) {
throw GraphMappingProviderException.becauseProvidedObjectMapDoesNotContainTypeField();
}
var serializationType = (String) serializableObjectMap.get(
AbstractSerializableObject.NAME_OF_FIELD_WITH_SERIALIZATION_TYPE);
return this.provideGraphMapping(serializationType, fieldName);
}
public ObjectGraphMapping provideGraphMapping(SerializableObject object) {
return this.provideGraphMapping(object.getSerializationType());
}
public ObjectGraphMapping provideGraphMapping(SerializableObject object, String fieldName) {
return this.provideGraphMapping(object.getSerializationType(), fieldName);
}
public ObjectGraphMapping provideGraphMapping(String serializationType, String fieldName) {
var provider = this.getSupportingProvider(serializationType);
return provider.provideGraphMapping(serializationType, fieldName);
}
public ObjectGraphMapping provideGraphMapping(String serializationType) {
var provider = this.getSupportingProvider(serializationType);
return provider.provideGraphMapping(serializationType);
}
public boolean supports(String serializationType) {
return this.mappingProviders.stream()
.anyMatch(provider -> provider.supports(serializationType));
}
private SpecificGraphMappingProvider getSupportingProvider(String serializationType) {
var listOfSupportingProviders = this.mappingProviders.stream()
.filter(specificObjectGraphMapper -> specificObjectGraphMapper.supports(serializationType))
.toList();
if (listOfSupportingProviders.isEmpty()) {
throw GraphMappingProviderException.becauseThereIsNoSupportingSpecificGraphMappingProvider(
serializationType);
}
var staticProviders = listOfSupportingProviders.stream()
.filter(provider -> (!(provider instanceof DynamicOgmProvider)))
.toList();
if (staticProviders.size() > 1) {
throw GraphMappingProviderException.becauseThereAreMoreThanOneSpecificGraphMappingProviders(
serializationType,
listOfSupportingProviders
);
}
if (staticProviders.size() == 1) {
return staticProviders.get(0);
}
var dynamicProvider = listOfSupportingProviders.stream()
.filter(DynamicOgmProvider.class::isInstance)
.findAny()
.orElse(null);
if (dynamicProvider != null) {
return dynamicProvider;
}
throw GraphMappingProviderException.becauseThereIsNoSupportingSpecificGraphMappingProvider(
serializationType
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/exception/GraphMappingProviderException.java | package ai.stapi.graphoperations.ogmProviders.exception;
import ai.stapi.graphoperations.ogmProviders.specific.SpecificGraphMappingProvider;
import ai.stapi.serialization.AbstractSerializableObject;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
public class GraphMappingProviderException extends RuntimeException {
private GraphMappingProviderException(String message) {
super(message);
}
public static GraphMappingProviderException becauseThereIsNoSupportingSpecificGraphMappingProvider(
String deserializationType) {
return new GraphMappingProviderException(
"There is no supporting "
+ SpecificGraphMappingProvider.class.getSimpleName()
+ " for object with serialization type '"
+ deserializationType + "'."
);
}
public static GraphMappingProviderException becauseThereAreMoreThanOneSpecificGraphMappingProviders(
String deserializationType,
List<SpecificGraphMappingProvider> listOfSupportingProviders
) {
return new GraphMappingProviderException(
"Object of type '"
+ deserializationType
+ "' is supported by multiple providers ("
+ StringUtils.join(listOfSupportingProviders, ", ")
+ ") and that is not allowed."
);
}
public static GraphMappingProviderException becauseProvidedObjectMapDoesNotContainTypeField() {
return new GraphMappingProviderException(
"Provided object map does not contain field '"
+ AbstractSerializableObject.NAME_OF_FIELD_WITH_SERIALIZATION_TYPE
+ "' with type information."
);
}
} |
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/SpecificGraphMappingProvider.java | package ai.stapi.graphoperations.ogmProviders.specific;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
public interface SpecificGraphMappingProvider {
default ObjectGraphMapping provideGraphMapping(String serializationType) {
return this.provideGraphMapping(serializationType, "");
}
ObjectGraphMapping provideGraphMapping(
String serializationType,
String fieldName
);
boolean supports(String serializationType);
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/dynamicObjectGraphMappingProvider/DynamicOgmProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.dynamicObjectGraphMappingProvider;
import ai.stapi.graph.attribute.LeafAttribute;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.ListAttributeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.SpecificObjectGraphMappingBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.InterfaceGraphMappingBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.LeafGraphMappingBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ListGraphMappingBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectFieldDefinitionBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ReferenceGraphMappingBuilder;
import ai.stapi.graphoperations.ogmProviders.specific.SpecificGraphMappingProvider;
import ai.stapi.graphoperations.ogmProviders.specific.dynamicObjectGraphMappingProvider.exception.DynamicOgmProviderException;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.BoxedPrimitiveStructureType;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.PrimitiveStructureType;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaProvider;
import ai.stapi.schema.structureSchemaProvider.exception.CannotProvideStructureSchema;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class DynamicOgmProvider implements SpecificGraphMappingProvider {
private final StructureSchemaProvider structureSchemaProvider;
private final Map<String, ObjectGraphMapping> cachedComplexTypes = new HashMap<>();
public DynamicOgmProvider(StructureSchemaProvider structureSchemaProvider) {
this.structureSchemaProvider = structureSchemaProvider;
}
public ObjectGraphMapping provideOgmForPrimitive(
String serializationType,
FieldDefinition fieldDefinition
) {
AbstractStructureType definition;
try {
definition = this.structureSchemaProvider.provideSpecific(serializationType);
} catch (CannotProvideStructureSchema e) {
throw DynamicOgmProviderException.becauseThereWasNoStructureSchema(serializationType, e);
}
if (definition instanceof PrimitiveStructureType) {
if (fieldDefinition.isList()) {
var leaf = this.resolveListPrimitiveType(serializationType);
var listGraphMappingBuilder = new ListGraphMappingBuilder();
listGraphMappingBuilder
.setGraphDescription(new ListAttributeDescription(fieldDefinition.getName()))
.setChildDefinition(leaf);
return listGraphMappingBuilder.build();
} else {
return this.resolvePrimitiveType(
fieldDefinition.getName(),
serializationType
).build();
}
}
if (definition instanceof BoxedPrimitiveStructureType boxedPrimitiveStructureType) {
if (fieldDefinition.isList()) {
var leaf = this.resolveListBoxedType(serializationType);
var listGraphMappingBuilder = new ListGraphMappingBuilder();
listGraphMappingBuilder
.setGraphDescription(new ListAttributeDescription(fieldDefinition.getName()))
.setChildDefinition(leaf);
return listGraphMappingBuilder.build();
} else {
return this.resolveBoxedType(
fieldDefinition.getName(),
boxedPrimitiveStructureType.getOriginalDefinitionType()
).build();
}
}
throw DynamicOgmProviderException.becauseSerializationTypeIsComplex(serializationType);
}
@Override
public ObjectGraphMapping provideGraphMapping(
String serializationType,
String fieldName
) {
AbstractStructureType definition;
try {
definition = this.structureSchemaProvider.provideSpecific(serializationType);
} catch (CannotProvideStructureSchema e) {
throw DynamicOgmProviderException.becauseThereWasNoStructureSchema(serializationType, e);
}
if (definition.getKind().equals(AbstractStructureType.PRIMITIVE_TYPE)) {
return this.provideOgmForPrimitive(
serializationType,
new FieldDefinition(
fieldName,
1,
"1",
"",
List.of(),
definition.getDefinitionType()
)
);
}
return this.provideGraphMapping(serializationType, definition);
}
public ObjectGraphMapping provideGraphMapping(
String serializationType,
AbstractStructureType abstractStructureType
) {
if (abstractStructureType instanceof PrimitiveStructureType) {
throw DynamicOgmProviderException.becauseSerializationTypeIsPrimitive(serializationType);
}
if (abstractStructureType instanceof BoxedPrimitiveStructureType) {
throw DynamicOgmProviderException.becauseSerializationTypeIsPrimitive(serializationType);
}
if (this.cachedComplexTypes.containsKey(serializationType)) {
return this.cachedComplexTypes.get(serializationType);
}
var resolvedComplexType = this.resolveComplexType(
(ComplexStructureType) abstractStructureType,
new ObjectGraphMappingBuilder()
).build();
this.cachedComplexTypes.put(serializationType, resolvedComplexType);
return resolvedComplexType;
}
public boolean supports(String serializationType) {
return this.structureSchemaProvider.provideSchema().containsDefinition(serializationType);
}
private ObjectGraphMappingBuilder resolveComplexType(
ComplexStructureType complexStructureType,
ObjectGraphMappingBuilder builder
) {
builder.setGraphDescription(
new GraphDescriptionBuilder().addNodeDescription(
complexStructureType.getDefinitionType()
)
);
complexStructureType.getAllFields().forEach(
(key, value) -> {
var fieldBuilder = new ObjectFieldDefinitionBuilder();
if (key.equals("id")) {
fieldBuilder.setChild(this.createIdentifyingField());
} else {
fieldBuilder.setChild(this.createChild(key, value));
}
builder.addField(key, fieldBuilder);
}
);
return builder;
}
private SpecificObjectGraphMappingBuilder createChild(
String fieldName,
FieldDefinition fieldDefinition
) {
if (fieldDefinition.isList()) {
return this.resolveList(fieldName, fieldDefinition);
} else {
return resolveSingleChild(fieldName, fieldDefinition);
}
}
private LeafGraphMappingBuilder createIdentifyingField() {
return new LeafGraphMappingBuilder()
.setGraphDescription(new UuidIdentityDescription());
}
private ListGraphMappingBuilder resolveList(
String fieldName,
FieldDefinition fieldDefinition
) {
var builder = new ListGraphMappingBuilder();
if (this.isFieldDefinitionRequiringAttribute(fieldDefinition)) {
builder.setGraphDescription(
new ListAttributeDescription(fieldName)
);
}
builder.setChildDefinition(this.resolveChildInList(fieldDefinition));
return builder;
}
private SpecificObjectGraphMappingBuilder resolveChildInList(
FieldDefinition fieldDefinition
) {
if (fieldDefinition.isUnionType() || fieldDefinition.isAnyType()) {
return new InterfaceGraphMappingBuilder().setGraphDescription(
new GraphDescriptionBuilder().addOutgoingEdge(fieldDefinition.getName())
);
} else {
var fieldType = fieldDefinition.getTypes().get(0);
if (fieldType.isPrimitiveType()) {
return this.resolveListPrimitiveType(fieldType.getType());
}
if (fieldType.isBoxed()) {
return this.resolveListBoxedType(fieldType.getType());
}
if (fieldType.isReference()) {
var builder = new ObjectGraphMappingBuilder().setGraphDescription(
new GraphDescriptionBuilder().addOutgoingEdge(fieldDefinition.getName())
);
builder.addField("id")
.addLeafAsObjectFieldMapping()
.setGraphDescription(
new GraphDescriptionBuilder()
.addNodeDescription(fieldType.getType())
.addUuidDescription()
);
return builder;
}
return new ReferenceGraphMappingBuilder()
.setReferencedSerializationType(fieldType.getType())
.setGraphDescription(
new GraphDescriptionBuilder().addOutgoingEdge(fieldDefinition.getName())
);
}
}
private SpecificObjectGraphMappingBuilder resolveSingleChild(
String fieldName,
FieldDefinition fieldDefinition
) {
if (fieldDefinition.isUnionType() || fieldDefinition.isAnyType()) {
return new InterfaceGraphMappingBuilder().setGraphDescription(
new GraphDescriptionBuilder().addOutgoingEdge(fieldName)
);
} else {
var fieldType = fieldDefinition.getTypes().get(0);
if (fieldType.isPrimitiveType()) {
return this.resolvePrimitiveType(
fieldName,
fieldType.getType()
);
}
if (fieldType.isBoxed()) {
return this.resolveBoxedType(
fieldName,
fieldType.getType()
);
}
if (fieldType.isReference()) {
var builder = new ObjectGraphMappingBuilder().setGraphDescription(
new GraphDescriptionBuilder().addOutgoingEdge(fieldName)
);
builder.addField("id")
.addLeafAsObjectFieldMapping()
.setGraphDescription(
new GraphDescriptionBuilder()
.addNodeDescription(fieldType.getType())
.addUuidDescription()
);
return builder;
}
return new ReferenceGraphMappingBuilder()
.setReferencedSerializationType(fieldType.getType())
.setGraphDescription(new GraphDescriptionBuilder().addOutgoingEdge(fieldName));
}
}
private LeafGraphMappingBuilder resolvePrimitiveType(
String fieldName,
String dataType
) {
return new LeafGraphMappingBuilder().setGraphDescription(
new GraphDescriptionBuilder()
.addAttributeByType(LeafAttribute.DATA_STRUCTURE_TYPE, fieldName)
.addAttributeValueByType(dataType)
);
}
private LeafGraphMappingBuilder resolveListPrimitiveType(
String dataType
) {
return new LeafGraphMappingBuilder().setGraphDescription(
new GraphDescriptionBuilder().addAttributeValueByType(dataType)
);
}
private SpecificObjectGraphMappingBuilder resolveListBoxedType(
String originalType
) {
var objectGraphMappingBuilder = new ObjectGraphMappingBuilder();
objectGraphMappingBuilder
.addField("value")
.addLeafAsObjectFieldMapping()
.setGraphDescription(
new GraphDescriptionBuilder().addAttributeValueByType(originalType));
return objectGraphMappingBuilder;
}
private SpecificObjectGraphMappingBuilder resolveBoxedType(
String fieldName,
String originalType
) {
var objectGraphMappingBuilder = new ObjectGraphMappingBuilder();
objectGraphMappingBuilder
.addField("value")
.addLeafAsObjectFieldMapping()
.setGraphDescription(
new GraphDescriptionBuilder()
.addAttributeByType(LeafAttribute.DATA_STRUCTURE_TYPE, fieldName)
.addAttributeValueByType(originalType));
return objectGraphMappingBuilder;
}
private boolean isFieldDefinitionRequiringEdge(FieldDefinition fieldDefinition) {
if (fieldDefinition.isUnionType() || fieldDefinition.isAnyType()) {
return true;
}
var fieldType = fieldDefinition.getTypes().get(0);
if (fieldType.isPrimitiveType() || fieldType.isBoxed()) {
return false;
}
return true;
}
private boolean isFieldDefinitionRequiringAttribute(FieldDefinition fieldDefinition) {
return fieldDefinition.getTypes().stream().anyMatch(
type -> type.isPrimitiveType() || type.isBoxed()
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/dynamicObjectGraphMappingProvider | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/dynamicObjectGraphMappingProvider/exception/DynamicOgmProviderException.java | package ai.stapi.graphoperations.ogmProviders.specific.dynamicObjectGraphMappingProvider.exception;
public class DynamicOgmProviderException extends RuntimeException {
private DynamicOgmProviderException(String message) {
super(message);
}
private DynamicOgmProviderException(String message, Throwable cause) {
super(message, cause);
}
public static DynamicOgmProviderException becauseFieldNameIsBlank(String serializationType) {
return new DynamicOgmProviderException(
"Serialization type '"
+ serializationType
+ "' is primitive-type, and so fieldName parameter must be not blank."
);
}
public static DynamicOgmProviderException becauseSerializationTypeIsPrimitive(
String serializationType) {
return new DynamicOgmProviderException(
"Serialization type '"
+ serializationType
+ "' is primitive-type, use method for primitive OGM instead."
);
}
public static DynamicOgmProviderException becauseSerializationTypeIsComplex(
String serializationType) {
return new DynamicOgmProviderException(
"Serialization type '"
+ serializationType
+ "' is complex-type, use main method provideGraphMapping instead."
);
}
public static DynamicOgmProviderException becauseThereWasNoStructureSchema(
String serializationType,
Throwable cause
) {
return new DynamicOgmProviderException(
String.format("Cannot provide Dynamic OGM for serializationType '%s'", serializationType),
cause
);
}
public static DynamicOgmProviderException becauseValueFieldForBoxedTypeIsMissing(
String serializationType) {
return new DynamicOgmProviderException(
"Boxed type '" + serializationType + "' is missing 'value' field.");
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/graphDescriptionMappingProviders/AbstractAttributeGraphMappingProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
public abstract class AbstractAttributeGraphMappingProvider
extends AbstractGraphDescriptionGraphMappingProvider {
@Override
protected void setParametersFields(ObjectGraphMappingBuilder parameters) {
parameters.addField("attributeName")
.addLeafAsObjectFieldMapping()
.setGraphDescription(
new GraphDescriptionBuilder()
.addLeafAttribute("attribute_name")
.addStringAttributeValue()
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/graphDescriptionMappingProviders/AbstractEdgeDescriptionGraphMappingProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
public abstract class AbstractEdgeDescriptionGraphMappingProvider
extends AbstractGraphDescriptionGraphMappingProvider {
@Override
protected void setParametersFields(ObjectGraphMappingBuilder parameters) {
parameters.addField("edgeType")
.addLeafAsObjectFieldMapping()
.setGraphDescription(
new GraphDescriptionBuilder()
.addLeafAttribute("edge_type")
.addStringAttributeValue()
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/graphDescriptionMappingProviders/AbstractGraphDescriptionGraphMappingProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.SpecificObjectGraphMappingBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import ai.stapi.graphoperations.ogmProviders.specific.SpecificGraphMappingProvider;
public abstract class AbstractGraphDescriptionGraphMappingProvider
implements SpecificGraphMappingProvider {
@Override
public ObjectGraphMapping provideGraphMapping(
String serializationType,
String fieldName
) {
var definition = new ObjectGraphMappingBuilder();
definition.setGraphDescription(
new GraphDescriptionBuilder().addNodeDescription(this.getGraphDescriptionNodeType())
);
definition.addField("parameters")
.setChild(this.getParametersDefinition());
definition.addField("childGraphDescriptions")
.setRelation(new GraphDescriptionBuilder().addOutgoingEdge("has_child_graph_mapping"))
.addListAsObjectFieldMapping()
.addInterfaceChildDefinition()
.setUuid(GraphDescription.INTERFACE_UUID);
return definition.build();
}
private SpecificObjectGraphMappingBuilder getParametersDefinition() {
var builder = new ObjectGraphMappingBuilder();
this.setParametersFields(builder);
return builder;
}
protected abstract String getGraphDescriptionNodeType();
protected abstract void setParametersFields(ObjectGraphMappingBuilder parameters);
@Override
public abstract boolean supports(String serializationType);
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/graphDescriptionMappingProviders/BooleanAttributeGraphMappingProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.BooleanAttributeValueDescription;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
public class BooleanAttributeGraphMappingProvider extends AbstractGraphDescriptionGraphMappingProvider {
public static final String GRAPH_DESCRIPTION_NODE_TYPE = "graph_description_attribute_boolean";
@Override
protected String getGraphDescriptionNodeType() {
return GRAPH_DESCRIPTION_NODE_TYPE;
}
@Override
protected void setParametersFields(ObjectGraphMappingBuilder parameters) {
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(BooleanAttributeValueDescription.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/graphDescriptionMappingProviders/EntityIdentifierGraphMappingProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import ai.stapi.graphoperations.objectLanguage.EntityIdentifier;
import ai.stapi.graphoperations.ogmProviders.specific.SpecificGraphMappingProvider;
public class EntityIdentifierGraphMappingProvider implements SpecificGraphMappingProvider {
protected String getGraphDescriptionNodeType() {
return "object_declaration_entity_identifier";
}
@Override
public ObjectGraphMapping provideGraphMapping(String serializationType,
String fieldName) {
var definition = new ObjectGraphMappingBuilder();
definition.setGraphDescription(
new GraphDescriptionBuilder().addNodeDescription(this.getGraphDescriptionNodeType()));
return definition.build();
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(EntityIdentifier.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/graphDescriptionMappingProviders/GraphDescriptionGraphElementTypes.java | package ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders;
public class GraphDescriptionGraphElementTypes {
public static final String NODE_DESCRIPTION_NODE = "graph_description_node";
public static final String OUTGOING_EDGE_DESCRIPTION_NODE = "graph_description_outgoing_edge";
public static final String INCOMING_EDGE_DESCRIPTION_NODE = "graph_description_ingoing_edge";
public static final String STRING_ATTRIBUTE_DESCRIPTION = "graph_description_attribute_string";
public static final String BOOLEAN_ATTRIBUTE_DESCRIPTION = "graph_description_attribute_boolean";
public static final String INTEGER_ATTRIBUTE_DESCRIPTION = "graph_description_attribute_integer";
public static final String LEAF_ATTRIBUTE_DESCRIPTION = "graph_description_leaf_attribute";
public static final String UUID_DESCRIPTION = "graph_description_uuid_identity";
public static final String REMOVAL_NODE_DESCRIPTION = "graph_description_removal_node";
public static final String REMOVAL_EDGE_DESCRIPTION = "graph_description_removal_edge";
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/graphDescriptionMappingProviders/IncomingEdgeDescriptionGraphMappingProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.IngoingEdgeDescription;
import org.springframework.stereotype.Service;
public class IncomingEdgeDescriptionGraphMappingProvider
extends AbstractEdgeDescriptionGraphMappingProvider {
@Override
protected String getGraphDescriptionNodeType() {
return "graph_description_ingoing_edge";
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(IngoingEdgeDescription.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/graphDescriptionMappingProviders/IntegerAttributeGraphMappingProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.IntegerAttributeValueDescription;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import org.springframework.stereotype.Service;
public class IntegerAttributeGraphMappingProvider extends AbstractGraphDescriptionGraphMappingProvider {
public static final String GRAPH_DESCRIPTION_NODE_TYPE = "graph_description_attribute_integer";
@Override
protected String getGraphDescriptionNodeType() {
return GRAPH_DESCRIPTION_NODE_TYPE;
}
@Override
protected void setParametersFields(ObjectGraphMappingBuilder parameters) {
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(IntegerAttributeValueDescription.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/graphDescriptionMappingProviders/InterfaceGraphDescriptionGraphMappingProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.InterfaceGraphDescription;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import org.springframework.stereotype.Service;
public class InterfaceGraphDescriptionGraphMappingProvider
extends AbstractGraphDescriptionGraphMappingProvider {
@Override
protected String getGraphDescriptionNodeType() {
return "graph_description_interface";
}
@Override
protected void setParametersFields(ObjectGraphMappingBuilder parameters) {
parameters.addField("interfaceId")
.addLeafAsObjectFieldMapping()
.setGraphDescription(
new GraphDescriptionBuilder()
.addLeafAttribute("interface_id")
.addStringAttributeValue()
);
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(InterfaceGraphDescription.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/graphDescriptionMappingProviders/LeafAttributeGraphMappingProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.LeafAttributeDescription;
import org.springframework.stereotype.Service;
public class LeafAttributeGraphMappingProvider extends AbstractAttributeGraphMappingProvider {
public static final String GRAPH_DESCRIPTION_NODE_TYPE = "graph_description_leaf_attribute";
@Override
protected String getGraphDescriptionNodeType() {
return GRAPH_DESCRIPTION_NODE_TYPE;
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(LeafAttributeDescription.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/graphDescriptionMappingProviders/NodeDescriptionGraphMappingProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescription;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import org.jetbrains.annotations.NotNull;
public class NodeDescriptionGraphMappingProvider
extends AbstractGraphDescriptionGraphMappingProvider {
@Override
@NotNull
protected String getGraphDescriptionNodeType() {
return "graph_description_node";
}
@Override
protected void setParametersFields(ObjectGraphMappingBuilder parameters) {
parameters.addField("nodeType")
.addLeafAsObjectFieldMapping()
.setGraphDescription(
new GraphDescriptionBuilder()
.addLeafAttribute("node_type")
.addStringAttributeValue()
);
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(NodeDescription.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/graphDescriptionMappingProviders/ObjectDeclarationGraphElementTypes.java | package ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders;
public class ObjectDeclarationGraphElementTypes {
public static final String ENTITY_IDENTIFIER_DECLARATION = "object_declaration_entity_identifier";
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/graphDescriptionMappingProviders/OutgoingEdgeDescriptionGraphMappingProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.OutgoingEdgeDescription;
import org.springframework.stereotype.Service;
public class OutgoingEdgeDescriptionGraphMappingProvider
extends AbstractEdgeDescriptionGraphMappingProvider {
@Override
protected String getGraphDescriptionNodeType() {
return "graph_description_outgoing_edge";
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(OutgoingEdgeDescription.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/graphDescriptionMappingProviders/RemovalEdgeDescriptionGraphMappingProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.removal.RemovalEdgeDescription;
public class RemovalEdgeDescriptionGraphMappingProvider
extends AbstractEdgeDescriptionGraphMappingProvider {
@Override
protected String getGraphDescriptionNodeType() {
return "graph_description_removal_edge";
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(RemovalEdgeDescription.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/graphDescriptionMappingProviders/RemovalNodeDescriptionGraphMappingProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.removal.RemovalNodeDescription;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import org.jetbrains.annotations.NotNull;
import org.springframework.stereotype.Service;
public class RemovalNodeDescriptionGraphMappingProvider
extends AbstractGraphDescriptionGraphMappingProvider {
@Override
@NotNull
protected String getGraphDescriptionNodeType() {
return "graph_description_removal_node";
}
@Override
protected void setParametersFields(ObjectGraphMappingBuilder parameters) {
parameters.addField("nodeType")
.addLeafAsObjectFieldMapping()
.setGraphDescription(
new GraphDescriptionBuilder()
.addLeafAttribute("node_type")
.addStringAttributeValue()
);
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(RemovalNodeDescription.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/graphDescriptionMappingProviders/StringAttributeGraphMappingProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.StringAttributeValueDescription;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import org.springframework.stereotype.Service;
public class StringAttributeGraphMappingProvider extends AbstractGraphDescriptionGraphMappingProvider {
public static final String GRAPH_DESCRIPTION_NODE_TYPE = "graph_description_attribute_string";
@Override
protected String getGraphDescriptionNodeType() {
return GRAPH_DESCRIPTION_NODE_TYPE;
}
@Override
protected void setParametersFields(ObjectGraphMappingBuilder parameters) {
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(StringAttributeValueDescription.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/graphDescriptionMappingProviders/UuidGraphDescriptionGraphMappingProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import org.springframework.stereotype.Service;
public class UuidGraphDescriptionGraphMappingProvider
extends AbstractGraphDescriptionGraphMappingProvider {
@Override
protected String getGraphDescriptionNodeType() {
return "graph_description_uuid_identity";
}
@Override
protected void setParametersFields(ObjectGraphMappingBuilder parameters) {
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(UuidIdentityDescription.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/objectGraphMappingMappingProviders/InterfaceOgmProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.objectGraphMappingMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.InterfaceObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import ai.stapi.graphoperations.ogmProviders.specific.SpecificGraphMappingProvider;
public class InterfaceOgmProvider implements SpecificGraphMappingProvider {
@Override
public ObjectGraphMapping provideGraphMapping(String serializationType,
String fieldName) {
var definition = new ObjectGraphMappingBuilder();
definition.setGraphDescription(
new GraphDescriptionBuilder().addNodeDescription("ogm_interface"));
definition.addField("interfaceUuid")
.addLeafAsObjectFieldMapping()
.setGraphDescription(
new GraphDescriptionBuilder()
.addLeafAttribute("interfaceUuid")
.addStringAttributeValue()
);
return definition.build();
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(InterfaceObjectGraphMapping.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/objectGraphMappingMappingProviders/LeafOgmProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.objectGraphMappingMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.LeafObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import ai.stapi.graphoperations.ogmProviders.specific.SpecificGraphMappingProvider;
public class LeafOgmProvider implements SpecificGraphMappingProvider {
@Override
public ObjectGraphMapping provideGraphMapping(String serializationType,
String fieldName) {
var definition = new ObjectGraphMappingBuilder();
definition.setGraphDescription(
new GraphDescriptionBuilder().addNodeDescription(OgmGraphElementTypes.OGM_LEAF_NODE));
definition.addField("graphDescription")
.setRelation(new GraphDescriptionBuilder().addOutgoingEdge(
OgmGraphElementTypes.EDGE_FROM_OGM_TO_GRAPH_DESCRIPTION))
.addInterfaceAsObjectFieldMapping()
.setUuid(GraphDescription.INTERFACE_UUID);
return definition.build();
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(LeafObjectGraphMapping.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/objectGraphMappingMappingProviders/ListOgmProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.objectGraphMappingMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.ListObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import ai.stapi.graphoperations.ogmProviders.specific.SpecificGraphMappingProvider;
public class ListOgmProvider implements SpecificGraphMappingProvider {
@Override
public ObjectGraphMapping provideGraphMapping(String serializationType,
String fieldName) {
var listBuilder = new ObjectGraphMappingBuilder();
listBuilder.setGraphDescription(new GraphDescriptionBuilder().addNodeDescription("ogm_list"));
listBuilder.addField("graphDescription")
.setRelation(new GraphDescriptionBuilder().addOutgoingEdge("has_graph_description"))
.addInterfaceAsObjectFieldMapping()
.setUuid(GraphDescription.INTERFACE_UUID);
listBuilder.addField("childObjectGraphMapping")
.setRelation(new GraphDescriptionBuilder().addOutgoingEdge("has_child_ogm"))
.addInterfaceAsObjectFieldMapping()
.setUuid(ObjectGraphMapping.INTERFACE_UUID);
return listBuilder.build();
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(ListObjectGraphMapping.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/objectGraphMappingMappingProviders/MapOgmProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.objectGraphMappingMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.MapObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import ai.stapi.graphoperations.ogmProviders.specific.SpecificGraphMappingProvider;
public class MapOgmProvider implements SpecificGraphMappingProvider {
@Override
public ObjectGraphMapping provideGraphMapping(String serializationType,
String fieldName) {
var mapBuilder = new ObjectGraphMappingBuilder();
mapBuilder.setGraphDescription(new GraphDescriptionBuilder().addNodeDescription("ogm_map"));
mapBuilder.addField("graphDescription")
.setRelation(new GraphDescriptionBuilder().addOutgoingEdge("has_graph_description"))
.addInterfaceAsObjectFieldMapping()
.setUuid(GraphDescription.INTERFACE_UUID);
mapBuilder.addField("keyObjectGraphMapping")
.setRelation(new GraphDescriptionBuilder().addOutgoingEdge("has_key_ogm"))
.addInterfaceAsObjectFieldMapping()
.setUuid(ObjectGraphMapping.INTERFACE_UUID);
mapBuilder.addField("valueObjectGraphMapping")
.setRelation(new GraphDescriptionBuilder().addOutgoingEdge("has_value_ogm"))
.addInterfaceAsObjectFieldMapping()
.setUuid(ObjectGraphMapping.INTERFACE_UUID);
return mapBuilder.build();
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(MapObjectGraphMapping.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/objectGraphMappingMappingProviders/ObjectFieldOgmProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.objectGraphMappingMappingProviders;
import ai.stapi.graphoperations.declaration.Declaration;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectFieldDefinition;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import ai.stapi.graphoperations.ogmProviders.specific.SpecificGraphMappingProvider;
public class ObjectFieldOgmProvider implements SpecificGraphMappingProvider {
@Override
public ObjectGraphMapping provideGraphMapping(String serializationType,
String fieldName) {
var fieldOgmBuilder = new ObjectGraphMappingBuilder();
fieldOgmBuilder
.setGraphDescription(new GraphDescriptionBuilder().addNodeDescription("ogm_object_field"));
fieldOgmBuilder
.addField("relation")
.setRelation(
new GraphDescriptionBuilder().addOutgoingEdge("has_child_relation_declaration"))
.addInterfaceAsObjectFieldMapping()
.setUuid(Declaration.INTERFACE_UUID);
fieldOgmBuilder
.addField("fieldObjectGraphMapping")
.setRelation(new GraphDescriptionBuilder().addOutgoingEdge("has_child_ogm"))
.addInterfaceAsObjectFieldMapping()
.setUuid(ObjectGraphMapping.INTERFACE_UUID);
return fieldOgmBuilder.build();
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(ObjectFieldDefinition.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/objectGraphMappingMappingProviders/ObjectOgmProvider.java | package ai.stapi.graphoperations.ogmProviders.specific.objectGraphMappingMappingProviders;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectFieldDefinition;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import ai.stapi.graphoperations.ogmProviders.specific.SpecificGraphMappingProvider;
public class ObjectOgmProvider implements SpecificGraphMappingProvider {
@Override
public ObjectGraphMapping provideGraphMapping(String serializationType, String fieldName) {
var objectOgmBuilder = new ObjectGraphMappingBuilder();
objectOgmBuilder
.setGraphDescription(
new GraphDescriptionBuilder().addNodeDescription(OgmGraphElementTypes.OGM_OBJECT_NODE));
objectOgmBuilder
.addField("graphDescription")
.setRelation(new GraphDescriptionBuilder().addOutgoingEdge(
OgmGraphElementTypes.EDGE_FROM_OGM_TO_GRAPH_DESCRIPTION))
.addInterfaceAsObjectFieldMapping()
.setUuid(GraphDescription.INTERFACE_UUID);
var mapOgmBuilder = objectOgmBuilder
.addField("fields")
.setRelation(new GraphDescriptionBuilder().addOutgoingEdge(
OgmGraphElementTypes.EDGE_FROM_OBJECT_OGM_TO_FIELD_OGM))
.addMapAsObjectFieldMapping();
mapOgmBuilder
.addLeafKeyMapping()
.setGraphDescription(
new GraphDescriptionBuilder()
.addLeafAttribute(OgmGraphElementTypes.FIELD_NAME_ATTRIBUTE)
.addStringAttributeValue()
);
mapOgmBuilder
.addInterfaceObjectValueMapping()
.setUuid(ObjectFieldDefinition.SERIALIZATION_TYPE);
return objectOgmBuilder.build();
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(ObjectObjectGraphMapping.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/ogmProviders/specific/objectGraphMappingMappingProviders/OgmGraphElementTypes.java | package ai.stapi.graphoperations.ogmProviders.specific.objectGraphMappingMappingProviders;
public class OgmGraphElementTypes {
public static final String OGM_LEAF_NODE = "ogm_leaf";
public static final String OGM_OBJECT_NODE = "ogm_object";
public static final String OGM_LIST_NODE = "ogm_list";
public static final String OGM_MAP_NODE = "ogm_map";
public static final String OGM_OBJECT_FIELD_NODE = "ogm_object_field";
public static final String OGM_INTERFACE_NODE = "ogm_interface";
public static final String EDGE_FROM_OGM_TO_GRAPH_DESCRIPTION = "has_graph_description";
public static final String EDGE_FROM_OBJECT_OGM_TO_FIELD_OGM = "has_field_mapping";
public static final String FIELD_NAME_ATTRIBUTE = "field_name";
}
|
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/serializableGraph/GraphElementKeys.java | package ai.stapi.graphoperations.serializableGraph;
public class GraphElementKeys {
public static final String ID = "_id";
public static final String KEY = "_key";
public static final String REV = "_rev";
public static final String ATTRIBUTES = "attributes";
public static final String FROM = "_from";
public static final String TO = "_to";
private GraphElementKeys() {}
}
|
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/serializableGraph/SerializableAttributeValue.java | package ai.stapi.graphoperations.serializableGraph;
import ai.stapi.graph.attribute.attributeFactory.AttributeValueFactoryInput;
import ai.stapi.graph.attribute.attributeValue.AttributeValue;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
public class SerializableAttributeValue {
private final String serializationType;
private final Object value;
@JsonCreator
public SerializableAttributeValue(
@JsonProperty("serializationType") String serializationType,
@JsonProperty("value") Object value
) {
this.serializationType = serializationType;
this.value = value;
}
public SerializableAttributeValue(AttributeValue<?> attributeValue) {
this.serializationType = attributeValue.getDataType();
this.value = attributeValue.getValue();
}
public AttributeValueFactoryInput toAttributeFactoryInput() {
return new AttributeValueFactoryInput(
this.value,
this.serializationType
);
}
public String getSerializationType() {
return serializationType;
}
public Object getValue() {
return value;
}
}
|
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/serializableGraph/SerializableAttributeVersion.java | package ai.stapi.graphoperations.serializableGraph;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import ai.stapi.graph.attribute.Attribute;
import ai.stapi.graph.attribute.LeafAttribute;
import ai.stapi.graph.attribute.ListAttribute;
import ai.stapi.graph.attribute.SetAttribute;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class SerializableAttributeVersion {
private final List<SerializableAttributeValue> values;
private final Map<String, List<SerializableAttributeValue>> metaData;
public static SerializableAttributeVersion fromAttribute(Attribute<?> attribute) {
var metaData = new HashMap<String, List<SerializableAttributeValue>>();
attribute.getMetaData().forEach((name, meta) -> metaData.put(
name,
meta.getValues().stream().map(SerializableAttributeValue::new).toList()
));
if (attribute instanceof LeafAttribute<?, ?> leafAttribute) {
return new SerializableAttributeVersion(
List.of(new SerializableAttributeValue(leafAttribute.getBoxedValue())),
metaData
);
}
if (attribute instanceof ListAttribute listAttribute) {
return new SerializableAttributeVersion(
listAttribute.getBoxedValues().stream().map(SerializableAttributeValue::new).toList(),
metaData
);
}
if (attribute instanceof SetAttribute setAttribute) {
return new SerializableAttributeVersion(
setAttribute.getBoxedValues().stream().map(SerializableAttributeValue::new).toList(),
metaData
);
}
return new SerializableAttributeVersion(
List.of(),
Map.of()
);
}
@JsonCreator
public SerializableAttributeVersion(
@JsonProperty("values") List<SerializableAttributeValue> values,
@JsonProperty("metaData") Map<String, List<SerializableAttributeValue>> metaData
) {
this.values = values;
this.metaData = metaData;
}
public List<SerializableAttributeValue> getValues() {
return values;
}
public Map<String, List<SerializableAttributeValue>> getMetaData() {
return metaData;
}
}
|
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/serializableGraph/SerializableEdge.java | package ai.stapi.graphoperations.serializableGraph;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import ai.stapi.graph.NodeIdAndType;
import ai.stapi.graph.graphelements.Edge;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class SerializableEdge extends SerializableGraphElement {
private final NodeIdAndType nodeFrom;
private final NodeIdAndType nodeTo;
public static SerializableEdge fromInputEdge(Edge edge) {
var attributeMap = new HashMap<String, List<SerializableAttributeVersion>>();
edge.getVersionedAttributes()
.getVersionedAttributeList()
.forEach(attr -> attributeMap.put(
attr.getName(),
attr.streamAttributeVersions().map(SerializableAttributeVersion::fromAttribute).toList()
));
return new SerializableEdge(
edge.getId().getId(),
edge.getType(),
attributeMap,
edge.getNodeFromIdAndType(),
edge.getNodeToIdAndType()
);
}
public SerializableEdge(
String id,
String type,
Map<String, List<SerializableAttributeVersion>> attributes,
NodeIdAndType nodeFrom,
NodeIdAndType nodeTo
) {
super(id, type, attributes);
this.nodeFrom = nodeFrom;
this.nodeTo = nodeTo;
}
@JsonCreator
private SerializableEdge(
@JsonProperty(GraphElementKeys.ID) String reference,
@JsonProperty(GraphElementKeys.ATTRIBUTES)
Map<String, List<SerializableAttributeVersion>> attributes,
@JsonProperty(GraphElementKeys.FROM) String from,
@JsonProperty(GraphElementKeys.TO) String to,
@JsonProperty(GraphElementKeys.REV) String revision,
@JsonProperty(GraphElementKeys.KEY) String key
) {
super(reference, attributes, key, revision);
this.nodeFrom = NodeIdAndType.fromString(from);
this.nodeTo = NodeIdAndType.fromString(to);
}
@JsonProperty(GraphElementKeys.FROM)
public String getFrom() {
return this.getNodeFrom().toString();
}
@JsonProperty(GraphElementKeys.TO)
public String getTo() {
return this.getNodeTo().toString();
}
@JsonIgnore
public NodeIdAndType getNodeFrom() {
return nodeFrom;
}
@JsonIgnore
public NodeIdAndType getNodeTo() {
return nodeTo;
}
}
|
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/serializableGraph/SerializableGraph.java | package ai.stapi.graphoperations.serializableGraph;
import com.fasterxml.jackson.annotation.JsonCreator;
import ai.stapi.graph.Graph;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.HashMap;
import java.util.Map;
public class SerializableGraph {
private final Map<String, SerializableNode> nodes;
private final Map<String, SerializableEdge> edges;
public static SerializableGraph fromInMemory(Graph graph) {
var nodes = new HashMap<String, SerializableNode>();
graph.getAllNodes()
.stream()
.map(SerializableNode::fromInputNode)
.forEach(node -> nodes.put(node.getGlobalId(), node));
var edges = new HashMap<String, SerializableEdge>();
graph.getAllEdges()
.stream()
.map(SerializableEdge::fromInputEdge)
.forEach(edge -> edges.put(edge.getGlobalId(), edge));
return new SerializableGraph(nodes, edges);
}
@JsonCreator
public SerializableGraph(
@JsonProperty("nodes") Map<String, SerializableNode> nodes,
@JsonProperty("edges") Map<String, SerializableEdge> edges
) {
this.nodes = nodes;
this.edges = edges;
}
public Map<String, SerializableNode> getNodes() {
return nodes;
}
public Map<String, SerializableEdge> getEdges() {
return edges;
}
}
|
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/serializableGraph/SerializableGraphElement.java | package ai.stapi.graphoperations.serializableGraph;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.List;
import java.util.Map;
public abstract class SerializableGraphElement {
private final String id;
private final String type;
private final Map<String, List<SerializableAttributeVersion>> attributes;
protected SerializableGraphElement(
String id,
String type,
Map<String, List<SerializableAttributeVersion>> attributes
) {
this.id = id;
this.type = type;
this.attributes = attributes;
}
@JsonCreator
protected SerializableGraphElement(
@JsonProperty(GraphElementKeys.ID) String reference,
@JsonProperty(GraphElementKeys.ATTRIBUTES)
Map<String, List<SerializableAttributeVersion>> attributes,
@JsonProperty(GraphElementKeys.KEY) String key,
@JsonProperty(GraphElementKeys.REV) String revision
) {
var split = reference.split("/");
this.id = split[1];
this.type = split[0];
this.attributes = attributes;
}
@JsonProperty(GraphElementKeys.ID)
public String getGlobalId() {
return String.format("%s/%s", this.getType(), this.getId());
}
@JsonProperty(GraphElementKeys.KEY)
public String getId() {
return id;
}
@JsonIgnore
public String getType() {
return type;
}
public Map<String, List<SerializableAttributeVersion>> getAttributes() {
return attributes;
}
}
|
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/serializableGraph/SerializableNode.java | package ai.stapi.graphoperations.serializableGraph;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import ai.stapi.graph.graphelements.Node;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class SerializableNode extends SerializableGraphElement {
public static SerializableNode fromInputNode(Node node) {
var attributeMap = new HashMap<String, List<SerializableAttributeVersion>>();
node.getVersionedAttributes()
.getVersionedAttributeList()
.forEach(attr -> attributeMap.put(
attr.getName(),
attr.streamAttributeVersions().map(SerializableAttributeVersion::fromAttribute).toList()
));
return new SerializableNode(
node.getId().getId(),
node.getType(),
attributeMap
);
}
public SerializableNode(
String id,
String type,
Map<String, List<SerializableAttributeVersion>> attributes
) {
super(id, type, attributes);
}
@JsonCreator
private SerializableNode(
@JsonProperty(GraphElementKeys.ID) String reference,
@JsonProperty(GraphElementKeys.ATTRIBUTES)
Map<String, List<SerializableAttributeVersion>> attributes,
@JsonProperty(GraphElementKeys.KEY) String key,
@JsonProperty(GraphElementKeys.REV) String revision
) {
super(reference, attributes, key, revision);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/serializableGraph | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/serializableGraph/deserializer/SerializableAttributeDeserializer.java | package ai.stapi.graphoperations.serializableGraph.deserializer;
import ai.stapi.graph.attribute.LeafAttribute;
import ai.stapi.graph.attribute.ListAttribute;
import ai.stapi.graph.attribute.MetaData;
import ai.stapi.graph.attribute.attributeFactory.AttributeValueFactoryInput;
import ai.stapi.graph.attribute.attributeFactory.GenericAttributeFactory;
import ai.stapi.graph.attribute.attributeFactory.attributeValueFactory.GenericAttributeValueFactory;
import ai.stapi.graph.versionedAttributes.ImmutableVersionedAttribute;
import ai.stapi.graph.versionedAttributes.ImmutableVersionedAttributeGroup;
import ai.stapi.graph.versionedAttributes.VersionedAttribute;
import ai.stapi.graphoperations.serializableGraph.SerializableAttributeValue;
import ai.stapi.graphoperations.serializableGraph.SerializableAttributeVersion;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.jetbrains.annotations.NotNull;
import org.springframework.stereotype.Service;
public class SerializableAttributeDeserializer {
private final StructureSchemaFinder structureSchemaFinder;
private final GenericAttributeFactory genericAttributeFactory;
private final GenericAttributeValueFactory genericAttributeValueFactory;
public SerializableAttributeDeserializer(
StructureSchemaFinder structureSchemaFinder,
GenericAttributeFactory genericAttributeFactory,
GenericAttributeValueFactory genericAttributeValueFactory
) {
this.structureSchemaFinder = structureSchemaFinder;
this.genericAttributeFactory = genericAttributeFactory;
this.genericAttributeValueFactory = genericAttributeValueFactory;
}
public VersionedAttribute<?> deserialize(
String graphElementType,
String attributeName,
List<SerializableAttributeVersion> attribute
) {
var fieldDefinition = this.structureSchemaFinder.getFieldDefinitionOrFallback(
graphElementType,
attributeName
);
return new ImmutableVersionedAttribute<>(
attribute.stream().map(
serializableAttributeVersion -> {
var metaData = new HashMap<String, MetaData>();
serializableAttributeVersion.getMetaData().forEach((name, meta) -> metaData.put(
name,
new MetaData(
name,
meta.stream().map(value -> this.genericAttributeValueFactory.create(
name,
new AttributeValueFactoryInput(
value.getValue(),
value.getSerializationType()
)
)).collect(Collectors.toList())
)
));
return this.genericAttributeFactory.create(
attributeName,
this.getStructureType(fieldDefinition),
serializableAttributeVersion.getValues().stream()
.map(SerializableAttributeValue::toAttributeFactoryInput)
.toList(),
metaData
);
}
).toList()
);
}
public ImmutableVersionedAttributeGroup deserializeGroup(
String graphElementType,
Map<String, List<SerializableAttributeVersion>> attributeMap
) {
var rawMap = new HashMap<String, VersionedAttribute<?>>();
attributeMap.forEach(
(attributeName, attribute) -> rawMap.put(
attributeName,
this.deserialize(
graphElementType,
attributeName,
attribute
)
)
);
return new ImmutableVersionedAttributeGroup(rawMap);
}
@NotNull
private String getStructureType(FieldDefinition fieldDefinition) {
return fieldDefinition.getStructureType().equals(FieldDefinition.LEAF_STRUCTURE_TYPE) ?
LeafAttribute.DATA_STRUCTURE_TYPE :
ListAttribute.DATA_STRUCTURE_TYPE;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/serializableGraph | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/serializableGraph/deserializer/SerializableEdgeDeserializer.java | package ai.stapi.graphoperations.serializableGraph.deserializer;
import ai.stapi.graph.graphelements.Edge;
import ai.stapi.graphoperations.serializableGraph.SerializableEdge;
import ai.stapi.identity.UniqueIdentifier;
import org.springframework.stereotype.Service;
public class SerializableEdgeDeserializer {
private final SerializableAttributeDeserializer attributeDeserializer;
public SerializableEdgeDeserializer(SerializableAttributeDeserializer attributeDeserializer) {
this.attributeDeserializer = attributeDeserializer;
}
public Edge deserialize(SerializableEdge serializableEdge) {
return new Edge(
new UniqueIdentifier(serializableEdge.getId()),
serializableEdge.getType(),
this.attributeDeserializer.deserializeGroup(
serializableEdge.getType(),
serializableEdge.getAttributes()
),
serializableEdge.getNodeFrom(),
serializableEdge.getNodeTo()
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/serializableGraph | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/serializableGraph/deserializer/SerializableGraphDeserializer.java | package ai.stapi.graphoperations.serializableGraph.deserializer;
import ai.stapi.graph.Graph;
import ai.stapi.graph.graphelements.Edge;
import ai.stapi.graph.graphelements.Node;
import ai.stapi.graphoperations.serializableGraph.SerializableEdge;
import ai.stapi.graphoperations.serializableGraph.SerializableGraph;
import ai.stapi.graphoperations.serializableGraph.SerializableNode;
import java.util.HashMap;
public class SerializableGraphDeserializer {
private final SerializableNodeDeserializer nodeDeserializer;
private final SerializableEdgeDeserializer edgeDeserializer;
public SerializableGraphDeserializer(
SerializableNodeDeserializer nodeDeserializer,
SerializableEdgeDeserializer edgeDeserializer
) {
this.nodeDeserializer = nodeDeserializer;
this.edgeDeserializer = edgeDeserializer;
}
public Graph deserialize(SerializableGraph serializableGraph) {
var nodes = new HashMap<Graph.GloballyUniqueIdentifier, Node>();
serializableGraph.getNodes().values()
.stream()
.map(this.nodeDeserializer::deserialize)
.forEach(node -> nodes.put(new Graph.GloballyUniqueIdentifier(node.getId(), node.getType()), node));
var edges = new HashMap<Graph.GloballyUniqueIdentifier, Edge>();
serializableGraph.getEdges().values()
.stream()
.map(this.edgeDeserializer::deserialize)
.forEach(edge -> edges.put(new Graph.GloballyUniqueIdentifier(edge.getId(), edge.getType()), edge));
return Graph.unsafe(nodes, edges);
}
public Edge deserializeEdge(SerializableEdge serializableEdge) {
return this.edgeDeserializer.deserialize(serializableEdge);
}
public Node deserializeNode(SerializableNode serializableNode) {
return this.nodeDeserializer.deserialize(serializableNode);
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.