src/java/org/eclipse/jetty/util/StringUtil.java - platform/external/jetty - Git at Google

 //
 //  ========================================================================
 //  Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd.
 //  ------------------------------------------------------------------------
 //  All rights reserved. This program and the accompanying materials
 //  are made available under the terms of the Eclipse Public License v1.0
 //  and Apache License v2.0 which accompanies this distribution.
 //
 //      The Eclipse Public License is available at
 //      http://www.eclipse.org/legal/epl-v10.html
 //
 //      The Apache License v2.0 is available at
 //      http://www.opensource.org/licenses/apache2.0.php
 //
 //  You may elect to redistribute this code under either of these licenses.
 //  ========================================================================
 //

 package org.eclipse.jetty.util;

 import java.io.UnsupportedEncodingException;
 import java.nio.charset.Charset;

 import org.eclipse.jetty.util.log.Log;
 import org.eclipse.jetty.util.log.Logger;

 /** Fast String Utilities.
  *
  * These string utilities provide both conveniance methods and
  * performance improvements over most standard library versions. The
  * main aim of the optimizations is to avoid object creation unless
  * absolutely required.
  *
  *
  */
 public class StringUtil
 {
     private static final Logger LOG = Log.getLogger(StringUtil.class);

     public static final String ALL_INTERFACES="0.0.0.0";
     public static final String CRLF="\015\012";
     public static final String __LINE_SEPARATOR=
         System.getProperty("line.separator","\n");

     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;
     public final static Charset __ISO_8859_1_CHARSET;

     static
     {
         __UTF8_CHARSET=Charset.forName(__UTF8);
         __ISO_8859_1_CHARSET=Charset.forName(__ISO_8859_1);
     }

     private static char[] lowercases = {
           '\000','\001','\002','\003','\004','\005','\006','\007',
           '\010','\011','\012','\013','\014','\015','\016','\017',
           '\020','\021','\022','\023','\024','\025','\026','\027',
           '\030','\031','\032','\033','\034','\035','\036','\037',
           '\040','\041','\042','\043','\044','\045','\046','\047',
           '\050','\051','\052','\053','\054','\055','\056','\057',
           '\060','\061','\062','\063','\064','\065','\066','\067',
           '\070','\071','\072','\073','\074','\075','\076','\077',
           '\100','\141','\142','\143','\144','\145','\146','\147',
           '\150','\151','\152','\153','\154','\155','\156','\157',
           '\160','\161','\162','\163','\164','\165','\166','\167',
           '\170','\171','\172','\133','\134','\135','\136','\137',
           '\140','\141','\142','\143','\144','\145','\146','\147',
           '\150','\151','\152','\153','\154','\155','\156','\157',
           '\160','\161','\162','\163','\164','\165','\166','\167',
           '\170','\171','\172','\173','\174','\175','\176','\177' };

     /* ------------------------------------------------------------ */
     /**
      * fast lower case conversion. Only works on ascii (not unicode)
      * @param s the string to convert
      * @return a lower case version of s
      */
     public static String asciiToLowerCase(String s)
     {
         char[] c = null;
         int i=s.length();

         // look for first conversion
         while (i-->0)
         {
             char c1=s.charAt(i);
             if (c1<=127)
             {
                 char c2=lowercases[c1];
                 if (c1!=c2)
                 {
                     c=s.toCharArray();
                     c[i]=c2;
                     break;
                 }
             }
         }

         while (i-->0)
         {
             if(c[i]<=127)
                 c[i] = lowercases[c[i]];
         }

         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.
      */
     public static String replace(String s, String sub, String with)
     {
         int c=0;
         int i=s.indexOf(sub,c);
         if (i == -1)
             return s;

         StringBuilder buf = new StringBuilder(s.length()+with.length());

         do
         {
             buf.append(s.substring(c,i));
             buf.append(with);
             c=i+sub.length();
         } while ((i=s.indexOf(sub,c))!=-1);

         if (c<s.length())
             buf.append(s.substring(c,s.length()));

         return buf.toString();

     }


     /* ------------------------------------------------------------ */
     /** 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
      *
      */
     public static void append(StringBuilder buf,byte b,int base)
     {
         int bi=0xff&b;
         int c='0'+(bi/base)%base;
         if (c>'9')
             c= 'a'+(c-'0'-10);
         buf.append((char)c);
         c='0'+bi%base;
         if (c>'9')
             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)
         {
             buf.append((char)(i/10+'0'));
             buf.append((char)(i%10+'0'));
         }
     }

     /* ------------------------------------------------------------ */
     /** 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
         {
             return new String(b,offset,length,charset);
         }
         catch (UnsupportedEncodingException e)
         {
             throw new IllegalArgumentException(e);
         }
     }


     /* ------------------------------------------------------------ */
     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
         {
             return s.getBytes(__ISO_8859_1);
         }
         catch(Exception e)
         {
             LOG.warn(e);
             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;
     }
 }
	//
	// ========================================================================
	// Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd.
	// ------------------------------------------------------------------------
	// All rights reserved. This program and the accompanying materials
	// are made available under the terms of the Eclipse Public License v1.0
	// and Apache License v2.0 which accompanies this distribution.
	//
	// The Eclipse Public License is available at
	// http://www.eclipse.org/legal/epl-v10.html
	//
	// The Apache License v2.0 is available at
	// http://www.opensource.org/licenses/apache2.0.php
	//
	// You may elect to redistribute this code under either of these licenses.
	// ========================================================================
	//

	package org.eclipse.jetty.util;

	import java.io.UnsupportedEncodingException;
	import java.nio.charset.Charset;

	import org.eclipse.jetty.util.log.Log;
	import org.eclipse.jetty.util.log.Logger;

	/** Fast String Utilities.
	*
	* These string utilities provide both conveniance methods and
	* performance improvements over most standard library versions. The
	* main aim of the optimizations is to avoid object creation unless
	* absolutely required.
	*
	*
	*/
	public class StringUtil
	{
	private static final Logger LOG = Log.getLogger(StringUtil.class);

	public static final String ALL_INTERFACES="0.0.0.0";
	public static final String CRLF="\015\012";
	public static final String __LINE_SEPARATOR=
	System.getProperty("line.separator","\n");

	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;
	public final static Charset __ISO_8859_1_CHARSET;

	static
	{
	__UTF8_CHARSET=Charset.forName(__UTF8);
	__ISO_8859_1_CHARSET=Charset.forName(__ISO_8859_1);
	}

	private static char[] lowercases = {
	'\000','\001','\002','\003','\004','\005','\006','\007',
	'\010','\011','\012','\013','\014','\015','\016','\017',
	'\020','\021','\022','\023','\024','\025','\026','\027',
	'\030','\031','\032','\033','\034','\035','\036','\037',
	'\040','\041','\042','\043','\044','\045','\046','\047',
	'\050','\051','\052','\053','\054','\055','\056','\057',
	'\060','\061','\062','\063','\064','\065','\066','\067',
	'\070','\071','\072','\073','\074','\075','\076','\077',
	'\100','\141','\142','\143','\144','\145','\146','\147',
	'\150','\151','\152','\153','\154','\155','\156','\157',
	'\160','\161','\162','\163','\164','\165','\166','\167',
	'\170','\171','\172','\133','\134','\135','\136','\137',
	'\140','\141','\142','\143','\144','\145','\146','\147',
	'\150','\151','\152','\153','\154','\155','\156','\157',
	'\160','\161','\162','\163','\164','\165','\166','\167',
	'\170','\171','\172','\173','\174','\175','\176','\177' };

	/* ------------------------------------------------------------ */
	/**
	* fast lower case conversion. Only works on ascii (not unicode)
	* @param s the string to convert
	* @return a lower case version of s
	*/
	public static String asciiToLowerCase(String s)
	{
	char[] c = null;
	int i=s.length();

	// look for first conversion
	while (i-->0)
	{
	char c1=s.charAt(i);
	if (c1<=127)
	{
	char c2=lowercases[c1];
	if (c1!=c2)
	{
	c=s.toCharArray();
	c[i]=c2;
	break;
	}
	}
	}

	while (i-->0)
	{
	if(c[i]<=127)
	c[i] = lowercases[c[i]];
	}

	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.
	*/
	public static String replace(String s, String sub, String with)
	{
	int c=0;
	int i=s.indexOf(sub,c);
	if (i == -1)
	return s;

	StringBuilder buf = new StringBuilder(s.length()+with.length());

	do
	{
	buf.append(s.substring(c,i));
	buf.append(with);
	c=i+sub.length();
	} while ((i=s.indexOf(sub,c))!=-1);

	if (c<s.length())
	buf.append(s.substring(c,s.length()));

	return buf.toString();

	}


	/* ------------------------------------------------------------ */
	/** 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
	*
	*/
	public static void append(StringBuilder buf,byte b,int base)
	{
	int bi=0xff&b;
	int c='0'+(bi/base)%base;
	if (c>'9')
	c= 'a'+(c-'0'-10);
	buf.append((char)c);
	c='0'+bi%base;
	if (c>'9')
	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)
	{
	buf.append((char)(i/10+'0'));
	buf.append((char)(i%10+'0'));
	}
	}

	/* ------------------------------------------------------------ */
	/** 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
	{
	return new String(b,offset,length,charset);
	}
	catch (UnsupportedEncodingException e)
	{
	throw new IllegalArgumentException(e);
	}
	}


	/* ------------------------------------------------------------ */
	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
	{
	return s.getBytes(__ISO_8859_1);
	}
	catch(Exception e)
	{
	LOG.warn(e);
	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;
	}
	}