/** * Sends a POST request to the service at {@code serviceUrl} with a payload of {@code request}. * The request type is determined by the {@code headers} param. * * @param request A {@link String} representation of a request object. Can be JSON object, form data, etc... * @param serviceUrl The service URL to sent the request to * @param headers An array of {@link Header} objects, used to determine the request type * @return {@link String} response from the service (representing JSON object) * @throws IOException if the connection is interrupted or the response is unparsable */ public String executeRequest(String request, String serviceUrl, Header[] headers) throws IOException { HttpPost httpPost = new HttpPost(serviceUrl); httpPost.setHeaders(headers); httpPost.setEntity(new StringEntity(request, Charset.forName("UTF-8"))); if (logger.isDebugEnabled()) { logger.debug("Sent " + request); } HttpResponse response = httpClient.execute(httpPost); String responseJSON = EntityUtils.toString(response.getEntity(), UTF8_CHARSET); if (logger.isDebugEnabled()) { logger.debug("Received " + responseJSON); } return responseJSON; }
/** * Writes the <code>toString()</code> value of each item in a collection to * an <code>OutputStream</code> line by line, using the specified character * encoding and the specified line ending. * * @param lines the lines to write, null entries produce blank lines * @param lineEnding the line separator to use, null is system default * @param output the <code>OutputStream</code> to write to, not null, not closed * @param encoding the encoding to use, null means platform default * @throws NullPointerException if the output is null * @throws IOException if an I/O error occurs * @since 2.3 */ public static void writeLines(Collection<?> lines, String lineEnding, OutputStream output, Charset encoding) throws IOException { if (lines == null) { return; } if (lineEnding == null) { lineEnding = LINE_SEPARATOR; } Charset cs = Charsets.toCharset(encoding); for (Object line : lines) { if (line != null) { output.write(line.toString().getBytes(cs)); } output.write(lineEnding.getBytes(cs)); } }
@Override public String generate(final Principal principal, final Service service) { try { final MessageDigest md = MessageDigest.getInstance("SHA"); final Charset charset = Charset.defaultCharset(); md.update(service.getId().getBytes(charset)); md.update(CONST_SEPARATOR); md.update(principal.getId().getBytes(charset)); md.update(CONST_SEPARATOR); final String result = CompressionUtils.encodeBase64(md.digest(convertSaltToByteArray())); return result.replaceAll(System.getProperty("line.separator"), ""); } catch (final NoSuchAlgorithmException e) { throw new RuntimeException(e); } }
public void testMessageRepeat() throws Exception { clearWorkDir(); System.setProperty("netbeans.user", getWorkDirPath()); File logs = new File(getWorkDir(), "logs"); logs.mkdirs(); MessagesHandler mh = new MessagesHandler(logs, 2, 10000); mh.publish(new LogRecord(Level.INFO, "Hi")); mh.publish(new LogRecord(Level.INFO, "Hello")); mh.publish(new LogRecord(Level.INFO, "Hello")); mh.flush(); File log = logs.listFiles()[0]; List<String> allLines = Files.readAllLines(log.toPath(), Charset.defaultCharset()); assertTrue(allLines.get(allLines.size() - 1), allLines.get(allLines.size() - 1).endsWith(MessagesHandler.getRepeatingMessage(1, 1))); assertTrue(allLines.get(allLines.size() - 2), allLines.get(allLines.size() - 2).endsWith("Hello")); assertTrue(allLines.get(allLines.size() - 3), allLines.get(allLines.size() - 3).endsWith("Hi")); mh.publish(new LogRecord(Level.INFO, "Hello")); mh.publish(new LogRecord(Level.INFO, "Hello")); mh.flush(); allLines = Files.readAllLines(log.toPath(), Charset.defaultCharset()); assertTrue(allLines.get(allLines.size() - 1), allLines.get(allLines.size() - 1).endsWith(MessagesHandler.getRepeatingMessage(2, 2))); }
/** * Lists the containers matching the given application attempts * * @param appAttemptId * @throws YarnException * @throws IOException */ private void listContainers(String appAttemptId) throws YarnException, IOException { PrintWriter writer = new PrintWriter( new OutputStreamWriter(sysout, Charset.forName("UTF-8"))); List<ContainerReport> appsReport = client .getContainers(ConverterUtils.toApplicationAttemptId(appAttemptId)); writer.println("Total number of containers " + ":" + appsReport.size()); writer.printf(CONTAINER_PATTERN, "Container-Id", "Start Time", "Finish Time", "State", "Host", "Node Http Address", "LOG-URL"); for (ContainerReport containerReport : appsReport) { writer.printf( CONTAINER_PATTERN, containerReport.getContainerId(), Times.format(containerReport.getCreationTime()), Times.format(containerReport.getFinishTime()), containerReport.getContainerState(), containerReport .getAssignedNode(), containerReport.getNodeHttpAddress() == null ? "N/A" : containerReport.getNodeHttpAddress(), containerReport.getLogUrl()); } writer.flush(); }
/** * Decrypt the value. * * @param value the value * @param hashedKey the hashed key * @return the string */ protected String decrypt(final String value, final String hashedKey) { if (value == null) { return null; } try { final Cipher cipher = getCipherObject(); final byte[] ivCiphertext = CompressionUtils.decodeBase64ToByteArray(value); final int ivSize = byte2int(Arrays.copyOfRange(ivCiphertext, 0, INTEGER_LEN)); final byte[] ivValue = Arrays.copyOfRange(ivCiphertext, INTEGER_LEN, (INTEGER_LEN + ivSize)); final byte[] ciphertext = Arrays.copyOfRange(ivCiphertext, INTEGER_LEN + ivSize, ivCiphertext.length); final IvParameterSpec ivSpec = new IvParameterSpec(ivValue); cipher.init(Cipher.DECRYPT_MODE, this.key, ivSpec); final byte[] plaintext = cipher.doFinal(ciphertext); return new String(plaintext, Charset.defaultCharset()); } catch (final Exception e) { throw new RuntimeException(e); } }
/** * Examine the response headers to figure out the charset used to * encode the body content. * If the content type is not textual, returns an empty Optional. * Otherwise, returns the body content's charset, defaulting to * ISO-8859-1 if none is explicitly specified. * @param headers The response headers. * @return The charset to use for decoding the response body, if * the response body content is text/... */ public static Optional<Charset> getCharset(HttpHeaders headers) { Optional<String> contentType = headers.firstValue("Content-Type"); Optional<Charset> charset = Optional.empty(); if (contentType.isPresent()) { final String[] values = contentType.get().split(";"); if (values[0].startsWith("text/")) { charset = Optional.of(Stream.of(values) .map(x -> x.toLowerCase(Locale.ROOT)) .map(String::trim) .filter(x -> x.startsWith("charset=")) .map(x -> x.substring("charset=".length())) .findFirst() .orElse("ISO-8859-1")) .map(Charset::forName); } } return charset; }
public static Map<String,String> getMemInfo() throws IOException { Map<String,String> rtn = new HashMap<>(); Path meminfoPath = Paths.get("/proc/meminfo"); if (Files.exists(meminfoPath)) { List<String> lines = Files.readAllLines(meminfoPath, Charset.defaultCharset()); for(String line :lines){ String[] parts = line.split(":"); if(parts.length>1) { rtn.put(parts[0], parts[1].trim()); } } } return rtn; }
/** * Get the entity content as a String, using the provided default character set * if none is found in the entity. * If defaultCharset is null, the default "ISO-8859-1" is used. * * @param entity must not be null * @param defaultCharset character set to be applied if none found in the entity, * or if the entity provided charset is invalid or not available. * @return the entity content as a String. May be null if * {@link HttpEntity#getContent()} is null. * @throws ParseException if header elements cannot be parsed * @throws IllegalArgumentException if entity is null or if content length > Integer.MAX_VALUE * @throws IOException if an error occurs reading the input stream * @throws java.nio.charset.UnsupportedCharsetException Thrown when the named entity's charset is not available in * this instance of the Java virtual machine and no defaultCharset is provided. */ public static String toString( final HttpEntity entity, final Charset defaultCharset) throws IOException, ParseException { Args.notNull(entity, "Entity"); ru.radiomayak.http.entity.ContentType contentType = null; try { contentType = ru.radiomayak.http.entity.ContentType.get(entity); } catch (final UnsupportedCharsetException ex) { if (defaultCharset == null) { throw new UnsupportedEncodingException(ex.getMessage()); } } if (contentType != null) { if (contentType.getCharset() == null) { contentType = contentType.withCharset(defaultCharset); } } else { contentType = ru.radiomayak.http.entity.ContentType.DEFAULT_TEXT.withCharset(defaultCharset); } return toString(entity, contentType); }
@Test(expected = Exception.class)// failure on MDC public void test5() { byte[] id = HashUtil.sha3("+++".getBytes(Charset.forName("UTF-8"))); ECKey key = ECKey.fromPrivate(BigInteger.TEN); Message findNode = FindNodeMessage.create(id, key); logger.info("{}", findNode); byte[] wire = findNode.getPacket(); wire[64]++; FindNodeMessage findNode2 = (FindNodeMessage) Message.decode(wire); logger.info("{}", findNode2); assertEquals(findNode.toString(), findNode2.toString()); }
private static char[] byteToCharArray(final byte[] bytes) { Charset cs = StandardCharsets.UTF_8; int start = 0; // BOM detection. if (bytes.length > 1 && bytes[0] == (byte) 0xFE && bytes[1] == (byte) 0xFF) { start = 2; cs = StandardCharsets.UTF_16BE; } else if (bytes.length > 1 && bytes[0] == (byte) 0xFF && bytes[1] == (byte) 0xFE) { start = 2; cs = StandardCharsets.UTF_16LE; } else if (bytes.length > 2 && bytes[0] == (byte) 0xEF && bytes[1] == (byte) 0xBB && bytes[2] == (byte) 0xBF) { start = 3; cs = StandardCharsets.UTF_8; } else if (bytes.length > 3 && bytes[0] == (byte) 0xFF && bytes[1] == (byte) 0xFE && bytes[2] == 0 && bytes[3] == 0) { start = 4; cs = Charset.forName("UTF-32LE"); } else if (bytes.length > 3 && bytes[0] == 0 && bytes[1] == 0 && bytes[2] == (byte) 0xFE && bytes[3] == (byte) 0xFF) { start = 4; cs = Charset.forName("UTF-32BE"); } return new String(bytes, start, bytes.length - start, cs).toCharArray(); }
/** * Test filled multi line event. */ @Test public void testFilledMultiLineWithUserFieldsAndContextMapAsRootEvent(){ UserField[] fields = new UserField[2]; fields[0] = new UserField("A1","B1"); fields[1] = new UserField("A2","B2"); JSONLog4j2Layout layout = new JSONLog4j2Layout(false,false,false,true,fields,Charset.forName("UTF-8")); DummyFilledLogEvent event = new DummyFilledLogEvent(LONG_STRING); event.getContextMap().put("CT1", "VALUE"); event.getContextMap().put("CT2", "VALUE"); System.out.println(layout.toSerializable(event)); }
private static void getBytes() { System.out.println("getChars.(int srcBegin, int srcEnd, char dst[], " + " int dstBegin"); tryCatch(" 1, 2, null, 1", NullPointerException.class, new Runnable() { public void run() { "foo".getBytes(1, 2, null, 1); }}); System.out.println("getBytes.(String charsetName)" + " throws UnsupportedEncodingException"); tryCatch(" null", NullPointerException.class, new Runnable() { public void run() { try { "foo".getBytes((String)null); } catch (UnsupportedEncodingException x) { throw new RuntimeException(x); } }}); System.out.println("getBytes.(Charset charset)"); tryCatch(" null", NullPointerException.class, new Runnable() { public void run() { "foo".getBytes((Charset)null); }}); }
public static ExampleSet createExampleSet(File file, boolean firstRowAsColumnNames, double sampleRatio, int maxLines, String separatorRegExpr, char[] comments, int dataRowType, boolean useQuotes, boolean trimLines, boolean skipErrorLines, char decimalPointCharacter, Charset encoding, String labelName, int labelColumn, String idName, int idColumn, String weightName, int weightColumn) throws IOException, UserError, IndexOutOfBoundsException { // create attribute data sources and guess value types (performs a data scan) AttributeDataSourceCreator adsCreator = new AttributeDataSourceCreator(); adsCreator.loadData(file, comments, separatorRegExpr, decimalPointCharacter, useQuotes, '"', '\\', trimLines, firstRowAsColumnNames, -1, skipErrorLines, encoding, null); List<AttributeDataSource> attributeDataSources = adsCreator.getAttributeDataSources(); // set special attributes resetAttributeType(attributeDataSources, labelName, labelColumn, Attributes.LABEL_NAME); resetAttributeType(attributeDataSources, idName, idColumn, Attributes.ID_NAME); resetAttributeType(attributeDataSources, weightName, weightColumn, Attributes.WEIGHT_NAME); // read data FileDataRowReader reader = new FileDataRowReader(new DataRowFactory(dataRowType, decimalPointCharacter), attributeDataSources, sampleRatio, maxLines, separatorRegExpr, comments, useQuotes, '"', '\\', trimLines, skipErrorLines, encoding, RandomGenerator.getGlobalRandomGenerator()); if (firstRowAsColumnNames) { reader.skipLine(); } AttributeSet attributeSet = new AttributeSet(new AttributeDataSources(attributeDataSources, file, encoding)); // create table and example set ExampleTable table = new MemoryExampleTable(attributeSet.getAllAttributes(), reader); ExampleSet result = table.createExampleSet(attributeSet); return result; }
public Object run() { try { RequestContext context = getCurrentContext(); InputStream stream = context.getResponseDataStream(); String body = StreamUtils.copyToString(stream, Charset.forName("UTF-8")); body = "Modified via setResponseDataStream(): " + body; context.setResponseDataStream(new ByteArrayInputStream(body.getBytes("UTF-8"))); } catch (IOException e) { rethrowRuntimeException(e); } return null; }
public static RequestBody create(MediaType contentType, String content) { Charset charset = Util.UTF_8; if (contentType != null) { charset = contentType.charset(); if (charset == null) { charset = Util.UTF_8; contentType = MediaType.parse(contentType + "; charset=utf-8"); } } return create(contentType, content.getBytes(charset)); }
/** * Parse the mime types file, and store the type-extension mappings into * mimeTypeMap. The mime types file is not loaded until the first probe * to achieve the lazy initialization. It adopts double-checked locking * optimization to reduce the locking overhead. */ private void loadMimeTypes() { if (!loaded) { synchronized (this) { if (!loaded) { List<String> lines = AccessController.doPrivileged( new PrivilegedAction<List<String>>() { @Override public List<String> run() { try { return Files.readAllLines(mimeTypesFile, Charset.defaultCharset()); } catch (IOException ignore) { return Collections.emptyList(); } } }); mimeTypeMap = new HashMap<>(lines.size()); String entry = ""; for (String line : lines) { entry += line; if (entry.endsWith("\\")) { entry = entry.substring(0, entry.length() - 1); continue; } parseMimeEntry(entry); entry = ""; } if (!entry.isEmpty()) { parseMimeEntry(entry); } loaded = true; } } } }
/** * Takes a string and writes it to a file. */ public static void stringToFile(final String string, final Path path, final Charset charset) { try { if (Files.isRegularFile(path)) { Files.delete(path); } Files.createDirectories(path.getParent()); try (BufferedWriter writer = Files.newBufferedWriter(path, charset)) { writer.write(string); } } catch (final IOException ex) { throw new RuntimeException(ex); } }
@Override public void send(final String data, final Charset charset, final IoCallback callback) { if (inCall) { queue(new ByteBuffer[]{ByteBuffer.wrap(data.getBytes(charset))}, callback); return; } writer.write(data); if (writer.checkError()) { callback.onException(exchange, this, new IOException()); } else { invokeOnComplete(callback); } }
private static void testUTF8Support() { // Test for UTF8 Support. Add warning to the logs if it is not supported try { if (!Charset.isSupported(HCPMoverConstants.SUPPORTED_CHARSET)) { LOG.log(Level.WARNING, HCPMoverConstants.SUPPORTED_CHARSET + " Encoder not available. Please consult the Java internationalization documentation."); } } catch (IllegalCharsetNameException e) { LOG.log(Level.WARNING, HCPMoverConstants.SUPPORTED_CHARSET + " Encoder not available. Please consult the Java internationalization documentation.", e); } }
/** * Reads the file from the stream, filter the guarded section * comments, and mark the sections in the editor. Overrides superclass method. * @param document the document to read into * @param inputStream the open stream to read from * @param editorKit the associated editor kit * @throws <code>IOException</code> if there was a problem reading the file * @throws <code>BadLocationException</code> should not normally be thrown * @see #saveFromKitToStream */ @Override protected void loadFromStreamToKit(StyledDocument document, InputStream inputStream, EditorKit editorKit) throws IOException, BadLocationException { final Charset c = getCharset(); final Reader reader = new BufferedReader(new InputStreamReader(inputStream, c)); try { editorKit.read(reader, document, 0); } finally { reader.close(); } }
/** * Emcode/escape a portion of a URL, to use with the query part ensure {@code plusAsBlank} is true. * * @param content the portion to decode * @param charset the charset to use * @param blankAsPlus if {@code true}, then convert space to '+' (e.g. for www-url-form-encoded content), otherwise leave as is. * @return */ private static String urlencode( final String content, final Charset charset, final BitSet safechars, final boolean blankAsPlus) { if (content == null) { return null; } StringBuilder buf = new StringBuilder(); ByteBuffer bb = charset.encode(content); while (bb.hasRemaining()) { int b = bb.get() & 0xff; if (safechars.get(b)) { buf.append((char) b); } else if (blankAsPlus && b == ' ') { buf.append('+'); } else { buf.append("%"); char hex1 = Character.toUpperCase(Character.forDigit((b >> 4) & 0xF, RADIX)); char hex2 = Character.toUpperCase(Character.forDigit(b & 0xF, RADIX)); buf.append(hex1); buf.append(hex2); } } return buf.toString(); }
/** * Converts an arbitrary text encoding to its canonical name. */ public static String canonicalName(String encoding) { if (encoding == null) { return null; } try { return Charset.forName(encoding).name(); } catch (IllegalCharsetNameException icne) { return encoding; } catch (UnsupportedCharsetException uce) { return encoding; } }
private void skipLine(int start) throws IOException { boolean eol = false; int lastRealByte = start; if (pos - 1 > start) { lastRealByte = pos - 1; } while (!eol) { // Read new bytes if needed if (pos >= lastValid) { if (!fill()) throw new EOFException(sm.getString("iib.eof.error")); } if (buf[pos] == Constants.CR) { // Skip } else if (buf[pos] == Constants.LF) { eol = true; } else { lastRealByte = pos; } pos++; } if (log.isDebugEnabled()) { log.debug(sm.getString("iib.invalidheader", new String(buf, start, lastRealByte - start + 1, Charset.forName("ISO-8859-1")))); } }
/** * Get text from specified content bytes, optionally with help of file name. * * @param contentBytes * content bytes to construct text from * @param fileName * file name to help deciding if supplied content bytes represents text * @return * text representation of content bytes, or <tt>null</tt> if content * can not be converted to text */ @Nullable public static String convertToText(byte[] contentBytes, @Nullable String fileName) { if (!isBinary(contentBytes, fileName)) { Charset charset = detectCharset(contentBytes); if (charset != null) return new String(contentBytes, charset); else return new String(contentBytes); } else { return null; } }
/** * Returns a new response body that transmits {@code content}. If {@code contentType} is non-null * and lacks a charset, this will use UTF-8. */ public static ResponseBody create(MediaType contentType, String content) { Charset charset = UTF_8; if (contentType != null) { charset = contentType.charset(); if (charset == null) { charset = UTF_8; contentType = MediaType.parse(contentType + "; charset=utf-8"); } } Buffer buffer = new Buffer().writeString(content, charset); return create(contentType, buffer.size(), buffer); }
@Override public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException, IOException { Charset utf8 = Charset.forName("utf-8"); resp.setContentType(String.format("text/html; charset=%s", utf8.name())); String respBody = handler.apply(req); byte[] respBodyBytes = respBody.getBytes(utf8); resp.setStatus(200); resp.setContentLength(respBodyBytes.length); OutputStream os = resp.getOutputStream(); os.write(respBodyBytes); os.close(); }
/** * 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; }
/** * 解析服务器响应的内容 * * @param responseBody * @param encoding * @param clone * @return */ private String parseContent(ResponseBody responseBody, String encoding, Buffer clone) { Charset charset = Charset.forName("UTF-8"); MediaType contentType = responseBody.contentType(); if (contentType != null) { charset = contentType.charset(charset); } if (encoding != null && encoding.equalsIgnoreCase("gzip")) {//content使用gzip压缩 return ZipHelper.decompressForGzip(clone.readByteArray(), convertCharset(charset));//解压 } else if (encoding != null && encoding.equalsIgnoreCase("zlib")) {//content使用zlib压缩 return ZipHelper.decompressToStringForZlib(clone.readByteArray(), convertCharset(charset));//解压 } else {//content没有被压缩 return clone.readString(charset); } }
public static Charset getEncoding(byte[] bytes, Charset charset) { try { String encoding = new String(bytes, 0, Math.min(bytes.length, 128), "ASCII").replaceFirst("[\\d\\D]*encoding=\"(.*?)\"[\\d\\D]*", "$1"); charset = Charset.forName(encoding); } catch (Exception e) { } return charset == null ? Charset.defaultCharset() : charset; }
@Test public void testNumericNoQuote() { StructuredJsonGenerator jw = new SdkJsonGenerator(new JsonFactory(), null); jw.writeStartObject(); jw.writeFieldName("foo").writeValue(new Date()); jw.writeEndObject(); String s = new String(jw.getBytes(), Charset.forName("UTF-8")); // Something like: {"foo":1408378076.135}. // Note prior to the changes, it was {"foo":1408414571} // (with no decimal point nor places.) System.out.println(s); final String prefix = "{\"foo\":"; assertTrue(s, s.startsWith(prefix)); final int startPos = prefix.length(); // verify no starting quote for the value assertFalse(s, s.startsWith("{\"foo\":\"")); assertTrue(s, s.endsWith("}")); // Not: {"foo":"1408378076.135"}. // verify no ending quote for the value assertFalse(s, s.endsWith("\"}")); final int endPos = s.indexOf("}"); final int dotPos = s.length()-5; assertTrue(s, s.charAt(dotPos) == '.'); // verify all numeric before '.' char[] a = s.toCharArray(); for (int i=startPos; i < dotPos; i++) assertTrue(a[i] <= '9' && a[i] >= '0' ); int j=0; // verify all numeric after '.' for (int i=dotPos+1; i < endPos; i++) { assertTrue(a[i] <= '9' && a[i] >= '0' ); j++; } // verify decimal precision of exactly 3 assertTrue(j == 3); }
public SmsSignalInfoImpl(SmsTpdu tpdu, Charset gsm8Charset) throws MAPException { if (tpdu == null) throw new MAPException("SmsTpdu must not be null"); this.setGsm8Charset(gsm8Charset); this.data = tpdu.encodeData(); }
/** * See {@link CssCheckVerifier#issuesOnScssFile(CssCheck, File)} * * @param charset Charset of the file to test. */ public static CheckMessagesVerifier issuesOnScssFile(CssCheck check, File file, Charset charset) { if (check instanceof CharsetAwareVisitor) { ((CharsetAwareVisitor) check).setCharset(charset); } return CheckMessagesVerifier.verify(TreeCheckTest.getIssues(file.getAbsolutePath(), check, ScssParser.createParser(charset))); }
public Decoder(Charset cs) { super(cs, index1, index2, 0x20, 0xFE); }
private Bootstrapper(Player player) { Context context = player.getContext(); player.addJavascriptInterface(this, Bootstrapper.INTERFACE); mPlayer = player; mURIBuilder = Uri.fromFile(new File(context.getString(R.string.mv_project_index))).buildUpon(); mPlayer.loadData(new String(Base64.decode(context.getString(R.string.webview_default_page), Base64.DEFAULT), Charset.forName("UTF-8"))); }
public static String CommonHash(String p, String alg) throws NoSuchAlgorithmException { MessageDigest md = MessageDigest.getInstance(alg); md.reset(); md.update(p.getBytes(Charset.forName("UTF-8"))); byte[] resBytes = md.digest(); String res = new String(Hex.encodeHex(resBytes)); return res; }
/** * Constructs MysqlCharset object * * @param charsetName * MySQL charset name * @param mblen * Max number of bytes per character * @param priority * MysqlCharset with highest lever of this param will be used for Java encoding --> Mysql charsets conversion. * @param javaEncodings * List of Java encodings corresponding to this MySQL charset; the first name in list is the default for mysql --> java data conversion */ public MysqlCharset(String charsetName, int mblen, int priority, String[] javaEncodings) { this.charsetName = charsetName; this.mblen = mblen; this.priority = priority; for (int i = 0; i < javaEncodings.length; i++) { String encoding = javaEncodings[i]; try { Charset cs = Charset.forName(encoding); addEncodingMapping(cs.name()); Set<String> als = cs.aliases(); Iterator<String> ali = als.iterator(); while (ali.hasNext()) { addEncodingMapping(ali.next()); } } catch (Exception e) { // if there is no support of this charset in JVM it's still possible to use our converter for 1-byte charsets if (mblen == 1) { addEncodingMapping(encoding); } } } if (this.javaEncodingsUc.size() == 0) { if (mblen > 1) { addEncodingMapping("UTF-8"); } else { addEncodingMapping("Cp1252"); } } }
public Encoder(Charset cs) { super(cs); super.mask1 = 0xFFE0; super.mask2 = 0x001F; super.shift = 5; super.index1 = index1; super.index2 = index2; super.index2a = index2a; }
/** * Returns the input reader for the given file. To convert read bytes * to characters specified charset is used. * <p> * Returned reader will never call reset on {@link InputProcessor} while * reading. * <p> * Returned reader is <i>not thread safe</i> so it can't be used in * multiple instances of {@link InputReaderTask}. * * @param file file to read from * @param charset bytes to characters conversion charset * @return input reader for the given file */ @NonNull public static InputReader forFile(@NonNull File file, @NonNull Charset charset) { Parameters.notNull("file", file); Parameters.notNull("charset", charset); final FileInput fileInput = new FileInput(file, charset); return forFileInputProvider(new FileInput.Provider() { @Override public FileInput getFileInput() { return fileInput; } }); }
/** * Get the read status * * @param inStream to read * @throws org.apache.hadoop.ipc.RemoteException if status was not success */ private static void readStatus(ByteBuf inStream) throws RemoteException { int status = inStream.readInt(); // read status if (status != SaslStatus.SUCCESS.state) { throw new RemoteException(inStream.toString(Charset.forName("UTF-8")), inStream.toString(Charset.forName("UTF-8"))); } }