001    /** 
002     * 
003     * Copyright 2004 Protique Ltd
004     * 
005     * Licensed under the Apache License, Version 2.0 (the "License"); 
006     * you may not use this file except in compliance with the License. 
007     * You may obtain a copy of the License at 
008     * 
009     * http://www.apache.org/licenses/LICENSE-2.0
010     * 
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS, 
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
014     * See the License for the specific language governing permissions and 
015     * limitations under the License. 
016     * 
017     **/
018    
019    package org.activemq.util;
020    import java.net.URI;
021    import java.net.URISyntaxException;
022    import java.util.HashMap;
023    import java.util.Map;
024    import java.util.StringTokenizer;
025    
026    /**
027     * Some URI based helper methods.
028     * 
029     * @version $Revision: 1.1.1.1 $
030     */
031    public class URIHelper {
032        /**
033         * Parsers the query string of the URI into a map of key-value pairs
034         */
035        public static Map parseQuery(URI uri) {
036            return parseQuery(getLastQuery(uri));
037        }
038    
039        /**
040         * Parsers the query string of the URI into a map of key-value pairs
041         */
042        public static Map parseQuery(String query) {
043            Map answer = new HashMap();
044            if (query != null) {
045                if (query.startsWith("?")) {
046                    query = query.substring(1);
047                }
048                StringTokenizer iter = new StringTokenizer(query, "&");
049                while (iter.hasMoreTokens()) {
050                    String pair = iter.nextToken();
051                    addKeyValuePair(answer, pair);
052                }
053            }
054            return answer;
055        }
056    
057        /**
058         * Get the query str
059         * @param uri
060         * @return the last query - the URI could be a composite
061         */
062        public static String getLastQuery(URI uri) {
063            String result = null;
064            if (uri != null) {
065                String uriString = uri.toString();
066                if (uriString != null) {
067                    int index = uri.toString().lastIndexOf('?');
068                    if (index >= 0 && (index + 1) < uriString.length()) {
069                        result = uriString.substring(index + 1);
070                    }
071                }
072            }
073            return result;
074        }
075        
076        /**
077         * Get the Path
078         * @param uri
079         * @return the last path - the URI could be a composite
080         */
081        public static String getLastPath(URI uri) {
082            
083            String path = uri.getPath();
084            if(path==null) {
085                path = uri.getRawSchemeSpecificPart();
086            }
087            
088            // Skip to the last composite uri in the path.
089            URIHelper helper = new URIHelper(path);
090            while( helper.hasNext() ) {
091                path = helper.getNext();
092            }
093    
094            // Was the last thing in the composite a URI?
095            if( path.indexOf(":") >=0 ) {
096                    try {
097                        path = new URI(path).getPath();
098                    } catch (URISyntaxException e) {
099                    }
100            }
101            
102            path = removeInitialSlash(path).trim();
103            if( path.length() == 0 )
104                return null;
105            
106            return path;
107        }
108    
109        /**
110         * @param path
111         * @return
112         */
113        private static String removeInitialSlash(String path) {
114            if( path.length()>0 && path.charAt(0)=='/' ) {
115                return path.substring(1);
116            }
117            return path;
118        }
119    
120        protected static void addKeyValuePair(Map answer, String pair) {
121            int idx = pair.indexOf('=');
122            String name = null;
123            String value = null;
124            if (idx >= 0) {
125                name = pair.substring(0, idx);
126                if (++idx < pair.length()) {
127                    value = pair.substring(idx);
128                }
129            }
130            else {
131                name = pair;
132            }
133            answer.put(name, value);
134        }
135        private StringTokenizer tokenizer;
136    
137        /**
138         * Create URIHelper with a path
139         * 
140         * @param path
141         */
142        public URIHelper(String path) {
143            if (path != null) {
144                this.tokenizer = new StringTokenizer(strip(path), ",");
145            }
146        }
147    
148        public boolean hasNext() {
149            return tokenizer == null ? false : tokenizer.hasMoreTokens();
150        }
151    
152        public String getNext() {
153            return tokenizer == null ? null : tokenizer.nextToken();
154        }
155    
156        private String strip(String str) {
157            String result = null;
158            if (str != null) {
159                result = str.trim();
160                int index = result.indexOf('(');
161                if (index >= 0 && (index + 1) < result.length()) {
162                    result = result.substring(index + 1);
163                    index = result.lastIndexOf(')');
164                    result = result.substring(0, index);
165                }
166            }
167            return result;
168        }
169    }