// Check int input edit field for an error
private static boolean intFieldError(TextField theField, double minValue, double maxValue) {
StringTokenizer fieldTokenizer = new StringTokenizer(theField.getText());
if (!fieldTokenizer.hasMoreElements()) {
theField.setText("Error");
return true;
} else {
String fieldString = fieldTokenizer.nextToken();
try {
int fieldValue = new Integer(fieldString).intValue();
if (fieldValue < minValue) {
theField.setText("Error");
return true;
} else if (fieldValue > maxValue) {
theField.setText("Error");
return true;
}
} catch (Throwable e) {
theField.setText("Error");
return true;
}
}
if (fieldTokenizer.hasMoreElements()) {
theField.setText("Error");
return true;
} else {
return false;
}
}
public FeatureList(String featReplyMsg) {
StringTokenizer responseTokenizer =
new StringTokenizer(featReplyMsg, System.getProperty("line.separator"));
// ignore the first part of the message
if (responseTokenizer.hasMoreElements()) {
responseTokenizer.nextToken();
}
while (responseTokenizer.hasMoreElements()) {
String line = (String) responseTokenizer.nextElement();
line = line.trim().toUpperCase();
if (line.startsWith("211 END")) {
break;
}
String[] splitFeature = line.split(" ");
if (splitFeature.length == 2) {
features.add(new Feature(splitFeature[0], splitFeature[1]));
} else {
features.add(new Feature(line));
}
}
}
@Override
public Locale read(JsonReader in) throws IOException {
if (in.peek() == JsonToken.NULL) {
in.nextNull();
return null;
}
String locale = in.nextString();
StringTokenizer tokenizer = new StringTokenizer(locale, "_");
String language = null;
String country = null;
String variant = null;
if (tokenizer.hasMoreElements()) {
language = tokenizer.nextToken();
}
if (tokenizer.hasMoreElements()) {
country = tokenizer.nextToken();
}
if (tokenizer.hasMoreElements()) {
variant = tokenizer.nextToken();
}
if (country == null && variant == null) {
return new Locale(language);
} else if (variant == null) {
return new Locale(language, country);
} else {
return new Locale(language, country, variant);
}
}
/**
* Search by criteria.
*
* @param criteria the criteria
* @return the list< t>
*/
protected List<T> searchByCriteria(E criteria) {
CriteriaQuery<T> query = getCriteriaBuilder().createQuery(getEntityClass());
Root<T> from = query.from(getEntityClass());
query.select(from);
List<Predicate> predicateList = buildConditions(from, criteria);
if (predicateList != null) {
Predicate[] predicates = new Predicate[predicateList.size()];
predicateList.toArray(predicates);
query.where(predicates);
}
if (criteria.getGroupBy() != null) {
query.groupBy(from.get(criteria.getGroupBy()));
}
if (criteria.getOrderField() != null) {
if (criteria.getOrderType() != null && !"".equals(criteria.getOrderType())) {
StringTokenizer outerTokenizer = new StringTokenizer(criteria.getOrderField(), ",");
StringTokenizer typeTokenizer = new StringTokenizer(criteria.getOrderType(), ",");
List<Order> orders = new ArrayList<Order>();
while (outerTokenizer.hasMoreElements()) {
String field = (String) outerTokenizer.nextElement();
String type = (String) typeTokenizer.nextElement();
Path ex = null;
if (field.indexOf(".") > 0) {
StringTokenizer tokenizer = new StringTokenizer(field, ".");
while (tokenizer.hasMoreElements()) {
String key = (String) tokenizer.nextElement();
if (ex == null) {
ex = from.get(key);
} else {
ex = ex.get(key);
}
}
} else {
ex = from.get(field);
}
if ("desc".equals(type)) {
orders.add(getCriteriaBuilder().desc(ex));
} else if ("asc".equals(type)) {
orders.add(getCriteriaBuilder().asc(ex));
}
}
if (orders.size() > 0) {
query.orderBy(orders);
}
} else {
query.orderBy(getCriteriaBuilder().desc(from.get(criteria.getOrderField())));
}
}
TypedQuery<T> typedQuery = getEntityManager().createQuery(query);
if (criteria.getStartIndex() != null) {
typedQuery.setFirstResult(criteria.getStartIndex());
typedQuery.setMaxResults(criteria.getPageSize());
} else {
typedQuery.setFirstResult(0);
typedQuery.setMaxResults(rowLimit);
}
System.out.println("dfjdfjdkfdkfjd" + typedQuery.toString());
return typedQuery.getResultList();
}
public static String findUrl(PsiFile file, int offset, String uri) {
final PsiElement currentElement = file.findElementAt(offset);
final XmlAttribute attribute = PsiTreeUtil.getParentOfType(currentElement, XmlAttribute.class);
if (attribute != null) {
final XmlTag tag = PsiTreeUtil.getParentOfType(currentElement, XmlTag.class);
if (tag != null) {
final String prefix = tag.getPrefixByNamespace(XmlUtil.XML_SCHEMA_INSTANCE_URI);
if (prefix != null) {
final String attrValue =
tag.getAttributeValue(XmlUtil.SCHEMA_LOCATION_ATT, XmlUtil.XML_SCHEMA_INSTANCE_URI);
if (attrValue != null) {
final StringTokenizer tokenizer = new StringTokenizer(attrValue);
while (tokenizer.hasMoreElements()) {
if (uri.equals(tokenizer.nextToken())) {
if (!tokenizer.hasMoreElements()) return uri;
final String url = tokenizer.nextToken();
return url.startsWith(HTTP_PROTOCOL) ? url : uri;
}
if (!tokenizer.hasMoreElements()) return uri;
tokenizer.nextToken(); // skip file location
}
}
}
}
}
return uri;
}
public static Triangle parseTriangle(String s) throws InvalidShapeStringException {
StringTokenizer st = new StringTokenizer(s, ":,");
int available;
String[] arr;
{
available = 0;
arr = new String[available];
}
while (st.hasMoreElements()) {
++available;
arr = Arrays.copyOf(arr, available);
arr[arr.length - 1] = (String) st.nextElement();
}
if (arr.length == 5) {
while (st.hasMoreElements()) {
String figure = st.nextElement().toString();
String color = st.nextElement().toString();
String a = st.nextElement().toString();
String b = st.nextElement().toString();
String c = st.nextElement().toString();
Triangle triangle =
new Triangle(
color, Double.parseDouble(a), Double.parseDouble(b), Double.parseDouble(c));
// System.out.println(triangle.toString());
}
} else throw new InvalidShapeStringException();
return new Triangle("WHITE", 1.1, 1.1, 1.1);
}
public static String newLineToBR(String data) {
StringTokenizer tokened = new StringTokenizer(data, "\n");
String result = new String();
while (tokened.hasMoreElements()) {
result += tokened.nextElement();
if (tokened.hasMoreElements()) result += "<BR>";
}
return result;
}
public Version(String s) {
StringTokenizer tok = new StringTokenizer(s, ".");
if (!tok.hasMoreElements()) return;
major = Integer.parseInt(tok.nextToken());
if (!tok.hasMoreElements()) return;
minor = Integer.parseInt(tok.nextToken());
if (!tok.hasMoreElements()) return;
build = Integer.parseInt(tok.nextToken());
}
private static Boolean analyzeTokens(StringTokenizer tok1, StringTokenizer tok2) {
List<String> alist1 = new ArrayList<String>();
List<String> alist2 = new ArrayList<String>();
while (tok1.hasMoreElements()) {
alist1.add(tok1.nextToken());
}
while (tok2.hasMoreElements()) {
alist2.add(tok2.nextToken());
}
for (String elem1 : new ArrayList<String>(alist1)) {
for (String elem2 : new ArrayList<String>(alist2)) {
if (elem1.equals(elem2)) {
alist1.remove(elem1);
alist2.remove(elem2);
break;
}
}
}
Boolean validated = false;
String returnString = "";
for (String elem1 : alist1) {
returnString = returnString + elem1 + ";";
}
if (returnString.length() > 0) {
returnString =
" |remaining tokenizer content: |##### | "
+ returnString
+ "<- from original file| ### |";
} else {
returnString =
" |no tokenizer content remained:|##### | "
+ returnString
+ "<- from original file| ### |";
validated = true;
}
for (String elem2 : alist2) {
returnString = returnString + elem2 + ";";
}
if (returnString.length() > 0) {
returnString = returnString + " <- from converted file|";
}
errorMsg = returnString;
return validated;
}
public EmployeeCSV(String values) {
StringTokenizer tokenizer = new StringTokenizer(values, ",");
if (tokenizer.hasMoreElements()) {
id = Integer.parseInt(tokenizer.nextToken());
}
if (tokenizer.hasMoreElements()) {
firstname = tokenizer.nextToken();
}
if (tokenizer.hasMoreElements()) {
lastname = tokenizer.nextToken();
}
if (tokenizer.hasMoreElements()) {
emailAddress = tokenizer.nextToken();
}
}
/**
* Gets a created package.
*
* @param qualifiedName the package to search
* @return a found package or null
*/
public CtPackage get(String qualifiedName) {
if (qualifiedName.contains(CtType.INNERTTYPE_SEPARATOR)) {
throw new RuntimeException("Invalid package name " + qualifiedName);
}
StringTokenizer token = new StringTokenizer(qualifiedName, CtPackage.PACKAGE_SEPARATOR);
CtPackage current = rootPackage;
if (token.hasMoreElements()) {
current = current.getPackage(token.nextToken());
while (token.hasMoreElements() && current != null) {
current = current.getPackage(token.nextToken());
}
}
return current;
}
public static ClassLoader newClassLoader(final Class... userClasses) throws Exception {
Set<URL> userClassUrls = new HashSet<>();
for (Class anyUserClass : userClasses) {
ProtectionDomain protectionDomain = anyUserClass.getProtectionDomain();
CodeSource codeSource = protectionDomain.getCodeSource();
URL classLocation = codeSource.getLocation();
userClassUrls.add(classLocation);
}
StringTokenizer tokenString =
new StringTokenizer(System.getProperty("java.class.path"), File.pathSeparator);
String pathIgnore = System.getProperty("java.home");
if (pathIgnore == null) {
pathIgnore = userClassUrls.iterator().next().toString();
}
List<URL> urls = new ArrayList<>();
while (tokenString.hasMoreElements()) {
String value = tokenString.nextToken();
URL itemLocation = new File(value).toURI().toURL();
if (!userClassUrls.contains(itemLocation)
&& itemLocation.toString().indexOf(pathIgnore) >= 0) {
urls.add(itemLocation);
}
}
URL[] urlArray = urls.toArray(new URL[urls.size()]);
ClassLoader masterClassLoader = URLClassLoader.newInstance(urlArray, null);
ClassLoader appClassLoader =
URLClassLoader.newInstance(userClassUrls.toArray(new URL[0]), masterClassLoader);
return appClassLoader;
}
/** Convert input from regular mathematical expression to a postfix one. */
public void convert(String input) {
StringHandler sh = new StringHandler();
this.input = sh.toStandardInput(input);
StringTokenizer tokenizer = new StringTokenizer(this.input, " ");
while (tokenizer.hasMoreElements()) {
String token = tokenizer.nextToken();
// Single digit, Check if type is digit or operator.
if (token.length() == 1) {
char temp = token.charAt(0);
// Digit
if (Character.isDigit(temp)) {
addToOutputQueue(token);
}
// Operator
else if (isOperator(temp)) {
processOperator(token);
}
// Parenthesis
else if (isParenthesis(temp)) {
processParenthesis(token);
}
}
// More than one digit. Can only be number
else {
addToOutputQueue(token);
}
}
while (opStack.size() != 0) {
addToOutputQueue(opStack.pop().getType());
}
}
/**
* Get the list of codecs listed in the configuration
*
* @param conf the configuration to look in
* @return a list of the Configuration classes or null if the attribute was not set
*/
public static List<Class<? extends CompressionCodec>> getCodecClasses(Configuration conf) {
String codecsString = conf.get("io.compression.codecs");
if (codecsString != null) {
List<Class<? extends CompressionCodec>> result =
new ArrayList<Class<? extends CompressionCodec>>();
StringTokenizer codecSplit = new StringTokenizer(codecsString, ",");
while (codecSplit.hasMoreElements()) {
String codecSubstring = codecSplit.nextToken();
if (codecSubstring.length() != 0) {
try {
Class<?> cls = conf.getClassByName(codecSubstring);
if (!CompressionCodec.class.isAssignableFrom(cls)) {
throw new IllegalArgumentException(
"Class " + codecSubstring + " is not a CompressionCodec");
}
result.add(cls.asSubclass(CompressionCodec.class));
} catch (ClassNotFoundException ex) {
throw new IllegalArgumentException(
"Compression codec " + codecSubstring + " not found.", ex);
}
}
}
return result;
} else {
return null;
}
}
/**
* Get currently running java version and subversion numbers. This is the running JRE version. If
* no version could be identified <code>null</code> is returned.
*
* @return Array of version and subversion numbers.
*/
public static int[] getJavaVersion() {
final String version = System.getProperty("java.version");
final List numbers = new ArrayList();
final StringTokenizer tokenizer = new StringTokenizer(version, ".");
while (tokenizer.hasMoreElements()) {
String sub = tokenizer.nextToken();
for (int i = 0; i < sub.length(); i++) {
if (!Character.isDigit(sub.charAt(i))) {
sub = sub.substring(0, i);
break;
}
}
try {
numbers.add(new Integer(Integer.parseInt(sub)));
} catch (Exception e) {
e.printStackTrace();
break;
}
}
if (numbers.size() == 0) {
return null;
}
final int[] result = new int[numbers.size()];
for (int i = 0; i < numbers.size(); i++) {
result[i] = ((Integer) numbers.get(i)).intValue();
}
return result;
}
public static void getTablePaths(String myMultiLocs) {
StringTokenizer st = new StringTokenizer(myMultiLocs, ",");
// get how many tokens inside st object
System.out.println("tokens count: " + st.countTokens());
int count = 0;
// iterate st object to get more tokens from it
while (st.hasMoreElements()) {
count++;
String token = st.nextElement().toString();
if (mode == TestMode.local) {
System.out.println("in mini, token: " + token);
// in mini, token: file:/homes/<uid>/grid/multipleoutput/pig-table/contrib/zebra/ustest3
if (count == 1) strTable1 = token;
if (count == 2) strTable2 = token;
if (count == 3) strTable3 = token;
} else {
System.out.println("in real, token: " + token);
// in real, token: /user/hadoopqa/ustest3
// note: no prefix file: in real cluster
if (count == 1) strTable1 = token;
if (count == 2) strTable2 = token;
if (count == 3) strTable3 = token;
}
}
}
private Object parseRecursive(StringTokenizer st) {
List<Object> currentSequence = new ArrayList<>();
Object lastParsed = null;
while (st.hasMoreElements()) {
String s = st.nextToken();
switch (s) {
case " ": // split on blanks
currentSequence.add(lastParsed);
break;
case "?":
lastParsed = grammar.zeroOrOne(lastParsed);
break;
case "*":
lastParsed = grammar.zeroOrMore(lastParsed);
break;
case "(":
lastParsed = parseRecursive(st);
break;
case ")": // current group finished
return finish(currentSequence, lastParsed);
case "'":
lastParsed = Token.getFromDescription(st.nextToken("'"));
st.nextToken("'?*() "); // '
break;
default:
lastParsed = s; // rule name
break;
}
}
return finish(currentSequence, lastParsed);
}
/**
* evaluates the 'Set-Cookie'-Header of a HTTP response
*
* @param name key of a cookie value
* @param conn URLConnection
* @return cookie value referenced by the key. null if key not found
* @throws IOException
*/
private static String getCookie(String name, URLConnection conn) {
for (int i = 0; ; i++) {
String headerName = conn.getHeaderFieldKey(i);
String headerValue = conn.getHeaderField(i);
if (headerName == null && headerValue == null) {
// No more headers
break;
}
if (headerName != null && headerName.equals("Set-Cookie")) {
if (headerValue.startsWith(name)) {
// several key-value-pairs are separated by ';'
StringTokenizer st = new StringTokenizer(headerValue, "; ");
while (st.hasMoreElements()) {
String token = st.nextToken();
if (token.startsWith(name)) {
return token;
}
}
}
}
}
return null;
}
public VersionString(String paramString) {
if (paramString != null) {
StringTokenizer localStringTokenizer = new StringTokenizer(paramString, " ", false);
while (localStringTokenizer.hasMoreElements())
this._versionIds.add(new VersionID(localStringTokenizer.nextToken()));
}
}
/**
* Given a context node and the argument to the XPath <code>id</code> function, checks whether the
* context node is in the set of nodes that results from that reference to the <code>id</code>
* function. This is used in the implementation of <code>id</code> patterns.
*
* @param node The context node
* @param value The argument to the <code>id</code> function
* @return <code>1</code> if the context node is in the set of nodes returned by the reference to
* the <code>id</code> function; <code>0</code>, otherwise
*/
public int containsID(int node, Object value) {
final String string = (String) value;
int rootHandle = _dom.getAxisIterator(Axis.ROOT).setStartNode(node).next();
// Get the mapping table for the document containing the context node
Hashtable index = (Hashtable) _rootToIndexMap.get(new Integer(rootHandle));
// Split argument to id function into XML whitespace separated tokens
final StringTokenizer values = new StringTokenizer(string, " \n\t");
while (values.hasMoreElements()) {
final String token = (String) values.nextElement();
IntegerArray nodes = null;
if (index != null) {
nodes = (IntegerArray) index.get(token);
}
// If input was from W3C DOM, use DOM's getElementById to do
// the look-up.
if (nodes == null && _enhancedDOM != null && _enhancedDOM.hasDOMSource()) {
nodes = getDOMNodeById(token);
}
// Did we find the context node in the set of nodes?
if (nodes != null && nodes.indexOf(node) >= 0) {
return 1;
}
}
// Didn't find the context node in the set of nodes returned by id
return 0;
}
public float[] getVertBinAltitude() throws Exception {
String propertyFileName = null;
float[] altitude = new float[VertLen];
try {
propertyFileName = (String) metadata.get(ancillary_file_name);
InputStream ios = getClass().getResourceAsStream(propertyFileName);
BufferedReader ancillaryReader = new BufferedReader(new InputStreamReader(ios));
int line_cnt = 0;
while (true) {
String line = ancillaryReader.readLine();
if (line == null) break;
if (line.startsWith("!")) continue;
StringTokenizer strTok = new StringTokenizer(line);
String[] tokens = new String[strTok.countTokens()];
int tokCnt = 0;
while (strTok.hasMoreElements()) {
tokens[tokCnt++] = strTok.nextToken();
}
altitude[line_cnt] = (Float.valueOf(tokens[0])) * 1000f;
line_cnt++;
}
ios.close();
} catch (Exception e) {
logger.error("fail on ancillary file read: " + propertyFileName);
}
return altitude;
}
/**
* Extracts column names referenced by enclosing them in curly braces (“{” and “}”) in a string
* template.
*
* @param stringTemplate
* @return
*/
public static Set<String> extractColumnNamesFromStringTemplate(String stringTemplate) {
Set<String> result = new HashSet<String>();
// Curly braces that do not enclose column names MUST be
// escaped by a backslash character (“\”).
stringTemplate = stringTemplate.replaceAll("\\\\\\{", "");
stringTemplate = stringTemplate.replaceAll("\\\\\\}", "");
if (stringTemplate != null) {
StringTokenizer st = new StringTokenizer(stringTemplate, "{}", true);
boolean keepNext = false;
String next = null;
while (st.hasMoreElements()) {
String element = st.nextElement().toString();
if (keepNext) next = element;
keepNext = element.equals("{");
if (element.equals("}") && element != null) {
log.debug(
"[R2RMLToolkit:extractColumnNamesFromStringTemplate] Extracted column name "
+ next
+ " from string template "
+ stringTemplate);
result.add(next);
next = null;
}
}
}
return result;
}
private long stringToIp(String ip) throws EntitlementException {
StringTokenizer st = new StringTokenizer(ip, ".");
int tokenCount = st.countTokens();
if (tokenCount != 4) {
String args[] = {"ip", ip};
throw new EntitlementException(400, args);
}
long ipValue = 0L;
while (st.hasMoreElements()) {
String s = st.nextToken();
short ipElement = 0;
try {
ipElement = Short.parseShort(s);
} catch (Exception e) {
String args[] = {"ip", ip};
throw new EntitlementException(400, args);
}
if (ipElement < 0 || ipElement > 255) {
String args[] = {"ipElement", s};
throw new EntitlementException(400, args);
}
ipValue = ipValue * 256L + ipElement;
}
return ipValue;
}
public static void buildWordMap(String out, List<String> wordMap, Set<String> dictionarySet)
throws IOException {
String currentLine = "", currentWord = "";
StringTokenizer st = new StringTokenizer(out.toString(), " ");
while (st.hasMoreElements()) {
Integer i = null;
currentWord = st.nextToken();
currentWord = CheckWord(currentWord); // remove any
// unwanted
// chars
if (currentWord == null) continue;
if (dictionarySet.contains(currentWord)) continue;
// List<Integer> lines = wordMap.get(currentWord);
// if (lines == null)
// {
// lines = new ArrayList<Integer>();
// wordMap.put(currentWord, lines);
// }
wordMap.add(currentWord);
// lines.add(LineNumber);
}
}
public void setAuthor(String authors) {
StringTokenizer st = new StringTokenizer(authors, ",");
author = new Vector<String>();
while (st.hasMoreElements()) {
author.add(st.nextToken());
}
}
/**
* Add a CLASSPATH or -lib to lib path urls. Only filesystem resources are supported.
*
* @param path the classpath or lib path to add to the libPathULRLs
* @param getJars if true and a path is a directory, add the jars in the directory to the path
* urls
* @param libPathURLs the list of paths to add to
* @throws MalformedURLException if we can't create a URL
*/
private void addPath(String path, boolean getJars, List libPathURLs)
throws MalformedURLException {
StringTokenizer tokenizer = new StringTokenizer(path, File.pathSeparator);
while (tokenizer.hasMoreElements()) {
String elementName = tokenizer.nextToken();
File element = new File(elementName);
if (elementName.indexOf('%') != -1 && !element.exists()) {
continue;
}
if (getJars && element.isDirectory()) {
// add any jars in the directory
URL[] dirURLs = Locator.getLocationURLs(element);
for (int j = 0; j < dirURLs.length; ++j) {
if (launchDiag) {
System.out.println("adding library JAR: " + dirURLs[j]);
}
libPathURLs.add(dirURLs[j]);
}
}
URL url = Locator.fileToURL(element);
if (launchDiag) {
System.out.println("adding library URL: " + url);
}
libPathURLs.add(url);
}
}
public static DataPointType lookup(String dptID) {
dptID = dptID.toUpperCase().trim();
if (dptID.startsWith("DPT")) {
dptID = dptID.substring(3, dptID.length()).trim();
}
StringTokenizer tokenizer = new StringTokenizer(dptID, ".");
int main, sub;
try {
main = Integer.parseInt(tokenizer.nextToken().trim());
if (!tokenizer.hasMoreElements()) {
throw new NoSuchCommandException("Unable to parse DPT : '" + dptID + "'.");
}
sub = Integer.parseInt(tokenizer.nextToken().trim());
return lookup.get(getDPTID(main, sub));
} catch (NumberFormatException exception) {
throw new NoSuchCommandException(
"Cannot parse datapoint type '" + dptID + "', " + exception.getMessage(), exception);
}
}
private void executeMultipleInlineStatements(String line, StringBuilder sql) {
final StringTokenizer sqlStatements = new StringTokenizer(line, getStatementDelimiter());
while (sqlStatements.hasMoreElements()) {
sql.append(sqlStatements.nextToken());
executeStatements(sql);
}
}
public static ArrayList<Long> splitStringToLongs(String line, String delim) {
if (line == null) {
err("splitString: line is null");
return null;
}
ArrayList<Long> res = new ArrayList<Long>();
StringTokenizer tokenizer = new StringTokenizer(line, delim);
while (tokenizer.hasMoreElements()) {
String next = tokenizer.nextToken().trim();
if (next.startsWith("\"")) {
next = next.substring(1, next.length());
}
if (next.endsWith("\"")) {
next = next.substring(0, next.length() - 1);
}
long d = 0;
try {
d = Long.parseLong(next);
} catch (Exception e) {
}
res.add(d);
// p("token "+res.size()+" is:"+next);
}
return res;
}
public Distribution<T> parse(String distrAsString) {
DiscreteDistribution<T> dist = new DiscreteDistribution<T>();
StringTokenizer tok = new StringTokenizer(distrAsString, ",");
while (tok.hasMoreElements()) {
String pair = tok.nextToken().trim();
StringTokenizer sub = new StringTokenizer(pair, "/");
try {
T value = (T) domainType.getConstructor(String.class).newInstance(sub.nextToken().trim());
Degree deg = (Degree) getDegreeStringConstructor().newInstance(sub.nextToken().trim());
dist.put(value, deg);
} catch (NoSuchMethodException nsme) {
nsme.printStackTrace();
} catch (IllegalAccessException iae) {
iae.printStackTrace();
} catch (InstantiationException ie) {
ie.printStackTrace();
} catch (InvocationTargetException ite) {
ite.printStackTrace();
}
}
return dist;
}