public static char unboxed(Character v) { return v == null ? '\0' : v.charValue(); }
public static char unboxed(Character v) { return v == null ? '\0' : v.charValue(); }
private char objectToKey(Object key) { return (char) ((Character) key).charValue(); }
private char objectToKey(Object key) { return (char) ((Character) key).charValue(); }
/** * Converts to primitive array. */ public static char[] values(Character[] array) { char[] dest = new char[array.length]; for (int i = 0; i < array.length; i++) { Character v = array[i]; if (v != null) { dest[i] = v.charValue(); } } return dest; } /**
@Override CharSequence trimTrailingPadding(CharSequence chars) { checkNotNull(chars); if (paddingChar == null) { return chars; } char padChar = paddingChar.charValue(); int l; for (l = chars.length() - 1; l >= 0; l--) { if (chars.charAt(l) != padChar) { break; } } return chars.subSequence(0, l + 1); }
@Override public BaseEncoding withPadChar(char padChar) { if (8 % alphabet.bitsPerChar == 0 || (paddingChar != null && paddingChar.charValue() == padChar)) { return this; } else { return newInstance(alphabet, padChar); } }
@Override public T convert(Character source) { return NumberUtils.convertNumberToTargetClass((short) source.charValue(), this.targetType); } }
@Override public void close() throws IOException { if (bitBufferLength > 0) { int charIndex = (bitBuffer << (alphabet.bitsPerChar - bitBufferLength)) & alphabet.mask; out.write(alphabet.encode(charIndex)); writtenChars++; if (paddingChar != null) { while (writtenChars % alphabet.charsPerChunk != 0) { out.write(paddingChar.charValue()); writtenChars++; } } } out.close(); } };
@Override public BaseEncoding withPadChar(char padChar) { if (8 % alphabet.bitsPerChar == 0 || (paddingChar != null && paddingChar.charValue() == padChar)) { return this; } else { return newInstance(alphabet, padChar); } }
@Override public BaseEncoding withSeparator(String separator, int afterEveryChars) { for (int i = 0; i < separator.length(); i++) { checkArgument( !alphabet.matches(separator.charAt(i)), "Separator (%s) cannot contain alphabet characters", separator); } if (paddingChar != null) { checkArgument( separator.indexOf(paddingChar.charValue()) < 0, "Separator (%s) cannot contain padding character", separator); } return new SeparatedBaseEncoding(this, separator, afterEveryChars); }
/** * Converts value to <code>char</code>. Returns default value * when conversion result is <code>null</code>. */ public char toCharValue(Object value, char defaultValue) { Character result = (Character) typeConverters[13].convert(value); if (result == null) { return defaultValue; } return result.charValue(); }
@Override public void encodeToWire(Buffer buffer, Character chr) { buffer.appendShort((short)chr.charValue()); }
/** * Converts type using type converter manager. */ protected char convertType(Object value) { return typeConverterManagerBean.convertType(value, char.class).charValue(); }
protected String objectToString(Object o) { if ( o == null ) { return "NULL"; } if ( o.getClass().isArray() ) return arrayToString(o); if ( o instanceof String ) { return "\""+o+"\""; } if ( o instanceof Character ) return "'"+o+"'("+(int)((Character) o).charValue()+")"; return ""+o; }
@Override public void writeObject(FSTObjectOutput out, Object toWrite, FSTClazzInfo clzInfo, FSTClazzInfo.FSTFieldInfo referencedBy, int streamPosition) throws IOException { out.writeChar(((Character)toWrite).charValue()); }
@Override public BaseEncoding withPadChar(char padChar) { if (8 % alphabet.bitsPerChar == 0 || (paddingChar != null && paddingChar.charValue() == padChar)) { return this; } else { return newInstance(alphabet, padChar); } }
void encodeChunkTo(Appendable target, byte[] bytes, int off, int len) throws IOException { checkNotNull(target); checkPositionIndexes(off, off + len, bytes.length); checkArgument(len <= alphabet.bytesPerChunk); long bitBuffer = 0; for (int i = 0; i < len; ++i) { bitBuffer |= bytes[off + i] & 0xFF; bitBuffer <<= 8; // Add additional zero byte in the end. } // Position of first character is length of bitBuffer minus bitsPerChar. final int bitOffset = (len + 1) * 8 - alphabet.bitsPerChar; int bitsProcessed = 0; while (bitsProcessed < len * 8) { int charIndex = (int) (bitBuffer >>> (bitOffset - bitsProcessed)) & alphabet.mask; target.append(alphabet.encode(charIndex)); bitsProcessed += alphabet.bitsPerChar; } if (paddingChar != null) { while (bitsProcessed < alphabet.bytesPerChunk * 8) { target.append(paddingChar.charValue()); bitsProcessed += alphabet.bitsPerChar; } } }
public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException { SerializeWriter out = serializer.out; Character value = (Character) object; if (value == null) { out.writeString(""); return; } char c = value.charValue(); if (c == 0) { out.writeString("\u0000"); } else { out.writeString(value.toString()); } }
public void testGetDefaultValue() { assertEquals(false, Defaults.defaultValue(boolean.class).booleanValue()); assertEquals('\0', Defaults.defaultValue(char.class).charValue()); assertEquals(0, Defaults.defaultValue(byte.class).byteValue()); assertEquals(0, Defaults.defaultValue(short.class).shortValue()); assertEquals(0, Defaults.defaultValue(int.class).intValue()); assertEquals(0, Defaults.defaultValue(long.class).longValue()); assertEquals(0.0f, Defaults.defaultValue(float.class).floatValue()); assertEquals(0.0d, Defaults.defaultValue(double.class).doubleValue()); assertNull(Defaults.defaultValue(void.class)); assertNull(Defaults.defaultValue(String.class)); } }