<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>WebContent (Apache Jena ARQ)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: module: org.apache.jena.arq, package: org.apache.jena.riot, class: WebContent">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-3.6.1.min.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
var pathtoroot = "../../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../module-summary.html">Module</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="class-use/WebContent.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li><a href="#field-detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="module-label-in-type">Module</span>&nbsp;<a href="../../../../module-summary.html">org.apache.jena.arq</a></div>
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.jena.riot</a></div>
<h1 title="Class WebContent" class="title">Class WebContent</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.jena.riot.WebContent</div>
</div>
<section class="class-description" id="class-description">
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">WebContent</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span></div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#charsetASCII" class="member-name-link">charsetASCII</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#charsetUTF8" class="member-name-link">charsetUTF8</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeHTML" class="member-name-link">contentTypeHTML</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeHTMLForm" class="member-name-link">contentTypeHTMLForm</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeJSON" class="member-name-link">contentTypeJSON</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeJSONLD" class="member-name-link">contentTypeJSONLD</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeMultiAlt" class="member-name-link">contentTypeMultiAlt</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeMultipartFormData" class="member-name-link">contentTypeMultipartFormData</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeMultipartMixed" class="member-name-link">contentTypeMultipartMixed</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeN3" class="member-name-link">contentTypeN3</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeN3Alt1" class="member-name-link">contentTypeN3Alt1</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeN3Alt2" class="member-name-link">contentTypeN3Alt2</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeNQuads" class="member-name-link">contentTypeNQuads</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeNQuadsAlt1" class="member-name-link">contentTypeNQuadsAlt1</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeNTriples" class="member-name-link">contentTypeNTriples</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeNTriplesAlt" class="member-name-link">contentTypeNTriplesAlt</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeOctets" class="member-name-link">contentTypeOctets</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypePatch" class="member-name-link">contentTypePatch</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypePatchThrift" class="member-name-link">contentTypePatchThrift</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeRDFJSON" class="member-name-link">contentTypeRDFJSON</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeRDFProto" class="member-name-link">contentTypeRDFProto</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeRDFThrift" class="member-name-link">contentTypeRDFThrift</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeRDFXML" class="member-name-link">contentTypeRDFXML</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeResultsJSON" class="member-name-link">contentTypeResultsJSON</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeResultsProtobuf" class="member-name-link">contentTypeResultsProtobuf</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeResultsThrift" class="member-name-link">contentTypeResultsThrift</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeResultsXML" class="member-name-link">contentTypeResultsXML</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeSPARQLQuery" class="member-name-link">contentTypeSPARQLQuery</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeSPARQLUpdate" class="member-name-link">contentTypeSPARQLUpdate</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeSSE" class="member-name-link">contentTypeSSE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeTextCSV" class="member-name-link">contentTypeTextCSV</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeTextPlain" class="member-name-link">contentTypeTextPlain</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeTextTSV" class="member-name-link">contentTypeTextTSV</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeTriG" class="member-name-link">contentTypeTriG</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeTriGAlt1" class="member-name-link">contentTypeTriGAlt1</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeTriX" class="member-name-link">contentTypeTriX</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeTriXxml" class="member-name-link">contentTypeTriXxml</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeTurtle" class="member-name-link">contentTypeTurtle</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeTurtleAlt1" class="member-name-link">contentTypeTurtleAlt1</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#contentTypeXML" class="member-name-link">contentTypeXML</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#contentTypeXMLAlt" class="member-name-link">contentTypeXMLAlt</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctHTMLForm" class="member-name-link">ctHTMLForm</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctJSON" class="member-name-link">ctJSON</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctJSONLD" class="member-name-link">ctJSONLD</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctMultiAlt" class="member-name-link">ctMultiAlt</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctMultipartFormData" class="member-name-link">ctMultipartFormData</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctMultipartMixed" class="member-name-link">ctMultipartMixed</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctN3Alt1" class="member-name-link">ctN3Alt1</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctN3Alt2" class="member-name-link">ctN3Alt2</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctNQuads" class="member-name-link">ctNQuads</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctNQuadsAlt1" class="member-name-link">ctNQuadsAlt1</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctNTriples" class="member-name-link">ctNTriples</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctNTriplesAlt" class="member-name-link">ctNTriplesAlt</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctOctets" class="member-name-link">ctOctets</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctPatch" class="member-name-link">ctPatch</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctPatchThrift" class="member-name-link">ctPatchThrift</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctRDFJSON" class="member-name-link">ctRDFJSON</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctRDFProto" class="member-name-link">ctRDFProto</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctRDFTHRIFT" class="member-name-link">ctRDFTHRIFT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctRDFXML" class="member-name-link">ctRDFXML</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctResultsJSON" class="member-name-link">ctResultsJSON</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctResultsProtobuf" class="member-name-link">ctResultsProtobuf</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctResultsThrift" class="member-name-link">ctResultsThrift</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctResultsXML" class="member-name-link">ctResultsXML</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctSPARQLQuery" class="member-name-link">ctSPARQLQuery</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctSPARQLUpdate" class="member-name-link">ctSPARQLUpdate</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctSSE" class="member-name-link">ctSSE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctTextCSV" class="member-name-link">ctTextCSV</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctTextHTML" class="member-name-link">ctTextHTML</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctTextPlain" class="member-name-link">ctTextPlain</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctTextTSV" class="member-name-link">ctTextTSV</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctTriG" class="member-name-link">ctTriG</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctTriGAlt1" class="member-name-link">ctTriGAlt1</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctTriX" class="member-name-link">ctTriX</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctTriXxml" class="member-name-link">ctTriXxml</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctTurtle" class="member-name-link">ctTurtle</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctTurtleAlt1" class="member-name-link">ctTurtleAlt1</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctTypeN3" class="member-name-link">ctTypeN3</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color"><code><a href="#ctXML" class="member-name-link">ctXML</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ctXMLAlt" class="member-name-link">ctXMLAlt</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#defaultDatasetAcceptHeader" class="member-name-link">defaultDatasetAcceptHeader</a></code></div>
<div class="col-last even-row-color">
<div class="block">Accept header when looking for a dataset</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#defaultGraphAcceptHeader" class="member-name-link">defaultGraphAcceptHeader</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Accept header when looking for a graph</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#defaultRDFAcceptHeader" class="member-name-link">defaultRDFAcceptHeader</a></code></div>
<div class="col-last even-row-color">
<div class="block">Accept header when looking for a graph or dataset</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#defaultSparqlAskHeader" class="member-name-link">defaultSparqlAskHeader</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#defaultSparqlResultsHeader" class="member-name-link">defaultSparqlResultsHeader</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#encodingDeflate" class="member-name-link">encodingDeflate</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#encodingGzip" class="member-name-link">encodingGzip</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#encodingUTF8" class="member-name-link">encodingUTF8</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Java name for UTF-8 encoding</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#langN3" class="member-name-link">langN3</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#langNQuads" class="member-name-link">langNQuads</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#langNTriple" class="member-name-link">langNTriple</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#langNTriples" class="member-name-link">langNTriples</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#langRdfJson" class="member-name-link">langRdfJson</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#langRDFXML" class="member-name-link">langRDFXML</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#langRDFXMLAbbrev" class="member-name-link">langRDFXMLAbbrev</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#langTriG" class="member-name-link">langTriG</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#langTTL" class="member-name-link">langTTL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#langTurtle" class="member-name-link">langTurtle</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#sparqlAsk" class="member-name-link">sparqlAsk</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#sparqlResults" class="member-name-link">sparqlResults</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li>
<section class="constructor-summary" id="constructor-summary">
<h2>Constructor Summary</h2>
<div class="caption"><span>Constructors</span></div>
<div class="summary-table two-column-summary">
<div class="table-header col-first">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E()" class="member-name-link">WebContent</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#contentTypeCanonical(java.lang.String)" class="member-name-link">contentTypeCanonical</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;contentType)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Return our "canonical" name for a Content Type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Lang.html" title="class in org.apache.jena.riot">Lang</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#contentTypeToLangResultSet(java.lang.String)" class="member-name-link">contentTypeToLangResultSet</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;contentType)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Map content-type to lang for SPARQL results, with pragmatic adapters.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#determineCT(java.lang.String,org.apache.jena.riot.Lang,java.lang.String)" class="member-name-link">determineCT</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;contentTypeStr,
 <a href="Lang.html" title="class in org.apache.jena.riot">Lang</a>&nbsp;hintLang,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;target)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">
 Determine the content type to be used, given the target URL, the content-type
 from Content Negotiation and a hint language.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isHtmlForm(org.apache.jena.atlas.web.ContentType)" class="member-name-link">isHtmlForm</a><wbr>(<a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a>&nbsp;ct)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isMultiPartForm(org.apache.jena.atlas.web.ContentType)" class="member-name-link">isMultiPartForm</a><wbr>(<a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a>&nbsp;ct)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#matchContentType(java.lang.String,java.lang.String)" class="member-name-link">matchContentType</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;ct1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;ct2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#matchContentType(org.apache.jena.atlas.web.ContentType,org.apache.jena.atlas.web.ContentType)" class="member-name-link">matchContentType</a><wbr>(<a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a>&nbsp;ct1,
 <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a>&nbsp;ct2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Match content type (ignores charsets and other parameters)</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="contentTypeTurtle">
<h3>contentTypeTurtle</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeTurtle</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeTurtle">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctTurtle">
<h3>ctTurtle</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctTurtle</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeTurtleAlt1">
<h3>contentTypeTurtleAlt1</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeTurtleAlt1</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeTurtleAlt1">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctTurtleAlt1">
<h3>ctTurtleAlt1</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctTurtleAlt1</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeRDFXML">
<h3>contentTypeRDFXML</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeRDFXML</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeRDFXML">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctRDFXML">
<h3>ctRDFXML</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctRDFXML</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeRDFJSON">
<h3>contentTypeRDFJSON</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeRDFJSON</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeRDFJSON">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctRDFJSON">
<h3>ctRDFJSON</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctRDFJSON</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeJSONLD">
<h3>contentTypeJSONLD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeJSONLD</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeJSONLD">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctJSONLD">
<h3>ctJSONLD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctJSONLD</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeTextPlain">
<h3>contentTypeTextPlain</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeTextPlain</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeTextPlain">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctTextPlain">
<h3>ctTextPlain</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctTextPlain</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeNTriples">
<h3>contentTypeNTriples</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeNTriples</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeNTriples">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctNTriples">
<h3>ctNTriples</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctNTriples</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeNTriplesAlt">
<h3>contentTypeNTriplesAlt</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeNTriplesAlt</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeNTriplesAlt">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctNTriplesAlt">
<h3>ctNTriplesAlt</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctNTriplesAlt</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeXML">
<h3>contentTypeXML</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeXML</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeXML">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctXML">
<h3>ctXML</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctXML</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeXMLAlt">
<h3>contentTypeXMLAlt</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeXMLAlt</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeXMLAlt">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctXMLAlt">
<h3>ctXMLAlt</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctXMLAlt</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeTriG">
<h3>contentTypeTriG</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeTriG</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeTriG">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctTriG">
<h3>ctTriG</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctTriG</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeNQuads">
<h3>contentTypeNQuads</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeNQuads</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeNQuads">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctNQuads">
<h3>ctNQuads</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctNQuads</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeTriGAlt1">
<h3>contentTypeTriGAlt1</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeTriGAlt1</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeTriGAlt1">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctTriGAlt1">
<h3>ctTriGAlt1</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctTriGAlt1</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeRDFProto">
<h3>contentTypeRDFProto</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeRDFProto</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeRDFProto">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctRDFProto">
<h3>ctRDFProto</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctRDFProto</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeRDFThrift">
<h3>contentTypeRDFThrift</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeRDFThrift</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeRDFThrift">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctRDFTHRIFT">
<h3>ctRDFTHRIFT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctRDFTHRIFT</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeNQuadsAlt1">
<h3>contentTypeNQuadsAlt1</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeNQuadsAlt1</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeNQuadsAlt1">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctNQuadsAlt1">
<h3>ctNQuadsAlt1</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctNQuadsAlt1</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeTriX">
<h3>contentTypeTriX</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeTriX</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeTriX">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctTriX">
<h3>ctTriX</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctTriX</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeTriXxml">
<h3>contentTypeTriXxml</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeTriXxml</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeTriXxml">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctTriXxml">
<h3>ctTriXxml</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctTriXxml</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeOctets">
<h3>contentTypeOctets</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeOctets</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeOctets">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctOctets">
<h3>ctOctets</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctOctets</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeMultipartMixed">
<h3>contentTypeMultipartMixed</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeMultipartMixed</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeMultipartMixed">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctMultipartMixed">
<h3>ctMultipartMixed</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctMultipartMixed</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeMultipartFormData">
<h3>contentTypeMultipartFormData</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeMultipartFormData</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeMultipartFormData">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctMultipartFormData">
<h3>ctMultipartFormData</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctMultipartFormData</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeMultiAlt">
<h3>contentTypeMultiAlt</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeMultiAlt</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeMultiAlt">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctMultiAlt">
<h3>ctMultiAlt</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctMultiAlt</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeN3">
<h3>contentTypeN3</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeN3</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeN3">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctTypeN3">
<h3>ctTypeN3</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctTypeN3</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeN3Alt1">
<h3>contentTypeN3Alt1</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeN3Alt1</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeN3Alt1">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctN3Alt1">
<h3>ctN3Alt1</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctN3Alt1</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeN3Alt2">
<h3>contentTypeN3Alt2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeN3Alt2</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeN3Alt2">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctN3Alt2">
<h3>ctN3Alt2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctN3Alt2</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeResultsXML">
<h3>contentTypeResultsXML</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeResultsXML</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeResultsXML">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctResultsXML">
<h3>ctResultsXML</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctResultsXML</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeResultsJSON">
<h3>contentTypeResultsJSON</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeResultsJSON</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeResultsJSON">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctResultsJSON">
<h3>ctResultsJSON</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctResultsJSON</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeJSON">
<h3>contentTypeJSON</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeJSON</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeJSON">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctJSON">
<h3>ctJSON</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctJSON</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeResultsProtobuf">
<h3>contentTypeResultsProtobuf</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeResultsProtobuf</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeResultsProtobuf">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctResultsProtobuf">
<h3>ctResultsProtobuf</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctResultsProtobuf</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeResultsThrift">
<h3>contentTypeResultsThrift</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeResultsThrift</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeResultsThrift">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctResultsThrift">
<h3>ctResultsThrift</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctResultsThrift</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeSPARQLQuery">
<h3>contentTypeSPARQLQuery</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeSPARQLQuery</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeSPARQLQuery">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctSPARQLQuery">
<h3>ctSPARQLQuery</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctSPARQLQuery</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeSPARQLUpdate">
<h3>contentTypeSPARQLUpdate</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeSPARQLUpdate</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeSPARQLUpdate">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctSPARQLUpdate">
<h3>ctSPARQLUpdate</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctSPARQLUpdate</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeHTMLForm">
<h3>contentTypeHTMLForm</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeHTMLForm</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeHTMLForm">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctHTMLForm">
<h3>ctHTMLForm</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctHTMLForm</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeHTML">
<h3>contentTypeHTML</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeHTML</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeHTML">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctTextHTML">
<h3>ctTextHTML</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctTextHTML</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeTextCSV">
<h3>contentTypeTextCSV</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeTextCSV</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeTextCSV">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctTextCSV">
<h3>ctTextCSV</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctTextCSV</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeTextTSV">
<h3>contentTypeTextTSV</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeTextTSV</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeTextTSV">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctTextTSV">
<h3>ctTextTSV</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctTextTSV</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypeSSE">
<h3>contentTypeSSE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeSSE</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypeSSE">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctSSE">
<h3>ctSSE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctSSE</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypePatch">
<h3>contentTypePatch</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypePatch</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypePatch">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctPatch">
<h3>ctPatch</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctPatch</span></div>
</section>
</li>
<li>
<section class="detail" id="contentTypePatchThrift">
<h3>contentTypePatchThrift</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypePatchThrift</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.contentTypePatchThrift">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ctPatchThrift">
<h3>ctPatchThrift</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">ctPatchThrift</span></div>
</section>
</li>
<li>
<section class="detail" id="charsetUTF8">
<h3>charsetUTF8</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">charsetUTF8</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.charsetUTF8">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="charsetASCII">
<h3>charsetASCII</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">charsetASCII</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.charsetASCII">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="langRDFXML">
<h3>langRDFXML</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">langRDFXML</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.langRDFXML">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="langRDFXMLAbbrev">
<h3>langRDFXMLAbbrev</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">langRDFXMLAbbrev</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.langRDFXMLAbbrev">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="langNTriple">
<h3>langNTriple</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">langNTriple</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.langNTriple">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="langNTriples">
<h3>langNTriples</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">langNTriples</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.langNTriples">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="langN3">
<h3>langN3</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">langN3</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.langN3">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="langTurtle">
<h3>langTurtle</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">langTurtle</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.langTurtle">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="langTTL">
<h3>langTTL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">langTTL</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.langTTL">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="langRdfJson">
<h3>langRdfJson</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">langRdfJson</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.langRdfJson">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="langNQuads">
<h3>langNQuads</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">langNQuads</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.langNQuads">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="langTriG">
<h3>langTriG</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">langTriG</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.langTriG">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="encodingUTF8">
<h3>encodingUTF8</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">encodingUTF8</span></div>
<div class="block">Java name for UTF-8 encoding</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.encodingUTF8">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="defaultGraphAcceptHeader">
<h3>defaultGraphAcceptHeader</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">defaultGraphAcceptHeader</span></div>
<div class="block">Accept header when looking for a graph</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.defaultGraphAcceptHeader">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="defaultDatasetAcceptHeader">
<h3>defaultDatasetAcceptHeader</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">defaultDatasetAcceptHeader</span></div>
<div class="block">Accept header when looking for a dataset</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.defaultDatasetAcceptHeader">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="defaultRDFAcceptHeader">
<h3>defaultRDFAcceptHeader</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">defaultRDFAcceptHeader</span></div>
<div class="block">Accept header when looking for a graph or dataset</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.defaultRDFAcceptHeader">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="encodingGzip">
<h3>encodingGzip</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">encodingGzip</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.encodingGzip">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="encodingDeflate">
<h3>encodingDeflate</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">encodingDeflate</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.jena.riot.WebContent.encodingDeflate">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sparqlResults">
<h3>sparqlResults</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">sparqlResults</span></div>
</section>
</li>
<li>
<section class="detail" id="defaultSparqlResultsHeader">
<h3>defaultSparqlResultsHeader</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">defaultSparqlResultsHeader</span></div>
</section>
</li>
<li>
<section class="detail" id="sparqlAsk">
<h3>sparqlAsk</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">sparqlAsk</span></div>
</section>
</li>
<li>
<section class="detail" id="defaultSparqlAskHeader">
<h3>defaultSparqlAskHeader</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">defaultSparqlAskHeader</span></div>
</section>
</li>
</ul>
</section>
</li>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor-detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;()">
<h3>WebContent</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">WebContent</span>()</div>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="contentTypeCanonical(java.lang.String)">
<h3>contentTypeCanonical</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentTypeCanonical</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;contentType)</span></div>
<div class="block">Return our "canonical" name for a Content Type. This should be the standard
 one, no X-*, no alternative names.</div>
</section>
</li>
<li>
<section class="detail" id="matchContentType(org.apache.jena.atlas.web.ContentType,org.apache.jena.atlas.web.ContentType)">
<h3>matchContentType</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">matchContentType</span><wbr><span class="parameters">(<a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a>&nbsp;ct1,
 <a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a>&nbsp;ct2)</span></div>
<div class="block">Match content type (ignores charsets and other parameters)</div>
</section>
</li>
<li>
<section class="detail" id="matchContentType(java.lang.String,java.lang.String)">
<h3>matchContentType</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">matchContentType</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;ct1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;ct2)</span></div>
</section>
</li>
<li>
<section class="detail" id="isHtmlForm(org.apache.jena.atlas.web.ContentType)">
<h3>isHtmlForm</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isHtmlForm</span><wbr><span class="parameters">(<a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a>&nbsp;ct)</span></div>
</section>
</li>
<li>
<section class="detail" id="isMultiPartForm(org.apache.jena.atlas.web.ContentType)">
<h3>isMultiPartForm</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isMultiPartForm</span><wbr><span class="parameters">(<a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a>&nbsp;ct)</span></div>
</section>
</li>
<li>
<section class="detail" id="determineCT(java.lang.String,org.apache.jena.riot.Lang,java.lang.String)">
<h3>determineCT</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../atlas/web/ContentType.html" title="class in org.apache.jena.atlas.web">ContentType</a></span>&nbsp;<span class="element-name">determineCT</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;contentTypeStr,
 <a href="Lang.html" title="class in org.apache.jena.riot">Lang</a>&nbsp;hintLang,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;target)</span></div>
<div class="block"><p>
 Determine the content type to be used, given the target URL, the content-type
 from Content Negotiation and a hint language. This is a pragmatic balance. A
 content-type of "text/plain" is ignored - it is too often wrong.
 </p>
 <p>
 The decision is <blockquote> <i>Content type</i> (but not text/plain)
 &gt; <i>hint</i> &gt; <i>file extension</i>. </blockquote>
 <p>We
 make content type (via content negotiation) strongest because a server may
 return something unexpected because that is all it can do. We are assuming
 servers don't lie. The "hint" is really a hint just for file extension
 override.
 </p>
 <p>
 In the case of no file extension, this reduces to the hint being the default
 choice if conneg does not produce anything useful.
 </p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>contentTypeStr</code> - Content-Type string</dd>
<dd><code>hintLang</code> - Default language</dd>
<dd><code>target</code> - The URL of the target (file extension may be used)</dd>
<dt>Returns:</dt>
<dd>ContentType or null</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="contentTypeToLangResultSet(java.lang.String)">
<h3>contentTypeToLangResultSet</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Lang.html" title="class in org.apache.jena.riot">Lang</a></span>&nbsp;<span class="element-name">contentTypeToLangResultSet</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;contentType)</span></div>
<div class="block">Map content-type to lang for SPARQL results, with pragmatic adapters.</div>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Licensed under the Apache License, Version 2.0</small></p>
</footer>
</div>
</div>
</body>
</html>
