/**
* The contents of this file are subject to the license and copyright
* detailed in the LICENSE and NOTICE files at the root of the source
* tree and available online at
*
* http://www.dspace.org/license/
*/
package org.dspace.rdf.negotiation;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
/**
*
* @author Pascal-Nicolas Becker (dspace -at- pascal -hyphen- becker -dot- de)
*/
public class MediaRange
{
// defined in RFC 2616
public static final double DEFAULT_QVALUE = 1.0;
// RFC 2616 defines syntax of the accept header using several patterns
// the patterns are defined in the parts 2.2, 3.6, 3.7, 3.9 and 14.1 of the rfc
// SEPARATOR: ( ) < > @ , ; : \ " / [ ] ? = { } <space> <tabulator>
// the separators can be used in as class inside square brackets. To be able
// to negate the class, the spearators necessary square brackets are not
// included in the string.
public static final String separators = "()<>@,;:\\\\\"/\\[\\]?={} \\t";
// TOKEN: ANY US ASCII except ctl an separtor
public static final String token = "[\\040-\\0176" + "&&[^" + separators + "]]+";
// "\" followed by any US ASCII character (octets 0 - 177)
public static final String quotedPair = "(?:\\\\[\\00-\\0177])";
// any 8 bit sequence, except CTLs (00-037, 0177) and " (042) but including LWS
public static final String qdtext = "(?:[\\040\\041\\043-\\0176\\0178-\\0377]|"
+ "(?:\\r\\n)?[ \\t]+)";
// ( <"> *(qdtext | quoted-pair) <">
public static final String quotedString = "(?:\"(?:" + qdtext + "|" + quotedPair + ")*\")";
public static final String nonQualityParam = "(?:\\s*;\\s*(?!q\\s*=)(" + token + ")="
+ "(" + token + "|" + quotedString + ")" + ")";
public static final String qualityParam = "(?:;\\s*q\\s*=\\s*(0(?:\\.\\d{0,3})?|1(?:\\.0{0,3})?))";
// group 0 contains the hole matched media range
// group 1 contains the type
// group 2 contains the subtype
// group 3 contains all parameters before the quality parameter if any
// group 4 contains the name of the last parameter before the quality parameter if any
// group 5 contains the value of the last parameter before the quality parameter if any
// group 6 contains the quality value if any
// group 7 contains all parameters after the quality parameter if any
// group 8 contains the name of the last parameter after the quality paremeter if any
// group 9 contains the value of the laster parameter after the quality paremeter if any
public static final String mediaRangeRegex = "(?:(" + token + ")/(" + token + "?)"
+ "(" + nonQualityParam + "*)" + qualityParam + "?(" + nonQualityParam + "*))";
private final static Logger log = Logger.getLogger(MediaRange.class);
protected final String type;
protected final String subtype;
protected final double qvalue;
// would be good to take a Map for the parameters, but if we get multiple
// parameters with the same name, we would have a problem.
protected final List<String> parameterNames;
protected final List<String> parameterValues;
private MediaRange() {
throw new RuntimeException("Default constructor of MediaRange must "
+ "not be called. Use static methods instead.");
}
public MediaRange(String mediarange)
throws IllegalArgumentException, IllegalStateException
{
Pattern mediaRangePattern = Pattern.compile("^" + mediaRangeRegex + "$");
Matcher rangeMatcher = mediaRangePattern.matcher(mediarange.trim());
if (!rangeMatcher.matches())
{
log.warn("Provided media range ('" + mediarange.trim() + "') "
+ "does not comply with RFC 2616.");
throw new IllegalArgumentException("Provided media range ('"
+ mediarange + "') does not comply with RFC 2616.");
}
String type = rangeMatcher.group(1);
String subtype = rangeMatcher.group(2);
if (StringUtils.isEmpty(type) || StringUtils.isEmpty(subtype))
{
throw new IllegalArgumentException("A media range had an unparsable type or subtype.");
}
type = type.trim().toLowerCase();
subtype = subtype.trim().toLowerCase();
if (type.equals("*") && !subtype.equals("*"))
{
throw new IllegalArgumentException("A media range's type cannot "
+ "be wildcarded if its subtype isn't as well.");
}
// initalize with defualt value, parse later
double qvalue = DEFAULT_QVALUE;
// initialize empty lists, parse parameters later
List<String> parameterNames = new ArrayList<>();
List<String> parameterValues = new ArrayList<>();
// parse qvalue
if (!StringUtils.isEmpty(rangeMatcher.group(6)))
{
// parse provided quality value
try
{
qvalue = Double.parseDouble(rangeMatcher.group(6));
}
catch (NumberFormatException ex)
{
// the regex should assure that the qvalue is parseable.
// if we get a NumberFormatException, we did something terribly
// wrong.
log.fatal("A quality value ('" + rangeMatcher.group(6) + "') "
+ "was unparsable. We probably have a problem with our "
+ "regex!", ex);
throw new IllegalStateException(ex);
}
}
// parse parameters
StringBuilder sb = new StringBuilder();
if (!StringUtils.isEmpty(rangeMatcher.group(3)))
{
sb.append(rangeMatcher.group(3));
}
if (!StringUtils.isEmpty(rangeMatcher.group(7)))
{
sb.append(rangeMatcher.group(7));
}
if (sb.length() > 0)
{
String unparsedParameters = sb.toString();
Pattern paramPattern = Pattern.compile(nonQualityParam);
Matcher m = paramPattern.matcher(unparsedParameters);
if (!m.matches())
{
// the mediarange string matched our mediaRangeRegex, but the
// parsed parameters doesn't?!
log.fatal("Unable to parse the parameters ('"
+ unparsedParameters + "') of a previously parsed media "
+ "range!");
throw new IllegalStateException("Run into problems while parsing "
+ "a substring of a previuosly succesfully parsed string.");
}
while (m.find())
{
if (!StringUtils.isEmpty(m.group(1)))
{
parameterNames.add(m.group(1).trim().toLowerCase());
parameterValues.add(StringUtils.isEmpty(m.group(2)) ? "" : m.group(2).trim());
}
}
}
this.type = type;
this.subtype = subtype;
this.qvalue = qvalue;
this.parameterNames = parameterNames;
this.parameterValues = parameterValues;
}
public double getQvalue() {
return this.qvalue;
}
public String getType() {
return type;
}
public String getSubtype() {
return subtype;
}
public List<String> getParameterNames() {
return parameterNames;
}
public List<String> getParameterValues() {
return parameterValues;
}
public boolean typeIsWildcard()
{
return (StringUtils.equals(type, "*"));
}
public boolean subtypeIsWildcard()
{
return (StringUtils.equals(subtype, "*"));
}
}