client/src/main/java/org/apache/qpid/client/url/URLParser_0_10.java - qpid-jms-amqp-0-x - Git at Google

 /* Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you 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 org.apache.qpid.client.url;

 import org.apache.qpid.client.BrokerDetails;

 import java.net.MalformedURLException;
 import java.util.ArrayList;
 import java.util.List;

 /**
  * The format Qpid URL is based on the AMQP one. The grammar is as follows:
  * <p>
  * <p>{@literal qpid_url          = "qpid:" [client_props "@"] port_addr_list ["/" future-parameters] }
  * <p>{@literal port_addr_list 	 = [port_addr ","]* port_addr }
  * <p>{@literal port_addr         = tcp_port_addr | tls_prot_addr | future_prot_addr }
  * <p>{@literal tcp_port_addr     = tcp_id tcp_addr }
  * <p>{@literal tcp_id            = "tcp:" | "" }
  * <p>{@literal tcp_addr          = host [":" port] }
  * <p>{@literal host              = <as per http://www.apps.ietf.org/> }
  * <p>{@literal port              = number }
  * <p>{@literal tls_prot_addr     = tls_id tls_addr }
  * <p>{@literal tls_id            = "tls:" | "" }
  * <p>{@literal tls_addr          = host [":" port] }
  * <p>{@literal future_prot_addr  = future_prot_id future_prot_addr }
  * <p>{@literal future_prot_id    = <placeholder, must end in ":". Example "sctp:"> }
  * <p>{@literal future_prot_addr  = <placeholder, protocl-specific address> }
  * <p>{@literal future_parameters = <placeholder, not used in failover addresses> }
  * <p>{@literal client_props      = [client_prop ";"]*  client_prop }
  * <p>{@literal client_prop       = prop "=" val }
  * <p>{@literal prop              = chars as per <as per http://www.apps.ietf.org/> }
  * <p>{@literal val               = valid as per <as per http://www.apps.ietf.org/> }
  * <p>
  * Ex:
  * <p>
  * {@literal qpid:virtualhost=tcp:host-foo,test,client_id=foo@tcp:myhost.com:5672,virtualhost=prod;
  * keystore=/opt/keystore@client_id2@tls:mysecurehost.com:5672 }
  */
 public class URLParser_0_10
 {
     private static final char[] URL_START_SEQ = new char[]{'q', 'p', 'i', 'd', ':'};
     private static final char PROPERTY_EQUALS_CHAR = '=';
     private static final char PROPERTY_SEPARATOR_CHAR = ';';
     private static final char ADDRESS_SEPERATOR_CHAR = ',';

     private static final char TRANSPORT_HOST_SEPARATOR_CHAR = ':';
     private static final char HOST_PORT_SEPARATOR_CHAR = ':';
     private static final char AT_CHAR = '@';
     private static final char END_OF_URL_MARKER = '^';

     enum URLParserState
     {
         QPID_URL_START,
         ADDRESS_START,
         PROPERTY_NAME,
         PROPERTY_EQUALS,
         PROPERTY_VALUE,
         PROPERTY_SEPARATOR,
         AT_CHAR,
         TRANSPORT,
         TRANSPORT_HOST_SEPARATOR,
         HOST,
         HOST_PORT_SEPARATOR,
         PORT,
         ADDRESS_END,
         ADDRESS_SEPERATOR,
         QPID_URL_END,
         ERROR
     }

     //-- Constructors

     private char[] _url;
     private List<BrokerDetails> _brokerDetailList = new ArrayList<BrokerDetails>();
     private String _error;
     private int _index = 0;
     private BrokerDetails _currentBroker;
     private String _currentPropName;
     private boolean _endOfURL = false;
     private URLParserState _currentParserState;

     public URLParser_0_10(String url) throws MalformedURLException
     {
         _url = (url + END_OF_URL_MARKER).toCharArray();
         _endOfURL = false;
         _currentParserState = URLParserState.QPID_URL_START;
         URLParserState prevState = _currentParserState; // for error handling
         try
         {
             while (_currentParserState != URLParserState.ERROR && _currentParserState != URLParserState.QPID_URL_END)
             {
                 prevState = _currentParserState;
                 _currentParserState = next();
             }

             if (_currentParserState == URLParserState.ERROR)
             {
                 _error =
                         "Invalid URL format [current_state = " + prevState + ", broker details parsed so far " + _currentBroker + " ] error at (" + _index + ") due to " + _error;
                 MalformedURLException ex;
                 ex = new MalformedURLException(_error);
                 throw ex;
             }
         }
         catch (ArrayIndexOutOfBoundsException e)
         {
             _error = "Invalid URL format [current_state = " + prevState + ", broker details parsed so far " + _currentBroker + " ] error at (" + _index + ")";
             MalformedURLException ex = new MalformedURLException(_error);
             throw ex;
         }
     }

     //-- interface QpidURL
     public List<BrokerDetails> getAllBrokerDetails()
     {
         return _brokerDetailList;
     }

     public String getURL()
     {
         return new String(_url);
     }

     private URLParserState next()
     {
         switch (_currentParserState)
         {
             case QPID_URL_START:
                 return checkSequence(URL_START_SEQ, URLParserState.ADDRESS_START);
             case ADDRESS_START:
                 return startAddress();
             case PROPERTY_NAME:
                 return extractPropertyName();
             case PROPERTY_EQUALS:
                 _index++; // skip the equal sign
                 return URLParserState.PROPERTY_VALUE;
             case PROPERTY_VALUE:
                 return extractPropertyValue();
             case PROPERTY_SEPARATOR:
                 _index++; // skip ","
                 return URLParserState.PROPERTY_NAME;
             case AT_CHAR:
                 _index++; // skip the @ sign
                 return URLParserState.TRANSPORT;
             case TRANSPORT:
                 return extractTransport();
             case TRANSPORT_HOST_SEPARATOR:
                 _index++; // skip ":"
                 return URLParserState.HOST;
             case HOST:
                 return extractHost();
             case HOST_PORT_SEPARATOR:
                 _index++; // skip ":"
                 return URLParserState.PORT;
             case PORT:
                 return extractPort();
             case ADDRESS_END:
                 return endAddress();
             case ADDRESS_SEPERATOR:
                 _index++; // skip ","
                 return URLParserState.ADDRESS_START;
             default:
                 return URLParserState.ERROR;
         }
     }

     private URLParserState checkSequence(char[] expected, URLParserState nextPart)
     {
         for (char expectedChar : expected)
         {
             if (expectedChar != _url[_index])
             {
                 _error = "Excepted (" + expectedChar + ") at position " + _index + ", got (" + _url[_index] + ")";
                 return URLParserState.ERROR;
             }
             _index++;
         }
         return nextPart;
     }

     private URLParserState startAddress()
     {
         _currentBroker = new BrokerDetails();

         for (int j = _index; j < _url.length; j++)
         {
             if (_url[j] == PROPERTY_EQUALS_CHAR)
             {
                 return URLParserState.PROPERTY_NAME;
             }
             else if (_url[j] == ADDRESS_SEPERATOR_CHAR)
             {
                 return URLParserState.TRANSPORT;
             }
         }
         return URLParserState.TRANSPORT;
     }

     private URLParserState endAddress()
     {
         _brokerDetailList.add(_currentBroker);
         if (_endOfURL)
         {
             return URLParserState.QPID_URL_END;
         }
         else
         {
             return URLParserState.ADDRESS_SEPERATOR;
         }
     }

     private URLParserState extractPropertyName()
     {
         StringBuilder b = new StringBuilder();
         char next = _url[_index];
         while (next != PROPERTY_EQUALS_CHAR && next != AT_CHAR)
         {
             b.append(next);
             next = _url[++_index];
         }
         _currentPropName = b.toString();
         if (_currentPropName.trim().equals(""))
         {
             _error = "Property name cannot be empty";
             return URLParserState.ERROR;
         }
         else if (next == PROPERTY_EQUALS_CHAR)
         {
             return URLParserState.PROPERTY_EQUALS;
         }
         else
         {
             return URLParserState.AT_CHAR;
         }
     }

     private URLParserState extractPropertyValue()
     {
         StringBuilder b = new StringBuilder();
         char next = _url[_index];
         while (next != PROPERTY_SEPARATOR_CHAR && next != AT_CHAR)
         {
             b.append(next);
             next = _url[++_index];
         }
         String propValue = b.toString();
         if (propValue.trim().equals(""))
         {
             _error = "Property values cannot be empty";
             return URLParserState.ERROR;
         }
         else
         {
             _currentBroker.setProperty(_currentPropName, propValue);
             if (next == PROPERTY_SEPARATOR_CHAR)
             {
                 return URLParserState.PROPERTY_SEPARATOR;
             }
             else
             {
                 return URLParserState.AT_CHAR;
             }
         }
     }

     private URLParserState extractTransport()
     {
         String transport = buildUntil(TRANSPORT_HOST_SEPARATOR_CHAR);
         if (transport.trim().equals(""))
         {
             _error = "Transport cannot be empty";
             return URLParserState.ERROR;
         }
         else if (!(transport.trim().equals(BrokerDetails.PROTOCOL_TCP) || transport.trim()
                 .equals(BrokerDetails.PROTOCOL_TLS)))
         {
             _error = "Transport cannot be " + transport + " value must be tcp or tls";
             return URLParserState.ERROR;
         }
         else
         {
             _currentBroker.setTransport(transport);
             return URLParserState.TRANSPORT_HOST_SEPARATOR;
         }
     }

     private URLParserState extractHost()
     {
         char nextSep = 'c';
         String host;
         URLParserState nextState;

         for (int i = _index; i < _url.length; i++)
         {
             if (_url[i] == HOST_PORT_SEPARATOR_CHAR)
             {
                 nextSep = HOST_PORT_SEPARATOR_CHAR;
                 break;
             }
             else if (_url[i] == ADDRESS_SEPERATOR_CHAR)
             {
                 nextSep = ADDRESS_SEPERATOR_CHAR;
                 break;
             }
         }

         if (nextSep == HOST_PORT_SEPARATOR_CHAR)
         {
             host = buildUntil(HOST_PORT_SEPARATOR_CHAR);
             nextState = URLParserState.HOST_PORT_SEPARATOR;
         }
         else if (nextSep == ADDRESS_SEPERATOR_CHAR)
         {
             host = buildUntil(ADDRESS_SEPERATOR_CHAR);
             nextState = URLParserState.ADDRESS_END;
         }
         else
         {
             host = buildUntil(END_OF_URL_MARKER);
             nextState = URLParserState.ADDRESS_END;
             _endOfURL = true;
         }

         if (host.trim().equals(""))
         {
             _error = "Host cannot be empty";
             return URLParserState.ERROR;
         }
         else
         {
             _currentBroker.setHost(host);
             return nextState;
         }
     }


     private URLParserState extractPort()
     {

         StringBuilder b = new StringBuilder();
         try
         {
             char next = _url[_index];
             while (next != ADDRESS_SEPERATOR_CHAR && next != END_OF_URL_MARKER )
             {
                 b.append(next);
                 next = _url[++_index];
             }
         }
         catch (ArrayIndexOutOfBoundsException e)
         {
             _endOfURL = true;
         }
         String portStr = b.toString();
         if (portStr.trim().equals(""))
         {
             _error = "Host cannot be empty";
             return URLParserState.ERROR;
         }
         else
         {
             try
             {
                 int port = Integer.parseInt(portStr);
                 _currentBroker.setPort(port);
                 if( _url[_index] == END_OF_URL_MARKER )
                 {
                     _endOfURL = true;
                 }
                 return URLParserState.ADDRESS_END;
             }
             catch (NumberFormatException e)
             {
                 _error = "Illegal number for port";
                 return URLParserState.ERROR;
             }
         }
     }

     private String buildUntil(char c)
     {
         StringBuilder b = new StringBuilder();
         char next = _url[_index];
         while (next != c)
         {
             b.append(next);
             next = _url[++_index];
         }
         return b.toString();
     }

     public static void main(String[] args)
     {
         String testurl = "qpid:password=pass;username=name@tcp:test1";
         try
         {
             URLParser_0_10 impl = new URLParser_0_10(testurl);
             for (BrokerDetails d : impl.getAllBrokerDetails())
             {
                 System.out.println(d);
             }
         }
         catch (Exception e)
         {
             e.printStackTrace();
         }
     }
 }
	/* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you 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 org.apache.qpid.client.url;

	import org.apache.qpid.client.BrokerDetails;

	import java.net.MalformedURLException;
	import java.util.ArrayList;
	import java.util.List;

	/**
	* The format Qpid URL is based on the AMQP one. The grammar is as follows:
	* <p>
	* <p>{@literal qpid_url = "qpid:" [client_props "@"] port_addr_list ["/" future-parameters] }
	* <p>{@literal port_addr_list = [port_addr ","]* port_addr }
	* <p>{@literal port_addr = tcp_port_addr \| tls_prot_addr \| future_prot_addr }
	* <p>{@literal tcp_port_addr = tcp_id tcp_addr }
	* <p>{@literal tcp_id = "tcp:" \| "" }
	* <p>{@literal tcp_addr = host [":" port] }
	* <p>{@literal host = <as per http://www.apps.ietf.org/> }
	* <p>{@literal port = number }
	* <p>{@literal tls_prot_addr = tls_id tls_addr }
	* <p>{@literal tls_id = "tls:" \| "" }
	* <p>{@literal tls_addr = host [":" port] }
	* <p>{@literal future_prot_addr = future_prot_id future_prot_addr }
	* <p>{@literal future_prot_id = <placeholder, must end in ":". Example "sctp:"> }
	* <p>{@literal future_prot_addr = <placeholder, protocl-specific address> }
	* <p>{@literal future_parameters = <placeholder, not used in failover addresses> }
	* <p>{@literal client_props = [client_prop ";"]* client_prop }
	* <p>{@literal client_prop = prop "=" val }
	* <p>{@literal prop = chars as per <as per http://www.apps.ietf.org/> }
	* <p>{@literal val = valid as per <as per http://www.apps.ietf.org/> }
	* <p>
	* Ex:
	* <p>
	* {@literal qpid:virtualhost=tcp:host-foo,test,client_id=foo@tcp:myhost.com:5672,virtualhost=prod;
	* keystore=/opt/keystore@client_id2@tls:mysecurehost.com:5672 }
	*/
	public class URLParser_0_10
	{
	private static final char[] URL_START_SEQ = new char[]{'q', 'p', 'i', 'd', ':'};
	private static final char PROPERTY_EQUALS_CHAR = '=';
	private static final char PROPERTY_SEPARATOR_CHAR = ';';
	private static final char ADDRESS_SEPERATOR_CHAR = ',';

	private static final char TRANSPORT_HOST_SEPARATOR_CHAR = ':';
	private static final char HOST_PORT_SEPARATOR_CHAR = ':';
	private static final char AT_CHAR = '@';
	private static final char END_OF_URL_MARKER = '^';

	enum URLParserState
	{
	QPID_URL_START,
	ADDRESS_START,
	PROPERTY_NAME,
	PROPERTY_EQUALS,
	PROPERTY_VALUE,
	PROPERTY_SEPARATOR,
	AT_CHAR,
	TRANSPORT,
	TRANSPORT_HOST_SEPARATOR,
	HOST,
	HOST_PORT_SEPARATOR,
	PORT,
	ADDRESS_END,
	ADDRESS_SEPERATOR,
	QPID_URL_END,
	ERROR
	}

	//-- Constructors

	private char[] _url;
	private List<BrokerDetails> _brokerDetailList = new ArrayList<BrokerDetails>();
	private String _error;
	private int _index = 0;
	private BrokerDetails _currentBroker;
	private String _currentPropName;
	private boolean _endOfURL = false;
	private URLParserState _currentParserState;

	public URLParser_0_10(String url) throws MalformedURLException
	{
	_url = (url + END_OF_URL_MARKER).toCharArray();
	_endOfURL = false;
	_currentParserState = URLParserState.QPID_URL_START;
	URLParserState prevState = _currentParserState; // for error handling
	try
	{
	while (_currentParserState != URLParserState.ERROR && _currentParserState != URLParserState.QPID_URL_END)
	{
	prevState = _currentParserState;
	_currentParserState = next();
	}

	if (_currentParserState == URLParserState.ERROR)
	{
	_error =
	"Invalid URL format [current_state = " + prevState + ", broker details parsed so far " + _currentBroker + " ] error at (" + _index + ") due to " + _error;
	MalformedURLException ex;
	ex = new MalformedURLException(_error);
	throw ex;
	}
	}
	catch (ArrayIndexOutOfBoundsException e)
	{
	_error = "Invalid URL format [current_state = " + prevState + ", broker details parsed so far " + _currentBroker + " ] error at (" + _index + ")";
	MalformedURLException ex = new MalformedURLException(_error);
	throw ex;
	}
	}

	//-- interface QpidURL
	public List<BrokerDetails> getAllBrokerDetails()
	{
	return _brokerDetailList;
	}

	public String getURL()
	{
	return new String(_url);
	}

	private URLParserState next()
	{
	switch (_currentParserState)
	{
	case QPID_URL_START:
	return checkSequence(URL_START_SEQ, URLParserState.ADDRESS_START);
	case ADDRESS_START:
	return startAddress();
	case PROPERTY_NAME:
	return extractPropertyName();
	case PROPERTY_EQUALS:
	_index++; // skip the equal sign
	return URLParserState.PROPERTY_VALUE;
	case PROPERTY_VALUE:
	return extractPropertyValue();
	case PROPERTY_SEPARATOR:
	_index++; // skip ","
	return URLParserState.PROPERTY_NAME;
	case AT_CHAR:
	_index++; // skip the @ sign
	return URLParserState.TRANSPORT;
	case TRANSPORT:
	return extractTransport();
	case TRANSPORT_HOST_SEPARATOR:
	_index++; // skip ":"
	return URLParserState.HOST;
	case HOST:
	return extractHost();
	case HOST_PORT_SEPARATOR:
	_index++; // skip ":"
	return URLParserState.PORT;
	case PORT:
	return extractPort();
	case ADDRESS_END:
	return endAddress();
	case ADDRESS_SEPERATOR:
	_index++; // skip ","
	return URLParserState.ADDRESS_START;
	default:
	return URLParserState.ERROR;
	}
	}

	private URLParserState checkSequence(char[] expected, URLParserState nextPart)
	{
	for (char expectedChar : expected)
	{
	if (expectedChar != _url[_index])
	{
	_error = "Excepted (" + expectedChar + ") at position " + _index + ", got (" + _url[_index] + ")";
	return URLParserState.ERROR;
	}
	_index++;
	}
	return nextPart;
	}

	private URLParserState startAddress()
	{
	_currentBroker = new BrokerDetails();

	for (int j = _index; j < _url.length; j++)
	{
	if (_url[j] == PROPERTY_EQUALS_CHAR)
	{
	return URLParserState.PROPERTY_NAME;
	}
	else if (_url[j] == ADDRESS_SEPERATOR_CHAR)
	{
	return URLParserState.TRANSPORT;
	}
	}
	return URLParserState.TRANSPORT;
	}

	private URLParserState endAddress()
	{
	_brokerDetailList.add(_currentBroker);
	if (_endOfURL)
	{
	return URLParserState.QPID_URL_END;
	}
	else
	{
	return URLParserState.ADDRESS_SEPERATOR;
	}
	}

	private URLParserState extractPropertyName()
	{
	StringBuilder b = new StringBuilder();
	char next = _url[_index];
	while (next != PROPERTY_EQUALS_CHAR && next != AT_CHAR)
	{
	b.append(next);
	next = _url[++_index];
	}
	_currentPropName = b.toString();
	if (_currentPropName.trim().equals(""))
	{
	_error = "Property name cannot be empty";
	return URLParserState.ERROR;
	}
	else if (next == PROPERTY_EQUALS_CHAR)
	{
	return URLParserState.PROPERTY_EQUALS;
	}
	else
	{
	return URLParserState.AT_CHAR;
	}
	}

	private URLParserState extractPropertyValue()
	{
	StringBuilder b = new StringBuilder();
	char next = _url[_index];
	while (next != PROPERTY_SEPARATOR_CHAR && next != AT_CHAR)
	{
	b.append(next);
	next = _url[++_index];
	}
	String propValue = b.toString();
	if (propValue.trim().equals(""))
	{
	_error = "Property values cannot be empty";
	return URLParserState.ERROR;
	}
	else
	{
	_currentBroker.setProperty(_currentPropName, propValue);
	if (next == PROPERTY_SEPARATOR_CHAR)
	{
	return URLParserState.PROPERTY_SEPARATOR;
	}
	else
	{
	return URLParserState.AT_CHAR;
	}
	}
	}

	private URLParserState extractTransport()
	{
	String transport = buildUntil(TRANSPORT_HOST_SEPARATOR_CHAR);
	if (transport.trim().equals(""))
	{
	_error = "Transport cannot be empty";
	return URLParserState.ERROR;
	}
	else if (!(transport.trim().equals(BrokerDetails.PROTOCOL_TCP) \|\| transport.trim()
	.equals(BrokerDetails.PROTOCOL_TLS)))
	{
	_error = "Transport cannot be " + transport + " value must be tcp or tls";
	return URLParserState.ERROR;
	}
	else
	{
	_currentBroker.setTransport(transport);
	return URLParserState.TRANSPORT_HOST_SEPARATOR;
	}
	}

	private URLParserState extractHost()
	{
	char nextSep = 'c';
	String host;
	URLParserState nextState;

	for (int i = _index; i < _url.length; i++)
	{
	if (_url[i] == HOST_PORT_SEPARATOR_CHAR)
	{
	nextSep = HOST_PORT_SEPARATOR_CHAR;
	break;
	}
	else if (_url[i] == ADDRESS_SEPERATOR_CHAR)
	{
	nextSep = ADDRESS_SEPERATOR_CHAR;
	break;
	}
	}

	if (nextSep == HOST_PORT_SEPARATOR_CHAR)
	{
	host = buildUntil(HOST_PORT_SEPARATOR_CHAR);
	nextState = URLParserState.HOST_PORT_SEPARATOR;
	}
	else if (nextSep == ADDRESS_SEPERATOR_CHAR)
	{
	host = buildUntil(ADDRESS_SEPERATOR_CHAR);
	nextState = URLParserState.ADDRESS_END;
	}
	else
	{
	host = buildUntil(END_OF_URL_MARKER);
	nextState = URLParserState.ADDRESS_END;
	_endOfURL = true;
	}

	if (host.trim().equals(""))
	{
	_error = "Host cannot be empty";
	return URLParserState.ERROR;
	}
	else
	{
	_currentBroker.setHost(host);
	return nextState;
	}
	}


	private URLParserState extractPort()
	{

	StringBuilder b = new StringBuilder();
	try
	{
	char next = _url[_index];
	while (next != ADDRESS_SEPERATOR_CHAR && next != END_OF_URL_MARKER )
	{
	b.append(next);
	next = _url[++_index];
	}
	}
	catch (ArrayIndexOutOfBoundsException e)
	{
	_endOfURL = true;
	}
	String portStr = b.toString();
	if (portStr.trim().equals(""))
	{
	_error = "Host cannot be empty";
	return URLParserState.ERROR;
	}
	else
	{
	try
	{
	int port = Integer.parseInt(portStr);
	_currentBroker.setPort(port);
	if( _url[_index] == END_OF_URL_MARKER )
	{
	_endOfURL = true;
	}
	return URLParserState.ADDRESS_END;
	}
	catch (NumberFormatException e)
	{
	_error = "Illegal number for port";
	return URLParserState.ERROR;
	}
	}
	}

	private String buildUntil(char c)
	{
	StringBuilder b = new StringBuilder();
	char next = _url[_index];
	while (next != c)
	{
	b.append(next);
	next = _url[++_index];
	}
	return b.toString();
	}

	public static void main(String[] args)
	{
	String testurl = "qpid:password=pass;username=name@tcp:test1";
	try
	{
	URLParser_0_10 impl = new URLParser_0_10(testurl);
	for (BrokerDetails d : impl.getAllBrokerDetails())
	{
	System.out.println(d);
	}
	}
	catch (Exception e)
	{
	e.printStackTrace();
	}
	}
	}