index int64 | repo_id string | file_path string | content string |
|---|---|---|---|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory/filter/InMemoryEqualsFilterResolver.java | package ai.stapi.graphoperations.graphLoader.inmemory.filter;
import ai.stapi.graph.attribute.attributeValue.AttributeValue;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGraphLoader;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AbstractOneValueFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.EqualsFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.List;
import java.util.Set;
public class InMemoryEqualsFilterResolver extends InMemoryOneValueFilterResolver {
public InMemoryEqualsFilterResolver(
StructureSchemaFinder structureSchemaFinder,
InMemoryGraphLoader inMemoryGraphLoader
) {
super(structureSchemaFinder, inMemoryGraphLoader);
}
@Override
public boolean resolveValue(AbstractOneValueFilterOption<?> option, AttributeValue<?> actualValue) {
if (option.hasListValue()) {
return false;
}
if (option.hasSetValue()) {
return false;
}
return option.getValueAsAttributeValue().equals(actualValue);
}
@Override
protected boolean resolveValue(AbstractOneValueFilterOption<?> option, List<AttributeValue<?>> actualValue) {
if (option.hasListValue()) {
return option.getValueAsListAttributeValue().equals(actualValue);
}
return false;
}
@Override
protected boolean resolveValue(AbstractOneValueFilterOption<?> option, Set<AttributeValue<?>> actualValue) {
if (option.hasSetValue()) {
return option.getValueAsSetAttributeValue().equals(actualValue);
}
return false;
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof EqualsFilterOption<?>;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory/filter/InMemoryFilterResolver.java | package ai.stapi.graphoperations.graphLoader.inmemory.filter;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.graphLoader.inmemory.AbstractInMemorySearchOptionResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemorySearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.search.filterOption.FilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
public abstract class InMemoryFilterResolver extends AbstractInMemorySearchOptionResolver<FilterOption<?>> {
protected InMemoryFilterResolver(
StructureSchemaFinder structureSchemaFinder
) {
super(structureSchemaFinder);
}
public abstract boolean resolveElement(
FilterOption<?> option,
TraversableGraphElement element,
InMemorySearchResolvingContext context
);
@Override
protected InMemorySearchResolvingContext resolveTyped(
FilterOption<?> option,
InMemorySearchResolvingContext context
) {
return context.setSearchOption(
elements -> elements.filter(element -> this.resolveElement(option, element, context))
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory/filter/InMemoryGreaterThanFilterResolver.java | package ai.stapi.graphoperations.graphLoader.inmemory.filter;
import ai.stapi.graph.attribute.attributeValue.AttributeValue;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGraphLoader;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AbstractOneValueFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.GreaterThanFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.List;
import java.util.Set;
public class InMemoryGreaterThanFilterResolver extends InMemoryOneValueFilterResolver {
public InMemoryGreaterThanFilterResolver(
StructureSchemaFinder structureSchemaFinder,
InMemoryGraphLoader inMemoryGraphLoader
) {
super(structureSchemaFinder, inMemoryGraphLoader);
}
@Override
public boolean resolveValue(AbstractOneValueFilterOption<?> option, AttributeValue<?> actualValue) {
if (option.hasListValue()) {
return false;
}
if (option.hasSetValue()) {
return false;
}
return option.getValueAsAttributeValue().compareTo(actualValue) < 0;
}
@Override
protected boolean resolveValue(AbstractOneValueFilterOption<?> option, List<AttributeValue<?>> actualValue) {
if (option.hasListValue() && (option.getValueAsListAttributeValue().isEmpty())) {
return !actualValue.isEmpty();
}
if (option.hasSetValue() && (option.getValueAsSetAttributeValue().isEmpty())) {
return !actualValue.isEmpty();
}
return false;
}
@Override
protected boolean resolveValue(AbstractOneValueFilterOption<?> option, Set<AttributeValue<?>> actualValue) {
if (option.hasListValue() && (option.getValueAsListAttributeValue().isEmpty())) {
return !actualValue.isEmpty();
}
if (option.hasSetValue() && (option.getValueAsSetAttributeValue().isEmpty())) {
return !actualValue.isEmpty();
}
return false;
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof GreaterThanFilterOption<?>;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory/filter/InMemoryGreaterThanOrEqualsFilterResolver.java | package ai.stapi.graphoperations.graphLoader.inmemory.filter;
import ai.stapi.graph.attribute.attributeValue.AttributeValue;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGraphLoader;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AbstractOneValueFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.GreaterThanOrEqualFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.List;
import java.util.Set;
public class InMemoryGreaterThanOrEqualsFilterResolver extends InMemoryOneValueFilterResolver {
public InMemoryGreaterThanOrEqualsFilterResolver(
StructureSchemaFinder structureSchemaFinder,
InMemoryGraphLoader inMemoryGraphLoader
) {
super(structureSchemaFinder, inMemoryGraphLoader);
}
@Override
public boolean resolveValue(AbstractOneValueFilterOption<?> option, AttributeValue<?> actualValue) {
if (option.hasListValue()) {
return false;
}
if (option.hasSetValue()) {
return false;
}
return option.getValueAsAttributeValue().compareTo(actualValue) <= 0;
}
@Override
protected boolean resolveValue(AbstractOneValueFilterOption<?> option, List<AttributeValue<?>> actualValue) {
if (option.hasListValue()) {
var valueAsListAttributeValue = option.getValueAsListAttributeValue();
if (valueAsListAttributeValue.isEmpty()) {
return true;
}
return valueAsListAttributeValue.equals(actualValue);
}
return option.hasSetValue() && (option.getValueAsSetAttributeValue().isEmpty());
}
@Override
protected boolean resolveValue(AbstractOneValueFilterOption<?> option, Set<AttributeValue<?>> actualValue) {
if (option.hasSetValue()) {
var valueAsSetAttributeValue = option.getValueAsSetAttributeValue();
if (valueAsSetAttributeValue.isEmpty()) {
return true;
}
return valueAsSetAttributeValue.equals(actualValue);
}
return option.hasListValue() && (option.getValueAsListAttributeValue().isEmpty());
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof GreaterThanOrEqualFilterOption<?>;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory/filter/InMemoryIsNullFilterResolver.java | package ai.stapi.graphoperations.graphLoader.inmemory.filter;
import ai.stapi.graph.attribute.attributeValue.AttributeValue;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGraphLoader;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.IsNullFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.LeafFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.List;
import java.util.Set;
public class InMemoryIsNullFilterResolver extends InMemoryLeafFilterResolver {
public InMemoryIsNullFilterResolver(
StructureSchemaFinder structureSchemaFinder,
InMemoryGraphLoader inMemoryGraphLoader
) {
super(structureSchemaFinder, inMemoryGraphLoader);
}
@Override
public boolean resolve(LeafFilterOption<?> option, AttributeValue<?> actualValue) {
return actualValue == null;
}
@Override
protected boolean resolve(LeafFilterOption<?> option, List<AttributeValue<?>> actualValue) {
return actualValue == null;
}
@Override
protected boolean resolve(LeafFilterOption<?> option, Set<AttributeValue<?>> actualValue) {
return actualValue == null;
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof IsNullFilterOption;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory/filter/InMemoryLeafFilterResolver.java | package ai.stapi.graphoperations.graphLoader.inmemory.filter;
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 ai.stapi.graph.attribute.attributeValue.AttributeValue;
import ai.stapi.graph.attribute.attributeValue.IdAttributeValue;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.CollectionComparisonOperator;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGraphLoader;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemorySearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.search.filterOption.FilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.LeafFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.List;
import java.util.Set;
public abstract class InMemoryLeafFilterResolver extends InMemoryFilterResolver {
private final InMemoryGraphLoader inMemoryGraphLoader;
protected InMemoryLeafFilterResolver(
StructureSchemaFinder structureSchemaFinder,
InMemoryGraphLoader inMemoryGraphLoader
) {
super(structureSchemaFinder);
this.inMemoryGraphLoader = inMemoryGraphLoader;
}
public abstract boolean resolve(LeafFilterOption<?> option, AttributeValue<?> actualValue);
protected abstract boolean resolve(LeafFilterOption<?> option, List<AttributeValue<?>> actualValue);
protected abstract boolean resolve(LeafFilterOption<?> option, Set<AttributeValue<?>> actualValue);
@Override
public boolean resolveElement(
FilterOption<?> option,
TraversableGraphElement element,
InMemorySearchResolvingContext context
) {
var leafFilterOption = (LeafFilterOption<?>) option;
if (leafFilterOption.isLeaf()) {
if (leafFilterOption.isDescribingAttribute()) {
var attributeName = leafFilterOption.getParameters().getAttributeName();
if (!element.hasAttribute(attributeName)) {
return this.resolve(leafFilterOption, (AttributeValue<?>) null);
}
var attribute = element.getAttribute(attributeName);
return this.resolveAttribute(leafFilterOption, attribute);
} else {
return this.resolve(leafFilterOption, new IdAttributeValue(element.getId().getId()));
}
} else {
var attributeNamePath = leafFilterOption.getParameters().getAttributeNamePath();
var copy = new GraphDescriptionBuilder().copyWithNewChildren(
context.getLastDescription(),
attributeNamePath
);
var filterValue = this.inMemoryGraphLoader.getSearchOptionAttributeValue(
element.getId(),
(PositiveGraphDescription) copy
);
var collectionComparisonSchema = this.createRelationshipStructureSchema(
attributeNamePath,
element.getType()
);
return this.resolveFilterValue(leafFilterOption, filterValue, collectionComparisonSchema);
}
}
private boolean resolveAttribute(LeafFilterOption<?> leafFilterOption, Attribute<?> attribute) {
if (attribute instanceof ListAttribute listAttribute) {
return this.resolve(leafFilterOption, listAttribute.getBoxedValues());
}
if (attribute instanceof SetAttribute setAttribute) {
return this.resolve(leafFilterOption, setAttribute.getBoxedValues());
}
return this.resolve(leafFilterOption, ((LeafAttribute<?, ?>) attribute).getBoxedValue());
}
private boolean resolveFilterValue(
LeafFilterOption<?> filterOption,
Object filterValue,
List<SchemaAndCollectionComparisonOperator> collectionComparisonSchema
) {
if (filterValue == null) {
return this.resolve(filterOption, (AttributeValue<?>) null);
}
if (collectionComparisonSchema.isEmpty()) {
var attribute = (Attribute<?>) filterValue;
return this.resolveAttribute(filterOption, attribute);
}
var currentComparison = collectionComparisonSchema.get(0);
var list = (List<Object>) filterValue;
var len = collectionComparisonSchema.size();
var restOfCollectionSchema = collectionComparisonSchema.subList(1, len);
if (currentComparison.operator().equals(CollectionComparisonOperator.ALL)) {
return list.stream().allMatch(value -> this.resolveFilterValue(filterOption, value, restOfCollectionSchema));
} else if (currentComparison.operator().equals(CollectionComparisonOperator.NONE)) {
return list.stream().noneMatch(value -> this.resolveFilterValue(filterOption, value, restOfCollectionSchema));
} else {
return list.stream().anyMatch(value -> this.resolveFilterValue(filterOption, value, restOfCollectionSchema));
}
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory/filter/InMemoryLowerThanFilterResolver.java | package ai.stapi.graphoperations.graphLoader.inmemory.filter;
import ai.stapi.graph.attribute.attributeValue.AttributeValue;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGraphLoader;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AbstractOneValueFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.LowerThanFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.List;
import java.util.Set;
public class InMemoryLowerThanFilterResolver extends InMemoryOneValueFilterResolver {
public InMemoryLowerThanFilterResolver(
StructureSchemaFinder structureSchemaFinder,
InMemoryGraphLoader inMemoryGraphLoader
) {
super(structureSchemaFinder, inMemoryGraphLoader);
}
@Override
public boolean resolveValue(AbstractOneValueFilterOption<?> option, AttributeValue<?> actualValue) {
if (option.hasListValue()) {
return true;
}
if (option.hasSetValue()) {
return true;
}
return option.getValueAsAttributeValue().compareTo(actualValue) > 0;
}
@Override
protected boolean resolveValue(AbstractOneValueFilterOption<?> option, List<AttributeValue<?>> actualValue) {
if (option.hasListValue() && !(option.getValueAsListAttributeValue().isEmpty())) {
return actualValue.isEmpty();
}
if (option.hasSetValue() && !(option.getValueAsSetAttributeValue().isEmpty())) {
return actualValue.isEmpty();
}
return false;
}
@Override
protected boolean resolveValue(AbstractOneValueFilterOption<?> option, Set<AttributeValue<?>> actualValue) {
if (option.hasListValue() && !(option.getValueAsListAttributeValue().isEmpty())) {
return actualValue.isEmpty();
}
if (option.hasSetValue() && !(option.getValueAsSetAttributeValue().isEmpty())) {
return actualValue.isEmpty();
}
return false;
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof LowerThanFilterOption<?>;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory/filter/InMemoryLowerThanOrEqualFilterResolver.java | package ai.stapi.graphoperations.graphLoader.inmemory.filter;
import ai.stapi.graph.attribute.attributeValue.AttributeValue;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGraphLoader;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AbstractOneValueFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.LowerThanOrEqualsFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.List;
import java.util.Set;
public class InMemoryLowerThanOrEqualFilterResolver extends InMemoryOneValueFilterResolver {
public InMemoryLowerThanOrEqualFilterResolver(
StructureSchemaFinder structureSchemaFinder,
InMemoryGraphLoader inMemoryGraphLoader
) {
super(structureSchemaFinder, inMemoryGraphLoader);
}
@Override
public boolean resolveValue(AbstractOneValueFilterOption<?> option, AttributeValue<?> actualValue) {
if (option.hasListValue()) {
return true;
}
if (option.hasSetValue()) {
return true;
}
return option.getValueAsAttributeValue().compareTo(actualValue) >= 0;
}
@Override
protected boolean resolveValue(AbstractOneValueFilterOption<?> option, List<AttributeValue<?>> actualValue) {
if (option.hasListValue()) {
if (actualValue.isEmpty()) {
return true;
}
return option.getValueAsListAttributeValue().equals(actualValue);
}
return option.hasSetValue() && actualValue.isEmpty();
}
@Override
protected boolean resolveValue(AbstractOneValueFilterOption<?> option, Set<AttributeValue<?>> actualValue) {
if (option.hasSetValue()) {
if (actualValue.isEmpty()) {
return true;
}
return option.getValueAsSetAttributeValue().equals(actualValue);
}
return option.hasListValue() && actualValue.isEmpty();
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof LowerThanOrEqualsFilterOption<?>;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory/filter/InMemoryNoneMatchFilterResolver.java | package ai.stapi.graphoperations.graphLoader.inmemory.filter;
import ai.stapi.graph.attribute.ListAttribute;
import ai.stapi.graph.attribute.SetAttribute;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGraphLoader;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AbstractOneValueFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.NoneMatchFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
public class InMemoryNoneMatchFilterResolver extends InMemoryArrayComparisonFilterResolver {
public InMemoryNoneMatchFilterResolver(
StructureSchemaFinder structureSchemaFinder,
GenericInMemoryFilterOptionResolver genericInMemoryFilterOptionResolver,
InMemoryGraphLoader inMemoryGraphLoader
) {
super(structureSchemaFinder, genericInMemoryFilterOptionResolver, inMemoryGraphLoader);
}
@Override
protected boolean resolveSetAttribute(AbstractOneValueFilterOption<?> childFilter, SetAttribute setAttribute) {
return setAttribute.getBoxedValues().stream().noneMatch(
attributeValue -> this.genericInMemoryFilterOptionResolver.resolveValue(childFilter, attributeValue)
);
}
@Override
protected boolean resolveListAttribute(AbstractOneValueFilterOption<?> childFilter, ListAttribute listAttribute) {
return listAttribute.getBoxedValues().stream().noneMatch(
attributeValue -> this.genericInMemoryFilterOptionResolver.resolveValue(childFilter, attributeValue)
);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof NoneMatchFilterOption;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory/filter/InMemoryNotEqualsFilterResolver.java | package ai.stapi.graphoperations.graphLoader.inmemory.filter;
import ai.stapi.graph.attribute.attributeValue.AttributeValue;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGraphLoader;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AbstractOneValueFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.NotEqualsFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.List;
import java.util.Set;
public class InMemoryNotEqualsFilterResolver extends InMemoryOneValueFilterResolver {
public InMemoryNotEqualsFilterResolver(
StructureSchemaFinder structureSchemaFinder,
InMemoryGraphLoader inMemoryGraphLoader
) {
super(structureSchemaFinder, inMemoryGraphLoader);
}
@Override
public boolean resolveValue(AbstractOneValueFilterOption<?> option, AttributeValue<?> actualValue) {
if (option.hasListValue()) {
return true;
}
if (option.hasSetValue()) {
return true;
}
return !option.getValueAsAttributeValue().equals(actualValue);
}
@Override
protected boolean resolveValue(AbstractOneValueFilterOption<?> option, List<AttributeValue<?>> actualValue) {
if (option.hasListValue()) {
return !option.getValueAsListAttributeValue().equals(actualValue);
}
return true;
}
@Override
protected boolean resolveValue(AbstractOneValueFilterOption<?> option, Set<AttributeValue<?>> actualValue) {
if (option.hasSetValue()) {
return !option.getValueAsSetAttributeValue().equals(actualValue);
}
return true;
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof NotEqualsFilterOption<?>;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory/filter/InMemoryNotFilterResolver.java | package ai.stapi.graphoperations.graphLoader.inmemory.filter;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemorySearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.FilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.NotFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
public class InMemoryNotFilterResolver extends InMemoryFilterResolver {
private final GenericInMemoryFilterOptionResolver genericInMemoryFilterOptionResolver;
public InMemoryNotFilterResolver(
StructureSchemaFinder structureSchemaFinder,
GenericInMemoryFilterOptionResolver genericInMemoryFilterOptionResolver
) {
super(structureSchemaFinder);
this.genericInMemoryFilterOptionResolver = genericInMemoryFilterOptionResolver;
}
@Override
public boolean resolveElement(
FilterOption<?> option,
TraversableGraphElement element,
InMemorySearchResolvingContext context
) {
var notFilter = (NotFilterOption) option;
return !this.genericInMemoryFilterOptionResolver.resolveElement(
notFilter.getChildFilterOption(),
element,
context
);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof NotFilterOption;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory/filter/InMemoryNotNullFilterResolver.java | package ai.stapi.graphoperations.graphLoader.inmemory.filter;
import ai.stapi.graph.attribute.attributeValue.AttributeValue;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGraphLoader;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.LeafFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.NotNullFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.List;
import java.util.Set;
public class InMemoryNotNullFilterResolver extends InMemoryLeafFilterResolver {
public InMemoryNotNullFilterResolver(
StructureSchemaFinder structureSchemaFinder,
InMemoryGraphLoader inMemoryGraphLoader
) {
super(structureSchemaFinder, inMemoryGraphLoader);
}
@Override
public boolean resolve(LeafFilterOption<?> option, AttributeValue<?> actualValue) {
return actualValue != null;
}
@Override
protected boolean resolve(LeafFilterOption<?> option, List<AttributeValue<?>> actualValue) {
return actualValue != null;
}
@Override
protected boolean resolve(LeafFilterOption<?> option, Set<AttributeValue<?>> actualValue) {
return actualValue != null;
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof NotNullFilterOption;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory/filter/InMemoryOneValueFilterResolver.java | package ai.stapi.graphoperations.graphLoader.inmemory.filter;
import ai.stapi.graph.attribute.attributeValue.AttributeValue;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGraphLoader;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AbstractOneValueFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.LeafFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.List;
import java.util.Set;
public abstract class InMemoryOneValueFilterResolver extends InMemoryLeafFilterResolver {
protected InMemoryOneValueFilterResolver(
StructureSchemaFinder structureSchemaFinder,
InMemoryGraphLoader inMemoryGraphLoader
) {
super(structureSchemaFinder, inMemoryGraphLoader);
}
public abstract boolean resolveValue(AbstractOneValueFilterOption<?> option, AttributeValue<?> actualValue);
protected abstract boolean resolveValue(AbstractOneValueFilterOption<?> option, List<AttributeValue<?>> actualValue);
protected abstract boolean resolveValue(AbstractOneValueFilterOption<?> option, Set<AttributeValue<?>> actualValue);
@Override
public boolean resolve(LeafFilterOption<?> option, AttributeValue<?> actualValue) {
if (actualValue == null) {
return false;
}
return this.resolveValue((AbstractOneValueFilterOption<?>) option, actualValue);
}
@Override
protected boolean resolve(LeafFilterOption<?> option, List<AttributeValue<?>> actualValue) {
if (actualValue == null) {
return false;
}
return this.resolveValue((AbstractOneValueFilterOption<?>) option, actualValue);
}
@Override
protected boolean resolve(LeafFilterOption<?> option, Set<AttributeValue<?>> actualValue) {
if (actualValue == null) {
return false;
}
return this.resolveValue((AbstractOneValueFilterOption<?>) option, actualValue);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory/filter/InMemoryOrFilterResolver.java | package ai.stapi.graphoperations.graphLoader.inmemory.filter;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemorySearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.FilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.OrFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
public class InMemoryOrFilterResolver extends InMemoryFilterResolver {
private final GenericInMemoryFilterOptionResolver genericInMemoryFilterOptionResolver;
public InMemoryOrFilterResolver(
StructureSchemaFinder structureSchemaFinder,
GenericInMemoryFilterOptionResolver genericInMemoryFilterOptionResolver
) {
super(structureSchemaFinder);
this.genericInMemoryFilterOptionResolver = genericInMemoryFilterOptionResolver;
}
@Override
public boolean resolveElement(
FilterOption<?> option,
TraversableGraphElement element,
InMemorySearchResolvingContext context
) {
var orFilter = (OrFilterOption) option;
return orFilter.getParameters().getChildFilterOptions().stream().anyMatch(
fiter -> this.genericInMemoryFilterOptionResolver.resolveElement(fiter, element, context)
);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof OrFilterOption;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/inmemory/filter/InMemoryStartsWithFilterResolver.java | package ai.stapi.graphoperations.graphLoader.inmemory.filter;
import ai.stapi.graph.attribute.attributeValue.AttributeValue;
import ai.stapi.graph.attribute.attributeValue.StringLikeAttributeValue;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGraphLoader;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AbstractOneValueFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.StartsWithFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.List;
import java.util.Set;
public class InMemoryStartsWithFilterResolver extends InMemoryOneValueFilterResolver {
public InMemoryStartsWithFilterResolver(
StructureSchemaFinder structureSchemaFinder,
InMemoryGraphLoader inMemoryGraphLoader
) {
super(structureSchemaFinder, inMemoryGraphLoader);
}
@Override
public boolean resolveValue(AbstractOneValueFilterOption<?> option, AttributeValue<?> actualValue) {
if (actualValue instanceof StringLikeAttributeValue<?> stringLikeAttributeValue) {
var stringFilterValue = (String) option.getParameters().getAttributeValue();
return stringLikeAttributeValue.toStringValue().startsWith(stringFilterValue);
}
return false;
}
@Override
protected boolean resolveValue(AbstractOneValueFilterOption<?> option, List<AttributeValue<?>> actualValue) {
return false;
}
@Override
protected boolean resolveValue(AbstractOneValueFilterOption<?> option, Set<AttributeValue<?>> actualValue) {
return false;
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof StartsWithFilterOption;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/AbstractGenericSearchOptionResolver.java | package ai.stapi.graphoperations.graphLoader.search;
import ai.stapi.graphoperations.graphLoader.search.exceptions.SearchOptionNotSupportedByExactlyOneResolver;
import java.util.List;
public abstract class AbstractGenericSearchOptionResolver<R extends ResolvedQueryPart>
implements GenericSearchOptionResolver<R> {
protected final List<SearchOptionResolver<R>> searchOptionResolvers;
protected AbstractGenericSearchOptionResolver(List<SearchOptionResolver<R>> searchOptionResolvers) {
this.searchOptionResolvers = searchOptionResolvers;
}
@Override
public R resolve(SearchOption<?> option, SearchResolvingContext context) {
var supporting = this.searchOptionResolvers.stream()
.filter(resolver -> resolver.supports(option))
.toList();
if (supporting.size() != 1) {
throw new SearchOptionNotSupportedByExactlyOneResolver(supporting.size(), option);
}
return supporting.get(0).resolve(option, context);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/AbstractSearchOption.java | package ai.stapi.graphoperations.graphLoader.search;
public abstract class AbstractSearchOption<ParametersType> implements SearchOption<ParametersType> {
private String optionType;
private String strategy;
private ParametersType parameters;
protected AbstractSearchOption() {
}
protected AbstractSearchOption(
String optionType,
String strategy,
ParametersType parameters
) {
this.optionType = optionType;
this.strategy = strategy;
this.parameters = parameters;
}
@Override
public String getOptionType() {
return this.optionType;
}
@Override
public String getStrategy() {
return this.strategy;
}
@Override
public ParametersType getParameters() {
return this.parameters;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/AbstractSearchOptionResolver.java | package ai.stapi.graphoperations.graphLoader.search;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractNodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.EdgeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.CollectionComparisonOperator;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.IngoingEdgeQueryDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.OutgoingEdgeQueryDescription;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.ArrayList;
import java.util.List;
public abstract class AbstractSearchOptionResolver<S extends SearchOption<?>, C extends SearchResolvingContext, R extends ResolvedQueryPart>
implements SearchOptionResolver<R> {
protected final StructureSchemaFinder structureSchemaFinder;
protected AbstractSearchOptionResolver(StructureSchemaFinder structureSchemaFinder) {
this.structureSchemaFinder = structureSchemaFinder;
}
protected abstract R resolveTyped(S option, C context);
@Override
public R resolve(SearchOption<?> option, SearchResolvingContext context) {
return this.resolveTyped((S) option, (C) context);
}
protected List<SchemaAndCollectionComparisonOperator> createRelationshipStructureSchema(
GraphDescription attributeNamePath,
String graphElementType
) {
var result = new ArrayList<SchemaAndCollectionComparisonOperator>();
var graphDescription = attributeNamePath;
var currentGraphElementType = graphElementType;
while (!graphDescription.getChildGraphDescriptions().isEmpty()) {
if (graphDescription instanceof AbstractNodeDescription nodeDescription) {
graphDescription = nodeDescription.getChildGraphDescriptions().get(0);
var param = (NodeDescriptionParameters) nodeDescription.getParameters();
currentGraphElementType = param.getNodeType();
} else if (graphDescription instanceof AbstractEdgeDescription edgeDescription) {
graphDescription = edgeDescription.getChildGraphDescriptions().get(0);
var param = (EdgeDescriptionParameters) edgeDescription.getParameters();
var schema = this.structureSchemaFinder.getFieldDefinitionOrFallback(
currentGraphElementType,
param.getEdgeType()
);
currentGraphElementType = param.getEdgeType();
if (edgeDescription instanceof OutgoingEdgeQueryDescription queryDescription) {
result.add(
new SchemaAndCollectionComparisonOperator(
schema,
queryDescription.getCollectionComparisonOperator()
)
);
} else if (edgeDescription instanceof IngoingEdgeQueryDescription queryDescription) {
result.add(
new SchemaAndCollectionComparisonOperator(
schema,
queryDescription.getCollectionComparisonOperator()
)
);
} else {
result.add(
new SchemaAndCollectionComparisonOperator(schema, CollectionComparisonOperator.ANY)
);
}
} else {
graphDescription = graphDescription.getChildGraphDescriptions().get(0);
}
}
return result;
}
public record SchemaAndCollectionComparisonOperator(
FieldDefinition fieldDefinition,
CollectionComparisonOperator operator
) {
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/GenericSearchOptionResolver.java | package ai.stapi.graphoperations.graphLoader.search;
public interface GenericSearchOptionResolver<R extends ResolvedQueryPart> {
R resolve(SearchOption<?> option, SearchResolvingContext context);
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/ResolvedQueryPart.java | package ai.stapi.graphoperations.graphLoader.search;
public interface ResolvedQueryPart {
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/SearchOption.java | package ai.stapi.graphoperations.graphLoader.search;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AbstractFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.FilterOption;
import ai.stapi.graphoperations.graphLoader.search.paginationOption.AbstractPaginationOption;
import ai.stapi.graphoperations.graphLoader.search.paginationOption.PaginationOption;
import ai.stapi.graphoperations.graphLoader.search.sortOption.AbstractSortOption;
import ai.stapi.graphoperations.graphLoader.search.sortOption.SortOption;
import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXISTING_PROPERTY, property = "optionType")
@JsonSubTypes({
@JsonSubTypes.Type(value = FilterOption.class, name = AbstractFilterOption.OPTION_TYPE),
@JsonSubTypes.Type(value = SortOption.class, name = AbstractSortOption.OPTION_TYPE),
@JsonSubTypes.Type(value = PaginationOption.class, name = AbstractPaginationOption.OPTION_TYPE)
})
public interface SearchOption<ParametersType> {
String getOptionType();
String getStrategy();
ParametersType getParameters();
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/SearchOptionResolver.java | package ai.stapi.graphoperations.graphLoader.search;
public interface SearchOptionResolver<R extends ResolvedQueryPart> {
boolean supports(SearchOption<?> option);
R resolve(SearchOption<?> option, SearchResolvingContext context);
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/SearchQueryParameters.java | package ai.stapi.graphoperations.graphLoader.search;
import ai.stapi.graphoperations.graphLoader.search.exceptions.SearchOptionResolverRuntimeException;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AbstractFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.FilterOption;
import ai.stapi.graphoperations.graphLoader.search.paginationOption.AbstractPaginationOption;
import ai.stapi.graphoperations.graphLoader.search.paginationOption.OffsetPaginationOption;
import ai.stapi.graphoperations.graphLoader.search.paginationOption.PaginationOption;
import ai.stapi.graphoperations.graphLoader.search.sortOption.AbstractSortOption;
import ai.stapi.graphoperations.graphLoader.search.sortOption.SortOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class SearchQueryParameters {
public static final OffsetPaginationOption DEFAULT_PAGINATION_OPTION = null;
private final List<FilterOption<?>> filterOptions;
private final List<SortOption> sortOptions;
@Nullable
private final PaginationOption<?> paginationOption;
public SearchQueryParameters(
List<FilterOption<?>> filterOptions,
List<SortOption> sortOptions,
@Nullable PaginationOption<?> paginationOption
) {
this.sortOptions = sortOptions;
this.filterOptions = filterOptions;
this.paginationOption = paginationOption;
}
public SearchQueryParameters(List<FilterOption<?>> filterOptions, List<SortOption> sortOptions) {
this(
filterOptions,
sortOptions,
SearchQueryParameters.DEFAULT_PAGINATION_OPTION
);
}
public SearchQueryParameters() {
this(new ArrayList<>(), new ArrayList<>());
}
public static SearchQueryParameters from(SearchOption<?>... searchOptions) {
Map<String, List<SearchOption<?>>> initialReduction = Map.ofEntries(
Map.entry(AbstractPaginationOption.OPTION_TYPE, new ArrayList<>()),
Map.entry(AbstractFilterOption.OPTION_TYPE, new ArrayList<>()),
Map.entry(AbstractSortOption.OPTION_TYPE, new ArrayList<>())
);
var optionMap = Arrays.stream(searchOptions)
.reduce(initialReduction, SearchQueryParameters::categorizeOption,
SearchQueryParameters::mergeMaps);
var paginationOptionCount = optionMap.get(AbstractPaginationOption.OPTION_TYPE).size();
if (paginationOptionCount > 1) {
throw SearchOptionResolverRuntimeException.becauseSearchQueryParamatersCanOnlyHaveOnePagingOptions();
}
var filters = new ArrayList<FilterOption<?>>();
optionMap.get(AbstractFilterOption.OPTION_TYPE)
.stream().map(searchOption -> (FilterOption<?>) searchOption)
.forEach(filters::add);
var sorts = optionMap.get(AbstractSortOption.OPTION_TYPE).stream()
.map(searchOption -> (SortOption) searchOption)
.collect(Collectors.toList());
PaginationOption<?> paginationOption;
if (paginationOptionCount == 0) {
paginationOption = SearchQueryParameters.DEFAULT_PAGINATION_OPTION;
} else {
paginationOption = (PaginationOption<?>) optionMap.get(AbstractPaginationOption.OPTION_TYPE).get(0);
}
return new SearchQueryParameters(
filters,
sorts,
paginationOption
);
}
public static SearchQueryParametersBuilder builder() {
return new SearchQueryParametersBuilder();
}
@NotNull
private static Map<String, List<SearchOption<?>>> categorizeOption(
Map<String, List<SearchOption<?>>> stringSearchOptionHashMap,
SearchOption<?> searchOption
) {
stringSearchOptionHashMap.get(searchOption.getOptionType()).add(searchOption);
return stringSearchOptionHashMap;
}
@NotNull
private static Map<String, List<SearchOption<?>>> mergeMaps(
Map<String, List<SearchOption<?>>> map1,
Map<String, List<SearchOption<?>>> map2
) {
map1.putAll(map2);
return map1;
}
public List<SortOption> getSortOptions() {
return sortOptions;
}
public List<FilterOption<?>> getFilterOptions() {
return filterOptions;
}
@Nullable
public PaginationOption<?> getPaginationOption() {
return paginationOption;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/SearchQueryParametersBuilder.java | package ai.stapi.graphoperations.graphLoader.search;
import ai.stapi.graphoperations.graphLoader.search.filterOption.FilterOption;
import ai.stapi.graphoperations.graphLoader.search.paginationOption.PaginationOption;
import ai.stapi.graphoperations.graphLoader.search.sortOption.SortOption;
import java.util.ArrayList;
import java.util.List;
public class SearchQueryParametersBuilder {
private final List<FilterOption<?>> filterOptions;
private final List<SortOption> sortOptions;
private PaginationOption<?> paginationOption;
public SearchQueryParametersBuilder() {
this.filterOptions = new ArrayList<>();
this.sortOptions = new ArrayList<>();
this.paginationOption = SearchQueryParameters.DEFAULT_PAGINATION_OPTION;
}
public SearchQueryParametersBuilder addFilterOption(FilterOption<?> filterOption) {
this.filterOptions.add(filterOption);
return this;
}
public SearchQueryParametersBuilder addFilterOptions(List<FilterOption<?>> filterOptions) {
filterOptions.forEach(this::addFilterOption);
return this;
}
public SearchQueryParametersBuilder addSortOption(SortOption sortOption) {
this.sortOptions.add(sortOption);
return this;
}
public SearchQueryParametersBuilder addSortOptions(List<SortOption> sortOptions) {
sortOptions.forEach(this::addSortOption);
return this;
}
public SearchQueryParametersBuilder setPaginationOption(PaginationOption<?> paginationOption) {
this.paginationOption = paginationOption;
return this;
}
public SearchQueryParameters build() {
return new SearchQueryParameters(filterOptions, sortOptions, paginationOption);
}
} |
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/SearchResolvingContext.java | package ai.stapi.graphoperations.graphLoader.search;
public interface SearchResolvingContext {
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/TraversableOption.java | package ai.stapi.graphoperations.graphLoader.search;
public enum TraversableOption {
INMEMORY_PRELOADED,
DATABASE
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/exceptions/CannotCreateFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.exceptions;
import ai.stapi.graphoperations.graphLoader.search.filterOption.FilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.FilterOptionParameters;
public class CannotCreateFilterOption extends RuntimeException {
private CannotCreateFilterOption(String becauseMessage) {
super("Cannot create FilterOption, " + becauseMessage);
}
public static CannotCreateFilterOption becauseInvalidLeafFilterStrategyProvided(
String filterStrategy) {
return new CannotCreateFilterOption(
"because invalid leaf filter strategy provided. " +
"Strategy: " + filterStrategy
);
}
public static CannotCreateFilterOption becauseInvalidListFilterStrategyProvided(
String filterStrategy) {
return new CannotCreateFilterOption(
"because invalid list filter strategy provided. " +
"Strategy: " + filterStrategy
);
}
public static CannotCreateFilterOption becauseInvalidLogicalFilterStrategyProvided(
String filterStrategy) {
return new CannotCreateFilterOption(
"because invalid logical filter strategy provided. " +
"Strategy: " + filterStrategy
);
}
public static CannotCreateFilterOption becauseInvalidFilterOptionParameters(
String filterStrategy,
FilterOptionParameters filterOptionParameters
) {
return new CannotCreateFilterOption(
"because invalid filter option parameters provided. " +
"\nParameters: " + filterOptionParameters.getClass().getSimpleName() +
"\nStrategy: " + filterStrategy
);
}
public static CannotCreateFilterOption becauseInvalidFilterOptionFoundWhenMakingCopy(
FilterOption<?> originalFilter) {
return new CannotCreateFilterOption(
"because invalid filter option found when making copy. " +
"\nFilter option: " + originalFilter.getClass().getSimpleName()
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/exceptions/SearchOptionNotSupportedByExactlyOneResolver.java | package ai.stapi.graphoperations.graphLoader.search.exceptions;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
public class SearchOptionNotSupportedByExactlyOneResolver extends RuntimeException {
public SearchOptionNotSupportedByExactlyOneResolver(int size, SearchOption<?> searchOption) {
super(
String.format(
"Search Option Of type: \"%s\" is supported by %d resolvers. But it should be exactly one.",
searchOption.getClass().getCanonicalName(),
size
)
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/exceptions/SearchOptionResolverRuntimeException.java | package ai.stapi.graphoperations.graphLoader.search.exceptions;
public class SearchOptionResolverRuntimeException extends RuntimeException {
private SearchOptionResolverRuntimeException(String becauseMessage) {
super("Search option resolver threw exception, " + becauseMessage);
}
public static SearchOptionResolverRuntimeException becauseSearchQueryParamatersCanOnlyHaveOnePagingOptions() {
return new SearchOptionResolverRuntimeException(
"because Search Query Paramaters Can Only Have One Paging Options"
);
}
public static SearchOptionResolverRuntimeException becauseGraphDescriptionInsideSortOptionMustBeSinglePath() {
return new SearchOptionResolverRuntimeException(
"because GraphDescription inside Sort Option must be single path."
);
}
public static SearchOptionResolverRuntimeException becauseGraphDescriptionInsideSortOptionMustEndWithValueDescription() {
return new SearchOptionResolverRuntimeException(
"because GraphDescription inside Sort Option must end with value description."
);
}
public static SearchOptionResolverRuntimeException becauseGraphDescriptionInsideOneValueFilterOptionMustBeSinglePath() {
return new SearchOptionResolverRuntimeException(
"because GraphDescription inside OneValueFilterOption must be single path."
);
}
public static SearchOptionResolverRuntimeException becauseGraphDescriptionInsideOneValueFilterOptionMustEndWithValueDescription() {
return new SearchOptionResolverRuntimeException(
"because GraphDescription inside OneValueFilterOption must end with value description."
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/exceptions/UnsupportedFilterOptionAttributeValueType.java | package ai.stapi.graphoperations.graphLoader.search.exceptions;
public class UnsupportedFilterOptionAttributeValueType extends RuntimeException {
public UnsupportedFilterOptionAttributeValueType(
Class<?> attributeValueType,
Class<?> optionClass
) {
super(
String.format(
"Attribute value of type: \"%s\" cannot be used in: \"%s\"",
attributeValueType.getCanonicalName(),
optionClass.getCanonicalName()
)
);
}
public UnsupportedFilterOptionAttributeValueType(
Class<?> optionClass
) {
super(
String.format(
"Null attribute value cannot be used in: \"%s\"",
optionClass.getCanonicalName()
)
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/AbstractCompositeFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import java.util.List;
public abstract class AbstractCompositeFilterOption
extends AbstractFilterOption<CompositeFilterParameters>
implements CompositeFilterOption {
protected AbstractCompositeFilterOption() {
}
public AbstractCompositeFilterOption(String operation, List<FilterOption<?>> childFilterOptions) {
super(operation, new CompositeFilterParameters(childFilterOptions));
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/AbstractCompositeFilterOptionResolver.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLoader.search.AbstractSearchOptionResolver;
import ai.stapi.graphoperations.graphLoader.search.GenericSearchOptionResolver;
import ai.stapi.graphoperations.graphLoader.search.ResolvedQueryPart;
import ai.stapi.graphoperations.graphLoader.search.SearchResolvingContext;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
public abstract class AbstractCompositeFilterOptionResolver<S extends CompositeFilterOption, C extends SearchResolvingContext, R extends ResolvedQueryPart>
extends AbstractSearchOptionResolver<S, C, R> {
private final GenericSearchOptionResolver<R> genericSearchOptionResolver;
protected AbstractCompositeFilterOptionResolver(
StructureSchemaFinder structureSchemaFinder,
GenericSearchOptionResolver<R> genericSearchOptionResolver
) {
super(structureSchemaFinder);
this.genericSearchOptionResolver = genericSearchOptionResolver;
}
protected abstract R reduceChildResolvedFilters(R reduced, R childResolvedFilter);
protected abstract SearchResolvingContext createCompositeChildContext(C parentContext);
protected abstract SearchResolvingContext createLeafChildContext(C parentContext,
Integer leafIndex);
protected R postProcessResolvedFilter(R resolvedFilter, C context) {
return resolvedFilter;
}
@Override
protected R resolveTyped(S option, C context) {
var leafOptionCounter = 0;
var childOptions = option.getParameters().getChildFilterOptions();
R reducedResolvedFilter;
if (childOptions.get(0) instanceof CompositeFilterOption) {
reducedResolvedFilter = this.genericSearchOptionResolver.resolve(
childOptions.get(0),
this.createCompositeChildContext(context)
);
} else {
reducedResolvedFilter = this.genericSearchOptionResolver.resolve(
childOptions.get(0),
this.createLeafChildContext(context, leafOptionCounter)
);
leafOptionCounter++;
}
for (var childOption : childOptions.subList(1, childOptions.size())) {
R childResolvedFilter;
if (childOption instanceof CompositeFilterOption) {
childResolvedFilter = this.genericSearchOptionResolver.resolve(
childOption,
this.createCompositeChildContext(context)
);
} else {
childResolvedFilter = this.genericSearchOptionResolver.resolve(
childOption,
this.createLeafChildContext(context, leafOptionCounter)
);
leafOptionCounter++;
}
reducedResolvedFilter =
this.reduceChildResolvedFilters(reducedResolvedFilter, childResolvedFilter);
}
return this.postProcessResolvedFilter(reducedResolvedFilter, context);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/AbstractFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLoader.search.AbstractSearchOption;
public abstract class AbstractFilterOption<ParametersType>
extends AbstractSearchOption<ParametersType> {
public static final String OPTION_TYPE = "filter";
protected AbstractFilterOption() {
}
public AbstractFilterOption(String strategy, ParametersType parameters) {
super(AbstractFilterOption.OPTION_TYPE, strategy, parameters);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/AbstractLeafFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
public abstract class AbstractLeafFilterOption<ParametersType extends LeafFilterOptionParameters>
extends AbstractFilterOption<ParametersType>
implements LeafFilterOption<ParametersType> {
protected AbstractLeafFilterOption() {
}
protected AbstractLeafFilterOption(String strategy, ParametersType parameters) {
super(strategy, parameters);
}
@Override
public boolean isLeaf() {
return this.getParameters().isLeaf();
}
@Override
public boolean isDescribingAttribute() {
return this.getParameters().isDescribingAttribute();
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/AbstractLeafFilterOptionParameters.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractAttributeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AttributeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.AttributeQueryDescription;
public class AbstractLeafFilterOptionParameters implements LeafFilterOptionParameters {
private final PositiveGraphDescription attributeNamePath;
public AbstractLeafFilterOptionParameters(PositiveGraphDescription attributeNamePath) {
this.attributeNamePath = attributeNamePath;
}
public AbstractLeafFilterOptionParameters(String attributeName) {
this.attributeNamePath = new AttributeQueryDescription(attributeName);
}
@Override
public PositiveGraphDescription getAttributeNamePath() {
return this.attributeNamePath;
}
@Override
public boolean isLeaf() {
return this.getAttributeNamePath() instanceof UuidIdentityDescription
|| this.getAttributeNamePath() instanceof AbstractAttributeDescription;
}
@Override
public boolean isDescribingAttribute() {
var lastGraphDescription = this.getLastGraphDescription();
return lastGraphDescription instanceof AbstractAttributeDescription;
}
@Override
public String getAttributeName() {
var lastGraphDescription = this.getLastGraphDescription();
var last = (AttributeDescriptionParameters) lastGraphDescription.getParameters();
return last.getAttributeName();
}
private GraphDescription getLastGraphDescription() {
var flat = GraphDescriptionBuilder
.getGraphDescriptionAsStream(this.getAttributeNamePath())
.toList();
return flat.get(flat.size() - 1);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/AbstractOneValueFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graph.attribute.attributeValue.AttributeValue;
import ai.stapi.graph.attribute.attributeValue.BooleanAttributeValue;
import ai.stapi.graph.attribute.attributeValue.DecimalAttributeValue;
import ai.stapi.graph.attribute.attributeValue.IntegerAttributeValue;
import ai.stapi.graph.attribute.attributeValue.StringAttributeValue;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphLoader.search.exceptions.UnsupportedFilterOptionAttributeValueType;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
public abstract class AbstractOneValueFilterOption<ValueType>
extends AbstractLeafFilterOption<OneValueFilterOptionParameters<ValueType>> {
protected AbstractOneValueFilterOption() {
}
protected AbstractOneValueFilterOption(
String operation,
String attributeName,
ValueType attributeValue
) {
super(operation, new OneValueFilterOptionParameters<>(attributeName, attributeValue));
this.ensureValidAttributeValueType(attributeValue);
}
protected AbstractOneValueFilterOption(
String strategy,
PositiveGraphDescription attributePathName,
ValueType attributeValue
) {
super(strategy, new OneValueFilterOptionParameters<>(attributePathName, attributeValue));
this.ensureValidAttributeValueType(attributeValue);
}
protected abstract List<Class<?>> setAllowedValueTypes();
public boolean hasListValue() {
return this.getParameters().getAttributeValue() instanceof List<?>;
}
public boolean hasSetValue() {
return this.getParameters().getAttributeValue() instanceof Set<?>;
}
public List<AttributeValue<?>> getValueAsListAttributeValue() {
if (!this.hasListValue()) {
throw new RuntimeException("Cannot provide value as list attribute value.");
}
var listValue = (List<?>) this.getParameters().getAttributeValue();
return listValue.stream().map(this::convertToAttributeValue).collect(Collectors.toList());
}
public Set<AttributeValue<?>> getValueAsSetAttributeValue() {
if (!this.hasSetValue()) {
throw new RuntimeException("Cannot provide value as set attribute value.");
}
var setValue = (Set<?>) this.getParameters().getAttributeValue();
return setValue.stream().map(this::convertToAttributeValue).collect(Collectors.toSet());
}
public AttributeValue<?> getValueAsAttributeValue() {
if (this.hasSetValue() || this.hasListValue()) {
throw new RuntimeException("Cannot provide value as single attribute value.");
}
return this.convertToAttributeValue(this.getParameters().getAttributeValue());
}
private void ensureValidAttributeValueType(ValueType value) {
if (value == null) {
throw new UnsupportedFilterOptionAttributeValueType(this.getClass());
}
if (!this.setAllowedValueTypes().contains(value.getClass())) {
throw new UnsupportedFilterOptionAttributeValueType(value.getClass(), this.getClass());
}
}
private AttributeValue<?> convertToAttributeValue(Object value) {
if (value instanceof String string) {
return new StringAttributeValue(string);
}
if (value instanceof Double doubleValue) {
return new DecimalAttributeValue(doubleValue);
}
if (value instanceof Float floatValue) {
return new DecimalAttributeValue(floatValue.doubleValue());
}
if (value instanceof Integer integerValue) {
return new IntegerAttributeValue(integerValue);
}
if (value instanceof Boolean booleanValue) {
return new BooleanAttributeValue(booleanValue);
}
throw new RuntimeException(
String.format(
"Cannot convert to attribute value, because unknown value type encountered.%nActual type: %s",
value.getClass().getSimpleName()
)
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/AllMatchFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import java.util.ArrayList;
import java.util.List;
public class AllMatchFilterOption extends AbstractCompositeFilterOption {
public static final String STRATEGY = "all_match";
private AllMatchFilterOption() {
}
public AllMatchFilterOption(AbstractOneValueFilterOption<?> childFilterOption) {
super(AllMatchFilterOption.STRATEGY, new ArrayList<>(List.of(childFilterOption)));
}
public AbstractOneValueFilterOption<?> getChildFilterOption() {
return (AbstractOneValueFilterOption<?>) this.getParameters().getChildFilterOptions().get(0);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/AndFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class AndFilterOption extends AbstractCompositeFilterOption {
public static final String STRATEGY = "and";
private AndFilterOption() {
}
public AndFilterOption(FilterOption<?>... childFilterOptions) {
this(Arrays.stream(childFilterOptions).collect(Collectors.toList()));
}
public AndFilterOption(List<FilterOption<?>> childFilterOptions) {
super(AndFilterOption.STRATEGY, childFilterOptions);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/AnyMatchFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import java.util.ArrayList;
import java.util.List;
public class AnyMatchFilterOption extends AbstractCompositeFilterOption {
public static final String STRATEGY = "any_match";
private AnyMatchFilterOption() {
}
public AnyMatchFilterOption(AbstractOneValueFilterOption<?> childFilterOption) {
super(AnyMatchFilterOption.STRATEGY, new ArrayList<>(List.of(childFilterOption)));
}
public AbstractOneValueFilterOption<?> getChildFilterOption() {
return (AbstractOneValueFilterOption<?>) this.getParameters().getChildFilterOptions().get(0);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/CompositeFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
public interface CompositeFilterOption extends FilterOption<CompositeFilterParameters> {
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/CompositeFilterParameters.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import java.util.ArrayList;
import java.util.List;
public class CompositeFilterParameters implements FilterOptionParameters {
private final List<FilterOption<?>> childFilterOptions;
private CompositeFilterParameters() {
this.childFilterOptions = new ArrayList<>();
}
public CompositeFilterParameters(List<FilterOption<?>> childFilterOptions) {
this.childFilterOptions = childFilterOptions;
}
public List<FilterOption<?>> getChildFilterOptions() {
return childFilterOptions;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/ContainsFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import java.util.List;
public class ContainsFilterOption extends AbstractOneValueFilterOption<String> {
public static final String STRATEGY = "contains";
private ContainsFilterOption() {
}
public ContainsFilterOption(String attributeName, String attributeValue) {
super(ContainsFilterOption.STRATEGY, attributeName, attributeValue);
}
public ContainsFilterOption(PositiveGraphDescription attributePathName, String attributeValue) {
super(ContainsFilterOption.STRATEGY, attributePathName, attributeValue);
}
@Override
protected List<Class<?>> setAllowedValueTypes() {
return List.of(String.class);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/EndsWithFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import java.util.List;
public class EndsWithFilterOption extends AbstractOneValueFilterOption<String> {
public static final String STRATEGY = "ends_with";
private EndsWithFilterOption() {
}
public EndsWithFilterOption(String attributeName, String attributeValue) {
super(EndsWithFilterOption.STRATEGY, attributeName, attributeValue);
}
public EndsWithFilterOption(PositiveGraphDescription attributePathName, String attributeValue) {
super(EndsWithFilterOption.STRATEGY, attributePathName, attributeValue);
}
@Override
protected List<Class<?>> setAllowedValueTypes() {
return List.of(String.class);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/EqualsFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import java.util.List;
import java.util.Set;
public class EqualsFilterOption<ValueType> extends AbstractOneValueFilterOption<ValueType> {
public static final String STRATEGY = "equals";
private EqualsFilterOption() {
}
public EqualsFilterOption(String attributeName, ValueType attributeValue) {
super(EqualsFilterOption.STRATEGY, attributeName, attributeValue);
}
public EqualsFilterOption(PositiveGraphDescription attributePathName, ValueType attributeValue) {
super(EqualsFilterOption.STRATEGY, attributePathName, attributeValue);
}
@Override
protected List<Class<?>> setAllowedValueTypes() {
return List.of(
String.class,
Boolean.class,
Integer.class,
Double.class,
Float.class,
List.class,
Set.class
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/FilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXISTING_PROPERTY, property = "strategy")
@JsonSubTypes({
@JsonSubTypes.Type(value = EqualsFilterOption.class, name = EqualsFilterOption.STRATEGY),
@JsonSubTypes.Type(value = ContainsFilterOption.class, name = ContainsFilterOption.STRATEGY),
@JsonSubTypes.Type(value = GreaterThanFilterOption.class, name = GreaterThanFilterOption.STRATEGY),
@JsonSubTypes.Type(value = AnyMatchFilterOption.class, name = AnyMatchFilterOption.STRATEGY),
@JsonSubTypes.Type(value = AndFilterOption.class, name = AndFilterOption.STRATEGY),
@JsonSubTypes.Type(value = OrFilterOption.class, name = OrFilterOption.STRATEGY),
@JsonSubTypes.Type(value = NotFilterOption.class, name = NotFilterOption.STRATEGY),
})
public interface FilterOption<ParametersType> extends SearchOption<ParametersType> {
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/FilterOptionParameters.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
public interface FilterOptionParameters {
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/GreaterThanFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import java.util.List;
public class GreaterThanFilterOption<ValueType> extends AbstractOneValueFilterOption<ValueType> {
public static final String STRATEGY = "greater_than";
private GreaterThanFilterOption() {
}
public GreaterThanFilterOption(String attributeName, ValueType attributeValue) {
super(GreaterThanFilterOption.STRATEGY, attributeName, attributeValue);
}
public GreaterThanFilterOption(PositiveGraphDescription attributePathName,
ValueType attributeValue) {
super(GreaterThanFilterOption.STRATEGY, attributePathName, attributeValue);
}
@Override
protected List<Class<?>> setAllowedValueTypes() {
return List.of(Integer.class, Double.class, Float.class);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/GreaterThanOrEqualFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import java.util.List;
public class GreaterThanOrEqualFilterOption<ValueType>
extends AbstractOneValueFilterOption<ValueType> {
public static final String STRATEGY = "greater_than_or_equals";
private GreaterThanOrEqualFilterOption() {
}
public GreaterThanOrEqualFilterOption(String attributeName, ValueType attributeValue) {
super(GreaterThanOrEqualFilterOption.STRATEGY, attributeName, attributeValue);
}
public GreaterThanOrEqualFilterOption(PositiveGraphDescription attributePathName,
ValueType attributeValue) {
super(GreaterThanOrEqualFilterOption.STRATEGY, attributePathName, attributeValue);
}
@Override
protected List<Class<?>> setAllowedValueTypes() {
return List.of(Integer.class, Double.class, Float.class);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/IsNullFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
public class IsNullFilterOption extends AbstractLeafFilterOption<NoValueFilterOptionParameters> {
public static final String STRATEGY = "is_null";
private IsNullFilterOption() {
}
public IsNullFilterOption(String attributeName) {
super(IsNullFilterOption.STRATEGY, new NoValueFilterOptionParameters(attributeName));
}
public IsNullFilterOption(PositiveGraphDescription attributePathName) {
super(IsNullFilterOption.STRATEGY, new NoValueFilterOptionParameters(attributePathName));
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/LeafFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
public interface LeafFilterOption<ParametersType extends LeafFilterOptionParameters>
extends FilterOption<ParametersType> {
boolean isLeaf();
boolean isDescribingAttribute();
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/LeafFilterOptionParameters.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
public interface LeafFilterOptionParameters extends FilterOptionParameters {
PositiveGraphDescription getAttributeNamePath();
boolean isLeaf();
boolean isDescribingAttribute();
String getAttributeName();
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/LowerThanFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import java.util.List;
public class LowerThanFilterOption<ValueType> extends AbstractOneValueFilterOption<ValueType> {
public static final String STRATEGY = "lower_than";
private LowerThanFilterOption() {
}
public LowerThanFilterOption(String attributeName, ValueType attributeValue) {
super(LowerThanFilterOption.STRATEGY, attributeName, attributeValue);
}
public LowerThanFilterOption(PositiveGraphDescription attributePathName,
ValueType attributeValue) {
super(LowerThanFilterOption.STRATEGY, attributePathName, attributeValue);
}
@Override
protected List<Class<?>> setAllowedValueTypes() {
return List.of(Integer.class, Double.class, Float.class);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/LowerThanOrEqualsFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import java.util.List;
public class LowerThanOrEqualsFilterOption<ValueType>
extends AbstractOneValueFilterOption<ValueType> {
public static final String STRATEGY = "lower_than_or_equals";
private LowerThanOrEqualsFilterOption() {
}
public LowerThanOrEqualsFilterOption(String attributeName, ValueType attributeValue) {
super(LowerThanOrEqualsFilterOption.STRATEGY, attributeName, attributeValue);
}
public LowerThanOrEqualsFilterOption(PositiveGraphDescription attributePathName,
ValueType attributeValue) {
super(LowerThanOrEqualsFilterOption.STRATEGY, attributePathName, attributeValue);
}
@Override
protected List<Class<?>> setAllowedValueTypes() {
return List.of(Integer.class, Double.class, Float.class);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/NoValueFilterOptionParameters.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
public class NoValueFilterOptionParameters extends AbstractLeafFilterOptionParameters {
public NoValueFilterOptionParameters(PositiveGraphDescription attributeNamePath) {
super(attributeNamePath);
}
public NoValueFilterOptionParameters(String attributeName) {
super(attributeName);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/NoneMatchFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import java.util.ArrayList;
import java.util.List;
public class NoneMatchFilterOption extends AbstractCompositeFilterOption {
public static final String STRATEGY = "none_match";
private NoneMatchFilterOption() {
}
public NoneMatchFilterOption(AbstractOneValueFilterOption<?> childFilterOption) {
super(NoneMatchFilterOption.STRATEGY, new ArrayList<>(List.of(childFilterOption)));
}
public AbstractOneValueFilterOption<?> getChildFilterOption() {
return (AbstractOneValueFilterOption<?>) this.getParameters().getChildFilterOptions().get(0);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/NotEqualsFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import java.util.List;
import java.util.Set;
public class NotEqualsFilterOption<ValueType> extends AbstractOneValueFilterOption<ValueType> {
public static final String STRATEGY = "not_equals";
private NotEqualsFilterOption() {
}
public NotEqualsFilterOption(String attributeName, ValueType attributeValue) {
super(NotEqualsFilterOption.STRATEGY, attributeName, attributeValue);
}
public NotEqualsFilterOption(
PositiveGraphDescription attributePathName,
ValueType attributeValue
) {
super(NotEqualsFilterOption.STRATEGY, attributePathName, attributeValue);
}
@Override
protected List<Class<?>> setAllowedValueTypes() {
return List.of(
String.class, Boolean.class, Integer.class, Double.class, Float.class, List.class, Set.class);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/NotFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import java.util.ArrayList;
import java.util.List;
public class NotFilterOption extends AbstractCompositeFilterOption {
public static final String STRATEGY = "not";
private NotFilterOption() {
}
public NotFilterOption(FilterOption<?> childFilterOption) {
super(NotFilterOption.STRATEGY, new ArrayList<>(List.of(childFilterOption)));
}
public FilterOption<?> getChildFilterOption() {
return this.getParameters().getChildFilterOptions().get(0);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/NotNullFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
public class NotNullFilterOption extends AbstractLeafFilterOption<NoValueFilterOptionParameters> {
public static final String STRATEGY = "not_null";
private NotNullFilterOption() {
}
public NotNullFilterOption(String attributeName) {
super(NotNullFilterOption.STRATEGY, new NoValueFilterOptionParameters(attributeName));
}
public NotNullFilterOption(
PositiveGraphDescription attributePathName
) {
super(NotNullFilterOption.STRATEGY, new NoValueFilterOptionParameters(attributePathName));
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/OneValueFilterOptionParameters.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.AttributeQueryDescription;
import ai.stapi.graphoperations.graphLoader.search.exceptions.SearchOptionResolverRuntimeException;
public class OneValueFilterOptionParameters<ValueType> extends AbstractLeafFilterOptionParameters {
private final ValueType attributeValue;
public OneValueFilterOptionParameters(
PositiveGraphDescription attributeNamePath,
ValueType attributeValue
) {
super(attributeNamePath);
this.attributeValue = attributeValue;
if (!GraphDescriptionBuilder.isGraphDescriptionSinglePath(attributeNamePath)) {
throw SearchOptionResolverRuntimeException.becauseGraphDescriptionInsideOneValueFilterOptionMustBeSinglePath();
}
if (!GraphDescriptionBuilder.isGraphDescriptionEndingWithAttributeOrUuidDescription(attributeNamePath)) {
throw SearchOptionResolverRuntimeException.becauseGraphDescriptionInsideOneValueFilterOptionMustEndWithValueDescription();
}
}
public OneValueFilterOptionParameters(String attributeName, ValueType attributeValue) {
this(new AttributeQueryDescription(attributeName), attributeValue);
}
public ValueType getAttributeValue() {
return attributeValue;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/OrFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class OrFilterOption extends AbstractCompositeFilterOption {
public static final String STRATEGY = "or";
private OrFilterOption() {
}
public OrFilterOption(FilterOption<?>... filterOptions) {
this(Arrays.stream(filterOptions).collect(Collectors.toList()));
}
public OrFilterOption(List<FilterOption<?>> childFilterOptions) {
super(OrFilterOption.STRATEGY, childFilterOptions);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/StartsWithFilterOption.java | package ai.stapi.graphoperations.graphLoader.search.filterOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import java.util.List;
public class StartsWithFilterOption extends AbstractOneValueFilterOption<String> {
public static final String STRATEGY = "starts_with";
private StartsWithFilterOption() {
}
public StartsWithFilterOption(String attributeName, String attributeValue) {
super(StartsWithFilterOption.STRATEGY, attributeName, attributeValue);
}
public StartsWithFilterOption(PositiveGraphDescription attributePathName, String attributeValue) {
super(StartsWithFilterOption.STRATEGY, attributePathName, attributeValue);
}
@Override
protected List<Class<?>> setAllowedValueTypes() {
return List.of(String.class);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/filterOption/factory/FilterOptionFactory.java | package ai.stapi.graphoperations.graphLoader.search.filterOption.factory;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.AttributeQueryDescription;
import ai.stapi.graphoperations.graphLoader.search.exceptions.CannotCreateFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AbstractOneValueFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AllMatchFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AndFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AnyMatchFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.CompositeFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.CompositeFilterParameters;
import ai.stapi.graphoperations.graphLoader.search.filterOption.ContainsFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.EndsWithFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.EqualsFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.FilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.FilterOptionParameters;
import ai.stapi.graphoperations.graphLoader.search.filterOption.GreaterThanFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.GreaterThanOrEqualFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.LowerThanFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.LowerThanOrEqualsFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.NoneMatchFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.NotEqualsFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.NotFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.OneValueFilterOptionParameters;
import ai.stapi.graphoperations.graphLoader.search.filterOption.OrFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.StartsWithFilterOption;
import java.util.ArrayList;
import java.util.List;
public class FilterOptionFactory {
public FilterOption<?> create(
String filterStrategy,
FilterOptionParameters filterOptionParameters
) {
if (filterOptionParameters instanceof OneValueFilterOptionParameters<?> oneValueFilterOptionParameters) {
return this.createLeaf(
filterStrategy,
oneValueFilterOptionParameters.getAttributeNamePath(),
oneValueFilterOptionParameters.getAttributeValue()
);
}
if (filterOptionParameters instanceof CompositeFilterParameters compositeFilterParameters) {
return this.createComposite(
filterStrategy,
compositeFilterParameters.getChildFilterOptions()
);
}
throw CannotCreateFilterOption.becauseInvalidFilterOptionParameters(filterStrategy,
filterOptionParameters);
}
public AbstractOneValueFilterOption<?> createLeaf(
String filterStrategy,
PositiveGraphDescription attributeNamePath,
Object attributeValue
) {
if (filterStrategy.equals(ContainsFilterOption.STRATEGY)) {
return new ContainsFilterOption(attributeNamePath, (String) attributeValue);
}
if (filterStrategy.equals(EndsWithFilterOption.STRATEGY)) {
return new EndsWithFilterOption(attributeNamePath, (String) attributeValue);
}
if (filterStrategy.equals(EqualsFilterOption.STRATEGY)) {
return new EqualsFilterOption<>(attributeNamePath, attributeValue);
}
if (filterStrategy.equals(GreaterThanFilterOption.STRATEGY)) {
return new GreaterThanFilterOption<>(attributeNamePath, attributeValue);
}
if (filterStrategy.equals(GreaterThanOrEqualFilterOption.STRATEGY)) {
return new GreaterThanOrEqualFilterOption<>(attributeNamePath, attributeValue);
}
if (filterStrategy.equals(LowerThanFilterOption.STRATEGY)) {
return new LowerThanFilterOption<>(attributeNamePath, attributeValue);
}
if (filterStrategy.equals(LowerThanOrEqualsFilterOption.STRATEGY)) {
return new LowerThanOrEqualsFilterOption<>(attributeNamePath, attributeValue);
}
if (filterStrategy.equals(NotEqualsFilterOption.STRATEGY)) {
return new NotEqualsFilterOption<>(attributeNamePath, attributeValue);
}
if (filterStrategy.equals(StartsWithFilterOption.STRATEGY)) {
return new StartsWithFilterOption(attributeNamePath, (String) attributeValue);
}
throw CannotCreateFilterOption.becauseInvalidLeafFilterStrategyProvided(filterStrategy);
}
public AbstractOneValueFilterOption<?> createLeaf(
String filterStrategy,
String attributeName,
Object attributeValue
) {
return this.createLeaf(
filterStrategy,
new AttributeQueryDescription(attributeName),
attributeValue
);
}
public FilterOption<?> createComposite(
String filterStrategy,
List<FilterOption<?>> childFilterOption
) {
try {
return this.createList(filterStrategy, (AbstractOneValueFilterOption<?>) childFilterOption.get(0));
} catch (CannotCreateFilterOption ignored) {
//ignore exception
}
return this.createLogical(filterStrategy, childFilterOption);
}
public FilterOption<?> createList(
String filterStrategy,
AbstractOneValueFilterOption<?> childFilterOption
) {
if (filterStrategy.equals(AllMatchFilterOption.STRATEGY)) {
return new AllMatchFilterOption(childFilterOption);
}
if (filterStrategy.equals(AnyMatchFilterOption.STRATEGY)) {
return new AnyMatchFilterOption(childFilterOption);
}
if (filterStrategy.equals(NoneMatchFilterOption.STRATEGY)) {
return new NoneMatchFilterOption(childFilterOption);
}
throw CannotCreateFilterOption.becauseInvalidListFilterStrategyProvided(filterStrategy);
}
public FilterOption<?> createLogical(
String filterStrategy,
List<FilterOption<?>> childFilterOption
) {
if (filterStrategy.equals(AndFilterOption.STRATEGY)) {
return new AndFilterOption(childFilterOption);
}
if (filterStrategy.equals(OrFilterOption.STRATEGY)) {
return new OrFilterOption(childFilterOption);
}
if (filterStrategy.equals(NotFilterOption.STRATEGY)) {
return new NotFilterOption(childFilterOption.get(0));
}
throw CannotCreateFilterOption.becauseInvalidLogicalFilterStrategyProvided(filterStrategy);
}
public FilterOption<?> copyWithNewAttributeNamePath(
FilterOption<?> originalFilter,
PositiveGraphDescription attributeNamePath
) {
if (originalFilter instanceof CompositeFilterOption compositeFilterOption) {
var newChildren = new ArrayList<FilterOption<?>>();
compositeFilterOption.getParameters().getChildFilterOptions()
.stream()
.map(child -> this.copyWithNewAttributeNamePath(child, attributeNamePath))
.forEach(newChildren::add);
return this.createComposite(
compositeFilterOption.getStrategy(),
newChildren
);
}
if (originalFilter instanceof AbstractOneValueFilterOption<?> oneValueFilterOption) {
return this.createLeaf(
oneValueFilterOption.getStrategy(),
attributeNamePath,
oneValueFilterOption.getParameters().getAttributeValue()
);
}
throw CannotCreateFilterOption.becauseInvalidFilterOptionFoundWhenMakingCopy(originalFilter);
}
public PositiveGraphDescription getAttributeNamePath(
FilterOption<?> filterOption
) {
if (filterOption instanceof CompositeFilterOption compositeFilterOption) {
return this.getAttributeNamePath(
compositeFilterOption.getParameters().getChildFilterOptions().get(0)
);
}
if (filterOption instanceof AbstractOneValueFilterOption<?> oneValueFilterOption) {
return oneValueFilterOption.getParameters().getAttributeNamePath();
}
return new NullGraphDescription();
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/paginationOption/AbstractPaginationOption.java | package ai.stapi.graphoperations.graphLoader.search.paginationOption;
import ai.stapi.graphoperations.graphLoader.search.AbstractSearchOption;
public abstract class AbstractPaginationOption<ParametersType>
extends AbstractSearchOption<ParametersType> implements PaginationOption<ParametersType> {
public static final String OPTION_TYPE = "paging";
protected AbstractPaginationOption() {
}
public AbstractPaginationOption(String strategy, ParametersType parameters) {
super(AbstractPaginationOption.OPTION_TYPE, strategy, parameters);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/paginationOption/OffsetPaginationOption.java | package ai.stapi.graphoperations.graphLoader.search.paginationOption;
public class OffsetPaginationOption extends AbstractPaginationOption<OffsetPaginationParameters> {
public static final String STRATEGY = "offset";
private OffsetPaginationOption() {
}
public OffsetPaginationOption(Integer offset, Integer limit) {
super(OffsetPaginationOption.STRATEGY, new OffsetPaginationParameters(offset, limit));
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/paginationOption/OffsetPaginationParameters.java | package ai.stapi.graphoperations.graphLoader.search.paginationOption;
public class OffsetPaginationParameters {
private Integer offset;
private Integer limit;
protected OffsetPaginationParameters() {
}
public OffsetPaginationParameters(Integer offset, Integer limit) {
this.offset = offset;
this.limit = limit;
}
public Integer getOffset() {
return offset;
}
public Integer getLimit() {
return limit;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/paginationOption/PaginationOption.java | package ai.stapi.graphoperations.graphLoader.search.paginationOption;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXISTING_PROPERTY, property = "strategy")
@JsonSubTypes({
@JsonSubTypes.Type(value = OffsetPaginationOption.class, name = OffsetPaginationOption.STRATEGY)
})
public interface PaginationOption<ParameterType> extends SearchOption<ParameterType> {
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/sortOption/AbstractSortOption.java | package ai.stapi.graphoperations.graphLoader.search.sortOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractAttributeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AttributeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.AttributeQueryDescription;
import ai.stapi.graphoperations.graphLoader.search.AbstractSearchOption;
import ai.stapi.graphoperations.graphLoader.search.exceptions.SearchOptionResolverRuntimeException;
public abstract class AbstractSortOption extends AbstractSearchOption<PositiveGraphDescription>
implements SortOption {
public static final String OPTION_TYPE = "sort";
protected AbstractSortOption() {
}
protected AbstractSortOption(String strategy, String attributeName) {
super(
AbstractSortOption.OPTION_TYPE,
strategy,
new AttributeQueryDescription(attributeName)
);
}
protected AbstractSortOption(String strategy, PositiveGraphDescription attributeNamePath) {
super(
AbstractSortOption.OPTION_TYPE,
strategy,
attributeNamePath
);
if (!GraphDescriptionBuilder.isGraphDescriptionSinglePath(attributeNamePath)) {
throw SearchOptionResolverRuntimeException.becauseGraphDescriptionInsideSortOptionMustBeSinglePath();
}
if (!GraphDescriptionBuilder.isGraphDescriptionEndingWithAttributeDescription(attributeNamePath)) {
throw SearchOptionResolverRuntimeException.becauseGraphDescriptionInsideSortOptionMustEndWithValueDescription();
}
}
public boolean isLeaf() {
return this.getParameters() instanceof AbstractAttributeDescription;
}
public String getAttributeName() {
var flat = GraphDescriptionBuilder.getGraphDescriptionAsStream(this.getParameters()).toList();
var last = (AttributeDescriptionParameters) flat.get(flat.size() - 1).getParameters();
return last.getAttributeName();
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/sortOption/AscendingSortOption.java | package ai.stapi.graphoperations.graphLoader.search.sortOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
public class AscendingSortOption extends AbstractSortOption {
public static final String STRATEGY = "ascending";
private AscendingSortOption() {
}
public AscendingSortOption(String attributeName) {
super(AscendingSortOption.STRATEGY, attributeName);
}
public AscendingSortOption(PositiveGraphDescription attributeNamePath) {
super(AscendingSortOption.STRATEGY, attributeNamePath);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/sortOption/DescendingSortOption.java | package ai.stapi.graphoperations.graphLoader.search.sortOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
public class DescendingSortOption extends AbstractSortOption {
public static final String STRATEGY = "descending";
private DescendingSortOption() {
}
public DescendingSortOption(String attributeName) {
super(DescendingSortOption.STRATEGY, attributeName);
}
public DescendingSortOption(PositiveGraphDescription attributeNamePath) {
super(DescendingSortOption.STRATEGY, attributeNamePath);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphLoader/search/sortOption/SortOption.java | package ai.stapi.graphoperations.graphLoader.search.sortOption;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXISTING_PROPERTY, property = "strategy")
@JsonSubTypes({
@JsonSubTypes.Type(value = AscendingSortOption.class, name = AscendingSortOption.STRATEGY),
@JsonSubTypes.Type(value = DescendingSortOption.class, name = DescendingSortOption.STRATEGY)
})
public interface SortOption extends SearchOption<PositiveGraphDescription> {
}
|
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/graphReader/AvailableMappingGraphElements.java | package ai.stapi.graphoperations.graphReader;
public class AvailableMappingGraphElements {
public static final String NODE = "node";
public static final String EDGE = "edge";
public static final String ATTRIBUTE = "attribute";
public static final String NOTHING = "nothing";
public static final String VALUE = "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/graphReader/GraphReader.java | package ai.stapi.graphoperations.graphReader;
import ai.stapi.graph.Graph;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graphoperations.graphLanguage.GraphBaseTypes;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.EdgeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.removal.RemovalGraphDescription;
import ai.stapi.graphoperations.graphReader.exception.GraphReaderException;
import ai.stapi.graphoperations.graphReader.mappingPartReadResolvers.GraphDescriptionReadResolver;
import ai.stapi.graphoperations.graphReader.readResults.EdgeReadResult;
import ai.stapi.graphoperations.graphReader.readResults.NodeReadResult;
import ai.stapi.graphoperations.graphReader.readResults.ReadResult;
import ai.stapi.graphoperations.graphReader.readResults.ValueReadResult;
import ai.stapi.identity.UniqueIdentifier;
import java.util.ArrayList;
import java.util.List;
import org.jetbrains.annotations.NotNull;
public class GraphReader {
private final List<GraphDescriptionReadResolver> graphDescriptionResolvers;
public GraphReader(List<GraphDescriptionReadResolver> graphDescriptionResolvers) {
this.graphDescriptionResolvers = graphDescriptionResolvers;
}
public List<ReadResult> read(
UniqueIdentifier startElementId,
PositiveGraphDescription graphDescription,
InMemoryGraphRepository contextualGraph
) {
if (graphDescription.getChildGraphDescriptions().size() > 1) {
throw GraphReaderException.becauseGraphDescriptionHasMultipleChildren(graphDescription);
}
this.ensureGraphDescriptionContainsOnlyUpsertDescriptions(graphDescription);
var firstReadResult = this.createFirstReadResult(
startElementId,
graphDescription,
contextualGraph
);
if (graphDescription.getChildGraphDescriptions().size() == 0) {
return firstReadResult;
}
return resolveRestOfTheGraphDescriptions(
firstReadResult,
graphDescription,
contextualGraph
);
}
public List<ReadResult> readFromUncertainFirstElement(
UniqueIdentifier startElementId,
String startElementType,
PositiveGraphDescription graphDescriptionForNextElement,
InMemoryGraphRepository contextualGraph
) {
if (graphDescriptionForNextElement.getChildGraphDescriptions().size() > 1) {
throw GraphReaderException.becauseGraphDescriptionHasMultipleChildren(
graphDescriptionForNextElement);
}
this.ensureGraphDescriptionContainsOnlyUpsertDescriptions(graphDescriptionForNextElement);
var firstReadResult = this.guessFirstReadResult(
startElementId,
startElementType,
contextualGraph
);
return this.resolveAllOfTheGraphDescriptions(
firstReadResult,
graphDescriptionForNextElement,
contextualGraph
);
}
public List<ReadResult> read(
UniqueIdentifier startElementId,
PositiveGraphDescription firstElementDescription,
PositiveGraphDescription graphDescription,
Graph contextualGraph
) {
if (graphDescription.getChildGraphDescriptions().size() > 1) {
throw GraphReaderException.becauseGraphDescriptionHasMultipleChildren(graphDescription);
}
this.ensureGraphDescriptionContainsOnlyUpsertDescriptions(graphDescription);
InMemoryGraphRepository traversable = contextualGraph.traversable();
var firstReadResult = this.createFirstReadResult(
startElementId,
firstElementDescription,
traversable
);
if (graphDescription.getChildGraphDescriptions().size() == 0) {
return firstReadResult;
}
return resolveRestOfTheGraphDescriptions(
firstReadResult,
graphDescription,
traversable
);
}
public <T> List<T> readValues(
UniqueIdentifier startElementId,
PositiveGraphDescription graphDescription,
InMemoryGraphRepository contextualGraph
) {
var results = this.read(startElementId, graphDescription, contextualGraph);
if (results.size() == 0) {
return (List<T>) results;
}
if (!(results.get(0) instanceof ValueReadResult)) {
throw GraphReaderException.becauseLastReadResultsAreNotValues(results.get(0));
}
return results.stream()
.map(ValueReadResult.class::cast)
.map(result -> (T) result.getValue())
.toList();
}
public <T> List<T> readValuesFromUncertainFirstElement(
UniqueIdentifier startElementId,
String startElementType,
PositiveGraphDescription graphDescription,
InMemoryGraphRepository contextualGraph
) {
var results =
this.readFromUncertainFirstElement(startElementId, startElementType, graphDescription, contextualGraph);
if (results.size() == 0) {
return (List<T>) results;
}
if (!(results.get(0) instanceof ValueReadResult)) {
throw GraphReaderException.becauseLastReadResultsAreNotValues(results.get(0));
}
return results.stream()
.map(result -> (ValueReadResult) result)
.map(result -> (T) result.getValue())
.toList();
}
@NotNull
private List<ReadResult> resolveRestOfTheGraphDescriptions(
List<ReadResult> firstReadResult,
PositiveGraphDescription graphDescription,
InMemoryGraphRepository contextualGraph
) {
var currentDescription = graphDescription;
do {
currentDescription =
(PositiveGraphDescription) currentDescription.getChildGraphDescriptions().get(0);
if (currentDescription.getChildGraphDescriptions().size() > 1) {
throw GraphReaderException.becauseGraphDescriptionHasMultipleChildren(graphDescription);
}
firstReadResult =
this.resolveGraphDescription(firstReadResult, currentDescription, contextualGraph);
} while (currentDescription.getChildGraphDescriptions().size() > 0);
return firstReadResult;
}
@NotNull
private List<ReadResult> resolveAllOfTheGraphDescriptions(
List<ReadResult> firstReadResult,
PositiveGraphDescription graphDescription,
InMemoryGraphRepository contextualGraph
) {
var currentDescription = graphDescription;
while (currentDescription != null) {
if (currentDescription.getChildGraphDescriptions().size() > 1) {
throw GraphReaderException.becauseGraphDescriptionHasMultipleChildren(graphDescription);
}
firstReadResult =
this.resolveGraphDescription(firstReadResult, currentDescription, contextualGraph);
if (currentDescription.getChildGraphDescriptions().size() == 0) {
break;
}
currentDescription =
(PositiveGraphDescription) currentDescription.getChildGraphDescriptions().get(0);
}
return firstReadResult;
}
@NotNull
private List<ReadResult> createFirstReadResult(
UniqueIdentifier startElementId,
PositiveGraphDescription graphDescription,
InMemoryGraphRepository contextualGraph
) {
List<ReadResult> readResult;
if (graphDescription instanceof NodeDescription nodeDescription) {
var parameters = (NodeDescriptionParameters) nodeDescription.getParameters();
if (!contextualGraph.nodeExists(startElementId, parameters.getNodeType())) {
throw GraphReaderException.becauseStartingElementWasNotFoundInProvidedGraph(
startElementId,
parameters.getNodeType(),
GraphBaseTypes.NODE_TYPE
);
}
readResult = List.of(
new NodeReadResult(contextualGraph.loadNode(startElementId, parameters.getNodeType())));
} else if (graphDescription instanceof AbstractEdgeDescription edgeDescription) {
var parameters = (EdgeDescriptionParameters) edgeDescription.getParameters();
if (!contextualGraph.edgeExists(startElementId, parameters.getEdgeType())) {
throw GraphReaderException.becauseStartingElementWasNotFoundInProvidedGraph(
startElementId,
parameters.getEdgeType(),
GraphBaseTypes.EDGE_TYPE
);
}
readResult = List.of(
new EdgeReadResult(contextualGraph.loadEdge(startElementId, parameters.getEdgeType())));
} else {
throw GraphReaderException.becauseProvidedGraphDescriptionCanNotBeFirst(graphDescription);
}
return readResult;
}
@NotNull
private List<ReadResult> guessFirstReadResult(
UniqueIdentifier startElementId,
String startElementType,
InMemoryGraphRepository contextualGraph
) {
List<ReadResult> readResult = null;
try {
var node = contextualGraph.loadNode(startElementId, startElementType);
readResult = List.of(new NodeReadResult(node));
} catch (RuntimeException ignored) {
}
try {
var edge = contextualGraph.loadEdge(startElementId, startElementType);
readResult = List.of(new EdgeReadResult(edge));
} catch (RuntimeException ignore) {
}
if (readResult == null) {
throw GraphReaderException.becauseStartingElementWasNotFoundInProvidedGraph(
startElementId);
}
return readResult;
}
@NotNull
private List<ReadResult> resolveGraphDescription(
List<ReadResult> readResults,
PositiveGraphDescription graphDescription,
InMemoryGraphRepository graph
) {
var resolver = this.getSupportingResolver(graphDescription);
List<ReadResult> flatReadResults = new ArrayList<>();
for (ReadResult readResult : readResults) {
var results = resolver.resolve(
readResult,
graphDescription,
graph
);
flatReadResults.addAll(results);
}
return flatReadResults;
}
private void ensureGraphDescriptionContainsOnlyUpsertDescriptions(
PositiveGraphDescription graphDescription) {
var removalDescription = GraphDescriptionBuilder.getGraphDescriptionAsStream(graphDescription)
.filter(description -> description instanceof RemovalGraphDescription)
.findAny();
removalDescription.ifPresent(
description -> {
throw GraphReaderException.becauseGraphDescriptionContainsRemovalGraphDescription(
description);
}
);
}
private GraphDescriptionReadResolver getSupportingResolver(PositiveGraphDescription mappingPart) {
var supportingResolvers = this.graphDescriptionResolvers.stream()
.filter(resolver -> resolver.supports(mappingPart))
.toList();
if (supportingResolvers.size() == 0) {
throw GraphReaderException.becauseThereIsNoSupportingResolverForMappingPart(mappingPart);
}
if (supportingResolvers.size() > 1) {
throw GraphReaderException.becauseThereIsMultipleSupportingResolverForMappingPart(
mappingPart);
}
return supportingResolvers.get(0);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/exception/GraphReaderException.java | package ai.stapi.graphoperations.graphReader.exception;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.removal.RemovalGraphDescription;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.graphReader.readResults.ReadResult;
import ai.stapi.graphoperations.graphReader.readResults.ValueReadResult;
import ai.stapi.identity.UniqueIdentifier;
import org.apache.commons.lang3.StringUtils;
public class GraphReaderException extends RuntimeException {
private GraphReaderException(String message) {
super(message);
}
public static GraphReaderException becauseStartingElementWasNotFoundInProvidedGraph(
UniqueIdentifier startElementId,
String startElementType,
String startElementGraphType
) {
return new GraphReaderException(
StringUtils.capitalize(startElementGraphType) + " '"
+ startElementId.toString()
+ "' of type '"
+ startElementType
+ "' not found in provided graph structure."
);
}
public static GraphReaderException becauseStartingElementWasNotFoundInProvidedGraph(
UniqueIdentifier startElementId) {
return new GraphReaderException(
"Graph element with ID ["
+ startElementId.toString()
+ "] was not found in provided graph structure."
);
}
public static GraphReaderException becauseThereIsNoSupportingResolverForMappingPart(
PositiveGraphDescription graphDescription) {
return new GraphReaderException(
"There is no supporting resolver for Graph Description '" + graphDescription.getClass()
.getSimpleName() + "'."
);
}
public static GraphReaderException becauseThereIsMultipleSupportingResolverForMappingPart(
PositiveGraphDescription graphDescription) {
return new GraphReaderException(
"There is multiple supporting resolvers for Graph Description '"
+ graphDescription.getClass().getSimpleName() + "'."
);
}
public static GraphReaderException becauseGraphDescriptionContainsRemovalGraphDescription(
GraphDescription description) {
return new GraphReaderException(
"Provided "
+ GraphDescription.class.getSimpleName()
+ " contains " + RemovalGraphDescription.class.getSimpleName()
+ " of type '" + description.getClass().getSimpleName()
+ "' and that is not allowed in " + GraphReaderException.class.getSimpleName()
+ "."
);
}
public static GraphReaderException becauseMappingPartReturnsTypeIncompatibleWithNext(
ObjectGraphMapping currentMappingPart,
ObjectGraphMapping nextMappingPart
) {
return new GraphReaderException(
"Mapping part '"
+ currentMappingPart.getClass().getSimpleName()
+ "' returns '"
+ currentMappingPart.getSerializationType()
+ "' ,but following mapping part '"
+ nextMappingPart.getClass().getSimpleName()
+ "' expects '"
+ nextMappingPart.getSerializationType() + "'."
);
}
public static GraphReaderException becauseProvidedGraphDescriptionCanNotBeFirst(
PositiveGraphDescription graphDescription) {
return new GraphReaderException(
"Provided Graph Description of type '"
+ graphDescription.getClass().getSimpleName()
+ "' can't be as first in the composite."
);
}
public static GraphReaderException becauseReadResultsFromLastMappingPartIsEmpty(
ObjectGraphMapping mappingPart, Integer index) {
return new GraphReaderException(
"Read Results from mapping part '"
+ mappingPart.getClass().getSimpleName()
+ "' at index '"
+ index.toString()
+ "' was empty. That is not allowed when reading."
);
}
public static GraphReaderException becauseGraphDescriptionHasMultipleChildren(
PositiveGraphDescription graphDescription) {
return new GraphReaderException(
"Graph Description of type '"
+ graphDescription.getClass().getSimpleName()
+ "' contains multiple children and that is not allowed in Graph Reader."
);
}
public static GraphReaderException becauseLastReadResultsAreNotValues(ReadResult readResult) {
return new GraphReaderException(
"When reading value, last Read Result must be of type '"
+ ValueReadResult.class.getSimpleName()
+ "' but was of type '"
+ readResult.getClass().getSimpleName()
+ "' instead."
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/mappingPartReadResolvers/AttributeDescriptionReadResolver.java | package ai.stapi.graphoperations.graphReader.mappingPartReadResolvers;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractAttributeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AttributeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphReader.readResults.AttributeReadResult;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graphoperations.graphReader.mappingPartReadResolvers.exception.GraphDescriptionReadResolverException;
import ai.stapi.graphoperations.graphReader.readResults.EdgeReadResult;
import ai.stapi.graphoperations.graphReader.readResults.NodeReadResult;
import ai.stapi.graphoperations.graphReader.readResults.ReadResult;
import java.util.List;
public class AttributeDescriptionReadResolver implements GraphDescriptionReadResolver {
@Override
public List<ReadResult> resolve(
ReadResult previousResult,
PositiveGraphDescription graphDescription,
InMemoryGraphRepository graph
) {
var parameters = (AttributeDescriptionParameters) graphDescription.getParameters();
if (previousResult instanceof NodeReadResult nodeReadResult) {
var node = graph.loadNode(
nodeReadResult.getGraphElement().getId(),
nodeReadResult.getGraphElement().getType()
);
if (!node.hasAttribute(parameters.getAttributeName())) {
return List.of();
// throw GraphDescriptionReadResolverException.becauseAttributeDoesNotExists(
// node.getId(),
// parameters.getAttributeName()
// );
}
return List.of(new AttributeReadResult(node.getAttribute(parameters.getAttributeName())));
}
if (previousResult instanceof EdgeReadResult edgeReadResult) {
var edge = graph.loadEdge(
edgeReadResult.getGraphElement().getId(),
edgeReadResult.getGraphElement().getType()
);
if (!edge.hasAttribute(parameters.getAttributeName())) {
throw GraphDescriptionReadResolverException.becauseAttributeDoesNotExists(edge.getId(),
parameters.getAttributeName());
}
return List.of(new AttributeReadResult(edge.getAttribute(parameters.getAttributeName())));
}
throw GraphDescriptionReadResolverException.becauseIngoingReadResultIsNotSupported(
previousResult,
this
);
}
@Override
public boolean supports(PositiveGraphDescription graphDescription) {
return graphDescription instanceof AbstractAttributeDescription;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/mappingPartReadResolvers/AttributeValueDescriptionReadResolver.java | package ai.stapi.graphoperations.graphReader.mappingPartReadResolvers;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractAttributeValueDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graphoperations.graphReader.readResults.ReadResult;
import java.util.List;
public class AttributeValueDescriptionReadResolver implements GraphDescriptionReadResolver {
@Override
public List<ReadResult> resolve(
ReadResult previousResult,
PositiveGraphDescription graphDescription,
InMemoryGraphRepository graph
) {
return List.of(previousResult);
}
@Override
public boolean supports(PositiveGraphDescription graphDescription) {
return graphDescription instanceof AbstractAttributeValueDescription;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/mappingPartReadResolvers/EdgeDescriptionReadResolver.java | package ai.stapi.graphoperations.graphReader.mappingPartReadResolvers;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.EdgeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.IngoingEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.OutgoingEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graphoperations.graphReader.mappingPartReadResolvers.exception.GraphDescriptionReadResolverException;
import ai.stapi.graphoperations.graphReader.readResults.EdgeReadResult;
import ai.stapi.graphoperations.graphReader.readResults.NodeReadResult;
import ai.stapi.graphoperations.graphReader.readResults.ReadResult;
import java.util.List;
public class EdgeDescriptionReadResolver implements GraphDescriptionReadResolver {
@Override
public List<ReadResult> resolve(
ReadResult previousResult,
PositiveGraphDescription graphDescription,
InMemoryGraphRepository context
) {
if (!(previousResult instanceof NodeReadResult nodeReadResult)) {
throw GraphDescriptionReadResolverException.becauseIngoingReadResultIsNotSupported(
previousResult, this);
}
var parameters = (EdgeDescriptionParameters) graphDescription.getParameters();
var edgeStream = nodeReadResult.getNode()
.getEdges(parameters.getEdgeType())
.stream();
if (graphDescription instanceof OutgoingEdgeDescription) {
return edgeStream
.filter(traversableEdge -> traversableEdge.getNodeFromId()
.equals(nodeReadResult.getGraphElement().getId()))
.map(edge -> (ReadResult) new EdgeReadResult(edge))
.toList();
}
if (graphDescription instanceof IngoingEdgeDescription) {
return edgeStream
.filter(traversableEdge -> traversableEdge.getNodeToId()
.equals(nodeReadResult.getGraphElement().getId()))
.map(edge -> (ReadResult) new EdgeReadResult(edge))
.toList();
}
throw GraphDescriptionReadResolverException.becauseGraphDescriptionTypeIsNotSupported(
graphDescription, this);
}
@Override
public boolean supports(PositiveGraphDescription graphDescription) {
return graphDescription instanceof AbstractEdgeDescription;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/mappingPartReadResolvers/GraphDescriptionReadResolver.java | package ai.stapi.graphoperations.graphReader.mappingPartReadResolvers;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphReader.readResults.ReadResult;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import java.util.List;
public interface GraphDescriptionReadResolver {
List<ReadResult> resolve(
ReadResult previousResult,
PositiveGraphDescription graphDescription,
InMemoryGraphRepository contextualGraph
);
boolean supports(PositiveGraphDescription graphDescription);
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/mappingPartReadResolvers/NodeDescriptionReadResolver.java | package ai.stapi.graphoperations.graphReader.mappingPartReadResolvers;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphReader.mappingPartReadResolvers.exception.GraphDescriptionReadResolverException;
import ai.stapi.graphoperations.graphReader.readResults.EdgeReadResult;
import ai.stapi.graphoperations.graphReader.readResults.NodeReadResult;
import ai.stapi.graphoperations.graphReader.readResults.ReadResult;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graph.traversableGraphElements.TraversableNode;
import java.util.List;
public class NodeDescriptionReadResolver implements GraphDescriptionReadResolver {
@Override
public List<ReadResult> resolve(
ReadResult previousResult,
PositiveGraphDescription graphDescription,
InMemoryGraphRepository contextualGraph
) {
if (!(previousResult instanceof EdgeReadResult edgeReadResult)) {
throw GraphDescriptionReadResolverException.becauseIngoingReadResultIsNotSupported(
previousResult,
this
);
}
var params = (NodeDescriptionParameters) graphDescription.getParameters();
TraversableNode node;
if (edgeReadResult.getEdge().getNodeToType().equals(params.getNodeType())) {
node = edgeReadResult.getEdge().getNodeTo();
} else if (edgeReadResult.getEdge().getNodeFromType().equals(params.getNodeType())) {
node = edgeReadResult.getEdge().getNodeFrom();
} else {
throw GraphDescriptionReadResolverException.becauseEdgeDoesNotContainNodeOfGivenType(
edgeReadResult.getGraphElement().getId(),
params.getNodeType()
);
}
return List.of(new NodeReadResult(node));
}
@Override
public boolean supports(PositiveGraphDescription graphDescription) {
return graphDescription instanceof NodeDescription;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/mappingPartReadResolvers/UuidDescriptionReadResolver.java | package ai.stapi.graphoperations.graphReader.mappingPartReadResolvers;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.graphReader.mappingPartReadResolvers.exception.GraphDescriptionReadResolverException;
import ai.stapi.graphoperations.graphReader.readResults.EdgeReadResult;
import ai.stapi.graphoperations.graphReader.readResults.NodeReadResult;
import ai.stapi.graphoperations.graphReader.readResults.ReadResult;
import ai.stapi.graphoperations.graphReader.readResults.UuidIdentityReadResult;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import java.util.List;
public class UuidDescriptionReadResolver implements GraphDescriptionReadResolver {
@Override
public List<ReadResult> resolve(
ReadResult previousResult,
PositiveGraphDescription graphDescription,
InMemoryGraphRepository graph
) {
if (previousResult instanceof NodeReadResult nodeReadResult) {
return List.of(
new UuidIdentityReadResult(nodeReadResult.getNode().getId())
);
}
if (previousResult instanceof EdgeReadResult edgeReadResult) {
return List.of(
new UuidIdentityReadResult(edgeReadResult.getEdge().getId())
);
}
throw GraphDescriptionReadResolverException.becauseIngoingReadResultIsNotSupported(
previousResult,
this
);
}
@Override
public boolean supports(PositiveGraphDescription graphDescription) {
return graphDescription instanceof UuidIdentityDescription;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/mappingPartReadResolvers | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/mappingPartReadResolvers/exception/AttributeMappingPartResolverException.java | package ai.stapi.graphoperations.graphReader.mappingPartReadResolvers.exception;
import ai.stapi.graph.attribute.Attribute;
public class AttributeMappingPartResolverException extends RuntimeException {
private AttributeMappingPartResolverException(String message) {
super(message);
}
public static AttributeMappingPartResolverException becauseFoundAttributeTypeIsNotSupported(
Attribute<?> attribute,
String dataType
) {
return new AttributeMappingPartResolverException(
"Found attribute '"
+ attribute.getName()
+ "' of type '"
+ dataType
+ "' is not supported by this resolver."
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/mappingPartReadResolvers | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/mappingPartReadResolvers/exception/GraphDescriptionReadResolverException.java | package ai.stapi.graphoperations.graphReader.mappingPartReadResolvers.exception;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphReader.readResults.ReadResult;
import ai.stapi.graphoperations.graphReader.mappingPartReadResolvers.GraphDescriptionReadResolver;
import ai.stapi.identity.UniqueIdentifier;
public class GraphDescriptionReadResolverException extends RuntimeException {
private GraphDescriptionReadResolverException(String message) {
super(message);
}
public static GraphDescriptionReadResolverException becauseIngoingReadResultIsNotSupported(
ReadResult readResult,
GraphDescriptionReadResolver resolver
) {
return new GraphDescriptionReadResolverException(
"Provided previous Read Result of type '"
+ readResult.getClass().getSimpleName()
+ "' is not supported by resolver '"
+ resolver.getClass().getSimpleName()
+ "'."
);
}
public static GraphDescriptionReadResolverException becauseEdgeDoesNotContainNodeOfGivenType(
UniqueIdentifier edgeId, String nodeType) {
return new GraphDescriptionReadResolverException(
"Edge '" + edgeId.toString() + "' does not contain node of type '" + nodeType + "'."
);
}
public static GraphDescriptionReadResolverException becauseGraphDescriptionTypeIsNotSupported(
PositiveGraphDescription graphDescription,
GraphDescriptionReadResolver resolver
) {
return new GraphDescriptionReadResolverException(
"Graph Description of type '"
+ graphDescription.getClass().getSimpleName()
+ "' is not supported by '"
+ resolver.getClass().getSimpleName()
+ "' resolver."
);
}
public static GraphDescriptionReadResolverException becauseAttributeDoesNotExists(
UniqueIdentifier graphElementId,
String attributeName
) {
return new GraphDescriptionReadResolverException(
"Graph Element with id '" + graphElementId + "' does not contain attribute '"
+ attributeName + "'."
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/readResults/AbstractGraphElementReadResult.java | package ai.stapi.graphoperations.graphReader.readResults;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
public class AbstractGraphElementReadResult implements ReadResult {
private final TraversableGraphElement graphElement;
public AbstractGraphElementReadResult(TraversableGraphElement graphElement) {
this.graphElement = graphElement;
}
public TraversableGraphElement getGraphElement() {
return graphElement;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/readResults/AttributeReadResult.java | package ai.stapi.graphoperations.graphReader.readResults;
import ai.stapi.graph.attribute.Attribute;
public class AttributeReadResult implements ValueReadResult {
private final Attribute<?> attribute;
public AttributeReadResult(Attribute<?> value) {
this.attribute = value;
}
public Attribute<?> getAttribute() {
return attribute;
}
@Override
public Object getValue() {
return this.attribute.getValue();
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/readResults/EdgeReadResult.java | package ai.stapi.graphoperations.graphReader.readResults;
import ai.stapi.graph.traversableGraphElements.TraversableEdge;
public class EdgeReadResult extends AbstractGraphElementReadResult {
public EdgeReadResult(TraversableEdge edge) {
super(edge);
}
public TraversableEdge getEdge() {
return (TraversableEdge) this.getGraphElement();
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/readResults/NodeReadResult.java | package ai.stapi.graphoperations.graphReader.readResults;
import ai.stapi.graph.traversableGraphElements.TraversableNode;
public class NodeReadResult extends AbstractGraphElementReadResult {
public NodeReadResult(TraversableNode node) {
super(node);
}
public TraversableNode getNode() {
return (TraversableNode) this.getGraphElement();
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/readResults/ReadResult.java | package ai.stapi.graphoperations.graphReader.readResults;
public interface ReadResult {
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/readResults/UuidIdentityReadResult.java | package ai.stapi.graphoperations.graphReader.readResults;
import ai.stapi.identity.UniqueIdentifier;
public class UuidIdentityReadResult implements ValueReadResult {
private final UniqueIdentifier uniqueIdentifier;
public UuidIdentityReadResult(UniqueIdentifier uniqueIdentifier) {
this.uniqueIdentifier = uniqueIdentifier;
}
public UniqueIdentifier getUniqueIdentifier() {
return uniqueIdentifier;
}
@Override
public Object getValue() {
return this.uniqueIdentifier.getId();
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphReader/readResults/ValueReadResult.java | package ai.stapi.graphoperations.graphReader.readResults;
public interface ValueReadResult extends ReadResult {
Object getValue();
}
|
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/graphToMapObjectMapper/GraphToMapObjectMapper.java | package ai.stapi.graphoperations.graphToMapObjectMapper;
import ai.stapi.graph.Graph;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graph.traversableGraphElements.TraversableNode;
import ai.stapi.graphoperations.graphToMapObjectMapper.exception.GraphToMapObjectMapperException;
import ai.stapi.graphoperations.graphToMapObjectMapper.specific.SpecificGraphToMapMapper;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import java.util.List;
import java.util.Map;
public class GraphToMapObjectMapper {
private final List<SpecificGraphToMapMapper> specificGraphToMapMappers;
private final GenericGraphMappingProvider genericGraphMappingProvider;
public GraphToMapObjectMapper(
List<SpecificGraphToMapMapper> specificGraphToMapMappers,
GenericGraphMappingProvider genericGraphMappingProvider
) {
this.specificGraphToMapMappers = specificGraphToMapMappers;
this.genericGraphMappingProvider = genericGraphMappingProvider;
}
public Map<String, Object> map(
TraversableNode element,
Graph graph
) {
if (!genericGraphMappingProvider.supports(element.getType())) {
throw GraphToMapObjectMapperException.becauseNodeTypeIsNotValidSerializationType(element.getType());
}
if (graph.getAllNodes().isEmpty()) {
throw GraphToMapObjectMapperException.becauseProvidedGraphIsEmpty();
}
var ogm = genericGraphMappingProvider.provideGraphMapping(element.getType());
return (Map<String, Object>) this.resolveInternally(
List.of(element),
ogm,
graph
);
}
public Object resolveInternally(
List<TraversableGraphElement> traversableGraphElements,
ObjectGraphMapping objectGraphMapping,
Graph contextualGraph
) {
var specificMapper = this.getSupportingMapper(objectGraphMapping);
return specificMapper.resolve(
traversableGraphElements,
objectGraphMapping,
contextualGraph
);
}
private SpecificGraphToMapMapper getSupportingMapper(ObjectGraphMapping mapping) {
var specificMapper = this.specificGraphToMapMappers.stream()
.filter(mapper -> mapper.supports(mapping))
.toList();
if (specificMapper.isEmpty()) {
throw GraphToMapObjectMapperException.becauseOgmIsNotSupported(mapping);
} else if (specificMapper.size() > 1) {
throw GraphToMapObjectMapperException.becauseOgmIsSupportedByMultipleMappers(mapping);
} else {
return specificMapper.get(0);
}
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphToMapObjectMapper | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphToMapObjectMapper/exception/GraphToMapObjectMapperException.java | package ai.stapi.graphoperations.graphToMapObjectMapper.exception;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.graphToMapObjectMapper.specific.SpecificGraphToMapMapper;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
public class GraphToMapObjectMapperException extends RuntimeException {
private GraphToMapObjectMapperException(String message) {
super(message);
}
public static GraphToMapObjectMapperException becauseNodeTypeIsNotValidSerializationType(
String nodeType
) {
return new GraphToMapObjectMapperException(
"Node of type '%s' is not valid serialization type.".formatted(nodeType)
);
}
public static GraphToMapObjectMapperException becauseOgmIsNotSupported(
ObjectGraphMapping mapping
) {
return new GraphToMapObjectMapperException(
"Ogm of type '%s' is not supported by any %s."
.formatted(
mapping.getClass().getSimpleName(),
SpecificGraphToMapMapper.class.getSimpleName()
)
);
}
public static GraphToMapObjectMapperException becauseOgmIsSupportedByMultipleMappers(
ObjectGraphMapping mapping
) {
return new GraphToMapObjectMapperException(
"Ogm of type '%s' is supported by multiple %s."
.formatted(
mapping.getClass().getSimpleName(),
SpecificGraphToMapMapper.class.getSimpleName()
)
);
}
public static GraphToMapObjectMapperException
becauseObjectCannotBeResolvedFromMultipleStartingElements(
List<TraversableGraphElement> elements
) {
return new GraphToMapObjectMapperException(
"""
Object cannot be resolved from multiple starting elements.
Element types: %s
""".formatted(
StringUtils.join(
elements.stream()
.map(TraversableGraphElement::getType)
.toArray(),
", "
)
));
}
public static GraphToMapObjectMapperException
becauseObjectsCannotSplitIntoMultipleBranchedInsideObjectOgm() {
return new GraphToMapObjectMapperException(
"Objects cannot split into multiple branched inside ObjectOgm.");
}
public static GraphToMapObjectMapperException becauseLeafCannotLeadToMultipleValues() {
return new GraphToMapObjectMapperException("Leaf cannot lead to multiple values.");
}
public static GraphToMapObjectMapperException becauseProvidedGraphIsEmpty() {
return new GraphToMapObjectMapperException(
"Provided graph was empty."
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphToMapObjectMapper | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphToMapObjectMapper/specific/AbstractSpecificGraphToMapMapper.java | package ai.stapi.graphoperations.graphToMapObjectMapper.specific;
import ai.stapi.graph.Graph;
import ai.stapi.graph.traversableGraphElements.TraversableEdge;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graph.traversableGraphElements.TraversableNode;
import ai.stapi.graphoperations.declaration.Declaration;
import ai.stapi.graphoperations.graphLanguage.graphDescription.AbstractGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractNodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.EdgeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphReader.GraphReader;
import ai.stapi.graphoperations.graphReader.exception.GraphReaderException;
import ai.stapi.graphoperations.graphReader.mappingPartReadResolvers.exception.GraphDescriptionReadResolverException;
import ai.stapi.graphoperations.graphReader.readResults.AbstractGraphElementReadResult;
import ai.stapi.graphoperations.graphToMapObjectMapper.GraphToMapObjectMapper;
import ai.stapi.graphoperations.graphToMapObjectMapper.exception.GraphToMapObjectMapperException;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import java.util.List;
import org.apache.commons.lang3.NotImplementedException;
public abstract class AbstractSpecificGraphToMapMapper implements SpecificGraphToMapMapper {
protected final GraphReader graphReader;
protected final GraphToMapObjectMapper graphToMapObjectMapper;
protected final GenericGraphMappingProvider genericGraphMappingProvider;
protected AbstractSpecificGraphToMapMapper(
GraphReader graphReader,
GraphToMapObjectMapper graphToMapObjectMapper,
GenericGraphMappingProvider genericGraphMappingProvider
) {
this.graphReader = graphReader;
this.graphToMapObjectMapper = graphToMapObjectMapper;
this.genericGraphMappingProvider = genericGraphMappingProvider;
}
protected List<TraversableGraphElement> traverseGraph(
Declaration declaration,
List<TraversableGraphElement> elements,
Graph graph
) throws GraphReaderException {
if (!(declaration instanceof AbstractGraphDescription)) {
return elements;
}
if (declaration instanceof NullGraphDescription) {
return elements;
}
return elements.stream().map(graphElement -> {
if (this.isDescriptionDescribingElement(graphElement, declaration)) {
return this.graphReader.read(
graphElement.getId(),
(PositiveGraphDescription) declaration,
graph.traversable()
);
} else {
return this.graphReader.readFromUncertainFirstElement(
graphElement.getId(),
graphElement.getType(),
(PositiveGraphDescription) declaration,
graph.traversable()
);
}
}).flatMap(List::stream)
.map(AbstractGraphElementReadResult.class::cast)
.map(AbstractGraphElementReadResult::getGraphElement)
.toList();
}
private boolean isDescriptionDescribingElement(
TraversableGraphElement element,
Declaration declaration
) {
if (!(declaration instanceof GraphDescription description)) {
return false;
}
if (element instanceof TraversableNode
&& description instanceof AbstractNodeDescription) {
var nodeParam = (NodeDescriptionParameters) description.getParameters();
return element.getType().equals(nodeParam.getNodeType());
}
if (element instanceof TraversableEdge
&& description instanceof AbstractEdgeDescription) {
var edgeParam = (EdgeDescriptionParameters) description.getParameters();
return element.getType().equals(edgeParam.getEdgeType());
}
return false;
}
protected Object traverseGraphToValue(
Declaration declaration,
TraversableGraphElement element,
Graph graph
) {
if (!(declaration instanceof AbstractGraphDescription)) {
return null;
}
if (declaration instanceof NullGraphDescription) {
return null;
}
List<Object> values;
try {
values = this.graphReader.readValuesFromUncertainFirstElement(
element.getId(),
element.getType(),
(PositiveGraphDescription) declaration,
graph.traversable()
);
} catch (GraphDescriptionReadResolverException exception) {
return null;
}
if (values.size() > 1) {
throw GraphToMapObjectMapperException.becauseLeafCannotLeadToMultipleValues();
}
if (values.isEmpty()) {
return null;
}
return values.get(0);
}
protected String resolveSerializationType(TraversableGraphElement element) {
if (element instanceof TraversableNode node) {
return node.getType();
}
if (element instanceof TraversableEdge edge) {
return edge.getNodeToType();
}
throw new NotImplementedException(
"Unknown element type: '%s'"
.formatted(element.getClass().getSimpleName())
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphToMapObjectMapper | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphToMapObjectMapper/specific/InterfaceGraphToMapMapper.java | package ai.stapi.graphoperations.graphToMapObjectMapper.specific;
import ai.stapi.graph.Graph;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.objectGraphLanguage.InterfaceObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.graphToMapObjectMapper.exception.GraphToMapObjectMapperException;
import ai.stapi.graphoperations.graphToMapObjectMapper.GraphToMapObjectMapper;
import ai.stapi.graphoperations.graphReader.GraphReader;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import java.util.List;
public class InterfaceGraphToMapMapper extends AbstractSpecificGraphToMapMapper {
public InterfaceGraphToMapMapper(
GraphReader graphReader,
GraphToMapObjectMapper graphToMapObjectMapper,
GenericGraphMappingProvider genericGraphMappingProvider
) {
super(graphReader, graphToMapObjectMapper, genericGraphMappingProvider);
}
@Override
public Object resolve(
List<TraversableGraphElement> elements,
ObjectGraphMapping mapping,
Graph graph
) {
if (elements.size() > 1) {
throw GraphToMapObjectMapperException.becauseObjectCannotBeResolvedFromMultipleStartingElements(elements);
}
var traversedInterface = this.traverseGraph(
mapping.getGraphDescription(),
elements,
graph
);
if (traversedInterface.size() > 1) {
throw GraphToMapObjectMapperException
.becauseObjectsCannotSplitIntoMultipleBranchedInsideObjectOgm();
}
if (traversedInterface.isEmpty()) {
return null;
}
var newSerializationType = this.resolveSerializationType(traversedInterface.get(0));
var ogm = this.genericGraphMappingProvider.provideGraphMapping(newSerializationType);
return this.graphToMapObjectMapper.resolveInternally(
traversedInterface,
ogm,
graph
);
}
@Override
public boolean supports(ObjectGraphMapping mapping) {
return mapping instanceof InterfaceObjectGraphMapping;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphToMapObjectMapper | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphToMapObjectMapper/specific/LeafGraphToMapMapper.java | package ai.stapi.graphoperations.graphToMapObjectMapper.specific;
import ai.stapi.graph.Graph;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.graphToMapObjectMapper.GraphToMapObjectMapper;
import ai.stapi.graphoperations.objectGraphLanguage.LeafObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.graphToMapObjectMapper.exception.GraphToMapObjectMapperException;
import ai.stapi.graphoperations.graphReader.GraphReader;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import java.util.List;
public class LeafGraphToMapMapper extends AbstractSpecificGraphToMapMapper {
public LeafGraphToMapMapper(
GraphReader graphReader,
GraphToMapObjectMapper graphToMapObjectMapper,
GenericGraphMappingProvider genericGraphMappingProvider
) {
super(graphReader, graphToMapObjectMapper, genericGraphMappingProvider);
}
@Override
public Object resolve(
List<TraversableGraphElement> elements,
ObjectGraphMapping mapping,
Graph graph
) {
if (elements.size() > 1) {
throw GraphToMapObjectMapperException.becauseObjectCannotBeResolvedFromMultipleStartingElements(elements);
}
return this.traverseGraphToValue(
mapping.getGraphDescription(),
elements.get(0),
graph
);
}
@Override
public boolean supports(ObjectGraphMapping mapping) {
return mapping instanceof LeafObjectGraphMapping;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphToMapObjectMapper | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphToMapObjectMapper/specific/ListGraphToMapMapper.java | package ai.stapi.graphoperations.graphToMapObjectMapper.specific;
import ai.stapi.graph.Graph;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractEdgeDescription;
import ai.stapi.graphoperations.objectGraphLanguage.ListObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.graphToMapObjectMapper.GraphToMapObjectMapper;
import ai.stapi.graphoperations.graphReader.GraphReader;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import java.util.List;
import java.util.Objects;
public class ListGraphToMapMapper extends AbstractSpecificGraphToMapMapper {
public ListGraphToMapMapper(
GraphReader graphReader,
GraphToMapObjectMapper graphToMapObjectMapper,
GenericGraphMappingProvider genericGraphMappingProvider
) {
super(graphReader, graphToMapObjectMapper, genericGraphMappingProvider);
}
@Override
public Object resolve(
List<TraversableGraphElement> elements,
ObjectGraphMapping mapping,
Graph graph
) {
var traversedList = this.traverseGraph(
mapping.getGraphDescription(),
elements,
graph
);
var listOgm = (ListObjectGraphMapping) mapping;
var childObjectGraphMapping = listOgm.getChildObjectGraphMapping();
var childGraphDescription = childObjectGraphMapping.getGraphDescription();
if (childGraphDescription instanceof AbstractEdgeDescription) {
traversedList = this.traverseGraph(
childGraphDescription,
traversedList,
graph
);
}
var resultingList = traversedList.stream()
.map(element -> this.graphToMapObjectMapper.resolveInternally(
List.of(element),
childObjectGraphMapping,
graph
)
).filter(Objects::nonNull)
.toList();
if (resultingList.isEmpty()) {
return null;
}
return resultingList;
}
@Override
public boolean supports(ObjectGraphMapping mapping) {
return mapping instanceof ListObjectGraphMapping;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphToMapObjectMapper | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphToMapObjectMapper/specific/ObjectGraphToMapMapper.java | package ai.stapi.graphoperations.graphToMapObjectMapper.specific;
import ai.stapi.graph.Graph;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectObjectGraphMapping;
import ai.stapi.graphoperations.graphToMapObjectMapper.exception.GraphToMapObjectMapperException;
import ai.stapi.graphoperations.graphToMapObjectMapper.GraphToMapObjectMapper;
import ai.stapi.graphoperations.graphReader.GraphReader;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import java.util.HashMap;
import java.util.List;
public class ObjectGraphToMapMapper extends AbstractSpecificGraphToMapMapper {
public ObjectGraphToMapMapper(
GraphReader graphReader,
GraphToMapObjectMapper graphToMapObjectMapper,
GenericGraphMappingProvider genericGraphMappingProvider
) {
super(graphReader, graphToMapObjectMapper, genericGraphMappingProvider);
}
@Override
public Object resolve(
List<TraversableGraphElement> elements,
ObjectGraphMapping mapping,
Graph graph
) {
if (elements.size() > 1) {
throw GraphToMapObjectMapperException.becauseObjectCannotBeResolvedFromMultipleStartingElements(elements);
}
var objectMap = new HashMap<String, Object>();
objectMap.put(
"serializationType",
this.resolveSerializationType(elements.get(0))
);
var objectOgm = (ObjectObjectGraphMapping) mapping;
var elementsAfterTraversingObjectOgm = this.traverseGraph(
objectOgm.getGraphDescription(),
elements,
graph
);
if (elementsAfterTraversingObjectOgm.size() > 1) {
throw GraphToMapObjectMapperException.becauseObjectsCannotSplitIntoMultipleBranchedInsideObjectOgm();
}
objectOgm.getFields().forEach(
(fieldName, field) -> {
var traversedField = this.traverseGraph(
field.getRelation(),
elementsAfterTraversingObjectOgm,
graph
);
if (traversedField.isEmpty()) {
return;
}
var fieldValue = this.graphToMapObjectMapper.resolveInternally(
traversedField,
field.getFieldObjectGraphMapping(),
graph
);
if (fieldValue != null) {
objectMap.put(fieldName, fieldValue);
}
}
);
return objectMap;
}
@Override
public boolean supports(ObjectGraphMapping mapping) {
return mapping instanceof ObjectObjectGraphMapping;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphToMapObjectMapper | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphToMapObjectMapper/specific/ReferenceGraphToMapMapper.java | package ai.stapi.graphoperations.graphToMapObjectMapper.specific;
import ai.stapi.graph.Graph;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.graphToMapObjectMapper.GraphToMapObjectMapper;
import ai.stapi.graphoperations.graphToMapObjectMapper.exception.GraphToMapObjectMapperException;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ReferenceObjectGraphMapping;
import ai.stapi.graphoperations.graphReader.GraphReader;
import ai.stapi.graphoperations.graphReader.exception.GraphReaderException;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import java.util.List;
public class ReferenceGraphToMapMapper extends AbstractSpecificGraphToMapMapper {
public ReferenceGraphToMapMapper(GraphReader graphReader,
GraphToMapObjectMapper graphToMapObjectMapper,
GenericGraphMappingProvider genericGraphMappingProvider
) {
super(graphReader, graphToMapObjectMapper, genericGraphMappingProvider);
}
@Override
public Object resolve(
List<TraversableGraphElement> elements,
ObjectGraphMapping mapping,
Graph graph
) {
if (elements.size() > 1) {
throw GraphToMapObjectMapperException.becauseObjectCannotBeResolvedFromMultipleStartingElements(elements);
}
List<TraversableGraphElement> traversedInterface;
try {
traversedInterface = this.traverseGraph(
mapping.getGraphDescription(),
elements,
graph
);
} catch (GraphReaderException exception) {
return null;
}
if (traversedInterface.isEmpty()) {
return null;
}
var referenceOgm = (ReferenceObjectGraphMapping) mapping;
var ogm = this.genericGraphMappingProvider.provideGraphMapping(
referenceOgm.getReferencedSerializationType()
);
return this.graphToMapObjectMapper.resolveInternally(
traversedInterface,
ogm,
graph
);
}
@Override
public boolean supports(ObjectGraphMapping mapping) {
return mapping instanceof ReferenceObjectGraphMapping;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphToMapObjectMapper | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/graphToMapObjectMapper/specific/SpecificGraphToMapMapper.java | package ai.stapi.graphoperations.graphToMapObjectMapper.specific;
import ai.stapi.graph.Graph;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import java.util.List;
public interface SpecificGraphToMapMapper {
Object resolve(
List<TraversableGraphElement> elements,
ObjectGraphMapping mapping,
Graph graph
);
boolean supports(ObjectGraphMapping mapping);
}
|
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/graphWriter/GenericGraphWriter.java | package ai.stapi.graphoperations.graphWriter;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.removal.RemovalGraphDescription;
import ai.stapi.graphoperations.graphWriter.exceptions.GenericGraphWriterException;
import ai.stapi.graphoperations.graphbuilder.GraphBuilder;
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.List;
import org.jetbrains.annotations.NotNull;
public class GenericGraphWriter {
private final List<SpecificGraphWriter> specificGraphWriters;
private final GenericAttributeFactory genericAttributeFactory;
public GenericGraphWriter(
List<SpecificGraphWriter> specificGraphWriters,
GenericAttributeFactory genericAttributeFactory
) {
this.specificGraphWriters = specificGraphWriters;
this.genericAttributeFactory = genericAttributeFactory;
}
public Graph createGraph(
UniqueIdentifier firstElementId,
PositiveGraphDescription graphDescription
) {
if (!(graphDescription instanceof NodeDescription)) {
throw GenericGraphWriterException.becauseFirstDescriptionHasToBeNode(graphDescription);
}
this.ensureGraphDescriptionContainsOnlyPositiveDescriptions(graphDescription);
var builder = this.resolvePositiveDescription(graphDescription, new GraphBuilder());
builder.getFirstGraphElement().setId(firstElementId);
builder.dropIncompleteEdges();
return builder.build(this.genericAttributeFactory);
}
public Graph createGraph(PositiveGraphDescription graphDescription) {
if (!(graphDescription instanceof NodeDescription)) {
throw GenericGraphWriterException.becauseFirstDescriptionHasToBeNode(graphDescription);
}
this.ensureGraphDescriptionContainsOnlyPositiveDescriptions(graphDescription);
var builder = this.resolvePositiveDescription(graphDescription, new GraphBuilder());
builder.dropIncompleteEdges();
return builder.build(this.genericAttributeFactory);
}
public List<GraphElementForRemoval> createElementsForRemoval(
List<RemovalGraphDescription> removalGraphDescriptions) {
var builder = new GraphBuilder();
removalGraphDescriptions.forEach(
description -> {
var resolver = this.getSupportingGraphWriter(description);
resolver.write(description, builder);
}
);
return builder.buildElementsForRemoval();
}
private GraphBuilder resolvePositiveDescription(
PositiveGraphDescription graphDescription,
GraphBuilder graphBuilder
) {
var supportingWriter = this.getSupportingGraphWriter(graphDescription);
supportingWriter.write(graphDescription, graphBuilder);
graphDescription.getChildGraphDescriptions().forEach(
child -> {
var newBranch = graphBuilder.createNewBranch();
this.resolvePositiveDescription((PositiveGraphDescription) child, newBranch);
}
);
return graphBuilder;
}
private GraphBuilder resolveRemovalDescription(
GraphDescription graphDescription,
GraphBuilder graphBuilder
) {
var supportingWriter = this.getSupportingGraphWriter(graphDescription);
supportingWriter.write(graphDescription, graphBuilder);
graphDescription.getChildGraphDescriptions().forEach(
child -> {
var newBranch = graphBuilder.createNewBranch();
this.resolveRemovalDescription(child, newBranch);
}
);
return graphBuilder;
}
private void ensureGraphDescriptionContainsOnlyPositiveDescriptions(
PositiveGraphDescription graphDescription
) {
var removalDescription = GraphDescriptionBuilder.getGraphDescriptionAsStream(graphDescription)
.filter(RemovalGraphDescription.class::isInstance)
.findAny();
removalDescription.ifPresent(
description -> {
throw GenericGraphWriterException.becauseGraphDescriptionContainsRemovalGraphDescription(
description
);
}
);
}
@NotNull
private SpecificGraphWriter getSupportingGraphWriter(GraphDescription graphDescription) {
var supportingGraphWriters = this.specificGraphWriters.stream()
.filter(specificGraphWriter -> specificGraphWriter.supports(graphDescription));
var listOfSupportingResolvers = supportingGraphWriters.toList();
if (listOfSupportingResolvers.isEmpty()) {
throw GenericGraphWriterException.becauseNoSupportingSpecificResolverForGivenDeclaration(
graphDescription);
}
if (listOfSupportingResolvers.size() > 1) {
throw GenericGraphWriterException.becauseMoreThanOneSpecificResolverForGivenDeclaration(
graphDescription,
listOfSupportingResolvers
);
}
return listOfSupportingResolvers.get(0);
}
}
|
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/graphWriter/SpecificGraphWriter.java | package ai.stapi.graphoperations.graphWriter;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphbuilder.GraphBuilder;
public interface SpecificGraphWriter {
GraphBuilder write(GraphDescription graphDescription, GraphBuilder builder);
boolean supports(GraphDescription graphDescription);
}
|
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/GenericGraphWriterException.java | package ai.stapi.graphoperations.graphWriter.exceptions;
import ai.stapi.graphoperations.declaration.Declaration;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.removal.RemovalGraphDescription;
import ai.stapi.graphoperations.graphWriter.GenericGraphWriter;
import ai.stapi.graphoperations.graphWriter.SpecificGraphWriter;
import ai.stapi.utils.LineFormatter;
import java.util.List;
import java.util.stream.Collectors;
public class GenericGraphWriterException extends RuntimeException {
public GenericGraphWriterException(String format) {
super(format);
}
public static GenericGraphWriterException becauseNoSupportingSpecificResolverForGivenDeclaration(
Declaration declaration) {
return new GenericGraphWriterException(
String.format(
"There is no supporting %s for declaration '%s'.",
SpecificGraphWriter.class.getSimpleName(),
declaration.getClass().getSimpleName()
)
);
}
public static GenericGraphWriterException becauseMoreThanOneSpecificResolverForGivenDeclaration(
Declaration declaration,
List<SpecificGraphWriter> supportingSpecificGraphWriters
) {
return new GenericGraphWriterException(
String.format(
"There is more than one supporting %s for declaration '%s'."
+ LineFormatter.createNewLine() +
"Supporting: " + LineFormatter.createNewLine() +
"'%s'",
SpecificGraphWriter.class.getSimpleName(),
declaration.getClass().getSimpleName(),
supportingSpecificGraphWriters.stream()
.map(supportingSpecificGraphWriter -> supportingSpecificGraphWriter.getClass()
.getSimpleName())
.collect(Collectors.joining("'" + LineFormatter.createNewLine() + "'"))
)
);
}
public static GenericGraphWriterException becauseFirstDescriptionHasToBeNode(
PositiveGraphDescription graphDescription) {
return new GenericGraphWriterException(
"First graph description must be of type '"
+ NodeDescription.class.getSimpleName()
+ "' but was of type '"
+ graphDescription.getClass().getSimpleName()
+ "'."
);
}
public static GenericGraphWriterException becauseGraphDescriptionContainsRemovalGraphDescription(
GraphDescription description) {
return new GenericGraphWriterException(
"Provided "
+ GraphDescription.class.getSimpleName()
+ " contains " + RemovalGraphDescription.class.getSimpleName()
+ " of type '" + description.getClass().getSimpleName()
+ "' and that is not allowed in " + GenericGraphWriter.class.getSimpleName()
+ "."
);
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.