Examples with Literal org.eclipse.rdf4j.model.Literal used on opensource projects

Example 41 with Literal

use of org.eclipse.rdf4j.model.Literal in project rdf4j by eclipse.

the class JSONLDInternalRDFParser method handleStatement.

public void handleStatement(RDFDataset result, Statement nextStatement) {
    // TODO: from a basic look at the code it seems some of these could be
    // null
    // null values for IRIs will probably break things further down the line
    // and i'm not sure yet if this should be something handled later on, or
    // something that should be checked here
    final String subject = getResourceValue(nextStatement.getSubject());
    final String predicate = getResourceValue(nextStatement.getPredicate());
    final Value object = nextStatement.getObject();
    final String graphName = getResourceValue(nextStatement.getContext());
    if (object instanceof Literal) {
        final Literal literal = (Literal) object;
        final String value = literal.getLabel();
        String datatype = getResourceValue(literal.getDatatype());
        // rdf:langString
        if (literal.getLanguage().isPresent() && datatype == null) {
            datatype = RDF.LANGSTRING.stringValue();
        }
        // type xsd:String
        if (!literal.getLanguage().isPresent() && datatype == null) {
            datatype = XMLSchema.STRING.stringValue();
        }
        result.addQuad(subject, predicate, value, datatype, literal.getLanguage().orElse(null), graphName);
    } else {
        result.addQuad(subject, predicate, getResourceValue((Resource) object), graphName);
    }
}

Example 42 with Literal

use of org.eclipse.rdf4j.model.Literal in project rdf4j by eclipse.

the class RDFParserHelper method createLiteral.

/**
 * Create a literal using the given parameters, including iterative verification and normalization by any
 * {@link DatatypeHandler} or {@link LanguageHandler} implementations that are found in the
 * {@link ParserConfig}.
 *
 * @param label
 *        The value for {@link Literal#getLabel()}, which may be iteratively normalized.
 * @param lang
 *        If this is not null, and the datatype is either not null, or is equal to {@link RDF#LANGSTRING},
 *        then a language literal will be created.
 * @param datatype
 *        If datatype is not null, and the datatype is not equal to {@link RDF#LANGSTRING} with a non-null
 *        lang, then a datatype literal will be created.
 * @param parserConfig
 *        The source of parser settings, including the desired list of {@link DatatypeHandler} and
 *        {@link LanguageHandler}s to use for verification and normalization of datatype and language
 *        literals respectively.
 * @param errListener
 *        The {@link ParseErrorListener} to use for signalling errors. This will be called if a setting is
 *        enabled by setting it to true in the {@link ParserConfig}, after which the error may trigger an
 *        {@link RDFParseException} if the setting is not present in
 *        {@link ParserConfig#getNonFatalErrors()}.
 * @param valueFactory
 *        The {@link ValueFactory} to use for creating new {@link Literal}s using this method.
 * @param lineNo
 *        Optional line number, should default to setting this as -1 if not known. Used for
 *        {@link ParseErrorListener#error(String, long, long)} and for
 *        {@link RDFParseException#RDFParseException(String, long, long)}.
 * @param columnNo
 *        Optional column number, should default to setting this as -1 if not known. Used for
 *        {@link ParseErrorListener#error(String, long, long)} and for
 *        {@link RDFParseException#RDFParseException(String, long, long)}.
 * @return A {@link Literal} created based on the given parameters.
 * @throws RDFParseException
 *         If there was an error during the process that could not be recovered from, based on settings in
 *         the given parser config.
 */
public static final Literal createLiteral(String label, String lang, IRI datatype, ParserConfig parserConfig, ParseErrorListener errListener, ValueFactory valueFactory, long lineNo, long columnNo) throws RDFParseException {
    if (label == null) {
        throw new NullPointerException("Cannot create a literal using a null label");
    }
    Literal result = null;
    String workingLabel = label;
    Optional<String> workingLang = Optional.ofNullable(lang);
    IRI workingDatatype = datatype;
    // non-null lang
    if (workingLang.isPresent() && (workingDatatype == null || RDF.LANGSTRING.equals(workingDatatype))) {
        boolean recognisedLanguage = false;
        for (LanguageHandler nextHandler : parserConfig.get(BasicParserSettings.LANGUAGE_HANDLERS)) {
            if (nextHandler.isRecognizedLanguage(workingLang.get())) {
                recognisedLanguage = true;
                if (parserConfig.get(BasicParserSettings.VERIFY_LANGUAGE_TAGS)) {
                    try {
                        if (!nextHandler.verifyLanguage(workingLabel, workingLang.get())) {
                            reportError("'" + lang + "' is not a valid language tag ", lineNo, columnNo, BasicParserSettings.VERIFY_LANGUAGE_TAGS, parserConfig, errListener);
                        }
                    } catch (LiteralUtilException e) {
                        reportError("'" + label + " could not be verified by a language handler that recognised it. language was " + lang, lineNo, columnNo, BasicParserSettings.VERIFY_LANGUAGE_TAGS, parserConfig, errListener);
                    }
                }
                if (parserConfig.get(BasicParserSettings.NORMALIZE_LANGUAGE_TAGS)) {
                    try {
                        result = nextHandler.normalizeLanguage(workingLabel, workingLang.get(), valueFactory);
                        workingLabel = result.getLabel();
                        workingLang = result.getLanguage();
                        workingDatatype = result.getDatatype();
                    } catch (LiteralUtilException e) {
                        reportError("'" + label + "' did not have a valid value for language " + lang + ": " + e.getMessage() + " and could not be normalised", lineNo, columnNo, BasicParserSettings.NORMALIZE_LANGUAGE_TAGS, parserConfig, errListener);
                    }
                }
            }
        }
        if (!recognisedLanguage) {
            reportError("'" + label + "' was not recognised as a language literal, and could not be verified, with language " + lang, lineNo, columnNo, BasicParserSettings.FAIL_ON_UNKNOWN_LANGUAGES, parserConfig, errListener);
        }
    } else if (workingDatatype != null) {
        boolean recognisedDatatype = false;
        for (DatatypeHandler nextHandler : parserConfig.get(BasicParserSettings.DATATYPE_HANDLERS)) {
            if (nextHandler.isRecognizedDatatype(workingDatatype)) {
                recognisedDatatype = true;
                if (parserConfig.get(BasicParserSettings.VERIFY_DATATYPE_VALUES)) {
                    try {
                        if (!nextHandler.verifyDatatype(workingLabel, workingDatatype)) {
                            reportError("'" + label + "' is not a valid value for datatype " + datatype, lineNo, columnNo, BasicParserSettings.VERIFY_DATATYPE_VALUES, parserConfig, errListener);
                        }
                    } catch (LiteralUtilException e) {
                        reportError("'" + label + " could not be verified by a datatype handler that recognised it. datatype was " + datatype, lineNo, columnNo, BasicParserSettings.VERIFY_DATATYPE_VALUES, parserConfig, errListener);
                    }
                }
                if (parserConfig.get(BasicParserSettings.NORMALIZE_DATATYPE_VALUES)) {
                    try {
                        result = nextHandler.normalizeDatatype(workingLabel, workingDatatype, valueFactory);
                        workingLabel = result.getLabel();
                        workingLang = result.getLanguage();
                        workingDatatype = result.getDatatype();
                    } catch (LiteralUtilException e) {
                        reportError("'" + label + "' is not a valid value for datatype " + datatype + ": " + e.getMessage() + " and could not be normalised", lineNo, columnNo, BasicParserSettings.NORMALIZE_DATATYPE_VALUES, parserConfig, errListener);
                    }
                }
            }
        }
        if (!recognisedDatatype) {
            reportError("'" + label + "' was not recognised, and could not be verified, with datatype " + datatype, lineNo, columnNo, BasicParserSettings.FAIL_ON_UNKNOWN_DATATYPES, parserConfig, errListener);
        }
    }
    if (result == null) {
        try {
            // Backup for unnormalised language literal creation
            if (workingLang.isPresent() && (workingDatatype == null || RDF.LANGSTRING.equals(workingDatatype))) {
                result = valueFactory.createLiteral(workingLabel, workingLang.get().intern());
            } else // Backup for unnormalised datatype literal creation
            if (workingDatatype != null) {
                result = valueFactory.createLiteral(workingLabel, workingDatatype);
            } else {
                result = valueFactory.createLiteral(workingLabel, XMLSchema.STRING);
            }
        } catch (Exception e) {
            reportFatalError(e, lineNo, columnNo, errListener);
        }
    }
    return result;
}

Example 43 with Literal

use of org.eclipse.rdf4j.model.Literal in project rdf4j by eclipse.

the class QueryStringUtilTest method testLanguageLiteral.

@Test
public void testLanguageLiteral() {
    Literal literal = VF.createLiteral("lang \"literal\"", "en");
    assertEquals("\"lang \\\"literal\\\"\"@en", QueryStringUtil.valueToString(literal));
    assertEquals("\"lang \\\"literal\\\"\"@en", valueToStringWithStringBuilder(literal));
}

Example 44 with Literal

use of org.eclipse.rdf4j.model.Literal in project rdf4j by eclipse.

the class QueryStringUtilTest method testTypedLiteral.

@Test
public void testTypedLiteral() {
    Literal literal = VF.createLiteral("typed \"literal\"", VF.createIRI("http://example.com/test"));
    assertEquals("\"typed \\\"literal\\\"\"^^<http://example.com/test>", QueryStringUtil.valueToString(literal));
    assertEquals("\"typed \\\"literal\\\"\"^^<http://example.com/test>", valueToStringWithStringBuilder(literal));
}

Example 45 with Literal

use of org.eclipse.rdf4j.model.Literal in project opentheso by miledrousset.

the class WriteRdf4j method writeLabel.

private void writeLabel(SKOSResource resource) {
    int prop;
    for (SKOSLabel label : resource.getLabelsList()) {
        prop = label.getProperty();
        Literal literal = vf.createLiteral(label.getLabel(), label.getLanguage());
        switch(prop) {
            case SKOSProperty.prefLabel:
                builder.add(SKOS.PREF_LABEL, literal);
                break;
            case SKOSProperty.altLabel:
                builder.add(SKOS.ALT_LABEL, literal);
                break;
            case SKOSProperty.hiddenLabel:
                builder.add(SKOS.HIDDEN_LABEL, literal);
                break;
            default:
                break;
        }
    }
}