Java CodingErrorAction.REPLACE属性代码示例

public B2CConverter(String encoding, boolean replaceOnError)
        throws IOException {
    byte[] left = new byte[LEFTOVER_SIZE];
    leftovers = ByteBuffer.wrap(left);
    CodingErrorAction action;
    if (replaceOnError) {
        action = CodingErrorAction.REPLACE;
    } else {
        action = CodingErrorAction.REPORT;
    }
    Charset charset = getCharset(encoding);
    // Special case. Use the Apache Harmony based UTF-8 decoder because it
    // - a) rejects invalid sequences that the JVM decoder does not
    // - b) fails faster for some invalid sequences
    if (charset.equals(UTF_8)) {
        decoder = new Utf8Decoder();
    } else {
        decoder = charset.newDecoder();
    }
    decoder.onMalformedInput(action);
    decoder.onUnmappableCharacter(action);
}
 

public CharsetDecoder getDecoder(String encodingName, boolean ignoreEncodingErrors) {
    Charset cs = (this.charset == null)
        ? Charset.forName(encodingName)
        : this.charset;
    CharsetDecoder decoder = cs.newDecoder();

    CodingErrorAction action;
    if (ignoreEncodingErrors)
        action = CodingErrorAction.REPLACE;
    else
        action = CodingErrorAction.REPORT;

    return decoder
        .onMalformedInput(action)
        .onUnmappableCharacter(action);
}
 

public B2CConverter(String encoding, boolean replaceOnError) throws IOException {
	byte[] left = new byte[LEFTOVER_SIZE];
	leftovers = ByteBuffer.wrap(left);
	CodingErrorAction action;
	if (replaceOnError) {
		action = CodingErrorAction.REPLACE;
	} else {
		action = CodingErrorAction.REPORT;
	}
	Charset charset = getCharset(encoding);
	// Special case. Use the Apache Harmony based UTF-8 decoder because it
	// - a) rejects invalid sequences that the JVM decoder does not
	// - b) fails faster for some invalid sequences
	if (charset.equals(UTF_8)) {
		decoder = new Utf8Decoder();
	} else {
		decoder = charset.newDecoder();
	}
	decoder.onMalformedInput(action);
	decoder.onUnmappableCharacter(action);
}
 

/**
 *
 * @param file
 *        File to read
 *
 * @param tracker
 *        PositionTracker implementation to make offset position durable
 *
 * @param bufSize
 *        Size of the underlying buffer used for input. If lesser than {@link #MIN_BUF_SIZE},
 *        a buffer of length {@link #MIN_BUF_SIZE} will be created instead.
 *
 * @param charset
 *        Character set used for decoding text, as necessary
 *
 * @param decodeErrorPolicy
 *        A {@link DecodeErrorPolicy} instance to determine how
 *        the decoder should behave in case of malformed input and/or
 *        unmappable character.
 *
 * @throws FileNotFoundException If the file to read does not exist
 * @throws IOException If the position reported by the tracker cannot be sought
 */
public ResettableFileInputStream(File file, PositionTracker tracker,
    int bufSize, Charset charset, DecodeErrorPolicy decodeErrorPolicy)
    throws IOException {
  this.file = file;
  this.tracker = tracker;
  this.in = new FileInputStream(file);
  this.chan = in.getChannel();
  this.buf = ByteBuffer.allocateDirect(Math.max(bufSize, MIN_BUF_SIZE));
  buf.flip();
  this.byteBuf = new byte[1]; // single byte
  this.charBuf = CharBuffer.allocate(2); // two chars for surrogate pairs
  charBuf.flip();
  this.fileSize = file.length();
  this.decoder = charset.newDecoder();
  this.position = 0;
  this.syncPosition = 0;
  if (charset.name().startsWith("UTF-8")) {
    // some JDKs wrongly report 3 bytes max
    this.maxCharWidth = 4;
  } else if (charset.name().startsWith("UTF-16")) {
    // UTF_16BE and UTF_16LE wrongly report 2 bytes max
    this.maxCharWidth = 4;
  } else if (charset.name().startsWith("UTF-32")) {
    // UTF_32BE and UTF_32LE wrongly report 4 bytes max
    this.maxCharWidth = 8;
  } else {
    this.maxCharWidth = (int) Math.ceil(charset.newEncoder().maxBytesPerChar());
  }

  CodingErrorAction errorAction;
  switch (decodeErrorPolicy) {
    case FAIL:
      errorAction = CodingErrorAction.REPORT;
      break;
    case REPLACE:
      errorAction = CodingErrorAction.REPLACE;
      break;
    case IGNORE:
      errorAction = CodingErrorAction.IGNORE;
      break;
    default:
      throw new IllegalArgumentException(
          "Unexpected value for decode error policy: " + decodeErrorPolicy);
  }
  decoder.onMalformedInput(errorAction);
  decoder.onUnmappableCharacter(errorAction);

  seek(tracker.getPosition());
}
 

public int encode(char[] sa, int sp, int len, byte[] da) {
    int sl = sp + len;
    int dp = 0;
    int dlASCII = dp + Math.min(len, da.length);

    // ASCII only optimized loop
    while (dp < dlASCII && sa[sp] < '\u0080')
        da[dp++] = (byte) sa[sp++];

    while (sp < sl) {
        char c = sa[sp++];
        if (c < 0x80) {
            // Have at most seven bits
            da[dp++] = (byte)c;
        } else if (c < 0x800) {
            // 2 bytes, 11 bits
            da[dp++] = (byte)(0xc0 | (c >> 6));
            da[dp++] = (byte)(0x80 | (c & 0x3f));
        } else if (Character.isSurrogate(c)) {
            if (sgp == null)
                sgp = new Surrogate.Parser();
            int uc = sgp.parse(c, sa, sp - 1, sl);
            if (uc < 0) {
                if (malformedInputAction() != CodingErrorAction.REPLACE)
                    return -1;
                da[dp++] = replacement()[0];
            } else {
                to3Bytes(da, dp, Character.highSurrogate(uc));
                dp += 3;
                to3Bytes(da, dp, Character.lowSurrogate(uc));
                dp += 3;
                sp++;  // 2 chars
            }
        } else {
            // 3 bytes, 16 bits
            to3Bytes(da, dp, c);
            dp += 3;
        }
    }
    return dp;
}
 

public int encode(char[] sa, int sp, int len, byte[] da) {
    int sl = sp + len;
    int dp = 0;
    int dlASCII = dp + Math.min(len, da.length);

    // ASCII only optimized loop
    while (dp < dlASCII && sa[sp] < '\u0080')
        da[dp++] = (byte) sa[sp++];

    while (sp < sl) {
        char c = sa[sp++];
        if (c < 0x80) {
            // Have at most seven bits
            da[dp++] = (byte)c;
        } else if (c < 0x800) {
            // 2 bytes, 11 bits
            da[dp++] = (byte)(0xc0 | (c >> 6));
            da[dp++] = (byte)(0x80 | (c & 0x3f));
        } else if (Character.isSurrogate(c)) {
            if (sgp == null)
                sgp = new Surrogate.Parser();
            int uc = sgp.parse(c, sa, sp - 1, sl);
            if (uc < 0) {
                if (malformedInputAction() != CodingErrorAction.REPLACE)
                    return -1;
                da[dp++] = repl;
            } else {
                da[dp++] = (byte)(0xf0 | ((uc >> 18)));
                da[dp++] = (byte)(0x80 | ((uc >> 12) & 0x3f));
                da[dp++] = (byte)(0x80 | ((uc >>  6) & 0x3f));
                da[dp++] = (byte)(0x80 | (uc & 0x3f));
                sp++;  // 2 chars
            }
        } else {
            // 3 bytes, 16 bits
            da[dp++] = (byte)(0xe0 | ((c >> 12)));
            da[dp++] = (byte)(0x80 | ((c >>  6) & 0x3f));
            da[dp++] = (byte)(0x80 | (c & 0x3f));
        }
    }
    return dp;
}