public String toString()
{
Objects.ToStringHelper localToStringHelper = Objects.toStringHelper(this);
if (this.c != -1)
localToStringHelper.add("initialCapacity", Integer.valueOf(this.c));
if (this.d != -1)
localToStringHelper.add("concurrencyLevel", Integer.valueOf(this.d));
if (this.e != -1)
localToStringHelper.add("maximumSize", Integer.valueOf(this.e));
if (this.h != -1L)
localToStringHelper.add("expireAfterWrite", this.h + "ns");
if (this.i != -1L)
localToStringHelper.add("expireAfterAccess", this.i + "ns");
if (this.f != null)
localToStringHelper.add("keyStrength", Ascii.toLowerCase(this.f.toString()));
if (this.g != null)
localToStringHelper.add("valueStrength", Ascii.toLowerCase(this.g.toString()));
if (this.k != null)
localToStringHelper.addValue("keyEquivalence");
if (this.l != null)
localToStringHelper.addValue("valueEquivalence");
if (this.a != null)
localToStringHelper.addValue("removalListener");
return localToStringHelper.toString();
}
void process() {
if (startType.getKind().isPrimitive()) {
// taking a shortcut for primitives
String typeName = Ascii.toLowerCase(startType.getKind().name());
this.rawTypeName = typeName;
this.returnTypeName = typeName;
List<? extends AnnotationMirror> annotations = AnnotationMirrors.from(startType);
if (!annotations.isEmpty()) {
returnTypeName = typeAnnotationsToBuffer(annotations).append(typeName).toString();
}
} else {
this.buffer = new StringBuilder(100);
caseType(startType);
if (workaroundTypeString != null) {
// to not mix the mess, we just replace buffer with workaround produced type string
this.buffer = new StringBuilder(workaroundTypeString);
}
// It seems that array type annotations are not exposed in javac
// Nested type argument's type annotations are not exposed as well (in javac)
// So currently we instert only for top level, declared type (here),
// and primitives (see above)
TypeKind k = startType.getKind();
if (k == TypeKind.DECLARED || k == TypeKind.ERROR) {
insertTypeAnnotationsIfPresent(startType, 0, rawTypeName.length());
}
this.returnTypeName = buffer.toString();
}
}
@Override
public String apply(String input) {
boolean assumedUnqualified = Ascii.isUpperCase(input.charAt(0));
if (assumedUnqualified) {
input = qualifyImportedIfPossible(input);
}
return input;
}
@VisibleForTesting
static String fromSecondLevel(String qualifiedTemplateClass) {
List<String> path = Splitter.on('.').splitToList(qualifiedTemplateClass);
for (int topLevel = 0; topLevel < path.size() - 1; topLevel++) {
if (Ascii.isUpperCase(path.get(topLevel).charAt(0))) {
return Joiner.on('_').join(path.subList(topLevel + 1, path.size()));
}
}
return Iterables.getLast(path);
}
@Description("converts all the alphabets in the string to upper case")
@ScalarFunction
@SqlType(VarcharType.class)
public static Slice upper(@SqlType(VarcharType.class) Slice slice) {
Slice upper = Slices.allocate(slice.length());
for (int i = 0; i < slice.length(); i++) {
upper.setByte(i, Ascii.toUpperCase((char) slice.getByte(i)));
}
return upper;
}
/**
* Returns a string representation for this MapMaker instance. The exact form of the returned
* string is not specificed.
*/
@Override
public String toString() {
MoreObjects.ToStringHelper s = MoreObjects.toStringHelper(this);
if (initialCapacity != UNSET_INT) {
s.add("initialCapacity", initialCapacity);
}
if (concurrencyLevel != UNSET_INT) {
s.add("concurrencyLevel", concurrencyLevel);
}
if (keyStrength != null) {
s.add("keyStrength", Ascii.toLowerCase(keyStrength.toString()));
}
if (valueStrength != null) {
s.add("valueStrength", Ascii.toLowerCase(valueStrength.toString()));
}
if (keyEquivalence != null) {
s.addValue("keyEquivalence");
}
return s.toString();
}
/**
* Returns a string representation for this CacheBuilder instance. The exact form of the returned
* string is not specified.
*/
@Override
public String toString() {
MoreObjects.ToStringHelper s = MoreObjects.toStringHelper(this);
if (initialCapacity != UNSET_INT) {
s.add("initialCapacity", initialCapacity);
}
if (concurrencyLevel != UNSET_INT) {
s.add("concurrencyLevel", concurrencyLevel);
}
if (maximumSize != UNSET_INT) {
s.add("maximumSize", maximumSize);
}
if (maximumWeight != UNSET_INT) {
s.add("maximumWeight", maximumWeight);
}
if (expireAfterWriteNanos != UNSET_INT) {
s.add("expireAfterWrite", expireAfterWriteNanos + "ns");
}
if (expireAfterAccessNanos != UNSET_INT) {
s.add("expireAfterAccess", expireAfterAccessNanos + "ns");
}
if (keyStrength != null) {
s.add("keyStrength", Ascii.toLowerCase(keyStrength.toString()));
}
if (valueStrength != null) {
s.add("valueStrength", Ascii.toLowerCase(valueStrength.toString()));
}
if (keyEquivalence != null) {
s.addValue("keyEquivalence");
}
if (valueEquivalence != null) {
s.addValue("valueEquivalence");
}
if (removalListener != null) {
s.addValue("removalListener");
}
return s.toString();
}
private Entry<String, List<String>> resolveTypes(Entry<String, List<String>> sourceTypes) {
String typeName = sourceTypes.getKey();
boolean assumedNotQualified = Ascii.isUpperCase(typeName.charAt(0));
if (assumedNotQualified) {
typeName = resolveIfPossible(typeName);
}
List<String> typeArguments = Lists.newArrayListWithCapacity(sourceTypes.getValue().size());
for (String typeArgument : sourceTypes.getValue()) {
String resolvedTypeArgument =
SourceTypes.stringify(resolveTypes(SourceTypes.extract(typeArgument)));
typeArguments.add(resolvedTypeArgument);
}
return Maps.immutableEntry(typeName, typeArguments);
}
private void appendResolved(DeclaredType type) {
TypeElement typeElement = (TypeElement) type.asElement();
String typeName = typeElement.getQualifiedName().toString();
if (unresolvedTypeHasOccured) {
boolean assumedNotQualified = Ascii.isUpperCase(typeName.charAt(0));
if (assumedNotQualified) {
typeName = resolveIfPossible(typeName);
}
}
buffer.append(typeName);
if (startType == type) {
rawTypeName = typeName;
}
}
public void testToString() {
for (String inputName : SOMEWHERE_UNDER_PS) {
InternetDomainName domain = InternetDomainName.from(inputName);
/*
* We would ordinarily use constants for the expected results, but
* doing it by derivation allows us to reuse the test case definitions
* used in other tests.
*/
String expectedName = Ascii.toLowerCase(inputName);
expectedName = expectedName.replaceAll("[\u3002\uFF0E\uFF61]", ".");
if (expectedName.endsWith(".")) {
expectedName = expectedName.substring(0, expectedName.length() - 1);
}
assertEquals(expectedName, domain.toString());
}
}
@Override
public String toString() {
return "ByteSource.wrap("
+ Ascii.truncate(BaseEncoding.base16().encode(bytes, offset, length), 30, "...")
+ ")";
}
@Beta
@GwtCompatible
@Immutable
public final class MediaType {
private static final String CHARSET_ATTRIBUTE = "charset";
private static final ImmutableListMultimap<String, String> UTF_8_CONSTANT_PARAMETERS =
ImmutableListMultimap.of("charset", Ascii.toLowerCase(Charsets.UTF_8.name()));
private static final CharMatcher TOKEN_MATCHER =
CharMatcher.ASCII
.and(CharMatcher.JAVA_ISO_CONTROL.negate())
.and(CharMatcher.isNot(' '))
.and(CharMatcher.noneOf("()<>@,;:\\\"/[]?="));
private static final CharMatcher QUOTED_TEXT_MATCHER =
CharMatcher.ASCII.and(CharMatcher.noneOf("\"\\\r"));
private static final CharMatcher LINEAR_WHITE_SPACE = CharMatcher.anyOf(" \t\r\n");
private static final String APPLICATION_TYPE = "application";
private static final String AUDIO_TYPE = "audio";
private static final String IMAGE_TYPE = "image";
private static final String TEXT_TYPE = "text";
private static final String VIDEO_TYPE = "video";
private static final String WILDCARD = "*";
private static final Map<MediaType, MediaType> KNOWN_TYPES = Maps.newHashMap();
private static MediaType createConstant(String type, String subtype) {
return addKnownType(new MediaType(type, subtype, ImmutableListMultimap.of()));
}
private static MediaType createConstantUtf8(String type, String subtype) {
return addKnownType(new MediaType(type, subtype, UTF_8_CONSTANT_PARAMETERS));
}
private static MediaType addKnownType(MediaType mediaType) {
KNOWN_TYPES.put(mediaType, mediaType);
return mediaType;
}
public static final MediaType ANY_TYPE = createConstant("*", "*");
public static final MediaType ANY_TEXT_TYPE = createConstant("text", "*");
public static final MediaType ANY_IMAGE_TYPE = createConstant("image", "*");
public static final MediaType ANY_AUDIO_TYPE = createConstant("audio", "*");
public static final MediaType ANY_VIDEO_TYPE = createConstant("video", "*");
public static final MediaType ANY_APPLICATION_TYPE = createConstant("application", "*");
public static final MediaType CACHE_MANIFEST_UTF_8 = createConstantUtf8("text", "cache-manifest");
public static final MediaType CSS_UTF_8 = createConstantUtf8("text", "css");
public static final MediaType CSV_UTF_8 = createConstantUtf8("text", "csv");
public static final MediaType HTML_UTF_8 = createConstantUtf8("text", "html");
public static final MediaType I_CALENDAR_UTF_8 = createConstantUtf8("text", "calendar");
public static final MediaType PLAIN_TEXT_UTF_8 = createConstantUtf8("text", "plain");
public static final MediaType TEXT_JAVASCRIPT_UTF_8 = createConstantUtf8("text", "javascript");
public static final MediaType TSV_UTF_8 = createConstantUtf8("text", "tab-separated-values");
public static final MediaType VCARD_UTF_8 = createConstantUtf8("text", "vcard");
public static final MediaType WML_UTF_8 = createConstantUtf8("text", "vnd.wap.wml");
public static final MediaType XML_UTF_8 = createConstantUtf8("text", "xml");
public static final MediaType BMP = createConstant("image", "bmp");
public static final MediaType CRW = createConstant("image", "x-canon-crw");
public static final MediaType GIF = createConstant("image", "gif");
public static final MediaType ICO = createConstant("image", "vnd.microsoft.icon");
public static final MediaType JPEG = createConstant("image", "jpeg");
public static final MediaType PNG = createConstant("image", "png");
public static final MediaType PSD = createConstant("image", "vnd.adobe.photoshop");
public static final MediaType SVG_UTF_8 = createConstantUtf8("image", "svg+xml");
public static final MediaType TIFF = createConstant("image", "tiff");
public static final MediaType WEBP = createConstant("image", "webp");
public static final MediaType MP4_AUDIO = createConstant("audio", "mp4");
public static final MediaType MPEG_AUDIO = createConstant("audio", "mpeg");
public static final MediaType OGG_AUDIO = createConstant("audio", "ogg");
public static final MediaType WEBM_AUDIO = createConstant("audio", "webm");
public static final MediaType MP4_VIDEO = createConstant("video", "mp4");
public static final MediaType MPEG_VIDEO = createConstant("video", "mpeg");
public static final MediaType OGG_VIDEO = createConstant("video", "ogg");
public static final MediaType QUICKTIME = createConstant("video", "quicktime");
public static final MediaType WEBM_VIDEO = createConstant("video", "webm");
public static final MediaType WMV = createConstant("video", "x-ms-wmv");
public static final MediaType APPLICATION_XML_UTF_8 = createConstantUtf8("application", "xml");
public static final MediaType ATOM_UTF_8 = createConstantUtf8("application", "atom+xml");
public static final MediaType BZIP2 = createConstant("application", "x-bzip2");
public static final MediaType EOT = createConstant("application", "vnd.ms-fontobject");
public static final MediaType EPUB = createConstant("application", "epub+zip");
public static final MediaType FORM_DATA = createConstant("application", "x-www-form-urlencoded");
public static final MediaType KEY_ARCHIVE = createConstant("application", "pkcs12");
public static final MediaType APPLICATION_BINARY = createConstant("application", "binary");
public static final MediaType GZIP = createConstant("application", "x-gzip");
public static final MediaType JAVASCRIPT_UTF_8 = createConstantUtf8("application", "javascript");
public static final MediaType JSON_UTF_8 = createConstantUtf8("application", "json");
public static final MediaType KML = createConstant("application", "vnd.google-earth.kml+xml");
public static final MediaType KMZ = createConstant("application", "vnd.google-earth.kmz");
public static final MediaType MBOX = createConstant("application", "mbox");
public static final MediaType MICROSOFT_EXCEL = createConstant("application", "vnd.ms-excel");
public static final MediaType MICROSOFT_POWERPOINT =
createConstant("application", "vnd.ms-powerpoint");
public static final MediaType MICROSOFT_WORD = createConstant("application", "msword");
public static final MediaType OCTET_STREAM = createConstant("application", "octet-stream");
public static final MediaType OGG_CONTAINER = createConstant("application", "ogg");
public static final MediaType OOXML_DOCUMENT =
createConstant("application", "vnd.openxmlformats-officedocument.wordprocessingml.document");
public static final MediaType OOXML_PRESENTATION =
createConstant(
"application", "vnd.openxmlformats-officedocument.presentationml.presentation");
public static final MediaType OOXML_SHEET =
createConstant("application", "vnd.openxmlformats-officedocument.spreadsheetml.sheet");
public static final MediaType OPENDOCUMENT_GRAPHICS =
createConstant("application", "vnd.oasis.opendocument.graphics");
public static final MediaType OPENDOCUMENT_PRESENTATION =
createConstant("application", "vnd.oasis.opendocument.presentation");
public static final MediaType OPENDOCUMENT_SPREADSHEET =
createConstant("application", "vnd.oasis.opendocument.spreadsheet");
public static final MediaType OPENDOCUMENT_TEXT =
createConstant("application", "vnd.oasis.opendocument.text");
public static final MediaType PDF = createConstant("application", "pdf");
public static final MediaType POSTSCRIPT = createConstant("application", "postscript");
public static final MediaType PROTOBUF = createConstant("application", "protobuf");
public static final MediaType RDF_XML_UTF_8 = createConstantUtf8("application", "rdf+xml");
public static final MediaType RTF_UTF_8 = createConstantUtf8("application", "rtf");
public static final MediaType SFNT = createConstant("application", "font-sfnt");
public static final MediaType SHOCKWAVE_FLASH =
createConstant("application", "x-shockwave-flash");
public static final MediaType SKETCHUP = createConstant("application", "vnd.sketchup.skp");
public static final MediaType TAR = createConstant("application", "x-tar");
public static final MediaType WOFF = createConstant("application", "font-woff");
public static final MediaType XHTML_UTF_8 = createConstantUtf8("application", "xhtml+xml");
public static final MediaType XRD_UTF_8 = createConstantUtf8("application", "xrd+xml");
public static final MediaType ZIP = createConstant("application", "zip");
private final String type;
private final String subtype;
private final ImmutableListMultimap<String, String> parameters;
private MediaType(String type, String subtype, ImmutableListMultimap<String, String> parameters) {
this.type = type;
this.subtype = subtype;
this.parameters = parameters;
}
public String type() {
return this.type;
}
public String subtype() {
return this.subtype;
}
public ImmutableListMultimap<String, String> parameters() {
return this.parameters;
}
private Map<String, ImmutableMultiset<String>> parametersAsMap() {
Maps.transformValues(
this.parameters.asMap(),
new Function() {
public ImmutableMultiset<String> apply(Collection<String> input) {
return ImmutableMultiset.copyOf(input);
}
});
}
public Optional<Charset> charset() {
ImmutableSet<String> charsetValues = ImmutableSet.copyOf(this.parameters.get("charset"));
switch (charsetValues.size()) {
case 0:
return Optional.absent();
case 1:
return Optional.of(Charset.forName((String) Iterables.getOnlyElement(charsetValues)));
}
throw new IllegalStateException("Multiple charset values defined: " + charsetValues);
}
public MediaType withoutParameters() {
return this.parameters.isEmpty() ? this : create(this.type, this.subtype);
}
public MediaType withParameters(Multimap<String, String> parameters) {
return create(this.type, this.subtype, parameters);
}
public MediaType withParameter(String attribute, String value) {
Preconditions.checkNotNull(attribute);
Preconditions.checkNotNull(value);
String normalizedAttribute = normalizeToken(attribute);
ImmutableListMultimap.Builder<String, String> builder = ImmutableListMultimap.builder();
for (Map.Entry<String, String> entry : this.parameters.entries()) {
String key = (String) entry.getKey();
if (!normalizedAttribute.equals(key)) {
builder.put(key, entry.getValue());
}
}
builder.put(normalizedAttribute, normalizeParameterValue(normalizedAttribute, value));
MediaType mediaType = new MediaType(this.type, this.subtype, builder.build());
return (MediaType) Objects.firstNonNull(KNOWN_TYPES.get(mediaType), mediaType);
}
public MediaType withCharset(Charset charset) {
Preconditions.checkNotNull(charset);
return withParameter("charset", charset.name());
}
public boolean hasWildcard() {
return ("*".equals(this.type)) || ("*".equals(this.subtype));
}
public boolean is(MediaType mediaTypeRange) {
return ((mediaTypeRange.type.equals("*")) || (mediaTypeRange.type.equals(this.type)))
&& ((mediaTypeRange.subtype.equals("*")) || (mediaTypeRange.subtype.equals(this.subtype)))
&& (this.parameters.entries().containsAll(mediaTypeRange.parameters.entries()));
}
public static MediaType create(String type, String subtype) {
return create(type, subtype, ImmutableListMultimap.of());
}
static MediaType createApplicationType(String subtype) {
return create("application", subtype);
}
static MediaType createAudioType(String subtype) {
return create("audio", subtype);
}
static MediaType createImageType(String subtype) {
return create("image", subtype);
}
static MediaType createTextType(String subtype) {
return create("text", subtype);
}
static MediaType createVideoType(String subtype) {
return create("video", subtype);
}
private static MediaType create(
String type, String subtype, Multimap<String, String> parameters) {
Preconditions.checkNotNull(type);
Preconditions.checkNotNull(subtype);
Preconditions.checkNotNull(parameters);
String normalizedType = normalizeToken(type);
String normalizedSubtype = normalizeToken(subtype);
Preconditions.checkArgument(
(!"*".equals(normalizedType)) || ("*".equals(normalizedSubtype)),
"A wildcard type cannot be used with a non-wildcard subtype");
ImmutableListMultimap.Builder<String, String> builder = ImmutableListMultimap.builder();
for (Map.Entry<String, String> entry : parameters.entries()) {
String attribute = normalizeToken((String) entry.getKey());
builder.put(attribute, normalizeParameterValue(attribute, (String) entry.getValue()));
}
MediaType mediaType = new MediaType(normalizedType, normalizedSubtype, builder.build());
return (MediaType) Objects.firstNonNull(KNOWN_TYPES.get(mediaType), mediaType);
}
private static String normalizeToken(String token) {
Preconditions.checkArgument(TOKEN_MATCHER.matchesAllOf(token));
return Ascii.toLowerCase(token);
}
private static String normalizeParameterValue(String attribute, String value) {
return "charset".equals(attribute) ? Ascii.toLowerCase(value) : value;
}
public static MediaType parse(String input) {
Preconditions.checkNotNull(input);
Tokenizer tokenizer = new Tokenizer(input);
try {
String type = tokenizer.consumeToken(TOKEN_MATCHER);
tokenizer.consumeCharacter('/');
String subtype = tokenizer.consumeToken(TOKEN_MATCHER);
ImmutableListMultimap.Builder<String, String> parameters = ImmutableListMultimap.builder();
while (tokenizer.hasMore()) {
tokenizer.consumeCharacter(';');
tokenizer.consumeTokenIfPresent(LINEAR_WHITE_SPACE);
String attribute = tokenizer.consumeToken(TOKEN_MATCHER);
tokenizer.consumeCharacter('=');
String value;
if ('"' == tokenizer.previewChar()) {
tokenizer.consumeCharacter('"');
StringBuilder valueBuilder = new StringBuilder();
while ('"' != tokenizer.previewChar()) {
if ('\\' == tokenizer.previewChar()) {
tokenizer.consumeCharacter('\\');
valueBuilder.append(tokenizer.consumeCharacter(CharMatcher.ASCII));
} else {
valueBuilder.append(tokenizer.consumeToken(QUOTED_TEXT_MATCHER));
}
}
String value = valueBuilder.toString();
tokenizer.consumeCharacter('"');
} else {
value = tokenizer.consumeToken(TOKEN_MATCHER);
}
parameters.put(attribute, value);
}
return create(type, subtype, parameters.build());
} catch (IllegalStateException e) {
throw new IllegalArgumentException("Could not parse '" + input + "'", e);
}
}
private static final class Tokenizer {
final String input;
int position = 0;
Tokenizer(String input) {
this.input = input;
}
String consumeTokenIfPresent(CharMatcher matcher) {
Preconditions.checkState(hasMore());
int startPosition = this.position;
this.position = matcher.negate().indexIn(this.input, startPosition);
return hasMore()
? this.input.substring(startPosition, this.position)
: this.input.substring(startPosition);
}
String consumeToken(CharMatcher matcher) {
int startPosition = this.position;
String token = consumeTokenIfPresent(matcher);
Preconditions.checkState(this.position != startPosition);
return token;
}
char consumeCharacter(CharMatcher matcher) {
Preconditions.checkState(hasMore());
char c = previewChar();
Preconditions.checkState(matcher.matches(c));
this.position += 1;
return c;
}
char consumeCharacter(char c) {
Preconditions.checkState(hasMore());
Preconditions.checkState(previewChar() == c);
this.position += 1;
return c;
}
char previewChar() {
Preconditions.checkState(hasMore());
return this.input.charAt(this.position);
}
boolean hasMore() {
return (this.position >= 0) && (this.position < this.input.length());
}
}
public boolean equals(@Nullable Object obj) {
if (obj == this) {
return true;
}
if ((obj instanceof MediaType)) {
MediaType that = (MediaType) obj;
return (this.type.equals(that.type))
&& (this.subtype.equals(that.subtype))
&& (parametersAsMap().equals(that.parametersAsMap()));
}
return false;
}
public int hashCode() {
return Objects.hashCode(new Object[] {this.type, this.subtype, parametersAsMap()});
}
private static final Joiner.MapJoiner PARAMETER_JOINER =
Joiner.on("; ").withKeyValueSeparator("=");
public String toString() {
StringBuilder builder = new StringBuilder().append(this.type).append('/').append(this.subtype);
if (!this.parameters.isEmpty()) {
builder.append("; ");
Multimap<String, String> quotedParameters =
Multimaps.transformValues(
this.parameters,
new Function() {
public String apply(String value) {
return MediaType.TOKEN_MATCHER.matchesAllOf(value)
? value
: MediaType.escapeAndQuote(value);
}
});
PARAMETER_JOINER.appendTo(builder, quotedParameters.entries());
}
return builder.toString();
}
private static String escapeAndQuote(String value) {
StringBuilder escaped = new StringBuilder(value.length() + 16).append('"');
for (char ch : value.toCharArray()) {
if ((ch == '\r') || (ch == '\\') || (ch == '"')) {
escaped.append('\\');
}
escaped.append(ch);
}
return '"';
}
}
private static String normalizeParameterValue(String attribute, String value) {
return "charset".equals(attribute) ? Ascii.toLowerCase(value) : value;
}
private static String normalizeToken(String token) {
Preconditions.checkArgument(TOKEN_MATCHER.matchesAllOf(token));
return Ascii.toLowerCase(token);
}
