Changeset 8304 in josm


Ignore:
Timestamp:
2015-05-01T21:47:18+02:00 (5 years ago)
Author:
Don-vip
Message:

simplify URL encoding/decoding

Location:
trunk/src/org/openstreetmap/josm
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/actions/SearchNotesDownloadAction.java

    r8196 r8304  
    77import java.awt.GridBagLayout;
    88import java.awt.event.ActionEvent;
    9 import java.io.UnsupportedEncodingException;
    10 import java.net.URLEncoder;
    119import java.util.Collections;
    1210import java.util.LinkedList;
     
    2321import org.openstreetmap.josm.gui.widgets.HistoryComboBox;
    2422import org.openstreetmap.josm.io.OsmApi;
     23import org.openstreetmap.josm.tools.Utils;
    2524
    2625/**
     
    9897        sb.append(closedLimit);
    9998        sb.append("&q=");
    100         try {
    101             sb.append(URLEncoder.encode(searchTerm, "UTF-8"));
    102         } catch (UnsupportedEncodingException ex) {
    103             Main.error(ex, true); // thrown if UTF-8 isn't supported which seems unlikely.
    104             return;
    105         }
     99        sb.append(Utils.encodeUrl(searchTerm));
    106100
    107101        new DownloadNotesTask().loadUrl(false, sb.toString(), null);
  • trunk/src/org/openstreetmap/josm/gui/dialogs/UserListDialog.java

    r7771 r8304  
    99import java.awt.event.MouseAdapter;
    1010import java.awt.event.MouseEvent;
    11 import java.io.UnsupportedEncodingException;
    12 import java.net.URLEncoder;
    1311import java.text.NumberFormat;
    1412import java.util.ArrayList;
     
    2523
    2624import javax.swing.AbstractAction;
    27 import javax.swing.JOptionPane;
    2825import javax.swing.JTable;
    2926import javax.swing.ListSelectionModel;
     
    4643import org.openstreetmap.josm.tools.OpenBrowser;
    4744import org.openstreetmap.josm.tools.Shortcut;
     45import org.openstreetmap.josm.tools.Utils;
    4846
    4947/**
     
    6260    private ShowUserInfoAction showUserInfoAction;
    6361
     62    /**
     63     * Constructs a new {@code UserListDialog}.
     64     */
    6465    public UserListDialog() {
    6566        super(tr("Authors"), "userlist", tr("Open a list of people working on the selected objects."),
    6667                Shortcut.registerShortcut("subwindow:authors", tr("Toggle: {0}", tr("Authors")), KeyEvent.VK_A, Shortcut.ALT_SHIFT), 150);
    67 
    6868        build();
    6969    }
     
    221221        protected String createInfoUrl(Object infoObject) {
    222222            User user = (User)infoObject;
    223             try {
    224                 return Main.getBaseUserUrl() + "/" + URLEncoder.encode(user.getName(), "UTF-8").replaceAll("\\+", "%20");
    225             } catch(UnsupportedEncodingException e) {
    226                 Main.error(e);
    227                 JOptionPane.showMessageDialog(
    228                         Main.parent,
    229                         tr("<html>Failed to create an URL because the encoding ''{0}''<br>"
    230                                 + "was missing on this system.</html>", "UTF-8"),
    231                                 tr("Missing encoding"),
    232                                 JOptionPane.ERROR_MESSAGE
    233                 );
    234                 return null;
    235             }
     223            return Main.getBaseUserUrl() + "/" + Utils.encodeUrl(user.getName()).replaceAll("\\+", "%20");
    236224        }
    237225
  • trunk/src/org/openstreetmap/josm/gui/dialogs/properties/PropertiesDialog.java

    r8285 r8304  
    1414import java.awt.event.MouseAdapter;
    1515import java.awt.event.MouseEvent;
    16 import java.io.UnsupportedEncodingException;
    1716import java.net.HttpURLConnection;
    1817import java.net.URI;
    1918import java.net.URISyntaxException;
    20 import java.net.URLEncoder;
    2119import java.util.ArrayList;
    2220import java.util.Arrays;
     
    10731071                if (tagTable.getSelectedRowCount() == 1) {
    10741072                    row = tagTable.getSelectedRow();
    1075                     String key = URLEncoder.encode(tagData.getValueAt(row, 0).toString(), "UTF-8");
     1073                    String key = Utils.encodeUrl(tagData.getValueAt(row, 0).toString());
    10761074                    @SuppressWarnings("unchecked")
    10771075                    Map<String, Integer> m = (Map<String, Integer>) tagData.getValueAt(row, 1);
    1078                     String val = URLEncoder.encode(m.entrySet().iterator().next().getKey(), "UTF-8");
     1076                    String val = Utils.encodeUrl(m.entrySet().iterator().next().getKey());
    10791077
    10801078                    uris.add(new URI(String.format("%s%sTag:%s=%s", base, lang, key, val)));
     
    10881086                    String type = ((Relation)membershipData.getValueAt(row, 0)).get("type");
    10891087                    if (type != null) {
    1090                         type = URLEncoder.encode(type, "UTF-8");
     1088                        type = Utils.encodeUrl(type);
    10911089                    }
    10921090
     
    11491147                    }
    11501148                });
    1151             } catch (URISyntaxException | UnsupportedEncodingException e1) {
     1149            } catch (URISyntaxException e1) {
    11521150                Main.error(e1);
    11531151            }
  • trunk/src/org/openstreetmap/josm/gui/download/PlaceSelection.java

    r8287 r8304  
    364364        @Override
    365365        protected void realRun() throws SAXException, IOException, OsmTransferException {
    366             String urlString = useserver.url+java.net.URLEncoder.encode(searchExpression, "UTF-8");
     366            String urlString = useserver.url+Utils.encodeUrl(searchExpression);
    367367
    368368            try {
  • trunk/src/org/openstreetmap/josm/gui/history/VersionInfoPanel.java

    r8291 r8304  
    1111import java.awt.Insets;
    1212import java.awt.event.ActionEvent;
    13 import java.io.UnsupportedEncodingException;
    14 import java.net.URLEncoder;
    1513import java.text.DateFormat;
    1614import java.util.Collections;
     
    185183    }
    186184
    187     protected static String getUserUrl(String username) throws UnsupportedEncodingException {
    188         return Main.getBaseUserUrl() + "/" +  URLEncoder.encode(username, "UTF-8").replaceAll("\\+", "%20");
     185    protected static String getUserUrl(String username) {
     186        return Main.getBaseUserUrl() + "/" +  Utils.encodeUrl(username).replaceAll("\\+", "%20");
    189187    }
    190188
     
    209207            }
    210208            lblUser.setDescription(username);
    211             try {
    212                 if (user != null && user != User.getAnonymous()) {
    213                     lblUser.setUrl(getUserUrl(username));
    214                 } else {
    215                     lblUser.setUrl(null);
    216                 }
    217             } catch(UnsupportedEncodingException e) {
    218                 Main.error(e);
     209            if (user != null && user != User.getAnonymous()) {
     210                lblUser.setUrl(getUserUrl(username));
     211            } else {
    219212                lblUser.setUrl(null);
    220213            }
     
    226219            } else {
    227220                lblUser.setDescription(username);
    228                 try {
    229                     lblUser.setUrl(getUserUrl(username));
    230                 } catch(UnsupportedEncodingException e) {
    231                     Main.error(e);
    232                     lblUser.setUrl(null);
    233                 }
     221                lblUser.setUrl(getUserUrl(username));
    234222            }
    235223            lblChangeset.setDescription(tr("none"));
  • trunk/src/org/openstreetmap/josm/gui/mappaint/mapcss/ExpressionFactory.java

    r8256 r8304  
    33
    44import java.awt.Color;
    5 import java.io.UnsupportedEncodingException;
    65import java.lang.annotation.ElementType;
    76import java.lang.annotation.Retention;
     
    1110import java.lang.reflect.InvocationTargetException;
    1211import java.lang.reflect.Method;
    13 import java.net.URLEncoder;
    1412import java.nio.charset.StandardCharsets;
    1513import java.util.ArrayList;
     
    801799         */
    802800        public static String URL_encode(String s) {
    803             try {
    804                 return s == null ? null : URLEncoder.encode(s, "UTF-8");
    805             } catch (UnsupportedEncodingException ex) {
    806                 throw new RuntimeException(ex);
    807             }
     801            return s == null ? null : Utils.encodeUrl(s);
    808802        }
    809803
  • trunk/src/org/openstreetmap/josm/gui/oauth/OsmOAuthAuthorizationClient.java

    r8291 r8304  
    99import java.io.InputStream;
    1010import java.io.InputStreamReader;
    11 import java.io.UnsupportedEncodingException;
    1211import java.lang.reflect.Field;
    1312import java.net.HttpURLConnection;
    1413import java.net.MalformedURLException;
    1514import java.net.URL;
    16 import java.net.URLEncoder;
    1715import java.nio.charset.StandardCharsets;
    1816import java.util.HashMap;
     
    251249
    252250    protected String buildPostRequest(Map<String,String> parameters) throws OsmOAuthAuthorizationException {
    253         try {
    254             StringBuilder sb = new StringBuilder();
    255 
    256             for(Iterator<Entry<String,String>> it = parameters.entrySet().iterator(); it.hasNext();) {
    257                 Entry<String,String> entry = it.next();
    258                 String value = entry.getValue();
    259                 value = (value == null) ? "" : value;
    260                 sb.append(entry.getKey()).append("=").append(URLEncoder.encode(value, "UTF-8"));
    261                 if (it.hasNext()) {
    262                     sb.append("&");
    263                 }
    264             }
    265             return sb.toString();
    266         } catch(UnsupportedEncodingException e) {
    267             throw new OsmOAuthAuthorizationException(e);
    268         }
     251        StringBuilder sb = new StringBuilder();
     252
     253        for(Iterator<Entry<String,String>> it = parameters.entrySet().iterator(); it.hasNext();) {
     254            Entry<String,String> entry = it.next();
     255            String value = entry.getValue();
     256            value = (value == null) ? "" : value;
     257            sb.append(entry.getKey()).append("=").append(Utils.encodeUrl(value));
     258            if (it.hasNext()) {
     259                sb.append("&");
     260            }
     261        }
     262        return sb.toString();
    269263    }
    270264
  • trunk/src/org/openstreetmap/josm/io/ChangesetQuery.java

    r8291 r8304  
    44import static org.openstreetmap.josm.tools.I18n.tr;
    55
    6 import java.io.UnsupportedEncodingException;
    7 import java.net.URLEncoder;
    86import java.text.DateFormat;
    97import java.text.MessageFormat;
     
    1816import java.util.Map.Entry;
    1917
    20 import org.openstreetmap.josm.Main;
    2118import org.openstreetmap.josm.data.Bounds;
    2219import org.openstreetmap.josm.data.coor.LatLon;
     
    258255            sb.append("user").append("=").append(uid);
    259256        } else if (userName != null) {
    260             try {
    261                 sb.append("display_name").append("=").append(URLEncoder.encode(userName, "UTF-8"));
    262             } catch (UnsupportedEncodingException e) {
    263                 Main.error(e);
    264             }
     257            sb.append("display_name").append("=").append(Utils.encodeUrl(userName));
    265258        }
    266259        if (bounds != null) {
  • trunk/src/org/openstreetmap/josm/io/OsmApi.java

    r8291 r8304  
    1515import java.io.StringReader;
    1616import java.io.StringWriter;
    17 import java.io.UnsupportedEncodingException;
    1817import java.net.ConnectException;
    1918import java.net.HttpURLConnection;
     
    2120import java.net.SocketTimeoutException;
    2221import java.net.URL;
    23 import java.net.URLEncoder;
    2422import java.nio.charset.StandardCharsets;
    2523import java.util.Collection;
     
    815813            .append(latlon.lon())
    816814            .append("&text=")
    817             .append(urlEncode(text)).toString();
     815            .append(Utils.encodeUrl(text)).toString();
    818816
    819817        String response = sendRequest("POST", noteUrl, null, monitor, true, false);
     
    833831        String noteUrl = noteStringBuilder(note)
    834832            .append("/comment?text=")
    835             .append(urlEncode(comment)).toString();
     833            .append(Utils.encodeUrl(comment)).toString();
    836834
    837835        String response = sendRequest("POST", noteUrl, null, monitor, true, false);
     
    849847    public Note closeNote(Note note, String closeMessage, ProgressMonitor monitor) throws OsmTransferException {
    850848        initialize(monitor);
    851         String encodedMessage = urlEncode(closeMessage);
     849        String encodedMessage = Utils.encodeUrl(closeMessage);
    852850        StringBuilder urlBuilder = noteStringBuilder(note)
    853851            .append("/close");
     
    871869    public Note reopenNote(Note note, String reactivateMessage, ProgressMonitor monitor) throws OsmTransferException {
    872870        initialize(monitor);
    873         String encodedMessage = urlEncode(reactivateMessage);
     871        String encodedMessage = Utils.encodeUrl(reactivateMessage);
    874872        StringBuilder urlBuilder = noteStringBuilder(note)
    875873            .append("/reopen");
     
    897895        }
    898896    }
    899 
    900     /** URL encodes a string. Useful for transforming user input into URL query strings*/
    901     private String urlEncode(String string) throws OsmTransferException {
    902         try {
    903             return URLEncoder.encode(string, "UTF-8");
    904         } catch (UnsupportedEncodingException e) {
    905             Main.error(e, true);
    906             throw new OsmTransferException(tr("Error encoding string: {0}", string), e);
    907         }
    908     }
    909897}
  • trunk/src/org/openstreetmap/josm/io/remotecontrol/AddTagsDialog.java

    r8285 r8304  
    1111import java.awt.event.KeyEvent;
    1212import java.awt.event.MouseEvent;
    13 import java.io.UnsupportedEncodingException;
    14 import java.net.URLDecoder;
    1513import java.util.Collection;
    1614import java.util.HashMap;
     
    3634import org.openstreetmap.josm.gui.util.TableHelper;
    3735import org.openstreetmap.josm.tools.GBC;
     36import org.openstreetmap.josm.tools.Utils;
    3837
    3938/**
     
    263262                public void run() {
    264263                    String[] tags = null;
    265                     try {
    266                         tags = URLDecoder.decode(args.get("addtags"), "UTF-8").split("\\|");
    267                     } catch (UnsupportedEncodingException e) {
    268                         throw new RuntimeException(e);
    269                     }
     264                    tags = Utils.decodeUrl(args.get("addtags")).split("\\|");
    270265                    Set<String> tagSet = new HashSet<>();
    271266                    for (String tag : tags) {
  • trunk/src/org/openstreetmap/josm/io/remotecontrol/handler/LoadDataHandler.java

    r8191 r8304  
    55
    66import java.io.ByteArrayInputStream;
    7 import java.io.UnsupportedEncodingException;
    8 import java.net.URLEncoder;
    97import java.nio.charset.StandardCharsets;
    108
     
    6260    @Override
    6361    public String[] getUsageExamples() {
    64         try {
    65             final String data = URLEncoder.encode("<osm version='0.6'><node id='-1' lat='1' lon='2' /></osm>", "UTF-8");
    66             return new String[]{
    67                     "/load_data?layer_name=extra_layer&new_layer=true&data=" + data};
    68         } catch (UnsupportedEncodingException ex) {
    69             throw new IllegalStateException(ex);
    70         }
     62        final String data = Utils.encodeUrl("<osm version='0.6'><node id='-1' lat='1' lon='2' /></osm>");
     63        return new String[]{
     64                "/load_data?layer_name=extra_layer&new_layer=true&data=" + data};
    7165    }
    7266
  • trunk/src/org/openstreetmap/josm/io/remotecontrol/handler/RequestHandler.java

    r8193 r8304  
    22package org.openstreetmap.josm.io.remotecontrol.handler;
    33
    4 import org.openstreetmap.josm.Main;
    5 import org.openstreetmap.josm.io.remotecontrol.PermissionPrefWithDefault;
    6 import org.openstreetmap.josm.tools.Utils;
    7 
    8 import javax.swing.JLabel;
    9 import javax.swing.JOptionPane;
    10 import java.io.UnsupportedEncodingException;
     4import static org.openstreetmap.josm.tools.I18n.tr;
     5
    116import java.net.URI;
    127import java.net.URISyntaxException;
    13 import java.net.URLDecoder;
    148import java.text.MessageFormat;
    159import java.util.Collections;
     
    2014import java.util.Map;
    2115
    22 import static org.openstreetmap.josm.tools.I18n.tr;
     16import javax.swing.JLabel;
     17import javax.swing.JOptionPane;
     18
     19import org.openstreetmap.josm.Main;
     20import org.openstreetmap.josm.io.remotecontrol.PermissionPrefWithDefault;
     21import org.openstreetmap.josm.tools.Utils;
    2322
    2423/**
     
    210209        }
    211210        for (String kv : uri.getRawQuery().split("&")) {
    212             try {
    213                 final String[] kvs = URLDecoder.decode(kv, "UTF-8").split("=", 2);
    214                 r.put(kvs[0], kvs.length > 1 ? kvs[1] : null);
    215             } catch (UnsupportedEncodingException ex) {
    216                 throw new IllegalStateException(ex);
    217             }
     211            final String[] kvs = Utils.decodeUrl(kv).split("=", 2);
     212            r.put(kvs[0], kvs.length > 1 ? kvs[1] : null);
    218213        }
    219214        return r;
     
    275270    }
    276271
    277     protected static String decodeParam(String param) {
    278         try {
    279             return URLDecoder.decode(param, "UTF-8");
    280         } catch (UnsupportedEncodingException e) {
    281             throw new RuntimeException(e);
    282         }
    283     }
    284 
    285272    public void setSender(String sender) {
    286273        this.sender = sender;
     
    333320                String query = request.substring(request.indexOf('?') + 1);
    334321                if (query.indexOf("url=") == 0) {
    335                     args.put("url", decodeParam(query.substring(4)));
     322                    args.put("url", Utils.decodeUrl(query.substring(4)));
    336323                } else {
    337324                    int urlIdx = query.indexOf("&url=");
    338325                    if (urlIdx != -1) {
    339                         args.put("url", decodeParam(query.substring(urlIdx + 5)));
     326                        args.put("url", Utils.decodeUrl(query.substring(urlIdx + 5)));
    340327                        query = query.substring(0, urlIdx);
    341328                    } else if (query.indexOf('#') != -1) {
     
    346333                        int eq = param.indexOf('=');
    347334                        if (eq != -1) {
    348                             args.put(param.substring(0, eq), decodeParam(param.substring(eq + 1)));
     335                            args.put(param.substring(0, eq), Utils.decodeUrl(param.substring(eq + 1)));
    349336                        }
    350337                    }
  • trunk/src/org/openstreetmap/josm/tools/ImageProvider.java

    r8286 r8304  
    2727import java.io.InputStream;
    2828import java.io.StringReader;
    29 import java.io.UnsupportedEncodingException;
    3029import java.net.URI;
    3130import java.net.URL;
    32 import java.net.URLDecoder;
    33 import java.net.URLEncoder;
    3431import java.nio.charset.StandardCharsets;
    3532import java.util.ArrayList;
     
    287284     *
    288285     * (optional)
     286     * @param archive zip file where the image is located
    289287     * @return the current object, for convenience
    290288     */
     
    816814     */
    817815    private static ImageResource getIfAvailableDataUrl(String url) {
    818         try {
    819             Matcher m = dataUrlPattern.matcher(url);
    820             if (m.matches()) {
    821                 String mediatype = m.group(1);
    822                 String base64 = m.group(2);
    823                 String data = m.group(3);
    824                 byte[] bytes;
    825                 if (";base64".equals(base64)) {
    826                     bytes = DatatypeConverter.parseBase64Binary(data);
    827                 } else {
    828                     try {
    829                         bytes = URLDecoder.decode(data, "UTF-8").getBytes(StandardCharsets.UTF_8);
    830                     } catch (IllegalArgumentException ex) {
    831                         Main.warn("Unable to decode URL data part: "+ex.getMessage() + " (" + data + ")");
    832                         return null;
    833                     }
    834                 }
    835                 if ("image/svg+xml".equals(mediatype)) {
    836                     String s = new String(bytes, StandardCharsets.UTF_8);
    837                     SVGDiagram svg = null;
    838                     synchronized (getSvgUniverse()) {
    839                         URI uri = getSvgUniverse().loadSVG(new StringReader(s), URLEncoder.encode(s, "UTF-8"));
    840                         svg = getSvgUniverse().getDiagram(uri);
    841                     }
    842                     if (svg == null) {
    843                         Main.warn("Unable to process svg: "+s);
    844                         return null;
    845                     }
    846                     return new ImageResource(svg);
    847                 } else {
    848                     try {
    849                         // See #10479: for PNG files, always enforce transparency to be sure tNRS chunk is used even not in paletted mode
    850                         // This can be removed if someday Oracle fixes https://bugs.openjdk.java.net/browse/JDK-6788458
    851                         // hg.openjdk.java.net/jdk7u/jdk7u/jdk/file/828c4fedd29f/src/share/classes/com/sun/imageio/plugins/png/PNGImageReader.java#l656
    852                         Image img = read(new ByteArrayInputStream(bytes), false, true);
    853                         return img == null ? null : new ImageResource(img);
    854                     } catch (IOException e) {
    855                         Main.warn("IOException while reading image: "+e.getMessage());
    856                     }
    857                 }
    858             }
    859             return null;
    860         } catch (UnsupportedEncodingException ex) {
    861             throw new RuntimeException(ex.getMessage(), ex);
    862         }
     816        Matcher m = dataUrlPattern.matcher(url);
     817        if (m.matches()) {
     818            String mediatype = m.group(1);
     819            String base64 = m.group(2);
     820            String data = m.group(3);
     821            byte[] bytes;
     822            if (";base64".equals(base64)) {
     823                bytes = DatatypeConverter.parseBase64Binary(data);
     824            } else {
     825                try {
     826                    bytes = Utils.decodeUrl(data).getBytes(StandardCharsets.UTF_8);
     827                } catch (IllegalArgumentException ex) {
     828                    Main.warn("Unable to decode URL data part: "+ex.getMessage() + " (" + data + ")");
     829                    return null;
     830                }
     831            }
     832            if ("image/svg+xml".equals(mediatype)) {
     833                String s = new String(bytes, StandardCharsets.UTF_8);
     834                SVGDiagram svg = null;
     835                synchronized (getSvgUniverse()) {
     836                    URI uri = getSvgUniverse().loadSVG(new StringReader(s), Utils.encodeUrl(s));
     837                    svg = getSvgUniverse().getDiagram(uri);
     838                }
     839                if (svg == null) {
     840                    Main.warn("Unable to process svg: "+s);
     841                    return null;
     842                }
     843                return new ImageResource(svg);
     844            } else {
     845                try {
     846                    // See #10479: for PNG files, always enforce transparency to be sure tNRS chunk is used even not in paletted mode
     847                    // This can be removed if someday Oracle fixes https://bugs.openjdk.java.net/browse/JDK-6788458
     848                    // hg.openjdk.java.net/jdk7u/jdk7u/jdk/file/828c4fedd29f/src/share/classes/com/sun/imageio/plugins/png/PNGImageReader.java#l656
     849                    Image img = read(new ByteArrayInputStream(bytes), false, true);
     850                    return img == null ? null : new ImageResource(img);
     851                } catch (IOException e) {
     852                    Main.warn("IOException while reading image: "+e.getMessage());
     853                }
     854            }
     855        }
     856        return null;
    863857    }
    864858
  • trunk/src/org/openstreetmap/josm/tools/OsmUrlToBounds.java

    r8291 r8304  
    66import java.awt.HeadlessException;
    77import java.awt.Toolkit;
    8 import java.io.UnsupportedEncodingException;
    9 import java.net.URLDecoder;
    108import java.util.HashMap;
    119import java.util.Map;
     
    2624            // a percent sign indicates an encoded URL (RFC 1738).
    2725            if (url.contains("%")) {
    28                 url = URLDecoder.decode(url, "UTF-8");
    29             }
    30         } catch (UnsupportedEncodingException | IllegalArgumentException x) {
     26                url = Utils.decodeUrl(url);
     27            }
     28        } catch (IllegalArgumentException x) {
    3129            Main.error(x);
    3230        }
  • trunk/src/org/openstreetmap/josm/tools/Utils.java

    r8291 r8304  
    2525import java.net.URL;
    2626import java.net.URLConnection;
     27import java.net.URLDecoder;
    2728import java.net.URLEncoder;
    2829import java.nio.charset.StandardCharsets;
     
    11161117                sb.append(c);
    11171118            } else {
    1118                 try {
    1119                     sb.append(URLEncoder.encode(c, "UTF-8"));
    1120                 } catch (UnsupportedEncodingException ex) {
    1121                     throw new RuntimeException(ex);
    1122                 }
     1119                sb.append(encodeUrl(c));
    11231120            }
    11241121        }
    11251122        return sb.toString();
     1123    }
     1124
     1125    /**
     1126     * Translates a string into <code>application/x-www-form-urlencoded</code>
     1127     * format. This method uses UTF-8 encoding scheme to obtain the bytes for unsafe
     1128     * characters.
     1129     *
     1130     * @param   s <code>String</code> to be translated.
     1131     * @return  the translated <code>String</code>.
     1132     * @see #decodeUrl(String)
     1133     * @since 8304
     1134     */
     1135    public static String encodeUrl(String s) {
     1136        final String enc = StandardCharsets.UTF_8.name();
     1137        try {
     1138            return URLEncoder.encode(s, enc);
     1139        } catch (UnsupportedEncodingException e) {
     1140            Main.error(e);
     1141            return null;
     1142        }
     1143    }
     1144
     1145    /**
     1146     * Decodes a <code>application/x-www-form-urlencoded</code> string.
     1147     * UTF-8 encoding is used to determine
     1148     * what characters are represented by any consecutive sequences of the
     1149     * form "<code>%<i>xy</i></code>".
     1150     *
     1151     * @param s the <code>String</code> to decode
     1152     * @return the newly decoded <code>String</code>
     1153     * @see #encodeUrl(String)
     1154     * @since 8304
     1155     */
     1156    public static String decodeUrl(String s) {
     1157        final String enc = StandardCharsets.UTF_8.name();
     1158        try {
     1159            return URLDecoder.decode(s, enc);
     1160        } catch (UnsupportedEncodingException e) {
     1161            Main.error(e);
     1162            return null;
     1163        }
    11261164    }
    11271165
Note: See TracChangeset for help on using the changeset viewer.