/**
* '$RCSfile$'
* Purpose: A Class that implements a URL for use in identifying metacat
* files. It also handles http urls
* Copyright: 2000 Regents of the University of California and the
* National Center for Ecological Analysis and Synthesis
* Authors: Chad Berkley
*
* '$Author$'
* '$Date$'
* '$Revision$'
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package edu.ucsb.nceas.metacat;
import java.net.MalformedURLException;
import java.util.Hashtable;
import java.util.Enumeration;
public class MetacatURL
{
private String[][] params = new String[200][2];
private Hashtable paramsHash = new Hashtable();
private String protocol = null;
private String host = null;
private String url;
/**
* This constructor takes a string url and parses it according to the
* following rules.
* 1) The protocol of the url is the text before the "://" symbol.
* 2) Parameter names are written first and are terminated with the = symbol
* 3) Parameter values come 2nd and are terminated with an & except for the
* last value
* The form of the url looks like:
* protocol://server.domain.com/servlet/?name1=val1&name2=val2&nameN=valN
* notice there is no & after the last param. If one is there it is ignored.
*
* @param url the string to parse
*/
public MetacatURL(String url) throws MalformedURLException
{
this.url = url;
parseURL(url);
}
/**
* This method takes a string url and parses it according to the following
* rules.
* 1) The protocol of the url is the text before the "://" symbol.
* 2) Parameter names are written first and are terminated with the = symbol
* 3) Parameter values come 2nd and are terminated with an & except for the
* last value
* The form of the url looks like:
* protocol://server.domain.com/servlet/?name1=val1&name2=val2&nameN=valN
* notice there is no & after the last param. If one is there it is ignored.
*/
private void parseURL(String url) throws MalformedURLException
{
String pname = null;
String param = null;
String temp = "";
boolean ampflag = true;
boolean poundflag = false;
int arrcount = 0;
//anything before this is the protocol
int protocolIndex = url.indexOf("://");
if (protocolIndex == -1) {
// URL badly formed, no protocol
throw new MalformedURLException("Invalid URL format: " +
"no protocol provided.");
}
this.protocol = url.substring(0, protocolIndex);
paramsHash.put("protocol", this.protocol);
if(this.protocol.equals("http"))
{//if this is an http url
params[0][0] = "httpurl";
params[0][1] = url.substring(0, url.length());
paramsHash.put(params[0][0], params[0][1]);
for(int i=url.length()-1; i>0; i--)
{
if(url.charAt(i) == '/')
{
i=0;
}
else
{
String exchange = temp;
temp = "";
temp += url.charAt(i);
temp += exchange;
}
}
params[1][0] = "filename";
params[1][1] = temp;
paramsHash.put(params[1][0], params[1][1]);
}
else
{//other urls that meet the metacat type url structure.
int hostIndex = url.indexOf("?");
this.host = url.substring(protocolIndex + 3, hostIndex);
paramsHash.put("host", this.host);
for(int i=hostIndex + 1; i<url.length(); i++)
{ //go throught the remainder of the url one character at a time.
if(url.charAt(i) == '=')
{ //if the current char is a # then the preceding should be a parametet
//name
if(!poundflag && ampflag)
{
params[arrcount][0] = temp.trim();
temp = "";
}
else
{ //if there are two #s or &s in a row throw an exception.
throw new MalformedURLException("metacatURL: Two parameter names " +
"not allowed in sequence");
}
poundflag = true;
ampflag = false;
}
else if(url.charAt(i) == '&' || i == url.length()-1)
{ //the text preceding the & should be the param value.
if(i == url.length() - 1)
{ //if we are at the end of the string grab the last value and append it.
if(url.charAt(i) != '=')
{ //ignore an extra & on the end of the string
temp += url.charAt(i);
}
}
if(!ampflag && poundflag)
{
params[arrcount][1] = temp.trim();
paramsHash.put(params[arrcount][0], params[arrcount][1]);
temp = "";
arrcount++; //increment the array to the next row.
}
else
{ //if there are two =s or &s in a row through an exception
throw new MalformedURLException("metacatURL: Two parameter values " +
"not allowed in sequence");
}
poundflag = false;
ampflag = true;
}
else
{ //get the next character in the string
temp += url.charAt(i);
}
}
}
}
/**
* Returns the type of the url. This is defined by the text before the "://"
* symbol in the url.
*/
public String getProtocol()
{
return this.protocol;
}
/**
* Returns the parameters as a 2D string array.
*/
public String[][] getParams()
{
return this.params;
}
/**
* Returns the parameters in a hashtable.
*/
public Hashtable getHashParams()
{
return this.paramsHash;
}
/**
* returns a single parameter from the hash by name
* @param paramname the name of the parameter to return.
*/
public Object getHashParam(String paramname)
{
return this.paramsHash.get(paramname);
}
/**
* returns a string representation of this metacatURL
*/
public String toString()
{
return this.url;
}
public void printHashParams()
{
Enumeration e = this.paramsHash.keys();
System.out.println("name value");
System.out.println("-------------------");
while(e.hasMoreElements())
{
String key = (String)e.nextElement();
System.out.print(key);
System.out.print(" ");
System.out.println((String)this.paramsHash.get(key));
}
}
/**
* Prints the parameters neatly to system.out
*/
public void printParams()
{
String[][] p = null;
System.out.println("protocol: " + this.getProtocol());
System.out.println("parameters: ");
p = this.getParams();
System.out.println("name value");
System.out.println("-------------------");
for(int i=0; i<p.length; i++)
{
if(p[i][0] != null)
{
System.out.print(p[i][0]);
System.out.print(" ");
System.out.print(p[i][1]);
System.out.println();
}
}
}
/**
* Returns a single parameter and value as a 1D string array.
*
* @param index the index of the parameter, value array that you want.
*/
public String[] getParam(int index)
{
String[] s = new String[2];
s[0] = this.params[index][0].trim();
s[1] = this.params[index][1].trim();
//System.out.println("0: " + s[0]);
//System.out.println("1: " + s[1]);
return s;
}
/**
* Test method for this class.
*/
public static void main(String args[])
{
String testurl = "metacat://dev.nceas.ucsb.edu?docid=NCEAS:10&username=chad&pasword=xyz";
String testurl2 = "http://dev.nceas.ucsb.edu/berkley/testdata.dat";
String testurl3 = "NCEAS.1287873498.32";
try
{
System.out.println("*********************************************");
MetacatURL murl = new MetacatURL(testurl);
//String[][] p = null;
System.out.println("protocol: " + murl.getProtocol());
System.out.println("parameters: ");
//p = murl.getParams();
//Hashtable h = murl.getHashParams();
murl.printParams();
murl.printHashParams();
System.out.println("*********************************************");
MetacatURL murl2 = new MetacatURL(testurl2);
System.out.println("protocol: " + murl2.getProtocol());
System.out.println("parameters: ");
murl2.printParams();
murl2.printHashParams();
System.out.println("*********************************************");
MetacatURL murl3 = new MetacatURL(testurl3);
System.out.println("protocol: " + murl3.getProtocol());
System.out.println("parameters: ");
murl3.printParams();
System.out.println("*********************************************");
}
catch(MalformedURLException murle)
{
System.out.println("bad url " + murle.getMessage());
}
}
}