/**
 * Verify that BIND clause alias from the SERVICE clause gets added to the result set.
 *
 * @see <a href="https://github.com/eclipse/rdf4j/issues/646">#646</a>
 */
@Test
public void testValuesBindClauseHandling() throws Exception {
	String query = "select * { service <" + getRepositoryUrl(1) + "> { Bind(1 as ?val) . VALUES ?x {1 2} . } }";

	try (RepositoryConnection conn = localRepository.getConnection()) {
		TupleQuery tq = conn.prepareTupleQuery(query);
		TupleQueryResult tqr = tq.evaluate();

		assertNotNull(tqr);
		assertTrue(tqr.hasNext());

		List<BindingSet> result = QueryResults.asList(tqr);
		assertEquals(2, result.size());
		for (BindingSet bs : result) {
			assertTrue(bs.hasBinding("val"));
			assertEquals(1, Literals.getIntValue(bs.getValue("val"), 0));
			assertTrue(bs.hasBinding("x"));
			int x = Literals.getIntValue(bs.getValue("x"), 0);
			assertTrue(x == 1 || x == 2);
		}
	}
}
 

private void writeValue(Value value, DataOutputStream dataOut) throws IOException {
	if (value instanceof IRI) {
		dataOut.writeByte(URI_MARKER);
		writeString(((IRI) value).toString(), dataOut);
	} else if (value instanceof BNode) {
		dataOut.writeByte(BNODE_MARKER);
		writeString(((BNode) value).getID(), dataOut);
	} else if (value instanceof Literal) {
		Literal lit = (Literal) value;

		String label = lit.getLabel();
		IRI datatype = lit.getDatatype();

		if (Literals.isLanguageLiteral(lit)) {
			dataOut.writeByte(LANG_LITERAL_MARKER);
			writeString(label, dataOut);
			writeString(lit.getLanguage().get(), dataOut);
		} else {
			dataOut.writeByte(DATATYPE_LITERAL_MARKER);
			writeString(label, dataOut);
			writeValue(datatype, dataOut);
		}
	} else {
		throw new IllegalArgumentException("unexpected value type: " + value.getClass());
	}
}
 

private void writeLiteral(Literal literal) throws IOException {
	if (Literals.isLanguageLiteral(literal)) {
		xmlWriter.setAttribute(LITERAL_LANG_ATT, literal.getLanguage().get());
	}
	// Only enter this section for non-language literals now, as the
	// rdf:langString datatype is handled implicitly above
	else {
		IRI datatype = literal.getDatatype();
		boolean ignoreDatatype = datatype.equals(XMLSchema.STRING) && xsdStringToPlainLiteral();
		if (!ignoreDatatype) {
			if (isQName(datatype)) {
				writeQName(datatype);
			}
			xmlWriter.setAttribute(LITERAL_DATATYPE_ATT, datatype.stringValue());
		}
	}

	xmlWriter.textElement(LITERAL_TAG, literal.getLabel());
}
 

/**
 * Checks whether the supplied two literal arguments are 'argument compatible' according to the SPARQL definition.
 *
 * @param arg1 the first argument
 * @param arg2 the second argument
 * @return true iff the two supplied arguments are argument compatible, false otherwise
 * @see <a href="http://www.w3.org/TR/sparql11-query/#func-arg-compatibility">SPARQL Argument Compatibility
 *      Rules</a>
 */
public static boolean compatibleArguments(Literal arg1, Literal arg2) {
	boolean arg1Language = Literals.isLanguageLiteral(arg1);
	boolean arg2Language = Literals.isLanguageLiteral(arg2);
	boolean arg1Simple = isSimpleLiteral(arg1);
	boolean arg2Simple = isSimpleLiteral(arg2);
	// 1. The arguments are literals typed as xsd:string
	// 2. The arguments are language literals with identical language tags
	// 3. The first argument is a language literal and the second
	// argument is a literal typed as xsd:string

	boolean compatible =

			(arg1Simple && arg2Simple)
					|| (arg1Language && arg2Language && arg1.getLanguage().equals(arg2.getLanguage()))
					|| (arg1Language && arg2Simple);

	return compatible;
}
 

private static StringBuilder appendValue(StringBuilder sb, Literal lit) {
	sb.append('"');
	sb.append(SPARQLUtil.encodeString(lit.getLabel()));
	sb.append('"');

	if (Literals.isLanguageLiteral(lit)) {
		sb.append('@');
		sb.append(lit.getLanguage().get());
	} else if (!lit.getDatatype().equals(XMLSchema.STRING)) {
		// Don't append type if it's xsd:string, this keeps it compatible with RDF 1.0
		sb.append("^^<");
		sb.append(lit.getDatatype().stringValue());
		sb.append('>');
	}
	return sb;
}
 

/**
 * Append the SPARQL query string rendering of the {@link org.eclipse.rdf4j.model.Value} to the supplied
 * {@link StringBuilder}.
 *
 * @param value   the value to render
 * @param builder the {@link StringBuilder} to append to
 * @return the original {@link StringBuilder} with the value appended.
 */
public static StringBuilder toSPARQL(Value value, StringBuilder builder) {
	if (value instanceof IRI) {
		IRI aURI = (IRI) value;
		builder.append("<").append(aURI.toString()).append(">");
	} else if (value instanceof BNode) {
		builder.append("_:").append(((BNode) value).getID());
	} else if (value instanceof Literal) {
		Literal aLit = (Literal) value;

		builder.append("\"\"\"").append(escape(aLit.getLabel())).append("\"\"\"");

		if (Literals.isLanguageLiteral(aLit)) {
			aLit.getLanguage().ifPresent(lang -> builder.append("@").append(lang));
		} else {
			builder.append("^^<").append(aLit.getDatatype().toString()).append(">");
		}
	}

	return builder;
}
 

/**
 * Return the query string rendering of the {@link Value}
 *
 * @param theValue the value to render
 * @return the value rendered in its query string representation
 */
public static String toSeRQL(Value theValue) {
	StringBuilder aBuffer = new StringBuilder();

	if (theValue instanceof IRI) {
		IRI aURI = (IRI) theValue;
		aBuffer.append("<").append(aURI.toString()).append(">");
	} else if (theValue instanceof BNode) {
		aBuffer.append("_:").append(((BNode) theValue).getID());
	} else if (theValue instanceof Literal) {
		Literal aLit = (Literal) theValue;

		aBuffer.append("\"").append(escape(aLit.getLabel())).append("\"");

		if (Literals.isLanguageLiteral(aLit)) {
			aBuffer.append("@").append(aLit.getLanguage());
		} else {
			aBuffer.append("^^<").append(aLit.getDatatype().toString()).append(">");
		}
	}

	return aBuffer.toString();
}
 

/**
 * Writes out the XML-representation for the supplied value.
 */
private void writeValue(Value value) throws IOException, RDFHandlerException {
	if (value instanceof IRI) {
		IRI uri = (IRI) value;
		xmlWriter.textElement(URI_TAG, uri.toString());
	} else if (value instanceof BNode) {
		BNode bNode = (BNode) value;
		xmlWriter.textElement(BNODE_TAG, bNode.getID());
	} else if (value instanceof Literal) {
		Literal literal = (Literal) value;
		IRI datatype = literal.getDatatype();

		if (Literals.isLanguageLiteral(literal)) {
			xmlWriter.setAttribute(LANGUAGE_ATT, literal.getLanguage().get());
			xmlWriter.textElement(PLAIN_LITERAL_TAG, literal.getLabel());
		} else {
			xmlWriter.setAttribute(DATATYPE_ATT, datatype.toString());
			xmlWriter.textElement(TYPED_LITERAL_TAG, literal.getLabel());
		}
	} else {
		throw new RDFHandlerException("Unknown value type: " + value.getClass());
	}
}
 

/**
 * Appends the N-Triples representation of the given {@link Literal} to the given {@link Appendable}, optionally
 * ignoring the xsd:string datatype as it is implied for RDF-1.1.
 *
 * @param lit                     The literal to write.
 * @param appendable              The object to append to.
 * @param xsdStringToPlainLiteral True to omit serializing the xsd:string datatype and false to always serialize the
 *                                datatype for literals.
 * @param escapeUnicode           True to escape non-ascii/non-printable characters using Unicode escapes
 *                                (<tt>&#x5C;uxxxx</tt> and <tt>&#x5C;Uxxxxxxxx</tt>), false to print without
 *                                escaping.
 * @throws IOException
 */
public static void append(Literal lit, Appendable appendable, boolean xsdStringToPlainLiteral,
		boolean escapeUnicode) throws IOException {
	// Do some character escaping on the label:
	appendable.append("\"");
	escapeString(lit.getLabel(), appendable, escapeUnicode);
	appendable.append("\"");

	if (Literals.isLanguageLiteral(lit)) {
		// Append the literal's language
		appendable.append("@");
		appendable.append(lit.getLanguage().get());
	} else {
		// SES-1917 : In RDF-1.1, all literals have a type, and if they are not
		// language literals we display the type for backwards compatibility
		// Append the literal's datatype
		IRI datatype = lit.getDatatype();
		boolean ignoreDatatype = datatype.equals(XMLSchema.STRING) && xsdStringToPlainLiteral;
		if (!ignoreDatatype) {
			appendable.append("^^");
			append(lit.getDatatype(), appendable);
		}
	}
}
 

/**
 * Converts a {@link Literal} into a {@link RyaType} representation of the
 * {@code literal}.
 * @param literal the {@link Literal} to convert.
 * @return the {@link RyaType} representation of the {@code literal}.
 */
public static RyaType convertLiteral(final Literal literal) {
    if (literal == null) {
        return null;
    }
    if (literal.getDatatype() != null) {
        if (Literals.isLanguageLiteral(literal)) {
            final String language = literal.getLanguage().get();
            if (Literals.isValidLanguageTag(language)) {
                return new RyaType(literal.getDatatype(), literal.stringValue(), language);
            } else {
                log.warn("Invalid language (" + LogUtils.clean(language) + ") found in Literal. Defaulting to: " + UNDETERMINED_LANGUAGE);
                // Replace invalid language with "und"
                return new RyaType(literal.getDatatype(), literal.stringValue(), UNDETERMINED_LANGUAGE);
            }
        }
        return new RyaType(literal.getDatatype(), literal.stringValue());
    }
    return new RyaType(literal.stringValue());
}
 

@Override
public RyaType deserialize(final byte[] bytes) throws RyaTypeResolverException {
    if (!deserializable(bytes)) {
        throw new RyaTypeResolverException("Bytes not deserializable");
    }
    final RyaType rt = newInstance();
    rt.setDataType(getRyaDataType());
    String data = new String(bytes, 0, bytes.length - 2, StandardCharsets.UTF_8);
    if (RDF.LANGSTRING.equals(rt.getDataType())) {
        final int langDelimiterPos = data.lastIndexOf(LiteralLanguageUtils.LANGUAGE_DELIMITER);
        final String parsedData = data.substring(0, langDelimiterPos);
        final String language = data.substring(langDelimiterPos + 1, data.length());
        if (language != null && Literals.isValidLanguageTag(language)) {
            rt.setLanguage(language);
        } else {
            rt.setLanguage(LiteralLanguageUtils.UNDETERMINED_LANGUAGE);
        }
        data = parsedData;
    }
    rt.setData(deserializeData(data));
    return rt;
}
 

@Test
public void testConvertLiteral_validLanguage() {
    final String expectedData = "Hello";
    for (final String language : LANGUAGE_CODES) {
        // This only checks the validity of the format. Not that the language tag actually exists.
        assertTrue(Literals.isValidLanguageTag(language));
        final RyaType ryaType = new RyaType(RDF.LANGSTRING, expectedData, language);
        final Literal literal = RyaToRdfConversions.convertLiteral(ryaType);
        assertEquals(RDF.LANGSTRING, literal.getDatatype());
        assertEquals(expectedData, literal.getLabel());
        assertTrue(literal.getLanguage().isPresent());
        assertEquals(language, literal.getLanguage().get());
        final Literal expectedLiteral = VF.createLiteral(expectedData, language);
        assertEquals(expectedLiteral, literal);
    }
}
 

@Test
public void testConvertLiteral_invalidLanguage() {
    final String expectedData = "Hello";
    final List<String> badLanguages = Lists.newArrayList(
            "bad language",
            "en-",
            "en-US-"
    );
    for (final String badLanguage : badLanguages) {
        // This only checks the validity of the format. Not that the language tag actually exists.
        assertFalse(Literals.isValidLanguageTag(badLanguage));
        final RyaType ryaType = new RyaType(RDF.LANGSTRING, expectedData, badLanguage);
        final Literal literal = RyaToRdfConversions.convertLiteral(ryaType);
        assertEquals(RDF.LANGSTRING, literal.getDatatype());
        assertEquals(expectedData, literal.getLabel());
        assertTrue(literal.getLanguage().isPresent());
        // Check that the invalid language is replaced with "und"
        assertEquals(LiteralLanguageUtils.UNDETERMINED_LANGUAGE, literal.getLanguage().get());
    }
}
 

@Test
public void testConvertLiteral_invalidLanguage() {
    final String expectedData = "Hello";
    final List<String> badLanguages = Lists.newArrayList(
            "bad language",
            "en-",
            "en-US-"
    );
    for (final String badLanguage : badLanguages) {
        // This only checks the validity of the format. Not that the language tag actually exists.
        assertFalse(Literals.isValidLanguageTag(badLanguage));
        final Literal literal = VF.createLiteral(expectedData, badLanguage);
        final RyaType ryaType = RdfToRyaConversions.convertLiteral(literal);
        assertEquals(RDF.LANGSTRING, ryaType.getDataType());
        assertEquals(expectedData, ryaType.getData());
        // Check that the invalid language is replaced with "und"
        assertEquals(LiteralLanguageUtils.UNDETERMINED_LANGUAGE, ryaType.getLanguage());
    }
}
 

public static StringBuilder toSPARQL(Value value, StringBuilder builder) {
    if(value instanceof IRI) {
        IRI aLit = (IRI)value;
        builder.append("<").append(aLit.toString()).append(">");
    } else if(value instanceof BNode) {
        builder.append("_:").append(((BNode)value).getID());
    } else if(value instanceof Literal) {
        Literal aLit1 = (Literal)value;
        builder.append("\"\"\"").append(RenderUtils.escape(aLit1.getLabel())).append("\"\"\"");
        if(Literals.isLanguageLiteral(aLit1)) {
            builder.append("@").append(aLit1.getLanguage());
        } else if (value instanceof PlainLiteral) {
            // do not print type
        } else {
            builder.append("^^<").append(aLit1.getDatatype().toString()).append(">");
        }
    }

    return builder;
}
 

private static StringBuilder appendValue(StringBuilder sb, Literal lit) {
    sb.append('"');
    sb.append(SPARQLUtil.encodeString(lit.getLabel()));
    sb.append('"');

    if (Literals.isLanguageLiteral(lit)) {
        sb.append('@');
        sb.append(lit.getLanguage().get());
    }
    else {
        sb.append("^^<");
        sb.append(lit.getDatatype().stringValue());
        sb.append('>');
    }
    return sb;
}
 

private void writeLiteral(Value obj) throws IOException {
    Literal objLit = (Literal) obj;
    // datatype attribute
    boolean isXMLLiteral = false;

    // language attribute
    if (Literals.isLanguageLiteral(objLit)) {
        writeAttribute("xml:lang", objLit.getLanguage().orElse(""));
    } else {
        IRI datatype = objLit.getDatatype();
        // Check if datatype is rdf:XMLLiteral
        isXMLLiteral = datatype.equals(RDF.XMLLITERAL);

        if (isXMLLiteral) {
            writeAttribute(RDF.NAMESPACE, "parseType", "Literal");
        } else if (!datatype.equals(XMLSchema.STRING)) {
            writeAttribute(RDF.NAMESPACE, "datatype", datatype.toString());
        }
    }

    writeEndOfStartTag();

    // label
    if (isXMLLiteral) {
        // Write XML literal as plain XML
        writer.write(objLit.getLabel());
    } else {
        writeCharacterData(objLit.getLabel());
    }
}
 

private Value copy(Value value) {
	if (value instanceof IRI) {
		return createIRI(value.stringValue());
	} else if (value instanceof Literal) {
		Literal lit = (Literal) value;
		if (Literals.isLanguageLiteral(lit)) {
			return createLiteral(value.stringValue(), lit.getLanguage().orElse(null));
		} else {
			return createLiteral(value.stringValue(), lit.getDatatype());
		}
	} else {
		return createBNode(value.stringValue());
	}
}
 

/**
 * Creates an NativeLiteral that is equal to the supplied literal. This method returns the supplied literal itself
 * if it is already a NativeLiteral that has been created by this ValueStore, which prevents unnecessary object
 * creations.
 *
 * @return A NativeLiteral for the specified literal.
 */
public NativeLiteral getNativeLiteral(Literal l) {
	if (isOwnValue(l)) {
		return (NativeLiteral) l;
	}

	if (Literals.isLanguageLiteral(l)) {
		return new NativeLiteral(revision, l.getLabel(), l.getLanguage().get());
	} else {
		NativeIRI datatype = getNativeURI(l.getDatatype());
		return new NativeLiteral(revision, l.getLabel(), datatype);
	}
}
 

private void writeLiteral(StringBuilder builder, Literal lit) {
	String label = lit.getLabel();

	if (label.indexOf('\n') > 0 || label.indexOf('\r') > 0 || label.indexOf('\t') > 0) {
		// Write label as long string
		builder.append("\"\"\"");
		builder.append(TurtleUtil.encodeLongString(label));
		builder.append("\"\"\"");
	} else {
		// Write label as normal string
		builder.append("\"");
		builder.append(TurtleUtil.encodeString(label));
		builder.append("\"");
	}

	IRI datatype = lit.getDatatype();
	if (Literals.isLanguageLiteral(lit)) {
		// Append the literal's language
		builder.append("@");
		builder.append(lit.getLanguage().get());
	} else {
		// Append the literal's data type (possibly written as an
		// abbreviated URI)
		builder.append("^^");
		writeURI(builder, datatype);
	}
}
 

private void writeLiteral(Literal literal) throws IOException {
	String label = literal.getLabel();
	IRI datatype = literal.getDatatype();

	int marker = PLAIN_LITERAL_RECORD_MARKER;

	if (Literals.isLanguageLiteral(literal)) {
		marker = LANG_LITERAL_RECORD_MARKER;
	} else {
		String namespace = datatype.getNamespace();

		if (!namespaceTable.containsKey(namespace)) {
			// Assign an ID to this new namespace
			writeNamespace(namespace);
		}

		marker = DATATYPE_LITERAL_RECORD_MARKER;
	}

	out.writeByte(marker);
	writeString(label);

	if (Literals.isLanguageLiteral(literal)) {
		writeString(literal.getLanguage().get());
	} else {
		writeQName(datatype);
	}
}
 

protected void writeValue(Value value) throws IOException, QueryResultHandlerException {
	jg.writeStartObject();

	if (value instanceof IRI) {
		jg.writeStringField("type", "uri");
		jg.writeStringField("value", ((IRI) value).toString());
	} else if (value instanceof BNode) {
		jg.writeStringField("type", "bnode");
		jg.writeStringField("value", ((BNode) value).getID());
	} else if (value instanceof Literal) {
		Literal lit = (Literal) value;

		if (Literals.isLanguageLiteral(lit)) {
			jg.writeObjectField("xml:lang", lit.getLanguage().orElse(null));
		} else {
			IRI datatype = lit.getDatatype();
			boolean ignoreDatatype = datatype.equals(XMLSchema.STRING) && xsdStringToPlainLiteral();
			if (!ignoreDatatype) {
				jg.writeObjectField("datatype", lit.getDatatype().stringValue());
			}
		}

		jg.writeObjectField("type", "literal");

		jg.writeObjectField("value", lit.getLabel());
	} else {
		throw new TupleQueryResultHandlerException("Unknown Value object type: " + value.getClass());
	}
	jg.writeEndObject();
}
 

@Override
protected Literal convert(ValueFactory valueFactory, Value value) throws ValueExprEvaluationException {
	if (value instanceof IRI) {
		return valueFactory.createLiteral(value.toString(), XMLSchema.STRING);
	} else if (value instanceof Literal) {
		Literal literal = (Literal) value;
		IRI datatype = literal.getDatatype();

		if (QueryEvaluationUtil.isSimpleLiteral(literal)) {
			return valueFactory.createLiteral(literal.getLabel(), XMLSchema.STRING);
		} else if (!Literals.isLanguageLiteral(literal)) {
			if (XMLDatatypeUtil.isNumericDatatype(datatype) || datatype.equals(XMLSchema.BOOLEAN)
					|| datatype.equals(XMLSchema.DATETIME) || datatype.equals(XMLSchema.DATETIMESTAMP)) {
				// FIXME Slightly simplified wrt the spec, we just always use the
				// canonical value of the
				// source literal as the target lexical value. This is not 100%
				// compliant with handling of
				// some date-related datatypes.
				//
				// See
				// http://www.w3.org/TR/xpath-functions/#casting-from-primitive-to-primitive
				if (XMLDatatypeUtil.isValidValue(literal.getLabel(), datatype)) {
					String normalizedValue = XMLDatatypeUtil.normalize(literal.getLabel(), datatype);
					return valueFactory.createLiteral(normalizedValue, XMLSchema.STRING);
				} else {
					return valueFactory.createLiteral(literal.getLabel(), XMLSchema.STRING);
				}
			} else {
				// for unknown datatypes, just use the lexical value.
				return valueFactory.createLiteral(literal.getLabel(), XMLSchema.STRING);
			}
		}
	}

	throw typeError(value, null);
}
 

private StringBuilder appendValue(StringBuilder sb, Literal lit) {
	sb.append('"');
	sb.append(lit.getLabel().replace("\"", "\\\""));
	sb.append('"');

	if (Literals.isLanguageLiteral(lit)) {
		sb.append('@');
		sb.append(lit.getLanguage().get());
	} else {
		sb.append("^^<");
		sb.append(lit.getDatatype().stringValue());
		sb.append('>');
	}
	return sb;
}
 

@Override
public Literal createLiteral(String label, String language) {
	if (!Literals.isValidLanguageTag(language)) {
		throw new IllegalArgumentException("Not a valid language tag: " + language);
	}
	return delegate.createLiteral(label, language);
}
 

protected void serialize(Literal literal, XMLWriter xmlWriter) throws IOException {
	if (literal != null) {
		if (Literals.isLanguageLiteral(literal)) {
			xmlWriter.setAttribute(TransactionXMLConstants.LANG_ATT, literal.getLanguage().get());
		} else {
			xmlWriter.setAttribute(TransactionXMLConstants.DATATYPE_ATT, literal.getDatatype().toString());
		}

		String label = literal.getLabel();

		boolean valid = true;
		int i = 0;
		while (valid && i < label.length()) {
			char c = label.charAt(i++);
			valid = XMLUtil.isValidCharacterDataChar(c);
		}

		if (!valid) {
			xmlWriter.setAttribute(TransactionXMLConstants.ENCODING_ATT, "base64");
			label = DatatypeConverter.printBase64Binary(label.getBytes(StandardCharsets.UTF_8));
		}

		xmlWriter.textElement(TransactionXMLConstants.LITERAL_TAG, label);
	} else {
		serializeNull(xmlWriter);
	}
}
 

@Override
public boolean isRecognizedLanguage(String languageTag) {
	Objects.requireNonNull(languageTag, "Language tag cannot be null");

	try {
		Literals.normalizeLanguageTag(languageTag);
	} catch (IllformedLocaleException e) {
		return false;
	}

	return true;
}
 

@Override
public Literal normalizeLanguage(String literalValue, String languageTag, ValueFactory valueFactory)
		throws LiteralUtilException {
	Objects.requireNonNull(languageTag, "Language tag cannot be null");
	Objects.requireNonNull(literalValue, "Literal value cannot be null");

	try {
		return valueFactory.createLiteral(literalValue, Literals.normalizeLanguageTag(languageTag));
	} catch (IllformedLocaleException e) {
		throw new LiteralUtilException("Could not normalize BCP47 language tag", e);
	}
}
 

/**
 * Helper method to reduce complexity of the JSON serialisation algorithm Any null contexts will only be serialised
 * to JSON if there are also non-null contexts in the contexts array
 *
 * @param object   The RDF value to serialise
 * @param contexts The set of contexts that are relevant to this object, including null contexts as they are found.
 * @param jg       the {@link JsonGenerator} to write to.
 * @throws IOException
 * @throws JsonGenerationException
 * @throws JSONException
 */
public static void writeObject(final Value object, final Set<Resource> contexts, final JsonGenerator jg)
		throws JsonGenerationException, IOException {
	jg.writeStartObject();
	if (object instanceof Literal) {
		jg.writeObjectField(RDFJSONUtility.VALUE, object.stringValue());

		jg.writeObjectField(RDFJSONUtility.TYPE, RDFJSONUtility.LITERAL);
		final Literal l = (Literal) object;

		if (Literals.isLanguageLiteral(l)) {
			jg.writeObjectField(RDFJSONUtility.LANG, l.getLanguage().orElse(null));
		} else {
			jg.writeObjectField(RDFJSONUtility.DATATYPE, l.getDatatype().stringValue());
		}
	} else if (object instanceof BNode) {
		jg.writeObjectField(RDFJSONUtility.VALUE, resourceToString((BNode) object));

		jg.writeObjectField(RDFJSONUtility.TYPE, RDFJSONUtility.BNODE);
	} else if (object instanceof IRI) {
		jg.writeObjectField(RDFJSONUtility.VALUE, resourceToString((IRI) object));

		jg.writeObjectField(RDFJSONUtility.TYPE, RDFJSONUtility.URI);
	}

	if (contexts != null && !contexts.isEmpty() && !(contexts.size() == 1 && contexts.iterator().next() == null)) {
		jg.writeArrayFieldStart(RDFJSONUtility.GRAPHS);
		for (final Resource nextContext : contexts) {
			if (nextContext == null) {
				jg.writeNull();
			} else {
				jg.writeString(resourceToString(nextContext));
			}
		}
		jg.writeEndArray();
	}

	jg.writeEndObject();
}
 

private void writeLiteral(Literal literal) throws IOException {
	String label = literal.getLabel();
	IRI datatype = literal.getDatatype();

	if (Literals.isLanguageLiteral(literal)) {
		out.writeByte(LANG_LITERAL_VALUE);
		writeString(label);
		writeString(literal.getLanguage().get());
	} else {
		out.writeByte(DATATYPE_LITERAL_VALUE);
		writeString(label);
		writeString(datatype.toString());
	}
}