Value replicate(Value value) { value.accept(this); return this.result; }
private void populateHasValues(final Individual<?,?> individual, List<? extends Value> values, final IndividualTranslator translator) { for(Value value:values) { value.accept( new ValueVisitor() { @Override public void visitLiteral(Literal<?> value) { individual.addValue(shaclTerm("hasValue"),value); } @Override public void visitIndividual(Individual<?, ?> value) { Individual<?, ?> translatedIndividual = translator.translate(value); individual.addValue(shaclTerm("hasValue"),translatedIndividual); } } ); } }
public static String toString(Value value) { final AtomicReference<String> result=new AtomicReference<String>(); value.accept( new ValueVisitor() { @Override public void visitLiteral(Literal<?> value) { result.set(String.format("%s [%s]",value.get(),value.get().getClass().getCanonicalName())); } @Override public void visitIndividual(Individual<?, ?> value) { result.set(FormatUtils.formatId(value)); } } ); return result.get(); }
public static String formatValue(Value value) { if(value==null) { return NULL; } ValueFormatter formatter=new ValueFormatter(); value.accept(formatter); return formatter.getFormat(); } public static String formatDataSet(DataSet dataSet) {
@Override public void accept(ValueVisitor visitor) { for(Value value:values()) { value.accept(visitor); } }
void iterate(final DataSetHelperImpl.TripleConsumer processor) { for(final Individual<?,?> individual:this.dataSet) { for(final Property property:individual) { final DataSetIterator.TripleConsumerAdapter visitor = new TripleConsumerAdapter(property,individual, processor); for(final Value value:property) { value.accept(visitor); } } } }
public final boolean matchesValue(Value propertyValue) { this.setMatches(false); propertyValue.accept(this); return this.matches; }
void addValue(Value value) { value.accept(new ValueAdder()); }
private static void formatIndividual(StringBuilder builder, Individual<?, ?> individual) { PropertyValueFormatter formatter=new PropertyValueFormatter(builder); builder.append(TAB).append("- Individual(").append(FormatUtils.formatId(individual)).append(BLOCK_START).append(NL); for(Property property:individual) { builder.append(TAB).append(TAB).append("+ Property(").append(property.predicate()).append(BLOCK_START).append(NL); for(Value value:property) { value.accept(formatter); } builder.append(TAB).append(TAB).append(BLOCK_END).append(NL); } builder.append(TAB).append(BLOCK_END).append(NL); }
public static boolean hasValue(Value value, final Collection<? extends Value> values) { final class ValueFinder implements ValueVisitor { private boolean found=false; @Override public void visitLiteral(Literal<?> value) { this.found=hasLiteral(value, values); } @Override public void visitIndividual(Individual<?, ?> value) { this.found=hasIdentifiedIndividual(value.id(), values); } } ValueFinder finder=new ValueFinder(); value.accept(finder); return finder.found; }
public T withValue(Value... values) { checkNotNull(values,"Value cannot be null"); this.literals=Lists.newArrayList(); this.individuals=Lists.newArrayList(); ValueCollector valueCollector=new ValueCollector(this.individuals,this.literals); for(Value value:values) { value.accept(valueCollector); } return delegate(); }
public T withAllowedValues(Value... allowedValues) { checkNotNull(allowedValues,"Allowed values cannot be null"); this.allowedLiterals=Sets.newLinkedHashSet(); this.allowedIndividuals=Sets.newLinkedHashSet(); ValueCollector valueCollector=new ValueCollector(this.allowedIndividuals,this.allowedLiterals); for(Value value:allowedValues) { value.accept(valueCollector); } return delegate(); }
private void checkRemovedValues(final Property property, final ValidationLogImpl log) { ValueVisitor removingVisitor = new ValueVisitor() { @Override public void visitLiteral(Literal<?> value) { if(!property.hasLiteralValue(value)) { log.addRemovedValue(property,value); } } @Override public void visitIndividual(Individual<?, ?> value) { if(!property.hasIdentifiedIndividual(value.id())) { log.addRemovedValue(property,value); } } }; for(Value value:constrainedValues()){ value.accept(removingVisitor); } }
private void checkAddedValues(final Property property, final ValidationLogImpl log) { final Collection<? extends Value> constrainedValues = constrainedValues(); ValueVisitor addingVisitor = new ValueVisitor() { @Override public void visitLiteral(Literal<?> value) { if(!DataSetUtils.hasLiteral(value,constrainedValues)) { log.addAddedValue(property,value); } } @Override public void visitIndividual(Individual<?, ?> value) { if(!DataSetUtils.hasIdentifiedIndividual(value.id(),constrainedValues)) { log.addAddedValue(property,value); } } }; for(Value value:property){ value.accept(addingVisitor); } }
@Override public void remove(final Individual<?, ?> src) { if(this!=src.dataSet()) { return; } for(Individual<?,?> individual:this) { for(Property property:individual) { for(Value value:property) { value.accept(new IndividualRemover(property,src,individual)); } } } this.individuals.remove(src.id()); }
/** * {@inheritDoc} */ @Override public Set<URI> types() { Property property = this.individual.property(RDF.TYPE.as(URI.class)); if(property==null) { return Collections.emptySet(); } TypeCollector collector = new TypeCollector(); for(Value value:property) { value.accept(collector); } return collector.collectedTypes(); }
private IndirectIdCollector(boolean strict, URI insertedContentRelation, Property property) { this.strict = strict; this.insertedContentRelation = insertedContentRelation; this.innerVisitor=new InnerVisitor(); this.memberSubject=LDP.MEMBER_SUBJECT.as(URI.class).equals(insertedContentRelation); if(property==null) { if(!this.memberSubject) { throw new InvalidIndirectIdentifierException(insertedContentRelation,"Inserted content relation '%s' not defined for the empty resource"); } } else { for(Value v:property) { this.totalValues++; v.accept(this); } } }
public static void remove(Individual<?,?> source, final Individual<?,?> target) { for(Property property:source.properties()) { final URI propertyId=property.predicate(); ValueVisitor visitor = new ValueVisitor(){ @Override public void visitLiteral(Literal<?> value) { target.removeValue(propertyId, value); } @Override public void visitIndividual(Individual<?,?> value) { Individual<?, ?> cValue = target.dataSet().individualOfId(value.id()); if(cValue!=null) { target.removeValue(propertyId, cValue); } } }; for(Value value:property) { value.accept(visitor); } } }
/** * {@inheritDoc} */ @Override public <T> T firstValue(final Class<? extends T> aClazz) { Property property=getProperty(); if(property==null) { return null; } LiteralValueExtractor<T> extractor =LiteralValueExtractor.newInstance(aClazz); for(Value value:property) { value.accept(extractor); if(extractor.isAvailable()) { break; } } return extractor.getValue(); }
/** * {@inheritDoc} */ @Override public <T extends Serializable, S extends Individual<T,S>> T firstIndividual(final Class<? extends S> clazz) { Property property=getProperty(); if(property==null) { return null; } IndividualExtractor<T,S> extractor=IndividualExtractor.newInstance(clazz); for(Value value:property) { value.accept(extractor); if(extractor.isAvailable()) { return extractor.getValue().id(); } } return null; }