@NotNull
private static Pair<CharSequence, String> convertLineSeparators(@NotNull CharBuffer buffer) {
int dst = 0;
char prev = ' ';
int crCount = 0;
int lfCount = 0;
int crlfCount = 0;
final int length = buffer.length();
final char[] bufferArray = CharArrayUtil.fromSequenceWithoutCopying(buffer);
for (int src = 0; src < length; src++) {
char c = bufferArray != null ? bufferArray[src] : buffer.charAt(src);
switch (c) {
case '\r':
if (bufferArray != null) bufferArray[dst++] = '\n';
else buffer.put(dst++, '\n');
crCount++;
break;
case '\n':
if (prev == '\r') {
crCount--;
crlfCount++;
} else {
if (bufferArray != null) bufferArray[dst++] = '\n';
else buffer.put(dst++, '\n');
lfCount++;
}
break;
default:
if (bufferArray != null) bufferArray[dst++] = c;
else buffer.put(dst++, c);
break;
}
prev = c;
}
String detectedLineSeparator = null;
if (crlfCount > crCount && crlfCount > lfCount) {
detectedLineSeparator = "\r\n";
} else if (crCount > lfCount) {
detectedLineSeparator = "\r";
} else if (lfCount > 0) {
detectedLineSeparator = "\n";
}
CharSequence result;
if (buffer.length() == dst) {
result = buffer;
} else {
// in Mac JDK CharBuffer.subSequence() signature differs from Oracle's
// more than that, the signature has changed between jd6 and jdk7,
// so use more generic CharSequence.subSequence() just in case
@SuppressWarnings("UnnecessaryLocalVariable")
CharSequence seq = buffer;
result = seq.subSequence(0, dst);
}
return Pair.create(result, detectedLineSeparator);
}
private void addCommand(String s) {
CharBuffer buffer = CharBuffer.allocate(s.length() + 1);
buffer.put(s);
buffer.put('\n');
buffer.flip();
_command.compact();
_encoder.encode(buffer, _command, true);
_command.flip();
}
public void char2byte(char[] src, int off, int len, byte[] dst, int off2) {
if (len > (BUFFER_SIZE / 2)) {
CharBuffer buffer = ByteBuffer.wrap(dst, off2, len * 2).order(order).asCharBuffer();
buffer.put(src, off, len);
} else {
charBuffer.clear();
charBuffer.put(src, off, len);
byteBuffer.position(0).limit(len * 2);
byteBuffer.get(dst, off2, len * 2);
}
}
/* */ protected CoderResult decodeLoop(
ByteBuffer paramByteBuffer, CharBuffer paramCharBuffer)
/* */ {
/* 65 */ if (paramByteBuffer.remaining() < 4) /* 66 */ return CoderResult.UNDERFLOW;
/* 67 */ int i = paramByteBuffer.position();
/* */ try
/* */ {
/* */ int j;
/* 70 */ if (this.currentBO == 0) {
/* 71 */ j =
(paramByteBuffer.get() & 0xFF) << 24
| (paramByteBuffer.get() & 0xFF) << 16
| (paramByteBuffer.get() & 0xFF) << 8
| paramByteBuffer.get() & 0xFF;
/* */
/* 75 */ if ((j == 65279) && (this.expectedBO != 2)) {
/* 76 */ this.currentBO = 1;
/* 77 */ i += 4;
/* 78 */ } else if ((j == -131072) && (this.expectedBO != 1)) {
/* 79 */ this.currentBO = 2;
/* 80 */ i += 4;
/* */ } else {
/* 82 */ if (this.expectedBO == 0) /* 83 */ this.currentBO = 1;
/* */ else /* 85 */ this.currentBO = this.expectedBO;
/* 86 */ paramByteBuffer.position(i);
/* */ }
/* */ }
/* */ CoderResult localCoderResult;
/* 89 */ while (paramByteBuffer.remaining() >= 4) {
/* 90 */ j = getCP(paramByteBuffer);
/* 91 */ if (Character.isBmpCodePoint(j)) {
/* 92 */ if (!paramCharBuffer.hasRemaining()) /* 93 */ return CoderResult.OVERFLOW;
/* 94 */ i += 4;
/* 95 */ paramCharBuffer.put((char) j);
/* 96 */ } else if (Character.isValidCodePoint(j)) {
/* 97 */ if (paramCharBuffer.remaining() < 2) /* 98 */ return CoderResult.OVERFLOW;
/* 99 */ i += 4;
/* 100 */ paramCharBuffer.put(Character.highSurrogate(j));
/* 101 */ paramCharBuffer.put(Character.lowSurrogate(j));
/* */ } else {
/* 103 */ return CoderResult.malformedForLength(4);
/* */ }
/* */ }
/* 106 */ return CoderResult.UNDERFLOW;
/* */ } finally {
/* 108 */ paramByteBuffer.position(i);
/* */ }
/* */ }
@Override
public void add() {
boolean done = false;
int pos = size - 1;
while (pos >= 0 && !done) {
char c = buffer.get(pos);
if (c == '9') {
buffer.put(pos, '0');
pos--;
} else {
c++;
buffer.put(pos, c);
done = true;
}
}
}
@Override
public void zero() {
buffer.rewind();
for (int x = 0; x < size; x++) {
buffer.put('0');
}
}
protected CoderResult decodeLoop(ByteBuffer in, CharBuffer out) {
while (true) {
if (in.remaining() < 1) return CoderResult.UNDERFLOW;
in.mark();
byte b = in.get();
char c = (char) (b & 0x7f);
if (CodingErrorAction.REPORT == unmappableCharacterAction()
&& !PrintableCharset.isPrintableChar(c)) {
/*
"bug" fix for 359010
return CoderResult.unmappableForLength(1);
*/
continue;
}
if (out.remaining() < 1) {
in.reset();
return CoderResult.OVERFLOW;
}
out.put(c);
}
}
/**
* Send as many items as possible from this buffer to the given byte buffer.
*
* <p>The <TT>sendItems()</TT> method must not block the calling thread; if it does, all message
* I/O in MP will be blocked.
*
* @param i Index of first item to send, in the range 0 .. <TT>length</TT>-1.
* @param buffer Byte buffer.
* @return Number of items sent.
*/
protected int sendItems(int i, ByteBuffer buffer) {
CharBuffer charbuffer = buffer.asCharBuffer();
int n = 0;
int r = i2r(i);
int row = r * myRowStride + myLowerRow;
int c = i2c(i);
int col = c * myColStride + myLowerCol;
int ncols = Math.min(myColCount - c, charbuffer.remaining());
while (r < myRowCount && ncols > 0) {
char[] myMatrix_row = myMatrix[row];
while (c < ncols) {
charbuffer.put(myMatrix_row[col]);
++c;
col += myColStride;
}
n += ncols;
++r;
row += myRowStride;
c = 0;
col = myLowerCol;
ncols = Math.min(myColCount, charbuffer.remaining());
}
buffer.position(buffer.position() + 2 * n);
return n;
}
@Override
public final boolean incrementToken() throws IOException {
if (isMailto) {
termAtt.setEmpty();
// return the scheme + the mail part
isMailto = false;
posIncrAtt.setPositionIncrement(0);
termAtt.copyBuffer(termBuffer.array(), 0, termBuffer.position());
return true;
}
if (input.incrementToken()) {
final String type = typeAtt.type();
if (type.equals(TupleTokenizer.getTokenTypes()[TupleTokenizer.URI])
&& this.isMailtoScheme()) {
this.updateBuffer();
termBuffer.put(termAtt.buffer(), 0, termAtt.length());
// return only the mail part
posIncrAtt.setPositionIncrement(1);
termAtt.copyBuffer(termBuffer.array(), 7, termBuffer.position() - 7);
}
return true;
}
return false;
}
/**
* Write a string to the network. The length header of the string is written automatically and its
* encoded to the correct CharSet automatically.
*
* @param value the string that shall be send to the server
*/
@Override
public void writeString(@Nonnull String value) throws CharacterCodingException {
int startIndex = buffer.position();
buffer.putShort((short) 0);
encodingBuffer.clear();
encodingBuffer.put(value, 0, Math.min(encodingBuffer.capacity(), value.length()));
encodingBuffer.flip();
do {
CoderResult encodingResult = encoder.encode(encodingBuffer, buffer, true);
if (!encodingResult.isError()) {
break;
}
if (encodingResult.isUnmappable()) {
log.warn(
"Found a character that failed to encode for the transfer to the server: {} - SKIP",
encodingBuffer.get());
} else {
encodingResult.throwException();
}
} while (encodingBuffer.hasRemaining());
int lastIndex = buffer.position();
buffer.position(startIndex);
writeUShort(lastIndex - startIndex - 2);
buffer.position(lastIndex);
}
static byte[] encode(char[] cc, Charset cs, boolean testDirect, Time t) throws Exception {
ByteBuffer bbf;
CharBuffer cbf;
CharsetEncoder enc = cs.newEncoder();
String csn = cs.name();
if (testDirect) {
bbf = ByteBuffer.allocateDirect(cc.length * 4);
cbf = ByteBuffer.allocateDirect(cc.length * 2).asCharBuffer();
cbf.put(cc).flip();
} else {
bbf = ByteBuffer.allocate(cc.length * 4);
cbf = CharBuffer.wrap(cc);
}
CoderResult cr = null;
long t1 = System.nanoTime() / 1000;
for (int i = 0; i < iteration; i++) {
cbf.rewind();
bbf.clear();
enc.reset();
cr = enc.encode(cbf, bbf, true);
}
long t2 = System.nanoTime() / 1000;
t.t = (t2 - t1) / iteration;
if (cr != CoderResult.UNDERFLOW) {
System.out.println("ENC-----------------");
int pos = cbf.position();
System.out.printf(" cr=%s, cbf.pos=%d, cc[pos]=%x%n", cr.toString(), pos, cc[pos] & 0xffff);
throw new RuntimeException("Encoding err: " + csn);
}
byte[] bb = new byte[bbf.position()];
bbf.flip();
bbf.get(bb);
return bb;
}
public void init(float vertices[], float normals[], float texcoords[], char indices[]) {
int nbVertex = vertices.length / 3;
mVertices = FloatBuffer.allocate(nbVertex * D3DMesh.nbFloatPerVertex);
for (int i = 0; i < nbVertex; i++) {
float px = vertices[i * 3];
float py = vertices[i * 3 + 1];
float pz = vertices[i * 3 + 2];
float nx = 0f;
float ny = 0f;
float nz = 0f;
if (normals != null) {
nx = normals[i * 3];
ny = normals[i * 3 + 1];
nz = normals[i * 3 + 2];
}
float tx = 0f;
float ty = 0f;
if (texcoords != null) {
tx = texcoords[i * 2];
ty = texcoords[i * 2 + 1];
}
this.addPoint(px, py, pz, nx, ny, nz, tx, ty);
}
mVertices.position(0);
mIndices = CharBuffer.allocate(indices.length);
mIndices.put(indices);
mIndices.position(0);
}
/**
* Attempts to read characters into the specified character buffer. The buffer is used as a
* repository of characters as-is: the only changes made are the results of a put operation. No
* flipping or rewinding of the buffer is performed.
*
* @param target the buffer to read characters into
* @return The number of characters added to the buffer, or -1 if this source of characters is at
* its end
* @throws IOException if an I/O error occurs
* @throws NullPointerException if target is null
* @throws java.nio.ReadOnlyBufferException if target is a read only buffer
* @since 1.5
*/
public int read(java.nio.CharBuffer target) throws IOException {
int len = target.remaining();
char[] cbuf = new char[len];
int n = read(cbuf, 0, len);
if (n > 0) target.put(cbuf, 0, n);
return n;
}
@Override
public boolean onStdinCharsReady(CharBuffer buffer) {
if (utf8Buffer.remaining() <= buffer.remaining()) {
charsWritten += utf8Buffer.remaining();
buffer.put(utf8Buffer);
buffer.flip();
return false;
} else {
charsWritten += buffer.remaining();
buffer.put(utf8Buffer.subSequence(0, buffer.remaining()));
buffer.flip();
utf8Buffer.position(utf8Buffer.position() + buffer.remaining());
stdinOverflow = true;
return true;
}
}
protected PlaceNameChunk createPlaceNameChunk(PlaceNameService service) {
int numChars = this.textArray.length();
CharBuffer textBuffer = newCharBuffer(numChars);
textBuffer.put(this.textArray.toString());
textBuffer.rewind();
return new PlaceNameChunk(
service, textBuffer, this.textIndexArray, this.latlonArray, this.numEntries);
}
// 将字符转为字节(编码)
public static byte[] getBytes(char[] chars) {
Charset cs = Charset.forName("UTF-8");
CharBuffer cb = CharBuffer.allocate(chars.length);
cb.put(chars);
cb.flip();
ByteBuffer bb = cs.encode(cb);
return bb.array();
}
private void ensureCharBuffRemaining(final int size) {
if (charBuff.remaining() < size) {
final int cpcty = (charBuff.capacity() + size) * 2;
final java.nio.CharBuffer newChBuf = java.nio.CharBuffer.allocate(cpcty);
newChBuf.put(charBuff);
charBuff = newChBuf;
}
}
private static boolean fillBuffer(CharBuffer buffer) {
if (index >= strings.length) {
return false;
}
String string = strings[index++];
for (int i = 0; i < string.length(); i++) {
buffer.put(string.charAt(i));
}
return true;
}
protected CoderResult decodeLoop(ByteBuffer src, CharBuffer dst) {
if (src.remaining() < 4) return CoderResult.UNDERFLOW;
int mark = src.position();
int cp;
try {
if (currentBO == NONE) {
cp =
((src.get() & 0xff) << 24)
| ((src.get() & 0xff) << 16)
| ((src.get() & 0xff) << 8)
| (src.get() & 0xff);
if (cp == BOM_BIG && expectedBO != LITTLE) {
currentBO = BIG;
mark += 4;
} else if (cp == BOM_LITTLE && expectedBO != BIG) {
currentBO = LITTLE;
mark += 4;
} else {
if (expectedBO == NONE) currentBO = BIG;
else currentBO = expectedBO;
src.position(mark);
}
}
while (src.remaining() >= 4) {
cp = getCP(src);
if (Character.isBmpCodePoint(cp)) {
if (!dst.hasRemaining()) return CoderResult.OVERFLOW;
mark += 4;
dst.put((char) cp);
} else if (Character.isValidCodePoint(cp)) {
if (dst.remaining() < 2) return CoderResult.OVERFLOW;
mark += 4;
dst.put(Character.highSurrogate(cp));
dst.put(Character.lowSurrogate(cp));
} else {
return CoderResult.malformedForLength(4);
}
}
return CoderResult.UNDERFLOW;
} finally {
src.position(mark);
}
}
@Override
public int read(CharBuffer target) throws IOException {
int len = target.remaining();
char[] cbuf = new char[len];
int n = read(cbuf, 0, len);
if (n > 0) {
target.put(cbuf, 0, n);
}
return n;
}
private void emit(int c) throws IOException {
assert c >= 0;
CharBuffer buf = lineBuffer;
if (buf.remaining() == 0) {
if (buf.capacity() == BUFFER_LIMIT) {
throw new IOException(
MessageFormat.format(
"Line is too large (near {0}:{1}, size={2}, record-number={3})",
path, currentPhysicalHeadLine, BUFFER_LIMIT, currentRecordNumber));
}
CharBuffer newBuf = CharBuffer.allocate(Math.min(buf.capacity() * 2, BUFFER_LIMIT));
newBuf.clear();
buf.flip();
newBuf.put(buf);
buf = newBuf;
lineBuffer = newBuf;
}
buf.put((char) c);
}
public void putTriangle(
float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3) {
// System.out.println("A= "+x1+" "+y1+" "+z1);
// System.out.println("B= "+x2+" "+y2+" "+z2);
// System.out.println("C= "+x3+" "+y3+" "+z3);
int indice = mVertices.position() / D3DMesh.nbFloatPerVertex;
// int indice = mVertices.position();
mVertices.put(x1);
mVertices.put(y1);
mVertices.put(z1);
mVertices.put(0f);
mVertices.put(0f);
mVertices.put(0f);
mVertices.put(0f);
mVertices.put(0f);
mVertices.put(x2);
mVertices.put(y2);
mVertices.put(z2);
mVertices.put(0f);
mVertices.put(0f);
mVertices.put(0f);
mVertices.put(0f);
mVertices.put(0f);
mVertices.put(x3);
mVertices.put(y3);
mVertices.put(z3);
mVertices.put(0f);
mVertices.put(0f);
mVertices.put(0f);
mVertices.put(0f);
mVertices.put(0f);
mIndices.put((char) indice);
mIndices.put((char) (indice + 1));
mIndices.put((char) (indice + 2));
}
private ByteBuffer charSequenceToBytes(final CharSequence word) throws UnmappableInputException {
// Encode word characters into bytes in the same encoding as the FSA's.
charBuffer = BufferUtils.clearAndEnsureCapacity(charBuffer, word.length());
for (int i = 0; i < word.length(); i++) {
final char chr = word.charAt(i);
charBuffer.put(chr);
}
charBuffer.flip();
return BufferUtils.charsToBytes(encoder, charBuffer, byteBuffer);
}
public static void main(String[] args) throws Exception {
// 创建简体中文对应的Charset
Charset cn = Charset.forName("GBK");
// 获取cn对象对应的编码器和解码器
CharsetEncoder cnEncoder = cn.newEncoder();
CharsetDecoder cnDecoder = cn.newDecoder();
// 创建一个CharBuffer对象
CharBuffer cbuff = CharBuffer.allocate(8);
cbuff.put('孙');
cbuff.put('悟');
cbuff.put('空');
cbuff.flip();
// 将CharBuffer中的字符序列转换成字节序列
ByteBuffer bbuff = cnEncoder.encode(cbuff);
// 循环访问ByteBuffer中的每个字节
for (int i = 0; i < bbuff.capacity(); i++) {
System.out.print(bbuff.get(i) + " ");
}
// 将ByteBuffer的数据解码成字符序列
System.out.println("\n" + cnDecoder.decode(bbuff));
}
private String generateRandomStringData(int dataSize) {
/*
* Generate a random string of "words" using random single and multi-byte characters that are
* separated by punctuation marks and whitespace.
*/
String punctuationChars = "!,.;?";
int wordLength = maxWordLength;
CharBuffer data = CharBuffer.allocate(dataSize);
while (data.remaining() > 0) {
String word;
if (limitWordCount) {
word = pickRandomWord(wordLength);
} else {
word = generateRandomUniqueWord(wordLength, true);
}
data = data.put(word);
countOfWordsInData++;
if (wordCount.containsKey(word)) {
wordCount.put(word, wordCount.get(word) + 1);
} else {
wordCount.put(word, 1);
}
if (data.remaining() >= 2 && random.nextInt() % newlinePunctuationModulo == 0) {
data.put(punctuationChars.charAt(random.nextInt(punctuationChars.length() - 1)));
data.put('\n');
} else {
if (data.remaining() >= 1) {
data.put(' ');
}
}
if (data.remaining() < wordLength) {
wordLength = data.remaining();
}
}
return data.rewind().toString();
}
private static CharBuffer allocate(CharBuffer buffer, int length) {
if (buffer == null) {
length = Math.max(length * 3 / 2, DEFAULT_BUFFER_CAPACITY);
return CharBuffer.allocate(length);
}
if (buffer.remaining() < length) {
CharBuffer expandedBuffer = CharBuffer.allocate((buffer.position() + length) * 3 / 2);
buffer.flip();
expandedBuffer.put(buffer);
return expandedBuffer;
}
return buffer;
}
@Override
public synchronized int read(CharBuffer target) throws IOException {
checkNotNull(target);
checkOpen();
if (!hasRemaining()) {
return -1;
}
int charsToRead = Math.min(target.remaining(), remaining());
for (int i = 0; i < charsToRead; i++) {
target.put(seq.charAt(pos++));
}
return charsToRead;
}
public LinkedList<CharBuffer> permuteTerms(char[] term, int offset, int end) {
LinkedList<CharBuffer> buffers = new LinkedList<CharBuffer>();
int i = offset;
for (; i < end; i++) {
if (term[i] == tokenDelimiter) {
int k = offset;
for (; k < i; k++) {
if (term[k] == pipe) {
break;
}
}
LinkedList<CharBuffer> nextBuffers = permuteTerms(term, i + 1, end);
Iterator iter = nextBuffers.iterator();
while (iter.hasNext()) {
CharBuffer formBuffer = CharBuffer.allocate(end - offset);
formBuffer.put((CharBuffer) iter.next());
/*if (k<i) {
formBuffer.put(term, k+1, i-k);
//formBuffer.put(term, offset, k-offset);
}
else {
formBuffer.put(term, offset, i-offset);
//formBuffer.put(term, offset, i-offset);
}*/
// formBuffer.put(' ');
buffers.add(formBuffer);
}
return buffers;
}
}
// i = length
CharBuffer formBuffer = CharBuffer.allocate(2);
formBuffer.put("hello", 0, 2);
buffers.add(formBuffer);
return buffers;
}
public void copy(D3DMesh mesh) {
mIndices = CharBuffer.allocate(mesh.mIndices.position());
mVertices = FloatBuffer.allocate(mesh.mVertices.position());
for (int j = 0; j < mIndices.capacity(); j++) mIndices.put(mesh.mIndices.get(j));
for (int j = 0; j < mVertices.capacity(); j++) {
mVertices.put(mesh.mVertices.get(j));
}
mIndices.position(0);
mVertices.position(0);
}
private void fillCharBuf() throws IOException {
int limit = 0;
int c = 0;
do {
c = _delegate.read();
if (c >= 0) {
_charBuf.put((char) c);
limit++;
}
} while ((c >= 0xD800) && (c <= 0xDBFF));
_charBuf.position(0);
_charBuf.limit(limit);
}