URL Parser : Utilities « Network Protocol « Java






URL Parser

URL Parser
      
/*
Copyright 2007 Creare Inc.

Licensed under the Apache License, Version 2.0 (the "License"); 
you may not use this file except in compliance with the License. 
You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0 

Unless required by applicable law or agreed to in writing, software 
distributed under the License is distributed on an "AS IS" BASIS, 
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
See the License for the specific language governing permissions and 
limitations under the License.
*/


//package com.rbnb.utility;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.Enumeration;
import java.util.Hashtable;

/******************************************************************************
 * Parse a URL into its components.
 * <p>
 * Components in the URL include:
 * 
 *
 * @author John P. Wilson
 *
 * @version 09/28/2006
 */

/*
 * Copyright 2006 Creare Inc.
 * All Rights Reserved
 *
 *   Date      By       Description
 * MM/DD/YYYY
 * ----------  --       -----------
 * 09/28/2006  JPW  RBNB servlet no longer supports special meaning for the
 *      "msg" munge.  Therefore, I have removed "msg" as an
 *      RBNB munge.  As part of this, I removed the method
 *      getCompleteMessageMunge() and the "message" member
 *      variable.
 * 09/15/2006  JPW      Switch over to using KeyValueHash to parse the munge
 * 05/10/2006  JPW      Created
 *
 */

public class ParseURL {
    
    // A copy of the original, full URL
    private String url;
    
    // Request protocol, such as "http" or "ftp"
    private String protocol = null;
    
    // The request string, stripped of any protocol and munge options
    private String request = null;
    
    // The original, complete munge string
    private String munge = null;
    
    // RBNB munge options
    private boolean hasRBNBMunge = false; //EMF 5/12/06
    private Double time = null;
    private Double duration = null;
    private String reference = null;
    private String fetch = null;
    private String byteorder = null;
    private String datatype = null;
    private Integer mux = null;
    private Integer blocksize = null;
    private String mime = null;
    
    // Hashtable of non-RBNB munge options
    private Hashtable nonRBNBMunge = null;
    
    /**************************************************************************
     * Default constructor.
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 05/10/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/10/2006  JPW    Created
     *
     */
    
    public ParseURL() {
  this(null,false);
    }
    
    /**************************************************************************
     * Constructor.  Call parse() to parse the given URL into its components.
     * <p>
     *
     * @author John P. Wilson
     *
     * @param urlStrI      The URL to parse.
     * @param bDebugI      Print debug?
     *
     * @version 05/10/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/10/2006  JPW    Created
     *
     */
    
    public ParseURL(String urlStrI, boolean bDebugI) {
  parse(urlStrI,bDebugI);
    }
    
    /**************************************************************************
     * Parse the given URL into its components.
     * <p>
     * This method parses a munged URL such as:
     *
     *     http://jpw.creare.com:80/RBNB/TestSource?r=newest&t=1.5
     *
     * In this case:
     *     "http" is the protocol
     *     "jpw.creare.com:80/RBNB/TestSource" is the request
     *     "newest" is the reference
     *     "1.5" is the time
     *
     * @author John P. Wilson
     *
     * @param urlStrI      The URL to parse.
     * @param bDebugI      Print debug?
     *
     * @version 09/15/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 09/15/2006  JPW    Switch over to using KeyValueHash to parse the munge
     * 05/10/2006  JPW    Created
     *
     */
    
    public void parse(String urlStrI, boolean bDebugI) {
  
  // Reset all member variables
  resetMemberData();
  
  if ( (urlStrI == null) || (urlStrI.trim().equals("")) ) {
      if (bDebugI) {
    System.err.println("Unable to parse URL: empty string");
      }
      return;
  }
  
  url = new String(urlStrI);
  
  if (bDebugI) {
      System.err.println("URL = \"" + urlStrI + "\"");
  }
  
  ////////////////////////////////////////////
  // See if a protocol is specified in the URL
  ////////////////////////////////////////////
  int colonIndex = urlStrI.indexOf(':');
  String requestAndMungeStr = urlStrI;
  if (colonIndex >= 0) {
      protocol = urlStrI.substring(0,colonIndex);
      if ( (protocol != null) && (protocol.trim().equals("")) ) {
    protocol = null;
      }
      if ( (protocol != null) && (bDebugI) ) {
    System.err.println("Protocol = \"" + protocol + "\"");
      } else if (bDebugI) {
    System.err.println("Protocol = null");
      }
      requestAndMungeStr = urlStrI.substring(colonIndex + 1);
  }
  
  ////////////////////////////////////////////////
  // Strip off leading '/' from requestAndMungeStr
  ////////////////////////////////////////////////
  while ( (requestAndMungeStr != null)     &&
    (!requestAndMungeStr.equals("")) &&
    (requestAndMungeStr.charAt(0) == '/') )
  {
      requestAndMungeStr = requestAndMungeStr.substring(1);
  }
  
  ///////////////////////////////////////////////////////////
  // Separate the request from the munge; munge portion could
  // begin with either '?' or '@'
  ///////////////////////////////////////////////////////////
  request = null;
  munge = null;
  int mungeStartCharIndex = requestAndMungeStr.indexOf('@');
  if (mungeStartCharIndex < 0) {
      mungeStartCharIndex = requestAndMungeStr.indexOf('?');
  }
  if (mungeStartCharIndex >= 0) {
      request =
          requestAndMungeStr.substring(0,mungeStartCharIndex);
      if ( (request != null) && (request.trim().equals("")) ) {
    request = null;
      }
      munge =
          requestAndMungeStr.substring(mungeStartCharIndex+1);
      if ( (munge != null) && (munge.trim().equals("")) ) {
    munge = null;
      }
  } else { //EMF 5/11/06: no munge, all request
      request = requestAndMungeStr;
      munge=null;
  }
  if (bDebugI) {
      if (request == null) {
    System.err.println("Request = null");
      } else {
    System.err.println("Request = \"" + request + "\"");
      }
      if (munge == null) {
    System.err.println("Munge = null");
      } else {
    System.err.println("Munge = \"" + munge + "\"");
      }
  }
  
  //////////////////////////
  // Parse the munge options
  //////////////////////////
  if (munge == null) {
      // We're all done
      return;
  }
  // JPW 09/15/2006: Use KeyValueHash to parse the munge
  char[] terminatorChars = {'&'};
  KeyValueHash kvh = new KeyValueHash(munge,terminatorChars);
  Hashtable fullHashtable = kvh.getHash();
  if (kvh.get("time") != null) {
      // Store time as a Double object
      try {
    time = new Double(kvh.get("time"));
    if (bDebugI) {
        System.err.println("time = " + time);
    }
    hasRBNBMunge=true;
      } catch (NumberFormatException e) {
    // Nothing to do
    time = null;
      }
      // Remove this entry from the hashtable
      fullHashtable.remove("time");
  }
  if (kvh.get("t") != null) {
      // Store time as a Double object
      try {
    time = new Double(kvh.get("t"));
    if (bDebugI) {
        System.err.println("time = " + time);
    }
    hasRBNBMunge=true;
      } catch (NumberFormatException e) {
    // Nothing to do
    time = null;
      }
      // Remove this entry from the hashtable
      fullHashtable.remove("t");
  }
  if (kvh.get("duration") != null) {
      // Store duration as a Double object
      try {
    duration = new Double(kvh.get("duration"));
    if (bDebugI) {
        System.err.println("duration = " + duration);
    }
    hasRBNBMunge=true;
      } catch (NumberFormatException e) {
    // Nothing to do
    duration = null;
      }
      // Remove this entry from the hashtable
      fullHashtable.remove("duration");
  }
  if (kvh.get("d") != null) {
      // Store duration as a Double object
      try {
    duration = new Double(kvh.get("d"));
    if (bDebugI) {
        System.err.println("duration = " + duration);
    }
    hasRBNBMunge=true;
      } catch (NumberFormatException e) {
    // Nothing to do
    duration = null;
      }
      // Remove this entry from the hashtable
      fullHashtable.remove("d");
  }
  if (kvh.get("reference") != null) {
      reference = kvh.get("reference");
      if (bDebugI) {
    System.err.println("reference = " + reference);
      }
      hasRBNBMunge=true;
      // Remove this entry from the hashtable
      fullHashtable.remove("reference");
  }
  if (kvh.get("r") != null) {
      reference = kvh.get("r");
      if (bDebugI) {
    System.err.println("reference = " + reference);
      }
      hasRBNBMunge=true;
      // Remove this entry from the hashtable
      fullHashtable.remove("r");
  }
  if (kvh.get("fetch") != null) {
      fetch = kvh.get("fetch");
      if (bDebugI) {
    System.err.println("fetch = " + fetch);
      }
      hasRBNBMunge=true;
      // Remove this entry from the hashtable
      fullHashtable.remove("fetch");
  }
  if (kvh.get("f") != null) {
      fetch = kvh.get("f");
      if (bDebugI) {
    System.err.println("fetch = " + fetch);
      }
      hasRBNBMunge=true;
      // Remove this entry from the hashtable
      fullHashtable.remove("f");
  }
  if (kvh.get("byteorder") != null) {
      byteorder = kvh.get("byteorder");
      if (bDebugI) {
    System.err.println("byteorder = " + byteorder);
      }
      hasRBNBMunge=true;
      // Remove this entry from the hashtable
      fullHashtable.remove("byteorder");
  }
  if (kvh.get("bo") != null) {
      byteorder = kvh.get("bo");
      if (bDebugI) {
    System.err.println("byteorder = " + byteorder);
      }
      hasRBNBMunge=true;
      // Remove this entry from the hashtable
      fullHashtable.remove("bo");
  }
  if (kvh.get("datatype") != null) {
      datatype = kvh.get("datatype");
      if (bDebugI) {
    System.err.println("datatype = " + datatype);
      }
      hasRBNBMunge=true;
      // Remove this entry from the hashtable
      fullHashtable.remove("datatype");
  }
  if (kvh.get("dt") != null) {
      datatype = kvh.get("dt");
      if (bDebugI) {
    System.err.println("datatype = " + datatype);
      }
      hasRBNBMunge=true;
      // Remove this entry from the hashtable
      fullHashtable.remove("dt");
  }
  if (kvh.get("mux") != null) {
      // Store mux as an Integer object
      try {
    mux = new Integer(kvh.get("mux"));
    if (bDebugI) {
        System.err.println("mux = " + mux);
    }
    hasRBNBMunge=true;
      } catch (NumberFormatException e) {
    // Nothing to do
    mux = null;
      }
      // Remove this entry from the hashtable
      fullHashtable.remove("mux");
  }
  if (kvh.get("x") != null) {
      // Store mux as an Integer object
      try {
    mux = new Integer(kvh.get("x"));
    if (bDebugI) {
        System.err.println("mux = " + mux);
    }
    hasRBNBMunge=true;
      } catch (NumberFormatException e) {
    // Nothing to do
    mux = null;
      }
      // Remove this entry from the hashtable
      fullHashtable.remove("x");
  }
  if (kvh.get("blocksize") != null) {
      // Store blocksize as an Integer object
      try {
    blocksize = new Integer(kvh.get("blocksize"));
    if (bDebugI) {
        System.err.println("blocksize = " + blocksize);
    }
    hasRBNBMunge=true;
      } catch (NumberFormatException e) {
    // Nothing to do
    blocksize = null;
      }
      // Remove this entry from the hashtable
      fullHashtable.remove("blocksize");
  }
  if (kvh.get("bs") != null) {
      // Store blocksize as an Integer object
      try {
    blocksize = new Integer(kvh.get("bs"));
    if (bDebugI) {
        System.err.println("blocksize = " + blocksize);
    }
    hasRBNBMunge=true;
      } catch (NumberFormatException e) {
    // Nothing to do
    blocksize = null;
      }
      // Remove this entry from the hashtable
      fullHashtable.remove("bs");
  }
  if (kvh.get("mime") != null) {
      mime = kvh.get("mime");
      if (bDebugI) {
    System.err.println("mime = " + mime);
      }
      hasRBNBMunge=true;
      // Remove this entry from the hashtable
      fullHashtable.remove("mime");
  }
  if (kvh.get("m") != null) {
      mime = kvh.get("m");
      if (bDebugI) {
    System.err.println("mime = " + mime);
      }
      hasRBNBMunge=true;
      // Remove this entry from the hashtable
      fullHashtable.remove("m");
  }
  
  // What remains in fullHashtable must be the non-RBNB munges
  if ( (fullHashtable != null) && (!fullHashtable.isEmpty()) ) {
      nonRBNBMunge = fullHashtable;
      if (bDebugI) {
    for (Enumeration e=nonRBNBMunge.keys(); e.hasMoreElements();) {
        String key = (String)e.nextElement();
        String value = (String)nonRBNBMunge.get(key);
        System.err.println(
          "Non-RBNB munge: key = \"" +
      key +
      "\", value = \"" +
      value +
      "\"");
    }
      }
  }
  
    }
    
    /**************************************************************************
     * Reset member data to default values.
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 05/10/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/10/2006  JPW    Created
     *
     */
    
    public void resetMemberData() {
  url = null;
  protocol = null;
  request = null;
  munge = null;
  time = null;
  duration = null;
  reference = null;
  fetch = null;
  byteorder = null;
  datatype = null;
  mux = null;
  blocksize = null;
  mime = null;
  nonRBNBMunge = null;
    }
    
    /**************************************************************************
     * Get the original URL as a String
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 05/11/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/11/2006  JPW    Created
     *
     */
    
    public String getURL() {
  return url;
    }
    
    /**************************************************************************
     * Get URL protocol as a String
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 05/11/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/11/2006  JPW    Created
     *
     */
    
    public String getProtocol() {
  return protocol;
    }
    
    /**************************************************************************
     * Get URL request as a String
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 05/11/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/11/2006  JPW    Created
     *
     */
    
    public String getRequest() {
  return request;
    }
    
    /**************************************************************************
     * Get the URL munge as a String
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 05/11/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/11/2006  JPW    Created
     *
     */
    
    public String getMunge() {
  return munge;
    }

     /**************************************************************************
     * Indicates whether any RBNB munge exists
     * <p>
     *
     * @author Eric M. Friets
     *
     * @version 05/12/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/12/2006  EMF    Created
     *
     */

    public boolean isRBNBMunge() {
  return hasRBNBMunge;
    }
   
    /**************************************************************************
     * Get time munge option as a Double object
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 05/11/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/11/2006  JPW    Created
     *
     */
    
    public Double getTime() {
  return time;
    }
    
    /**************************************************************************
     * Get duration munge option as a Double object
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 05/11/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/11/2006  JPW    Created
     *
     */
    
    public Double getDuration() {
  return duration;
    }
    
    /**************************************************************************
     * Set a new duration for the munge.
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 06/02/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 06/02/2006  JPW    Created
     *
     */
    
    public void setDuration(double durationI) {
  if (durationI >= 0.0) {
      duration = new Double(durationI);
  }
    }
    
    /**************************************************************************
     * Get reference munge option as a String
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 05/11/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/11/2006  JPW    Created
     *
     */
    
    public String getReference() {
  return reference;
    }
    
    /**************************************************************************
     * Get fetch munge option as a String
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 05/11/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/11/2006  JPW    Created
     *
     */
    
    public String getFetch() {
  return fetch;
    }
    
    /**************************************************************************
     * Get byteorder munge option as a String
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 05/11/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/11/2006  JPW    Created
     *
     */
    
    public String getByteorder() {
  return byteorder;
    }
    
    /**************************************************************************
     * Get datatype munge option as a String
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 05/11/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/11/2006  JPW    Created
     *
     */
    
    public String getDatatype() {
  return datatype;
    }
    
    /**************************************************************************
     * Get mux munge option as an Integer object
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 05/11/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/11/2006  JPW    Created
     *
     */
    
    public Integer getMux() {
  return mux;
    }
    
    /**************************************************************************
     * Get blocksize munge option as an Integer object
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 05/11/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/11/2006  JPW    Created
     *
     */
    
    public Integer getBlocksize() {
  return blocksize;
    }
    
    /**************************************************************************
     * Get mime munge option as a String
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 05/11/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/11/2006  JPW    Created
     *
     */
    
    public String getMime() {
  return mime;
    }
    
    /**************************************************************************
     * Get Hashtable nonRBNBMunge
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 05/11/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/11/2006  JPW    Created
     *
     */
    
    public Hashtable getNonRBNBMunge() {
  return nonRBNBMunge;
    }
    
    /**************************************************************************
     * Get all non-RBNB munge options concatenated together, using '&' as
     * the separator character.
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 05/11/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 05/11/2006  JPW    Created
     *
     */
    
    public String getNonRBNBMungeStr() {
  if (nonRBNBMunge == null) {
      return null;
  }
  StringBuffer mungeStrBuf = null;
  for (Enumeration e = nonRBNBMunge.keys(); e.hasMoreElements(); ) {
      String nextKey = (String)e.nextElement();
      String nextValue = (String)nonRBNBMunge.get(nextKey);
      if (mungeStrBuf == null) {
    mungeStrBuf = new StringBuffer(nextKey + "=" + nextValue);
      } else {
    mungeStrBuf.append("&" + nextKey + "=" + nextValue);
      }
  }
  return mungeStrBuf.toString();
    }
    
    /**************************************************************************
     * Default version of this method; include all munge components.
     * <p>
     *
     * @author John P. Wilson
     *
     * @version 06/02/2006
     */
     
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 06/02/2006  JPW    Created
     *
     */
    
    public String createNewRBNBMunge() {
  return
      createNewRBNBMunge(
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false);
    }
    
    /**************************************************************************
     * Create a new munge string containing the desired RBNB munge components.
     * <p>
     * The user can selectively remove munge components as specified by the
     * boolean arguments.  If the user has not chosen to remove any munge
     * component, then the original, complete munge string is returned.
     *
     * @author John P. Wilson
     *
     * @param bRemoveTimeI    Remove time from returned munge?
     * @param bRemoveDurationI    Remove duration from returned munge?
     * @param bRemoveReferenceI    Remove reference from returned munge?
     * @param bRemoveFetchI    Remove fetch from returned munge?
     * @param bRemoveByteorderI    Remove byteorder from returned munge?
     * @param bRemoveDatatypeI    Remove datatype from returned munge?
     * @param bRemoveMuxI    Remove mux from returned munge?
     * @param bRemoveBlocksizeI    Remove blocksize from returned munge?
     * @param bRemoveMimeI    Remove mime from returned munge?
     * @param bRemoveNonRBNBMungeI  Remove non RBNB munges from returned munge?
     *
     * @version 09/28/2006
     */
    
    /*
     *
     *   Date      By     Description
     * MM/DD/YYYY
     * ----------  --     -----------
     * 09/28/2006  JPW    Change "bRemoveMessageI" to "bRemoveNonRBNBMungeI"
     * 06/02/2006  JPW    Created
     *
     */
    
    public String createNewRBNBMunge(
      boolean bRemoveTimeI,
  boolean bRemoveDurationI,
  boolean bRemoveReferenceI,
  boolean bRemoveFetchI,
  boolean bRemoveByteorderI,
  boolean bRemoveDatatypeI,
  boolean bRemoveMuxI,
  boolean bRemoveBlocksizeI,
  boolean bRemoveMimeI,
  boolean bRemoveNonRBNBMungeI)
    {
  
  // JPW 09/28/2006: If user has not chosen to remove anything, then
  //                 simply return the original, complete munge string.
  if ( (!bRemoveTimeI)      &&
       (!bRemoveDurationI)  &&
       (!bRemoveReferenceI) &&
       (!bRemoveFetchI)     &&
       (!bRemoveByteorderI) &&
       (!bRemoveDatatypeI)  &&
       (!bRemoveMuxI)       &&
       (!bRemoveBlocksizeI) &&
       (!bRemoveMimeI)      &&
       (!bRemoveNonRBNBMungeI) )
  {
      return munge;
  }
  
  StringBuffer newMunge = new StringBuffer();
  
  if ( (getTime() != null) && (!bRemoveTimeI) ) {
      newMunge.append("&t=" + getTime().toString());
  }
  if ( (getDuration() != null) && (!bRemoveDurationI) ) {
      newMunge.append("&d=" + getDuration().toString());
  }
  if ( (getReference() != null) && (!bRemoveReferenceI) ) {
      newMunge.append("&r=" + getReference());
  }
  if ( (getFetch() != null) && (!bRemoveFetchI) ) {
      newMunge.append("&f=" + getFetch());
  }
  if ( (getByteorder() != null) && (!bRemoveByteorderI) ) {
      newMunge.append("&bo=" + getByteorder());
  }
  if ( (getDatatype() != null) && (!bRemoveDatatypeI) ) {
      newMunge.append("&dt=" + getDatatype());
  }
  if ( (getMux() != null) && (!bRemoveMuxI) ) {
      newMunge.append("&x=" + getMux().toString());
  }
  if ( (getBlocksize() != null) && (!bRemoveBlocksizeI) ) {
      newMunge.append("&bs=" + getBlocksize().toString());
  }
  if ( (getMime() != null) && (!bRemoveMimeI) ) {
      newMunge.append("&m=" + getMime());
  }
  // JPW 09/28/2006: Return the non RBNB munges as a series of key/value
  //                 pairs; don't return them encoded in the "msg"
  //                 munge (RBNB servlet doesn't do anything special
  //                 with the "msg" munge now).
  if ( (getNonRBNBMungeStr() != null) && (!bRemoveNonRBNBMungeI) ) {
      newMunge.append("&" + getNonRBNBMungeStr());
  }
  
  if (newMunge.length() == 0) {
      return null;
  }
  
  // If there is a leading '&', remove it
  if (newMunge.charAt(0) == '&') {
      newMunge = newMunge.deleteCharAt(0);
  }
  
  return newMunge.toString();
  
     }
    
}
class KeyValueHash {
     Hashtable hash = new Hashtable();
     
     public KeyValueHash(byte[] userData) {
        
        // JPW 09/15/2006: These aren't used
        //ByteArrayInputStream byteArray = new ByteArrayInputStream(userData);
        //DataInputStream inStream = new DataInputStream(byteArray);
        
        // JPW 09/15/2006: Add new constructor
        this(new String(userData), null);
     }
     
     public KeyValueHash(String inString) {
         this(inString,null);
     }
     
     // JPW 09/15/2006: Add new constructor that takes a String and an optional
     //                 set of terminating characters
     public KeyValueHash(String inString, char[] terminatorCharsI) {
        
        // The default terminating characters
        char[] terminatorChars = {',','\n','\r'};
        if ( (terminatorCharsI != null) && (terminatorCharsI.length > 0) ) {
      terminatorChars = terminatorCharsI;
        }
        
        int lt = -1; // location of the terminator from the previous iteration
        int nt=nextTerminator(inString,lt,terminatorChars);
        while (nt!=-1) {
     int ne=inString.indexOf('=',lt+1);  // next equals sign
     if (ne>lt+1 && ne<nt-1) { //have key,value isolated
        hash.put(inString.substring(lt+1,ne),inString.substring(ne+1,nt));
        //System.out.println(inString.substring(lt+1,ne)+"  "+inString.substring(ne+1,nt));
        }
     lt=nt;
     while ((nt=nextTerminator(inString,lt,terminatorChars))==lt+1) //ignore multiple adjacent separators
        lt=nt;
     }
     } //end KeyValueHash constructor
     
     
     public String get(String key) {
        // JPW 09/15/2006: Add some checks for null
        if (key == null) {
      return null;
        }
        Object value = hash.get(key);
        if (value == null) {
      return null;
        }
        return (String)value;
     }
     
     public Hashtable getHash() {
        return hash;
     }
     
     private int nextTerminator(String s, int n, char[] t) {
        
        // JPW 09/15/2006: The terminator characters are provided as a parameter
        // char[] t = {',','\n','\r'}; //terminator characters
        
        int min=-1;
        boolean foundOne=false;
        
        if (n>=s.length()) return -1; //at end of string
        
        for (int i=0;i<t.length;i++) {
     int j=s.indexOf(t[i],n+1);
     if (j>=0) {
        if (foundOne) {
           if (j<min) min=j;
           }
        else {
           foundOne=true;
           min=j;
           }
        }
     }
        if (foundOne) return min;
        else return s.length();
     }
     
  } //end class KeyValueHash

   
    
    
    
    
    
  








Related examples in the same category

1.A class that encodes URL parameter values for MIDP devices.
2.Get the listing of everyone logged on
3.Scan your computer for ports in useScan your computer for ports in use
4.Using the URL Class (GetURL.java)
5.TCP socket monitor
6.Create Socket helper
7.Implements a TCP/IP bounce utility (proxy)
8.URL utilities class that makes it easy to create new URLs based off of old URLs without having to assemble or parse them yourself
9.Download from URL
10.A simple class to load an URL in a browser
11.Using the java API URL class, extract the http/https hostname.
12.Utility class for URL decoding.
13.Utility class for URL encoding.
14.Allows easy downloading of files from HTTP sites
15.enum Http Status