package org.opendaylight.netconf.mdsal.connector;
-import com.google.common.base.Charsets;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.io.CharStreams;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
String source;
try {
sourceStream = rootSchemaSourceProviderDependency.getSource(moduleSourceIdentifier).checkedGet().openStream();
- source = CharStreams.toString(new InputStreamReader(sourceStream, Charsets.UTF_8));
+ source = CharStreams.toString(new InputStreamReader(sourceStream, StandardCharsets.UTF_8));
} catch (IOException | SchemaSourceException e) {
LOG.warn("Ignoring source for module {}. Unable to read content", moduleSourceIdentifier, e);
source = null;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import com.google.common.base.Charsets;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.embedded.EmbeddedChannel;
import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
import java.util.Queue;
import org.junit.Before;
import org.junit.Test;
private static long getHeaderLength(byte[] bytes) {
byte[] HEADER_START = new byte[] { (byte) 0x0a, (byte) 0x23 };
- return Long.parseLong(Charsets.US_ASCII.decode(
+ return Long.parseLong(StandardCharsets.US_ASCII.decode(
ByteBuffer.wrap(bytes, HEADER_START.length, bytes.length - HEADER_START.length - 1)).toString());
}
}
import static org.mockito.Mockito.mock;
import static org.opendaylight.netconf.util.test.XmlUnitUtil.assertContainsElementWithText;
-import com.google.common.base.Charsets;
import com.google.common.base.Optional;
import com.google.common.collect.Sets;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.net.Socket;
+import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.List;
import java.util.Set;
final String get = XmlFileLoader.fileToString(fileName);
final Socket sock = new Socket(TCP_ADDRESS.getHostName(), TCP_ADDRESS.getPort());
- sock.getOutputStream().write(hello.getBytes(Charsets.UTF_8));
+ sock.getOutputStream().write(hello.getBytes(StandardCharsets.UTF_8));
final String separator = "]]>]]>";
- sock.getOutputStream().write(separator.getBytes(Charsets.UTF_8));
- sock.getOutputStream().write(get.getBytes(Charsets.UTF_8));
- sock.getOutputStream().write(separator.getBytes(Charsets.UTF_8));
+ sock.getOutputStream().write(separator.getBytes(StandardCharsets.UTF_8));
+ sock.getOutputStream().write(get.getBytes(StandardCharsets.UTF_8));
+ sock.getOutputStream().write(separator.getBytes(StandardCharsets.UTF_8));
final StringBuilder responseBuilder = new StringBuilder();
package org.opendaylight.netconf.nettyutil.handler;
-import com.google.common.base.Charsets;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
+import java.nio.charset.StandardCharsets;
import org.opendaylight.netconf.util.messages.NetconfMessageConstants;
public class ChunkedFramingMechanismEncoder extends MessageToByteEncoder<ByteBuf> {
final int xfer = Math.min(chunkSize, msg.readableBytes());
out.writeBytes(NetconfMessageConstants.START_OF_CHUNK);
- out.writeBytes(String.valueOf(xfer).getBytes(Charsets.US_ASCII));
+ out.writeBytes(String.valueOf(xfer).getBytes(StandardCharsets.US_ASCII));
out.writeByte('\n');
out.writeBytes(msg, xfer);
package org.opendaylight.netconf.nettyutil.handler;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Charsets;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import java.io.IOException;
+import java.nio.charset.StandardCharsets;
import javax.xml.transform.TransformerException;
import org.opendaylight.netconf.api.messages.NetconfHelloMessage;
import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
// If additional header present, serialize it along with netconf hello message
if (headerOptional.isPresent()) {
- out.writeBytes(headerOptional.get().toFormattedString().getBytes(Charsets.UTF_8));
+ out.writeBytes(headerOptional.get().toFormattedString().getBytes(StandardCharsets.UTF_8));
}
super.encode(ctx, msg, out);
package org.opendaylight.netconf.nettyutil.handler;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Charsets;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.List;
import org.opendaylight.controller.config.util.xml.XmlUtil;
private static void logMessage(final byte[] bytes) {
if (LOG.isDebugEnabled()) {
- String s = Charsets.UTF_8.decode(ByteBuffer.wrap(bytes)).toString();
+ String s = StandardCharsets.UTF_8.decode(ByteBuffer.wrap(bytes)).toString();
LOG.debug("Parsing message \n{}", s);
}
}
}
private static String additionalHeaderToString(final byte[] bytes) {
- return Charsets.UTF_8.decode(ByteBuffer.wrap(bytes)).toString();
+ return StandardCharsets.UTF_8.decode(ByteBuffer.wrap(bytes)).toString();
}
/**
package org.opendaylight.netconf.nettyutil.handler.ssh.client;
-import com.google.common.base.Charsets;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelPromise;
+import java.nio.charset.StandardCharsets;
import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
}
public static String byteBufToString(final ByteBuf msg) {
- final String s = msg.toString(Charsets.UTF_8);
+ final String s = msg.toString(StandardCharsets.UTF_8);
msg.resetReaderIndex();
return s;
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import com.google.common.base.Charsets;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
byte[] buf = new byte[destination.readableBytes()];
destination.readBytes(buf);
- String s = Charsets.US_ASCII.decode(ByteBuffer.wrap(buf)).toString();
+ String s = StandardCharsets.US_ASCII.decode(ByteBuffer.wrap(buf)).toString();
assertTrue(s.startsWith("\n#256\na"));
assertTrue(s.endsWith("\n#20\naaaaaaaaaaaaaaaaaaaa\n##\n"));
import static org.junit.Assert.assertEquals;
-import com.google.common.base.Charsets;
import com.google.common.collect.Lists;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
+import java.nio.charset.StandardCharsets;
import java.util.List;
import org.junit.BeforeClass;
import org.junit.Test;
@Test
public void testMultipleChunks() throws Exception {
final List<Object> output = Lists.newArrayList();
- final ByteBuf input = Unpooled.copiedBuffer(CHUNKED_MESSAGE.getBytes(Charsets.UTF_8));
+ final ByteBuf input = Unpooled.copiedBuffer(CHUNKED_MESSAGE.getBytes(StandardCharsets.UTF_8));
agr.decode(null, input, output);
assertEquals(1, output.size());
final ByteBuf chunk = (ByteBuf) output.get(0);
- assertEquals(EXPECTED_MESSAGE, chunk.toString(Charsets.UTF_8));
+ assertEquals(EXPECTED_MESSAGE, chunk.toString(StandardCharsets.UTF_8));
}
@Test
public void testOneChunks() throws Exception {
final List<Object> output = Lists.newArrayList();
- final ByteBuf input = Unpooled.copiedBuffer(CHUNKED_MESSAGE_ONE.getBytes(Charsets.UTF_8));
+ final ByteBuf input = Unpooled.copiedBuffer(CHUNKED_MESSAGE_ONE.getBytes(StandardCharsets.UTF_8));
agr.decode(null, input, output);
assertEquals(1, output.size());
final ByteBuf chunk = (ByteBuf) output.get(0);
- assertEquals(EXPECTED_MESSAGE, chunk.toString(Charsets.UTF_8));
+ assertEquals(EXPECTED_MESSAGE, chunk.toString(StandardCharsets.UTF_8));
}
package org.opendaylight.netconf.netty;
import static com.google.common.base.Preconditions.checkState;
+import static java.nio.charset.StandardCharsets.UTF_8;
-import com.google.common.base.Charsets;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
@Override
public synchronized void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ByteBuf bb = (ByteBuf) msg;
- String string = bb.toString(Charsets.UTF_8);
+ String string = bb.toString(UTF_8);
fromServer.append(string);
LOG.info(">{}", string);
bb.release();
package org.opendaylight.netconf.netty;
-import com.google.common.base.Charsets;
import com.google.common.base.Splitter;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandler.Sharable;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
+import java.nio.charset.StandardCharsets;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ByteBuf byteBuf = (ByteBuf) msg;
- String message = byteBuf.toString(Charsets.UTF_8);
+ String message = byteBuf.toString(StandardCharsets.UTF_8);
LOG.info("writing back '{}'", message);
ctx.write(msg);
fromLastNewLine += message;
package org.opendaylight.netconf.netty;
-import com.google.common.base.Charsets;
import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.local.LocalAddress;
import io.netty.channel.local.LocalChannel;
+import java.nio.charset.StandardCharsets;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
ByteBuf bb = (ByteBuf) msg;
- LOG.info(">{}", bb.toString(Charsets.UTF_8));
+ LOG.info(">{}", bb.toString(StandardCharsets.UTF_8));
remoteCtx.write(msg);
}
package org.opendaylight.netconf.util.messages;
-import com.google.common.base.Charsets;
+import static java.nio.charset.StandardCharsets.UTF_8;
public final class NetconfMessageConstants {
private NetconfMessageConstants(){}
+
/**
* The NETCONF 1.0 old-style message separator. This is framing mechanism
* is used by default.
*/
- public static final byte[] END_OF_MESSAGE = "]]>]]>".getBytes(Charsets.UTF_8);
+ public static final byte[] END_OF_MESSAGE = "]]>]]>".getBytes(UTF_8);
// bytes
public static final int MAX_HEADER_LENGTH = 13;
- public static final byte[] START_OF_CHUNK = "\n#".getBytes(Charsets.UTF_8);
- public static final byte[] END_OF_CHUNK = "\n##\n".getBytes(Charsets.UTF_8);
+ public static final byte[] START_OF_CHUNK = "\n#".getBytes(UTF_8);
+ public static final byte[] END_OF_CHUNK = "\n##\n".getBytes(UTF_8);
}
package org.opendaylight.netconf.util.test;
-import com.google.common.base.Charsets;
import com.google.common.base.Preconditions;
import com.google.common.io.ByteSource;
import java.io.IOException;
import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
import javax.xml.parsers.ParserConfigurationException;
import org.opendaylight.controller.config.util.xml.XmlUtil;
import org.opendaylight.netconf.api.NetconfMessage;
public InputStream openStream() {
return resourceAsStream;
}
- }.asCharSource(Charsets.UTF_8).read();
+ }.asCharSource(StandardCharsets.UTF_8).read();
}
}
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_DATA_QNAME;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.toId;
-import com.google.common.base.Charsets;
import com.google.common.base.Function;
import com.google.common.base.MoreObjects;
import com.google.common.base.Optional;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
import javax.xml.transform.dom.DOMSource;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
@Override
public InputStream openStream() throws IOException {
- return new ByteArrayInputStream(schemaString.get().getBytes(Charsets.UTF_8));
+ return new ByteArrayInputStream(schemaString.get().getBytes(StandardCharsets.UTF_8));
}
}
}
import static com.google.common.base.Preconditions.checkNotNull;
import ch.qos.logback.classic.Level;
-import com.google.common.base.Charsets;
import com.google.common.base.Preconditions;
import com.google.common.base.Stopwatch;
import com.google.common.collect.Lists;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
try (InputStream stream = Main.class.getResourceAsStream(NETCONF_CONNECTOR_XML)) {
checkNotNull(stream, "Cannot load %s", NETCONF_CONNECTOR_XML);
- String configBlueprint = CharStreams.toString(new InputStreamReader(stream, Charsets.UTF_8));
+ String configBlueprint = CharStreams.toString(new InputStreamReader(stream, StandardCharsets.UTF_8));
final String before = configBlueprint.substring(0, configBlueprint.indexOf("<module>"));
final String middleBlueprint = configBlueprint.substring(configBlueprint.indexOf("<module>"), configBlueprint.indexOf("</module>"));
b.append(after);
final File to = new File(configDir, String.format(SIM_DEVICE_CFG_PREFIX + "%d-%d.xml", batchStart, openDevice));
generatedConfigs.add(to);
- Files.write(b.toString(), to, Charsets.UTF_8);
+ Files.write(b.toString(), to, StandardCharsets.UTF_8);
connectorCount = 0;
b = new StringBuilder();
b.append(before);
b.append(after);
final File to = new File(configDir, String.format(SIM_DEVICE_CFG_PREFIX + "%d-%d.xml", batchStart, openDevices.get(openDevices.size() - 1)));
generatedConfigs.add(to);
- Files.write(b.toString(), to, Charsets.UTF_8);
+ Files.write(b.toString(), to, StandardCharsets.UTF_8);
}
LOG.info("Config files generated in {}", configDir);
import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.base.Charsets;
import com.google.common.base.Preconditions;
import com.google.common.io.CharStreams;
import com.google.common.io.Files;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
final String editContentString;
try {
if (stream == null) {
- editContentString = Files.toString(editContent, Charsets.UTF_8);
+ editContentString = Files.toString(editContent, StandardCharsets.UTF_8);
} else {
- editContentString = CharStreams.toString(new InputStreamReader(stream, Charsets.UTF_8));
+ editContentString = CharStreams.toString(new InputStreamReader(stream, StandardCharsets.UTF_8));
}
} catch (final IOException e) {
throw new IllegalArgumentException("Cannot read content of " + editContent);
package org.opendaylight.netconf.test.tool.client.http.perf;
-import com.google.common.base.Charsets;
import com.google.common.base.Stopwatch;
import com.google.common.io.Files;
import java.io.IOException;
+import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
final String editContentString;
try {
- editContentString = Files.toString(parameters.editContent, Charsets.UTF_8);
+ editContentString = Files.toString(parameters.editContent, StandardCharsets.UTF_8);
} catch (final IOException e) {
throw new IllegalArgumentException("Cannot read content of " + parameters.editContent);
}
package org.opendaylight.netconf.test.tool.client.stress;
import ch.qos.logback.classic.Level;
-import com.google.common.base.Charsets;
import com.google.common.base.Stopwatch;
import com.google.common.io.Files;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.util.HashedWheelTimer;
import io.netty.util.Timer;
import java.io.IOException;
+import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
final String editContentString;
try {
- editContentString = Files.toString(params.editContent, Charsets.UTF_8);
+ editContentString = Files.toString(params.editContent, StandardCharsets.UTF_8);
} catch (final IOException e) {
throw new IllegalArgumentException("Cannot read content of " + params.editContent);
}
*/
package org.opendaylight.netconf.sal.rest.impl;
-import com.google.common.base.Charsets;
import com.google.common.base.Optional;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.net.URI;
+import java.nio.charset.StandardCharsets;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
private JsonWriter createJsonWriter(final OutputStream entityStream, final boolean prettyPrint) {
if (prettyPrint) {
- return JsonWriterFactory.createJsonWriter(new OutputStreamWriter(entityStream, Charsets.UTF_8),
+ return JsonWriterFactory.createJsonWriter(new OutputStreamWriter(entityStream, StandardCharsets.UTF_8),
DEFAULT_INDENT_SPACES_NUM);
} else {
- return JsonWriterFactory.createJsonWriter(new OutputStreamWriter(entityStream, Charsets.UTF_8));
+ return JsonWriterFactory.createJsonWriter(new OutputStreamWriter(entityStream, StandardCharsets.UTF_8));
}
}
package org.opendaylight.netconf.sal.rest.impl;
-import com.google.common.base.Charsets;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
+import java.nio.charset.StandardCharsets;
import java.util.List;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
}
private static JsonWriter createJsonWriter(final OutputStream entityStream) {
- return JsonWriterFactory.createJsonWriter(new OutputStreamWriter(entityStream, Charsets.UTF_8));
+ return JsonWriterFactory.createJsonWriter(new OutputStreamWriter(entityStream, StandardCharsets.UTF_8));
}
}
package org.opendaylight.netconf.sal.rest.impl;
-import com.google.common.base.Charsets;
import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
import com.google.common.collect.Iterables;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.URI;
+import java.nio.charset.StandardCharsets;
import java.util.Iterator;
import java.util.List;
import javax.ws.rs.core.Context;
final DataSchemaNode schema = (DataSchemaNode) context.getSchemaNode();
SchemaPath path = context.getSchemaNode().getPath();
- final OutputStreamWriter outputWriter = new OutputStreamWriter(outStream, Charsets.UTF_8);
+ final OutputStreamWriter outputWriter = new OutputStreamWriter(outStream, StandardCharsets.UTF_8);
if (data == null) {
throw new RestconfDocumentedException(Response.Status.NOT_FOUND);
}
*/
package org.opendaylight.netconf.sal.restconf.impl;
-import com.google.common.base.Charsets;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.annotation.Annotation;
+import java.nio.charset.StandardCharsets;
import java.util.List;
import javax.ws.rs.core.MediaType;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
LOG.debug("put: uriPath: {}, payload: {}", uriPath, payload);
- InputStream entityStream = new ByteArrayInputStream(payload.getBytes(Charsets.UTF_8));
+ InputStream entityStream = new ByteArrayInputStream(payload.getBytes(StandardCharsets.UTF_8));
NormalizedNodeContext context = JsonNormalizedNodeBodyReader.readFrom(uriPath, entityStream, false);
LOG.debug("Parsed YangInstanceIdentifier: {}", context.getInstanceIdentifierContext().getInstanceIdentifier());
LOG.debug("post: uriPath: {}, payload: {}", uriPath, payload);
- InputStream entityStream = new ByteArrayInputStream(payload.getBytes(Charsets.UTF_8));
+ InputStream entityStream = new ByteArrayInputStream(payload.getBytes(StandardCharsets.UTF_8));
NormalizedNodeContext context = JsonNormalizedNodeBodyReader.readFrom(uriPath, entityStream, true);
LOG.debug("Parsed YangInstanceIdentifier: {}", context.getInstanceIdentifierContext().getInstanceIdentifier());
try {
NormalizedNodeContext outputContext;
if(actualInput != null) {
- InputStream entityStream = new ByteArrayInputStream(actualInput.getBytes(Charsets.UTF_8));
+ InputStream entityStream = new ByteArrayInputStream(actualInput.getBytes(StandardCharsets.UTF_8));
NormalizedNodeContext inputContext = JsonNormalizedNodeBodyReader.readFrom(uriPath, entityStream, true);
LOG.debug("Parsed YangInstanceIdentifier: {}", inputContext.getInstanceIdentifierContext()
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
writer.writeTo(readData, NormalizedNodeContext.class, null, EMPTY_ANNOTATIONS,
MediaType.APPLICATION_JSON_TYPE, null, outputStream );
- return outputStream.toString(Charsets.UTF_8.name());
+ return outputStream.toString(StandardCharsets.UTF_8.name());
}
private boolean isDataMissing(Exception e) {
*/
package org.opendaylight.netconf.sal.streams.listeners;
-import com.google.common.base.Charsets;
import com.google.common.base.Preconditions;
import com.google.common.eventbus.AsyncEventBus;
import com.google.common.eventbus.EventBus;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
+import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Date;
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
- transformer.transform(new DOMSource(doc), new StreamResult(new OutputStreamWriter(out, Charsets.UTF_8)));
+ transformer.transform(new DOMSource(doc), new StreamResult(new OutputStreamWriter(out, StandardCharsets.UTF_8)));
final byte[] charData = out.toByteArray();
return new String(charData, "UTF-8");
} catch (TransformerException | UnsupportedEncodingException e) {