Java CharsetEncoder.canEncode方法代码示例

import java.nio.charset.CharsetEncoder; //导入方法依赖的package包/类
/**
 * Create a text response with known length.
 */
public static Response newFixedLengthResponse(IStatus status, String mimeType, String txt) {
    ContentType contentType = new ContentType(mimeType);
    if (txt == null) {
        return newFixedLengthResponse(status, mimeType, new ByteArrayInputStream(new byte[0]), 0);
    } else {
        byte[] bytes;
        try {
            CharsetEncoder newEncoder = Charset.forName(contentType.getEncoding()).newEncoder();
            if (!newEncoder.canEncode(txt)) {
                contentType = contentType.tryUTF8();
            }
            bytes = txt.getBytes(contentType.getEncoding());
        } catch (UnsupportedEncodingException e) {
            NanoHTTPD.LOG.log(Level.SEVERE, "encoding problem, responding nothing", e);
            bytes = new byte[0];
        }
        return newFixedLengthResponse(status, contentType.getContentTypeHeader(), new ByteArrayInputStream(bytes), bytes.length);
    }
}
 

import java.nio.charset.CharsetEncoder; //导入方法依赖的package包/类
private boolean checkCharsetConversion(final String encoding) {
    boolean value = true;
    try {
        CharsetEncoder coder = Charset.forName(encoding).newEncoder();
        if (!coder.canEncode(getDocument().getText(0, getDocument().getLength()))){
            NotifyDescriptor nd = new NotifyDescriptor.Confirmation(
                    NbBundle.getMessage(XmlMultiViewEditorSupport.class, "MSG_BadCharConversion",
                    new Object [] { getDataObject().getPrimaryFile().getNameExt(),
                    encoding}),
                    NotifyDescriptor.YES_NO_OPTION,
                    NotifyDescriptor.WARNING_MESSAGE);
            nd.setValue(NotifyDescriptor.NO_OPTION);
            DialogDisplayer.getDefault().notify(nd);
            if(nd.getValue() != NotifyDescriptor.YES_OPTION) {
                value = false;
            }
        }
    } catch (BadLocationException e){
        ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, e);
    }
    return value;
}
 

import java.nio.charset.CharsetEncoder; //导入方法依赖的package包/类
public static Response newFixedLengthResponse(Response.IStatus status, String mimeType, String txt) {
    ContentType contentType = new ContentType(mimeType);
    if (txt == null) {
        return newFixedLengthResponse(status, mimeType, new ByteArrayInputStream(new byte[0]), 0);
    } else {
        byte[] bytes;
        try {
            CharsetEncoder newEncoder = Charset.forName(contentType.getEncoding()).newEncoder();
            if (!newEncoder.canEncode(txt)) {
                contentType = contentType.tryUTF8();
            }
            bytes = txt.getBytes(contentType.getEncoding());
        } catch (UnsupportedEncodingException e) {
            NanoHTTPD.LOG.log(Level.SEVERE, "encoding problem, responding nothing", e);
            bytes = new byte[0];
        }
        return newFixedLengthResponse(status, contentType.getContentTypeHeader(), new ByteArrayInputStream(bytes), bytes.length);
    }
}
 

import java.nio.charset.CharsetEncoder; //导入方法依赖的package包/类
/**
 * Check the value can be encoded with the specified encoding
 * @return
 */
public boolean canBeEncoded()
{
    //Try and write to buffer using the CharSet defined by the textEncoding field (note if using UTF16 we dont
    //need to worry about LE,BE at this point it makes no difference)
    final byte textEncoding = this.getBody().getTextEncoding();
    final TextEncoding encoding = TextEncoding.getInstanceOf();
    final Charset charset = encoding.getCharsetForId(textEncoding);
    CharsetEncoder encoder = charset.newEncoder();

    if (encoder.canEncode((String) value))
    {
        return true;
    }
    else
    {
        logger.finest("Failed Trying to decode" + value + "with" + encoder.toString());
        return false;
    }
}
 

import java.nio.charset.CharsetEncoder; //导入方法依赖的package包/类
/**
 * If the description cannot be encoded using the current encoding change the encoder
 */
public void write(ByteArrayOutputStream tagBuffer)
{
    CharsetEncoder encoder = StandardCharsets.ISO_8859_1.newEncoder();
    String origUrl = getUrlLink();
    if (!encoder.canEncode(origUrl))
    {
        //ALL W Frames only support ISO-8859-1 for the url itself, if unable to encode let us assume
        //the link just needs url encoding
        setUrlLink(encodeURL(origUrl));

        //We still cant convert so just set log error and set to blank to allow save to continue
        if (!encoder.canEncode(getUrlLink()))
        {
            logger.warning(ErrorMessage.MP3_UNABLE_TO_ENCODE_URL.getMsg(origUrl));
            setUrlLink("");
        }
        //it was ok, just note the modification made
        else
        {
            logger.warning(ErrorMessage.MP3_URL_SAVED_ENCODED.getMsg(origUrl, getUrlLink()));
        }
    }
    super.write(tagBuffer);
}
 

import java.nio.charset.CharsetEncoder; //导入方法依赖的package包/类
/**
 * 创建一个已知大小的（超）文本相应
 */
public static Response newFixedLengthResponse(Response.IStatus status, String mimeType, String txt) {
    ContentType contentType = new ContentType(mimeType);
    if (txt == null) {
        return newFixedLengthResponse(status, mimeType, new ByteArrayInputStream(new byte[0]), 0);
    } else {
        byte[] bytes;
        try {
            CharsetEncoder newEncoder = Charset.forName(contentType.getEncoding()).newEncoder();
            if (!newEncoder.canEncode(txt)) {
                contentType = contentType.tryUTF8();
            }
            bytes = txt.getBytes(contentType.getEncoding());
        } catch (UnsupportedEncodingException e) {
            NanoHTTPD.LOG.log(Level.SEVERE, "encoding problem, responding nothing", e);
            bytes = new byte[0];
        }
        return newFixedLengthResponse(status, contentType.getContentTypeHeader(), new ByteArrayInputStream(bytes), bytes.length);
    }
}
 

import java.nio.charset.CharsetEncoder; //导入方法依赖的package包/类
/**
 * If the description cannot be encoded using the current encoding change the encoder
 */
public void write(ByteArrayOutputStream tagBuffer) {
    CharsetEncoder encoder = Charset.forName(TextEncoding.CHARSET_ISO_8859_1).newEncoder();
    String origUrl = getUrlLink();
    if (!encoder.canEncode(origUrl)) {
        //ALL W Frames only support ISO-8859-1 for the url itself, if unable to encode let us assume
        //the link just needs url encoding
        setUrlLink(encodeURL(origUrl));

        //We still cant convert so just set log error and set to blank to allow save to continue
        if (!encoder.canEncode(getUrlLink())) {
            logger.warning(ErrorMessage.MP3_UNABLE_TO_ENCODE_URL.getMsg(origUrl));
            setUrlLink("");
        }
        //it was ok, just note the modification made
        else {
            logger.warning(ErrorMessage.MP3_URL_SAVED_ENCODED.getMsg(origUrl, getUrlLink()));
        }
    }
    super.write(tagBuffer);
}
 

import java.nio.charset.CharsetEncoder; //导入方法依赖的package包/类
@Override
protected String validateInput() {
    String errorMessage = super.validateInput();
    
    if (errorMessage == null) {
        // #222846 - non-ascii characters in installation path
        File installationFolder = new File(getDestinationPath());
        CharsetEncoder encoder = Charset.forName("US-ASCII").newEncoder();
        if (!encoder.canEncode(installationFolder.getAbsolutePath())) {
            return StringUtils.format(panel.getProperty(ERROR_CONTAINS_NON_ASCII_CHARS));
        }
    }
    
    return errorMessage;
}
 

import java.nio.charset.CharsetEncoder; //导入方法依赖的package包/类
private String sanitize(String title) {
    StringBuilder sb = new StringBuilder();
    char[] cs = title.toCharArray();
    CharsetEncoder asciiEncoder = Charset.forName("US-ASCII").newEncoder();
    for (char c : cs) {
        if (!valid(c) || !asciiEncoder.canEncode(c)) {
            c = unaccent(c);
        }
        sb.append(c);

    }
    return sb.toString();
}
 

import java.nio.charset.CharsetEncoder; //导入方法依赖的package包/类
private List<Integer> getAsciiKeycodes() {
    CharsetEncoder asciiEncoder = Charset.forName("ascii").newEncoder();
    Set<Entry<Integer, String>> entrySet = keyCodeText.entrySet();
    List<Integer> out = new ArrayList<Integer>();
    for (Entry<Integer, String> entry : entrySet) {
        String keyText = KeyEvent.getKeyText(entry.getKey());
        if (keyText.length() == 1 && asciiEncoder.canEncode(keyText)) {
            out.add(entry.getKey());
        }
    }
    return out;
}
 

import java.nio.charset.CharsetEncoder; //导入方法依赖的package包/类
/**
 * Determines the number of consecutive characters that are encodable using binary compaction.
 *
 * @param msg      the message
 * @param startpos the start position within the message
 * @param encoding the charset used to convert the message to a byte array
 * @return the requested character count
 */
private static int determineConsecutiveBinaryCount(String msg, int startpos, Charset encoding)
    throws WriterException {
  final CharsetEncoder encoder = encoding.newEncoder();
  int len = msg.length();
  int idx = startpos;
  while (idx < len) {
    char ch = msg.charAt(idx);
    int numericCount = 0;

    while (numericCount < 13 && isDigit(ch)) {
      numericCount++;
      //textCount++;
      int i = idx + numericCount;
      if (i >= len) {
        break;
      }
      ch = msg.charAt(i);
    }
    if (numericCount >= 13) {
      return idx - startpos;
    }
    ch = msg.charAt(idx);

    if (!encoder.canEncode(ch)) {
      throw new WriterException("Non-encodable character detected: " + ch + " (Unicode: " + (int) ch + ')');
    }
    idx++;
  }
  return idx - startpos;
}
 

import java.nio.charset.CharsetEncoder; //导入方法依赖的package包/类
private static boolean isValidForCharset(String id, String charsetName) {
  CharsetEncoder encoder = null;
  try {
    Charset charset = Charset.forName(charsetName);
    encoder = charset.newEncoder();
  } catch (UnsupportedCharsetException e) {
    Log.w("Unsupported charset: " + charsetName);
  }
  if (encoder != null && !encoder.canEncode(id)) {
    Log.v("Invalid id (contains invalid characters): " + id);
    return false;
  }
  return true;
}
 

import java.nio.charset.CharsetEncoder; //导入方法依赖的package包/类
/**
 * Check if encode can handle the chars in this string.
 *
 */
protected boolean canEncode(String s) {
    final CharsetEncoder encoder =
        Charset.forName(System.getProperty("file.encoding")).newEncoder();
    char[] chars = s.toCharArray();
    for (int i=0; i<chars.length; i++) {
        if(!encoder.canEncode(chars[i])) {
            return false;
        }
    }
    return true;
}
 

import java.nio.charset.CharsetEncoder; //导入方法依赖的package包/类
private String getAllAvailableChars(String charsetName) {
    CharsetEncoder ce = Charset.forName(charsetName).newEncoder();
    StringBuilder result = new StringBuilder();
    for (char c = 0; c < Character.MAX_VALUE; c++) {
        if (ce.canEncode(c)) {
            result.append(c);
        }
    }
    return result.toString();
}
 

import java.nio.charset.CharsetEncoder; //导入方法依赖的package包/类
private static int determineConsecutiveBinaryCount(String msg, int startpos, Charset
        encoding) throws WriterException {
    CharsetEncoder encoder = encoding.newEncoder();
    int len = msg.length();
    int idx = startpos;
    while (idx < len) {
        char ch = msg.charAt(idx);
        int numericCount = 0;
        while (numericCount < 13 && isDigit(ch)) {
            numericCount++;
            int i = idx + numericCount;
            if (i >= len) {
                break;
            }
            ch = msg.charAt(i);
        }
        if (numericCount >= 13) {
            return idx - startpos;
        }
        ch = msg.charAt(idx);
        if (encoder.canEncode(ch)) {
            idx++;
        } else {
            throw new WriterException("Non-encodable character detected: " + ch + " (Unicode:" +
                    " " + ch + ')');
        }
    }
    return idx - startpos;
}