juplo.de Git - percentcodec/blob - percentcodec/src/main/java/de/juplo/percentcodec/PercentCodec.java

   1 package de.juplo.percentcodec;
   2
   3 import java.nio.charset.Charset;
   4
   5 /**
   6  * This class performes percent-encoding/-decoding like described in RFC 3986.
   7  * <p>
   8  * Complete URI's are not handled by this implementation.
   9  * That is done best with the original {@linkplain java.net.URI}-class from core Java.
  10  * The purpose of this class is to have a simple tool to encode/decode the
  11  * inner parts of an URI, like a segment of the URI-path (the part between two
  12  * forward slashes) or a name or value segment of the query, where all reserved
  13  * characters must be encoded/decoded.
  14  *
  15  * @author kai
  16  */
  17 public class PercentCodec {
  18   private final Charset charset;
  19
  20
  21   public PercentCodec(String encoding) {
  22     charset = Charset.forName(encoding);
  23   }
  24
  25
  26   public String encode(CharSequence in) {
  27     StringBuilder out = new StringBuilder();
  28     int i = 0;
  29     int length = in.length();
  30     while (i < length) {
  31       int codePoint = Character.codePointAt(in, i);
  32       i += Character.charCount(codePoint);
  33       switch (codePoint) {
  34         case 'a':
  35         case 'A':
  36         case 'b':
  37         case 'B':
  38         case 'c':
  39         case 'C':
  40         case 'd':
  41         case 'D':
  42         case 'e':
  43         case 'E':
  44         case 'f':
  45         case 'F':
  46         case 'g':
  47         case 'G':
  48         case 'h':
  49         case 'H':
  50         case 'i':
  51         case 'I':
  52         case 'j':
  53         case 'J':
  54         case 'k':
  55         case 'K':
  56         case 'l':
  57         case 'L':
  58         case 'm':
  59         case 'M':
  60         case 'n':
  61         case 'N':
  62         case 'o':
  63         case 'O':
  64         case 'p':
  65         case 'P':
  66         case 'q':
  67         case 'Q':
  68         case 'r':
  69         case 'R':
  70         case 's':
  71         case 'S':
  72         case 't':
  73         case 'T':
  74         case 'u':
  75         case 'U':
  76         case 'v':
  77         case 'V':
  78         case 'w':
  79         case 'W':
  80         case 'x':
  81         case 'X':
  82         case 'y':
  83         case 'Y':
  84         case 'z':
  85         case 'Z':
  86         case '0':
  87         case '1':
  88         case '2':
  89         case '3':
  90         case '4':
  91         case '5':
  92         case '6':
  93         case '7':
  94         case '8':
  95         case '9':
  96         case '-':
  97         case '_':
  98         case '.':
  99         case '~':
 100           /**
 101            * Unreserved characters can (and should!) stay unchanged!
 102            * (See {@link http://en.wikipedia.org/wiki/Percent-encoding#Types_of_URI_characters})
 103            */
 104           out.append(Character.toChars(codePoint));
 105           break;
 106         default:
 107           /**
 108            * All other characters are reserved or special characters and,
 109            * hence, must be encoded!
 110            */
 111           String encoded = new String(Character.toChars(codePoint));
 112           byte[] bytes = encoded.getBytes(charset);
 113           for (int j = 0; j < bytes.length; j++) {
 114             out.append('%');
 115             out.append(Character.forDigit((bytes[j] >> 4) & 0xF, 16));
 116             out.append(Character.forDigit((bytes[j]) & 0xF, 16));
 117           }
 118       }
 119     }
 120     return out.toString();
 121   }
 122
 123   public String decode(CharSequence in) {
 124     StringBuilder out = new StringBuilder();
 125     int i = 0;
 126     int length = in.length();
 127     while (i < length) {
 128       char c = in.charAt(i);
 129       if (c != '%') {
 130         out.append(c);
 131         i++;
 132       }
 133       else {
 134         byte[] bytes = new byte[length-i/3];
 135         int pos = 0;
 136         while (i+2 < length && in.charAt(i) == '%' ) {
 137           int b = 0;
 138           switch (in.charAt(i+1)) {
 139             case '0': break;
 140             case '1': b = 16*1; break;
 141             case '2': b = 16*2; break;
 142             case '3': b = 16*3; break;
 143             case '4': b = 16*4; break;
 144             case '5': b = 16*5; break;
 145             case '6': b = 16*6; break;
 146             case '7': b = 16*7; break;
 147             case '8': b = 16*8; break;
 148             case '9': b = 16*9; break;
 149             case 'a':
 150             case 'A': b = 16*10; break;
 151             case 'b':
 152             case 'B': b = 16*11; break;
 153             case 'c':
 154             case 'C': b = 16*12; break;
 155             case 'd':
 156             case 'D': b = 16*13; break;
 157             case 'e':
 158             case 'E': b = 16*14; break;
 159             case 'f':
 160             case 'F': b = 16*15; break;
 161             default: throw new IllegalArgumentException("Illegal escape-sequence: %" + in.subSequence(i, i+3));
 162           }
 163           switch (in.charAt(i+2)) {
 164             case '0': break;
 165             case '1': b += 1; break;
 166             case '2': b += 2; break;
 167             case '3': b += 3; break;
 168             case '4': b += 4; break;
 169             case '5': b += 5; break;
 170             case '6': b += 6; break;
 171             case '7': b += 7; break;
 172             case '8': b += 8; break;
 173             case '9': b += 9; break;
 174             case 'a':
 175             case 'A': b += 10; break;
 176             case 'b':
 177             case 'B': b += 11; break;
 178             case 'c':
 179             case 'C': b += 12; break;
 180             case 'd':
 181             case 'D': b += 13; break;
 182             case 'e':
 183             case 'E': b += 14; break;
 184             case 'f':
 185             case 'F': b += 15; break;
 186             default: throw new IllegalArgumentException("Illegal escape-sequence: %" + in.subSequence(i, i+3));
 187           }
 188           bytes[pos++] = (byte)b;
 189           i += 3;
 190         }
 191         out.append(new String(bytes, 0, pos, charset));
 192         if (i < length && in.charAt(i) == '%')
 193           throw  new IllegalArgumentException("Incomplete escape-sequence: %" + in.subSequence(i, length));
 194       }
 195     }
 196     return out.toString();
 197   }
 198 }