Examples with LanguageHandler org.eclipse.rdf4j.rio.LanguageHandler used on opensource projects

Example 1 with LanguageHandler

use of org.eclipse.rdf4j.rio.LanguageHandler 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;
}