public Value value(Object value) { return Literals.newLiteral(value); } }
private static Literal<?> literal(Object value) { return Literals.newLiteral(value); }
@Override public Value visitLiteral(Literal<?> node, Value defaultResult) { return Literals.newLiteral(serializable(node.getValue())); }
@Override public void addValue(IndividualReference<?,?> subjectReference, URI property, Object value) { subjectReference.realize(this.dataSet).addValue(property,Literals.newLiteral(value)); if(LOGGER.isDebugEnabled()) { LOGGER.debug("Added datatype property triple: <{}, {}, {} ({})>",subjectReference,property,value,value.getClass().getCanonicalName()); } }
private void checkNewLiteral(URI datatype, Object value) { LOGGER.debug("Trying literal creation using temporal value {} ({})...",value,value.getClass().getName()); Literal<?> literal=Literals.newLiteral(value); LOGGER.debug("Got: {}",literal); assertThat( temporalAssertionMessage(value), literal,instanceOf(DateTimeLiteral.class)); assertThat(((DateTimeLiteral)literal).type(),equalTo(datatype)); assertThat(((DateTimeLiteral)literal).get(),equalTo(this.dateTime.get())); }
/** * {@inheritDoc} */ @Override public IndividualPropertyHelper withLiteral(Object rawValue) { if(rawValue!=null) { Literal<?> value = Literals.newLiteral(rawValue); this.individual.addValue(this.propertyId,value); } return new IndividualPropertyHelperImpl(new IndividualHelperImpl(this.individual),this); }
@Test public void testNewLiteral$nonTemporal$notSerializable() { NotSerializableData data = new NotSerializableData(); Literal<? extends Serializable> literal = Literals.newLiteral(data); assertThat(literal.get(),equalTo((Serializable)data.toString())); if(literal instanceof TypedLiteral<?>) { assertThat(((TypedLiteral<?>)literal).type(),equalTo(Datatypes.STRING)); } }
@Test public void testIsEmpty$nonEmptyIndividual() throws Exception { Individual<?,?> individual=sut.individual(URI.create("urn:individual"), ExternalIndividual.class); individual.addValue(URI.create("urn:property"), Literals.newLiteral("data")); assertThat(sut.isEmpty(),equalTo(false)); }
@Test public void testVisitLiteral$plainLiteral() throws Exception { LiteralValueExtractor<Number> extractor = LiteralValueExtractor.newInstance(Number.class); extractor.visitLiteral(Literals.newLiteral(1)); assertThat(extractor.getValue(),equalTo(LITERAL_VALUE)); assertThat(extractor.isAvailable(),equalTo(true)); }
@Test public void testVisitLiteral$plainLiteral$doesNotMatch() throws Exception { LiteralValueExtractor<Number> extractor = LiteralValueExtractor.newInstance(Number.class); extractor.visitLiteral(Literals.newLiteral("test")); assertThat(extractor.getValue(),nullValue()); assertThat(extractor.isAvailable(),equalTo(false)); }
@Test public void testNewLiteral$nonTemporal$serializable() { SerializableData data = new SerializableData(); Literal<? extends Serializable> literal = Literals.newLiteral(data); assertThat(literal.get(),sameInstance((Serializable)data)); if(literal instanceof TypedLiteral<?>) { assertThat(((TypedLiteral<?>)literal).type(),equalTo(Datatypes.STRING)); } }
@Test public void testVisitLiteral$valid() throws Exception { LiteralAdapter<Number> nAdapter = LiteralAdapter.newInstance(Number.class); nAdapter.visitLiteral(Literals.newLiteral(1)); assertThat(nAdapter.adaptedValue(),equalTo((Number)1)); }
private void verifyResult(final ResourceSnapshot snapshot, DynamicResourceHandler handler, boolean resolveToUri, boolean resolveRoundtrip, String roundtrip) throws UnknownResourceException { DataSet dataSet = handler.get(snapshot); Individual<?, ?> resource=dataSet.individualOfId(ManagedIndividualId.createId(RID, DynamicResourceHandler.ID)); assertThat("Could "+(resolveToUri?"not":"")+" resolve uri",resource.hasProperty(DynamicResourceResolver.SNAPSHOT_ENDPOINT),equalTo(resolveToUri)); if(resolveToUri) { assertThat("Invalid uri resolution",resource.property(DynamicResourceResolver.SNAPSHOT_ENDPOINT).hasLiteralValue(Literals.newLiteral(ENDPOINT)),equalTo(resolveRoundtrip)); } assertThat("Could "+(resolveRoundtrip?"not":"")+" resolve roundtrip",resource.hasProperty(DynamicResourceResolver.SNAPSHOT_RESOLUTION),equalTo(resolveRoundtrip)); if(resolveRoundtrip) { assertThat("Invalid roundtrip resolution",resource.property(DynamicResourceResolver.SNAPSHOT_RESOLUTION).hasLiteralValue(Literals.of(roundtrip)),equalTo(resolveRoundtrip)); } }
@Test public void testNewLiteral$duration$jodaDuration() { checkDurationLiteral(Literals.newLiteral(jodaDuration())); }
@Test public void testNewLiteral$duration$javaDuration() throws DatatypeConfigurationException { checkDurationLiteral(Literals.newLiteral(javaDuration())); }
addValue( SNAPSHOT_ENDPOINT, Literals.newLiteral(snapshotEndpoint)); individual. addValue( SNAPSHOT_RESOLUTION, Literals.newLiteral(roundtrip(snapshotResolver,snapshotEndpoint,snapshot)));
individual.property(DynamicResourceUpdater.REFRESHED_ON).numberOfValues(),greaterThanOrEqualTo(1)); assertThat( individual.property(DynamicResourceResolver.SNAPSHOT_ENDPOINT).hasLiteralValue(Literals.newLiteral(ENDPOINT)),equalTo(true)); assertThat( individual.property(DynamicResourceResolver.SNAPSHOT_RESOLUTION).hasLiteralValue(Literals.of("OK")),equalTo(true));