--- a/src/org/eclipse/jetty/util/StringUtil.java	Sun Oct 23 23:59:08 2016 -0600
+++ b/src/org/eclipse/jetty/util/StringUtil.java	Mon Oct 24 00:47:24 2016 -0600
@@ -33,16 +33,14 @@
  *
  * 
  */
-public class StringUtil
+public final class StringUtil
 {
 	private static final Logger LOG = LoggerFactory.getLogger(StringUtil.class);
 	
 	public static final String ALL_INTERFACES="0.0.0.0";
-	public static final String CRLF="\015\012";
 	   
 	public static final String __ISO_8859_1="ISO-8859-1";
 	public final static String __UTF8="UTF-8";
-	public final static String __UTF8Alt="UTF8";
 	public final static String __UTF16="UTF-16";
 	
 	public final static Charset __UTF8_CHARSET;
@@ -108,77 +106,6 @@
 		return c==null?s:new String(c);
 	}
 
-
-	/* ------------------------------------------------------------ */
-	public static boolean startsWithIgnoreCase(String s,String w)
-	{
-		if (w==null)
-			return true;
-		
-		if (s==null || s.length()<w.length())
-			return false;
-		
-		for (int i=0;i<w.length();i++)
-		{
-			char c1=s.charAt(i);
-			char c2=w.charAt(i);
-			if (c1!=c2)
-			{
-				if (c1<=127)
-					c1=lowercases[c1];
-				if (c2<=127)
-					c2=lowercases[c2];
-				if (c1!=c2)
-					return false;
-			}
-		}
-		return true;
-	}
-	
-	/* ------------------------------------------------------------ */
-	public static boolean endsWithIgnoreCase(String s,String w)
-	{
-		if (w==null)
-			return true;
-
-		if (s==null)
-			return false;
-			
-		int sl=s.length();
-		int wl=w.length();
-		
-		if (sl<wl)
-			return false;
-		
-		for (int i=wl;i-->0;)
-		{
-			char c1=s.charAt(--sl);
-			char c2=w.charAt(i);
-			if (c1!=c2)
-			{
-				if (c1<=127)
-					c1=lowercases[c1];
-				if (c2<=127)
-					c2=lowercases[c2];
-				if (c1!=c2)
-					return false;
-			}
-		}
-		return true;
-	}
-	
-	/* ------------------------------------------------------------ */
-	/**
-	 * returns the next index of a character from the chars string
-	 */
-	public static int indexFrom(String s,String chars)
-	{
-		for (int i=0;i<s.length();i++)
-		   if (chars.indexOf(s.charAt(i))>=0)
-			  return i;
-		return -1;
-	}
-	
 	/* ------------------------------------------------------------ */
 	/**
 	 * replace substrings within string.
@@ -208,40 +135,6 @@
 
 
 	/* ------------------------------------------------------------ */
-	/** Remove single or double quotes.
-	 */
-	public static String unquote(String s)
-	{
-		return QuotedStringTokenizer.unquote(s);
-	}
-
-
-	/* ------------------------------------------------------------ */
-	/** Append substring to StringBuilder 
-	 * @param buf StringBuilder to append to
-	 * @param s String to append from
-	 * @param offset The offset of the substring
-	 * @param length The length of the substring
-	 */
-	public static void append(StringBuilder buf,
-							  String s,
-							  int offset,
-							  int length)
-	{
-		synchronized(buf)
-		{
-			int end=offset+length;
-			for (int i=offset; i<end;i++)
-			{
-				if (i>=s.length())
-					break;
-				buf.append(s.charAt(i));
-			}
-		}
-	}
-
-	
-	/* ------------------------------------------------------------ */
 	/**
 	 * append hex digit
 	 * 
@@ -258,18 +151,7 @@
 			c= 'a'+(c-'0'-10);
 		buf.append((char)c);
 	}
-
-	/* ------------------------------------------------------------ */
-	public static void append2digits(StringBuffer buf,int i)
-	{
-		if (i<100)
-		{
-			buf.append((char)(i/10+'0'));
-			buf.append((char)(i%10+'0'));
-		}
-	}
 	
-	/* ------------------------------------------------------------ */
 	public static void append2digits(StringBuilder buf,int i)
 	{
 		if (i<100)
@@ -279,43 +161,6 @@
 		}
 	}
 	
-	/* ------------------------------------------------------------ */
-	/** Return a non null string.
-	 * @param s String
-	 * @return The string passed in or empty string if it is null. 
-	 */
-	public static String nonNull(String s)
-	{
-		if (s==null)
-			return "";
-		return s;
-	}
-	
-	/* ------------------------------------------------------------ */
-	public static boolean equals(String s,char[] buf, int offset, int length)
-	{
-		if (s.length()!=length)
-			return false;
-		for (int i=0;i<length;i++)
-			if (buf[offset+i]!=s.charAt(i))
-				return false;
-		return true;
-	}
-
-	/* ------------------------------------------------------------ */
-	public static String toUTF8String(byte[] b,int offset,int length)
-	{
-		try
-		{
-			return new String(b,offset,length,__UTF8);
-		}
-		catch (UnsupportedEncodingException e)
-		{
-			throw new IllegalArgumentException(e);
-		}
-	}
-
-	/* ------------------------------------------------------------ */
 	public static String toString(byte[] b,int offset,int length,String charset)
 	{
 		try
@@ -328,47 +173,12 @@
 		}
 	}
 
-
-	/* ------------------------------------------------------------ */
 	public static boolean isUTF8(String charset)
 	{
 		return __UTF8.equalsIgnoreCase(charset)||__UTF8Alt.equalsIgnoreCase(charset);
 	}
 
 
-	/* ------------------------------------------------------------ */
-	public static String printable(String name)
-	{
-		if (name==null)
-			return null;
-		StringBuilder buf = new StringBuilder(name.length());
-		for (int i=0;i<name.length();i++)
-		{
-			char c=name.charAt(i);
-			if (!Character.isISOControl(c))
-				buf.append(c);
-		}
-		return buf.toString();
-	}
-	
-	/* ------------------------------------------------------------ */
-	public static String printable(byte[] b)
-	{
-		StringBuilder buf = new StringBuilder();
-		for (int i=0;i<b.length;i++)
-		{
-			char c=(char)b[i];
-			if (Character.isWhitespace(c)|| c>' ' && c<0x7f)
-				buf.append(c);
-			else 
-			{
-				buf.append("0x");
-				TypeUtil.toHex(b[i],buf);
-			}
-		}
-		return buf.toString();
-	}
-	
 	public static byte[] getBytes(String s)
 	{
 		try
@@ -381,122 +191,5 @@
 			return s.getBytes();
 		}
 	}
-	
-	public static byte[] getBytes(String s,String charset)
-	{
-		try
-		{
-			return s.getBytes(charset);
-		}
-		catch(Exception e)
-		{
-			LOG.warn("",e);
-			return s.getBytes();
-		}
-	}
-	
-	
-	
-	/**
-	 * Converts a binary SID to a string SID
-	 * 
-	 * http://en.wikipedia.org/wiki/Security_Identifier
-	 * 
-	 * S-1-IdentifierAuthority-SubAuthority1-SubAuthority2-...-SubAuthorityn
-	 */
-	public static String sidBytesToString(byte[] sidBytes)
-	{
-		StringBuilder sidString = new StringBuilder();
-		
-		// Identify this as a SID
-		sidString.append("S-");
-		
-		// Add SID revision level (expect 1 but may change someday)
-		sidString.append(Byte.toString(sidBytes[0])).append('-');
-		
-		StringBuilder tmpBuilder = new StringBuilder();
-		
-		// crunch the six bytes of issuing authority value
-		for (int i = 2; i <= 7; ++i)
-		{
-			tmpBuilder.append(Integer.toHexString(sidBytes[i] & 0xFF));
-		}
-		
-		sidString.append(Long.parseLong(tmpBuilder.toString(), 16)); // '-' is in the subauth loop
-   
-		// the number of subAuthorities we need to attach
-		int subAuthorityCount = sidBytes[1];
 
-		// attach each of the subAuthorities
-		for (int i = 0; i < subAuthorityCount; ++i)
-		{
-			int offset = i * 4;
-			tmpBuilder.setLength(0);
-			// these need to be zero padded hex and little endian
-			tmpBuilder.append(String.format("%02X%02X%02X%02X", 
-					(sidBytes[11 + offset] & 0xFF),
-					(sidBytes[10 + offset] & 0xFF),
-					(sidBytes[9 + offset] & 0xFF),
-					(sidBytes[8 + offset] & 0xFF)));  
-			sidString.append('-').append(Long.parseLong(tmpBuilder.toString(), 16));
-		}
-		
-		return sidString.toString();
-	}
-	
-	/**
-	 * Converts a string SID to a binary SID
-	 * 
-	 * http://en.wikipedia.org/wiki/Security_Identifier
-	 * 
-	 * S-1-IdentifierAuthority-SubAuthority1-SubAuthority2-...-SubAuthorityn
-	 */
-	public static byte[] sidStringToBytes( String sidString )
-	{
-		String[] sidTokens = sidString.split("-");
-		
-		int subAuthorityCount = sidTokens.length - 3; // S-Rev-IdAuth-
-		
-		int byteCount = 0;
-		byte[] sidBytes = new byte[1 + 1 + 6 + (4 * subAuthorityCount)];
-		
-		// the revision byte
-		sidBytes[byteCount++] = (byte)Integer.parseInt(sidTokens[1]);
-
-		// the # of sub authorities byte
-		sidBytes[byteCount++] = (byte)subAuthorityCount;
-
-		// the certAuthority
-		String hexStr = Long.toHexString(Long.parseLong(sidTokens[2]));
-		
-		while( hexStr.length() < 12) // pad to 12 characters
-		{
-			hexStr = "0" + hexStr;
-		}
-
-		// place the certAuthority 6 bytes
-		for ( int i = 0 ; i < hexStr.length(); i = i + 2)
-		{
-			sidBytes[byteCount++] = (byte)Integer.parseInt(hexStr.substring(i, i + 2),16);
-		}
-				
-		
-		for ( int i = 3; i < sidTokens.length ; ++i)
-		{
-			hexStr = Long.toHexString(Long.parseLong(sidTokens[i]));
-			
-			while( hexStr.length() < 8) // pad to 8 characters
-			{
-				hexStr = "0" + hexStr;
-			}     
-			
-			// place the inverted sub authorities, 4 bytes each
-			for ( int j = hexStr.length(); j > 0; j = j - 2)
-			{          
-				sidBytes[byteCount++] = (byte)Integer.parseInt(hexStr.substring(j-2, j),16);
-			}
-		}
-	  
-		return sidBytes;
-	}
 }