Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.apache.qpid.messaging.util.AddressParser Maven / Gradle / Ivy
/*
*
* 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.messaging.util;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.apache.qpid.configuration.ClientProperties;
import org.apache.qpid.messaging.Address;
/**
* AddressParser
*
*/
public class AddressParser extends Parser
{
private static Lexicon lxi = new Lexicon();
private static Token.Type LBRACE = lxi.define("LBRACE", "\\{");
private static Token.Type RBRACE = lxi.define("RBRACE", "\\}");
private static Token.Type LBRACK = lxi.define("LBRACK", "\\[");
private static Token.Type RBRACK = lxi.define("RBRACK", "\\]");
private static Token.Type COLON = lxi.define("COLON", ":");
private static Token.Type SEMI = lxi.define("SEMI", ";");
private static Token.Type SLASH = lxi.define("SLASH", "/");
private static Token.Type COMMA = lxi.define("COMMA", ",");
private static Token.Type NUMBER = lxi.define("NUMBER", "[+-]?[0-9]*\\.?[0-9]+");
private static Token.Type TRUE = lxi.define("TRUE", "True");
private static Token.Type FALSE = lxi.define("FALSE", "False");
private static Token.Type ID = lxi.define("ID", "[a-zA-Z_](?:[a-zA-Z0-9_-]*[a-zA-Z0-9_])?");
private static Token.Type STRING = lxi.define("STRING", "\"(?:[^\\\"]|\\.)*\"|'(?:[^\\']|\\.)*'");
private static Token.Type ESC = lxi.define("ESC", "\\\\[^ux]|\\\\x[0-9a-fA-F][0-9a-fA-F]|\\\\u[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]");
private static Token.Type SYM = lxi.define("SYM", "[.#*%@$^!+-]");
private static Token.Type WSPACE = lxi.define("WSPACE", "[\\s]+");
private static Token.Type EOF = lxi.eof("EOF");
private static Lexer LEXER = lxi.compile();
private static final int MAX_CACHED_ENTRIES = Integer.getInteger(ClientProperties.QPID_MAX_CACHED_ADDR_OPTION_STRINGS,
ClientProperties.DEFAULT_MAX_CACHED_ADDR_OPTION_STRINGS);
// stores address options maps for options strings that we have encountered; using a synchronizedMap wrapper
// in case multiple threads are parsing addresses.
private static Map> optionsMaps =
Collections.synchronizedMap(
new LinkedHashMap>(MAX_CACHED_ENTRIES +1,1.1f,true)
{
@Override
protected boolean removeEldestEntry(Map.Entry> eldest)
{
return size() > MAX_CACHED_ENTRIES;
}
});
public static List lex(String input)
{
return LEXER.lex(input);
}
static List wlex(String input)
{
List tokens = new ArrayList();
for (Token t : lex(input))
{
if (t.getType() != WSPACE)
{
tokens.add(t);
}
}
return tokens;
}
static String unquote(String st, Token tok)
{
StringBuilder result = new StringBuilder();
for (int i = 1; i < st.length() - 1; i++)
{
char ch = st.charAt(i);
if (ch == '\\')
{
char code = st.charAt(i+1);
switch (code)
{
case '\n':
break;
case '\\':
result.append('\\');
break;
case '\'':
result.append('\'');
break;
case '"':
result.append('"');
break;
case 'a':
result.append((char) 0x07);
break;
case 'b':
result.append((char) 0x08);
break;
case 'f':
result.append('\f');
break;
case 'n':
result.append('\n');
break;
case 'r':
result.append('\r');
break;
case 't':
result.append('\t');
break;
case 'u':
result.append(decode(st.substring(i+2, i+6)));
i += 4;
break;
case 'v':
result.append((char) 0x0b);
break;
case 'o':
result.append(decode(st.substring(i+2, i+4), 8));
i += 2;
break;
case 'x':
result.append(decode(st.substring(i+2, i+4)));
i += 2;
break;
default:
throw new ParseError(tok);
}
i += 1;
}
else
{
result.append(ch);
}
}
return result.toString();
}
static char[] decode(String hex)
{
return decode(hex, 16);
}
static char[] decode(String code, int radix)
{
return Character.toChars(Integer.parseInt(code, radix));
}
static String tok2str(Token tok)
{
Token.Type type = tok.getType();
String value = tok.getValue();
if (type == STRING)
{
return unquote(value, tok);
}
else if (type == ESC)
{
if (value.charAt(1) == 'x' || value.charAt(1) == 'u')
{
return new String(decode(value.substring(2)));
}
else
{
return value.substring(1);
}
}
else
{
return value;
}
}
static Object tok2obj(Token tok)
{
Token.Type type = tok.getType();
String value = tok.getValue();
if (type == STRING)
{
return unquote(value, tok);
}
else if (type == NUMBER)
{
if (value.indexOf('.') >= 0)
{
return Double.valueOf(value);
}
else
{
return Integer.decode(value);
}
}
else if (type == TRUE)
{
return true;
}
else if (type == FALSE)
{
return false;
}
else
{
return value;
}
}
static String toks2str(List toks)
{
if (toks.size() > 0)
{
StringBuilder result = new StringBuilder();
for (Token t : toks)
{
result.append(tok2str(t));
}
return result.toString();
}
else
{
return null;
}
}
public AddressParser(String input)
{
super(wlex(input));
}
public Address parse()
{
Address result = address();
eat(EOF);
return result;
}
public Address address()
{
String name = toks2str(eat_until(SLASH, SEMI, EOF));
if (name == null)
{
throw new ParseError(next());
}
String subject;
if (matches(SLASH))
{
eat(SLASH);
subject = toks2str(eat_until(SEMI, EOF));
if ("None".equals(subject))
{
subject = null;
}
}
else
{
subject = null;
}
Map options;
if (matches(SEMI))
{
eat(SEMI);
// get the remaining string denoting the options and see if we've already encountered an address
// with the same options before
String optionsString = toks2str(remainder());
Map storedMap = optionsMaps.get(optionsString);
if (storedMap == null)
{
// if these are new options, construct a new map and store it in the encountered collection
options = Collections.unmodifiableMap(map());
optionsMaps.put(optionsString, options);
}
else
{
// if we already have the map for these options, use the stored map
options = storedMap;
eat_until(EOF);
}
}
else
{
options = null;
}
return new Address(name, subject, options);
}
public Map map()
{
eat(LBRACE);
Map result = new HashMap();
while (true)
{
if (matches(NUMBER, STRING, ID, LBRACE, LBRACK))
{
keyval(result);
if (matches(COMMA))
{
eat(COMMA);
}
else if (matches(RBRACE))
{
break;
}
else
{
throw new ParseError(next(), COMMA, RBRACE);
}
}
else if (matches(RBRACE))
{
break;
}
else
{
throw new ParseError(next(), NUMBER, STRING, ID, LBRACE, LBRACK,
RBRACE);
}
}
eat(RBRACE);
return result;
}
void keyval(Map map)
{
Object key = value();
eat(COLON);
Object val = value();
map.put(key, val);
}
Object value()
{
if (matches(NUMBER, STRING, ID, TRUE, FALSE))
{
return tok2obj(eat());
}
else if (matches(LBRACE))
{
return map();
}
else if (matches(LBRACK))
{
return list();
}
else
{
throw new ParseError(next(), NUMBER, STRING, ID, LBRACE, LBRACK);
}
}
List list()
{
eat(LBRACK);
List result = new ArrayList();
while (true)
{
if (matches(RBRACK))
{
break;
}
else
{
result.add(value());
if (matches(COMMA))
{
eat(COMMA);
}
else if (matches(RBRACK))
{
break;
}
else
{
throw new ParseError(next(), COMMA, RBRACK);
}
}
}
eat(RBRACK);
return result;
}
}
