public String findDups(String MyString) { if (MyString == null) { return ""; } String dups = ""; char[] a; Map<Character, Boolean> result = new HashMap<Character, Boolean>(); Map<Character, Boolean> b = new HashMap<Character, Boolean>(); a = MyString.toCharArray(); for (char elm : a) { if (b.containsKey(elm)) { if (result.containsKey(elm) != true) { result.put(elm, true); } } b.put(elm, true); } for (Character c : result.keySet()) { dups = dups + c; } return dups; }
public static Map<String, String> postDataAPI( EndPointInfo apiUtilities, Map<String, String> headers) throws IDPTokenManagerException { HTTP_METHODS httpMethod = apiUtilities.getHttpMethod(); String url = apiUtilities.getEndPoint(); Map<String, String> params = apiUtilities.getRequestParamsMap(); Map<String, String> responseParams = new HashMap<String, String>(); HttpClient httpclient = getCertifiedHttpClient(); String payload = buildPayload(params); if (httpMethod.equals(HTTP_METHODS.POST)) { HttpPost httpPost = new HttpPost(url); HttpPost httpPostWithHeaders = (HttpPost) buildHeaders(httpPost, headers, httpMethod); byte[] postData = payload.getBytes(); try { httpPostWithHeaders.setEntity(new ByteArrayEntity(postData)); HttpResponse response = httpclient.execute(httpPostWithHeaders); String status = String.valueOf(response.getStatusLine().getStatusCode()); responseParams.put(Constants.SERVER_RESPONSE_BODY, getResponseBody(response)); responseParams.put(Constants.SERVER_RESPONSE_STATUS, status); return responseParams; } catch (ClientProtocolException e) { throw new IDPTokenManagerException("Invalid client protocol.", e); } catch (IOException e) { responseParams.put(Constants.SERVER_RESPONSE_BODY, "Internal Server Error"); responseParams.put(Constants.SERVER_RESPONSE_STATUS, Constants.INTERNAL_SERVER_ERROR); throw new IDPTokenManagerException("Server connectivity failure.", e); } } return responseParams; }
public void invokeServerOutbound(Source source, OutputStream os) { Map<String, DataHandler> attachments = new HashMap<String, DataHandler>(); Map<String, Object> httpProperties = new HashMap<String, Object>(); httpProperties.put(HTTP_RESPONSE_CODE, Integer.valueOf(200)); httpProperties.put(HTTP_RESPONSE_HEADERS, new HashMap<String, List<String>>()); prepare(httpProperties, /*request=*/ false); if (!invokeOutbound(source, attachments)) { if (getProtocolException() != null) { reverseDirection(); invokeOutboundFaultHandlers(); } /* else if (getRuntimeException() != null) { closeServer(); finish(response.getOutputStream()); throw getRuntimeException(); }*/ } // XXX closeServer(); finish(os); }
public static void testDetermineMergeParticipantsAndMergeCoords4() { Address a = Util.createRandomAddress(), b = Util.createRandomAddress(), c = Util.createRandomAddress(), d = Util.createRandomAddress(); org.jgroups.util.UUID.add(a, "A"); org.jgroups.util.UUID.add(b, "B"); org.jgroups.util.UUID.add(c, "C"); org.jgroups.util.UUID.add(d, "D"); View v1 = View.create(a, 1, a, b); View v2 = View.create(c, 1, c, d); Map<Address, View> map = new HashMap<>(); map.put(a, v1); map.put(b, v1); map.put(d, v2); StringBuilder sb = new StringBuilder("map:\n"); for (Map.Entry<Address, View> entry : map.entrySet()) sb.append(entry.getKey() + ": " + entry.getValue() + "\n"); System.out.println(sb); Collection<Address> merge_participants = Util.determineMergeParticipants(map); System.out.println("merge_participants = " + merge_participants); assert merge_participants.size() == 3; assert merge_participants.contains(a) && merge_participants.contains(c) && merge_participants.contains(d); Collection<Address> merge_coords = Util.determineMergeCoords(map); System.out.println("merge_coords = " + merge_coords); assert merge_coords.size() == 2; assert merge_coords.contains(a) && merge_coords.contains(c); }
public void processMethodMapping( String className, int firstLineNumber, int lastLineNumber, String methodReturnType, String methodName, String methodArguments, String newMethodName) { // Original class name -> obfuscated method names. Map methodMap = (Map) classMethodMap.get(className); if (methodMap == null) { methodMap = new HashMap(); classMethodMap.put(className, methodMap); } // Obfuscated method name -> methods. Set methodSet = (Set) methodMap.get(newMethodName); if (methodSet == null) { methodSet = new LinkedHashSet(); methodMap.put(newMethodName, methodSet); } // Add the method information. methodSet.add( new MethodInfo( firstLineNumber, lastLineNumber, methodReturnType, methodArguments, methodName)); }
private int dfsVisit(Pack u, int[] status, boolean wipe, Map<String, PackColor> colours) { colours.put(u.getName(), PackColor.GREY); int check = checkValues[getPos(u.getName())]; if (Math.abs(check) != 1) { wipe = true; } List<String> deps = u.getDependants(); if (deps != null) { for (String name : deps) { Pack v = nameToPack.get(name); if (wipe) { status[getPos(v.getName())] = 1; } if (colours.get(v.getName()) == PackColor.WHITE) { final int result = dfsVisit(v, status, wipe, colours); if (result != 0) { return result; } } } } colours.put(u.getName(), PackColor.BLACK); return 0; }
public void initProperties(Grain g) { int currentGridRow = FIRST_PROPERTY_ROW; propertiesGp.getChildren().remove(FIRST_PROPERTY_ROW + 1, propertiesGp.getChildren().size()); propertiesCb.clear(); propertiesTf.clear(); for (Entry<String, Property> entry : g.getProperties().entrySet()) { Property property = entry.getValue(); String propertyName = entry.getKey(); propertiesCb.put(propertyName, new CheckBox(property.getDescription())); propertiesCb.get(propertyName).setOnAction(eh); GridPane.setConstraints(propertiesCb.get(propertyName), 0, currentGridRow); propertiesGp.getChildren().add(propertiesCb.get(propertyName)); propertiesTf.put(propertyName, new TextField(Double.toString(property.getValue()))); GridPane.setConstraints(propertiesTf.get(propertyName), 1, currentGridRow); propertiesGp.getChildren().add(propertiesTf.get(propertyName)); if (property.isEnabled()) { propertiesCb.get(propertyName).setSelected(true); } else { propertiesTf.get(propertyName).setDisable(true); } currentGridRow++; } }
public Map exportToMap() throws IOException { Map map = new HashMap(); Map vuze_map = new HashMap(); map.put("vuze", vuze_map); List list = new ArrayList(); vuze_map.put("components", list); for (int i = 0; i < components.length; i++) { VuzeFileComponent comp = components[i]; Map entry = new HashMap(); entry.put("type", new Long(comp.getType())); entry.put("content", comp.getContent()); list.add(entry); } return (map); }
public void summaryAction(HttpServletRequest req, HttpServletResponse res) { if (AccountController.redirectIfNoCookie(req, res)) return; Map<String, Object> viewData = new HashMap<String, Object>(); DocumentManager docMan = new DocumentManager(); try { if (req.getParameter("documentId") != null) { // Get the document ID int docId = Integer.parseInt(req.getParameter("documentId")); // Get the document using document id Document document = docMan.get(docId); // Set title to name of the document viewData.put("title", document.getDocumentName()); // Create List of access records List<AccessRecord> accessRecords = new LinkedList<AccessRecord>(); // Add access records for document to the list accessRecords = docMan.getAccessRecords(docId); viewData.put("accessRecords", accessRecords); } else { // Go back to thread page. } } catch (Exception e) { Logger.getLogger("").log(Level.SEVERE, "An error occurred when getting profile user", e); } view(req, res, "/views/group/Document.jsp", viewData); }
/** * Displays a Discussion Thread page * * <p>- Requires a cookie for the session user - Requires a threadId request parameter for the * HTTP GET * * @param req The HTTP Request * @param res The HTTP Response */ public void discussionAction(HttpServletRequest req, HttpServletResponse res) { // Ensure there is a cookie for the session user if (AccountController.redirectIfNoCookie(req, res)) return; Map<String, Object> viewData = new HashMap<>(); if (req.getMethod() == HttpMethod.Get) { // Get the thread GroupManager gm = new GroupManager(); int threadId = Integer.parseInt(req.getParameter("threadId")); DiscussionManager discussionManager = new DiscussionManager(); DiscussionThread thread = discussionManager.getThread(threadId); thread.setGroup(gm.get(thread.getGroupId())); thread.setPosts(discussionManager.getPosts(threadId)); // get documents for the thread DocumentManager docMan = new DocumentManager(); viewData.put("documents", docMan.getDocumentsForThread(threadId)); viewData.put("thread", thread); viewData.put("title", "Discussion: " + thread.getThreadName()); view(req, res, "/views/group/DiscussionThread.jsp", viewData); } else { httpNotFound(req, res); } }
/** * Not only deserialises the object, also performs adjustments on the timestamps to bring them in * alignment with the local time. Reads the current time on the peer node first. If the timestamp * of any items in the cache or commands are newer throws and IOException, because that means the * object is corrupted. Sets the timestamp of the contribution of the peer (if any) to the current * local time. */ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { name = (String) in.readObject(); cache = new Hashtable(); commands = new Hashtable(); final long max = in.readLong(); // the timestamp that should be maximal final long diff = System.currentTimeMillis() - max; myContribution = (ContributionBox) in.readObject(); if (myContribution != null) myContribution.timeStamp = max + diff; int cachesize = in.readInt(); for (int i = 0; i < cachesize; ++i) { ContributionBox cb = (ContributionBox) in.readObject(); if (cb.timeStamp > max) throw new IOException("corrupted timestamp in cache: " + cb.timeStamp + " " + max); cb.timeStamp += diff; cache.put(cb.contributor.name, cb); } int commandssize = in.readInt(); for (int i = 0; i < commandssize; ++i) { Object comm = in.readObject(); long time = in.readLong(); if (time > max) throw new IOException("corrupted timestamp in commands: " + time + " " + max); time += diff; commands.put(comm, new Long(time)); } }
/* * Verify that the provider JAR files are signed properly, which * means the signer's certificate can be traced back to a * JCE trusted CA. * Return null if ok, failure Exception if verification failed. */ static synchronized Exception getVerificationResult(Provider p) { Object o = verificationResults.get(p); if (o == PROVIDER_VERIFIED) { return null; } else if (o != null) { return (Exception) o; } if (verifyingProviders.get(p) != null) { // this method is static synchronized, must be recursion // return failure now but do not save the result return new NoSuchProviderException("Recursion during verification"); } try { verifyingProviders.put(p, Boolean.FALSE); URL providerURL = getCodeBase(p.getClass()); verifyProviderJar(providerURL); // Verified ok, cache result verificationResults.put(p, PROVIDER_VERIFIED); return null; } catch (Exception e) { verificationResults.put(p, e); return e; } finally { verifyingProviders.remove(p); } }
@Override protected void setUp() throws Exception { tmp = IO.getFile("generated/tmp"); tmp.mkdirs(); configuration = new HashMap<String, Object>(); configuration.put( Constants.FRAMEWORK_STORAGE_CLEAN, Constants.FRAMEWORK_STORAGE_CLEAN_ONFIRSTINIT); configuration.put(Constants.FRAMEWORK_STORAGE, new File(tmp, "fwstorage").getAbsolutePath()); configuration.put( Constants.FRAMEWORK_SYSTEMPACKAGES_EXTRA, "org.osgi.framework.launch;version=1.4"); framework = new org.apache.felix.framework.FrameworkFactory().newFramework(configuration); framework.init(); framework.start(); BundleContext context = framework.getBundleContext(); String[] bundles = { "../cnf/repo/osgi.cmpn/osgi.cmpn-4.3.1.jar", "testdata/slf4j-simple-1.7.12.jar", "testdata/slf4j-api-1.7.12.jar", "testdata/org.apache.aries.util-1.1.0.jar", "testdata/org.apache.aries.jmx-1.1.1.jar", "generated/biz.aQute.remote.test.jmx.jar" }; for (String bundle : bundles) { String location = "reference:" + IO.getFile(bundle).toURI().toString(); Bundle b = context.installBundle(location); if (!bundle.contains("slf4j-simple")) { b.start(); } } super.setUp(); }
private static void addAllInterfaceTypes( Map<ClassDoc, Type> results, Type type, Type[] interfaceTypes, boolean raw, Configuration configuration) { for (int i = 0; i < interfaceTypes.length; i++) { Type interfaceType = interfaceTypes[i]; ClassDoc interfaceClassDoc = interfaceType.asClassDoc(); if (!(interfaceClassDoc.isPublic() || (configuration != null && isLinkable(interfaceClassDoc, configuration)))) { continue; } if (raw) interfaceType = interfaceType.asClassDoc(); results.put(interfaceClassDoc, interfaceType); List<Type> superInterfaces = getAllInterfaces(interfaceType, configuration); for (Iterator<Type> iter = superInterfaces.iterator(); iter.hasNext(); ) { Type superInterface = iter.next(); results.put(superInterface.asClassDoc(), superInterface); } } if (type instanceof ParameterizedType) findAllInterfaceTypes(results, (ParameterizedType) type, configuration); else if (((ClassDoc) type).typeParameters().length == 0) findAllInterfaceTypes(results, (ClassDoc) type, raw, configuration); else findAllInterfaceTypes(results, (ClassDoc) type, true, configuration); }
// Store the invariant for later printing. Ignore duplicate // invariants at the same program point. private static boolean store_invariant( String predicate, String index, HashedConsequent consequent, String pptname) { if (!pptname_to_conditions.containsKey(pptname)) { pptname_to_conditions.put(pptname, new HashMap<String, Map<String, HashedConsequent>>()); } Map<String, Map<String, HashedConsequent>> cluster_to_conditions = pptname_to_conditions.get(pptname); if (!cluster_to_conditions.containsKey(predicate)) { cluster_to_conditions.put(predicate, new HashMap<String, HashedConsequent>()); } Map<String, HashedConsequent> conditions = cluster_to_conditions.get(predicate); if (conditions.containsKey(index)) { HashedConsequent old = conditions.get(index); if (old.fakeFor != null && consequent.fakeFor == null) { // We already saw (say) "x != y", but we're "x == y", so replace it. conditions.remove(index); conditions.remove(old.fakeFor); conditions.put(index, consequent); return true; } return false; } else { conditions.put(index, consequent); return true; } }
public static void toCRAWDAD(LinkTrace links, OutputStream out, double timeMul) throws IOException { StatefulReader<LinkEvent, Link> linkReader = links.getReader(); BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(out)); Map<Link, Long> activeContacts = new AdjacencyMap.Links<Long>(); linkReader.seek(links.minTime()); for (Link l : linkReader.referenceState()) activeContacts.put(l, links.minTime()); while (linkReader.hasNext()) { for (LinkEvent lev : linkReader.next()) { Link l = lev.link(); if (lev.isUp()) { activeContacts.put(l, linkReader.time()); } else { double b = activeContacts.get(l) * timeMul; double e = linkReader.time() * timeMul; activeContacts.remove(l); bw.write(l.id1() + "\t" + l.id2() + "\t" + b + "\t" + e + "\n"); } } } linkReader.close(); bw.close(); }
/** gets map for all languages */ public Map<String, String> getCaptionToQueryMap(Collection<Document> docs) { // identify all the langs in the docs, and the corresponding lexicons Set<String> languages = IndexUtils.allLanguagesInDocs(docs); Set<Lexicon1Lang> lexicons = new LinkedHashSet<Lexicon1Lang>(); for (String lang : languages) { Lexicon1Lang lex = languageToLexicon.get(lang); if (lex != null) lexicons.add(lex); // this lexicon doesn't know about this language else log.warn("Warning: no support for " + lang + " in lexicon " + name); } Map<String, String> result = new LinkedHashMap<String, String>(); // aggregate results for each lang into result for (Lexicon1Lang lex : lexicons) { Map<String, String> resultsForThisLang = lex.captionToExpandedQuery; for (String caption : resultsForThisLang.keySet()) { String queryThisLang = resultsForThisLang.get(caption); String query = result.get(caption); // if caption doesn't exist already, create a new entry, or else add to the existing set of // docs that match this caption if (query == null) result.put(caption, queryThisLang); else result.put(caption, query + "|" + queryThisLang); } } return result; }
/** Read input to test and break down into blocks. See parser-tests/readme.txt */ private Map readBlocks(Reader input) throws IOException { Map blocks = new HashMap(); LineNumberReader reader = new LineNumberReader(input); String line; String blockName = null; StringBuffer blockContents = null; while ((line = reader.readLine()) != null) { if (line.startsWith("~~~ ") && line.endsWith(" ~~~")) { if (blockName != null) { blocks.put(blockName, blockContents.toString()); } blockName = line.substring(4, line.length() - 4); blockContents = new StringBuffer(); } else { if (blockName != null) { blockContents.append(line); blockContents.append('\n'); } } } if (blockName != null) { blocks.put(blockName, blockContents.toString()); } return blocks; }
/** * Reads image meta data. * * @param oimage * @return */ public static Map<String, String> readImageData(IIOImage oimage) { Map<String, String> dict = new HashMap<String, String>(); IIOMetadata imageMetadata = oimage.getMetadata(); if (imageMetadata != null) { IIOMetadataNode dimNode = (IIOMetadataNode) imageMetadata.getAsTree("javax_imageio_1.0"); NodeList nodes = dimNode.getElementsByTagName("HorizontalPixelSize"); int dpiX; if (nodes.getLength() > 0) { float dpcWidth = Float.parseFloat(nodes.item(0).getAttributes().item(0).getNodeValue()); dpiX = (int) Math.round(25.4f / dpcWidth); } else { dpiX = Toolkit.getDefaultToolkit().getScreenResolution(); } dict.put("dpiX", String.valueOf(dpiX)); nodes = dimNode.getElementsByTagName("VerticalPixelSize"); int dpiY; if (nodes.getLength() > 0) { float dpcHeight = Float.parseFloat(nodes.item(0).getAttributes().item(0).getNodeValue()); dpiY = (int) Math.round(25.4f / dpcHeight); } else { dpiY = Toolkit.getDefaultToolkit().getScreenResolution(); } dict.put("dpiY", String.valueOf(dpiY)); } return dict; }
void installDefaultAccessScopes() { decodingAccessScope.put(FIELD_SCOPE, PUBLIC); decodingAccessScope.put(PROPERTY_SCOPE, PUBLIC); decodingAccessScope.put(CONSTRUCTOR_SCOPE, PUBLIC); encodingAccessScope.put(FIELD_SCOPE, PUBLIC); encodingAccessScope.put(PROPERTY_SCOPE, PUBLIC); }
public static Map<String, Object> readPythonSettings(File file) throws IOException { String all = readStringFully(new FileInputStream(file)); Map<String, Object> map = new TreeMap<String, Object>(); for (String line : all.split("\n")) { line = line.trim(); if (line.length() == 0) continue; String[] pcs = line.split("="); if (pcs.length != 2) continue; String name = pcs[0].trim(); String value = pcs[1].trim(); if (value.startsWith("\"")) { map.put(name, value.substring(1, value.length() - 1)); } else { map.put(name, Long.parseLong(value)); } } return map; }
/** * Returns the existing git repositories for the given file path, following the given traversal * rule. * * @param path expected format /file/{Workspace}/{projectName}[/{path}] * @return a map of all git repositories found, or <code>null</code> if the provided path format * doesn't match the expected format. * @throws CoreException */ public static Map<IPath, File> getGitDirs(IPath path, Traverse traverse) throws CoreException { IPath p = path.removeFirstSegments(1); // remove /file IFileStore fileStore = NewFileServlet.getFileStore(null, p); if (fileStore == null) return null; Map<IPath, File> result = new HashMap<IPath, File>(); File file = fileStore.toLocalFile(EFS.NONE, null); // jgit can only handle a local file if (file == null) return result; switch (traverse) { case CURRENT: if (RepositoryCache.FileKey.isGitRepository(file, FS.DETECTED)) { result.put(new Path(""), file); // $NON-NLS-1$ } else if (RepositoryCache.FileKey.isGitRepository( new File(file, Constants.DOT_GIT), FS.DETECTED)) { result.put(new Path(""), new File(file, Constants.DOT_GIT)); // $NON-NLS-1$ } break; case GO_UP: getGitDirsInParents(file, result); break; case GO_DOWN: getGitDirsInChildren(file, p, result); break; } return result; }
public List getUserListAT() { List<Map> list = new ArrayList<Map>(); String[][] data = { {"3537255778", "Alex Chen"}, {"2110989338", "Brian Wang"}, {"3537640807", "David Hsieh"}, {"5764816553", "James Yu"}, {"3756404948", "K.C."}, {"2110994764", "Neil Weinstock"}, {"6797798390", "Owen Chen"}, {"3831206627", "Randy Chen"}, {"6312460903", "Tony Shen"}, {"2110993498", "Yee Liaw"} }; for (int i = 0; i < data.length; i++) { Map map = new HashMap(); String userRef = data[i][0]; String userName = data[i][1]; map.put("userObjectId", userRef); map.put("userName", userName); list.add(map); } return list; }
private void processLog(Object obj, long time, String type) { Map<String, Object> logItem = new HashMap<String, Object>(); logItem.put("Time", time); logItem.put("logMsg", obj); logItem.put("msgType", type); this.processLog.add(logItem); }
BuildSession( UUID sessionId, Channel channel, CmdlineRemoteProto.Message.ControllerMessage.ParametersMessage params, @Nullable CmdlineRemoteProto.Message.ControllerMessage.FSEvent delta) { mySessionId = sessionId; myChannel = channel; // globals Map<String, String> pathVars = new HashMap<String, String>(); final CmdlineRemoteProto.Message.ControllerMessage.GlobalSettings globals = params.getGlobalSettings(); for (CmdlineRemoteProto.Message.KeyValuePair variable : globals.getPathVariableList()) { pathVars.put(variable.getKey(), variable.getValue()); } // session params myProjectPath = FileUtil.toCanonicalPath(params.getProjectId()); String globalOptionsPath = FileUtil.toCanonicalPath(globals.getGlobalOptionsPath()); myBuildType = convertCompileType(params.getBuildType()); List<CmdlineRemoteProto.Message.ControllerMessage.ParametersMessage.TargetTypeBuildScope> scopes = params.getScopeList(); List<String> filePaths = params.getFilePathList(); Map<String, String> builderParams = new HashMap<String, String>(); for (CmdlineRemoteProto.Message.KeyValuePair pair : params.getBuilderParameterList()) { builderParams.put(pair.getKey(), pair.getValue()); } myInitialFSDelta = delta; JpsModelLoaderImpl loader = new JpsModelLoaderImpl(myProjectPath, globalOptionsPath, pathVars, null); myBuildRunner = new BuildRunner(loader, scopes, filePaths, builderParams); }
/** * @param ctx Kernal context. * @param cfg Ignite configuration. * @param providers Plugin providers. */ @SuppressWarnings("TypeMayBeWeakened") public IgnitePluginProcessor( GridKernalContext ctx, IgniteConfiguration cfg, List<PluginProvider> providers) { super(ctx); ExtensionRegistryImpl registry = new ExtensionRegistryImpl(); for (PluginProvider provider : providers) { GridPluginContext pluginCtx = new GridPluginContext(ctx, cfg); if (F.isEmpty(provider.name())) throw new IgniteException("Plugin name can not be empty."); if (plugins.containsKey(provider.name())) throw new IgniteException("Duplicated plugin name: " + provider.name()); plugins.put(provider.name(), provider); pluginCtxMap.put(provider, pluginCtx); provider.initExtensions(pluginCtx, registry); if (provider.plugin() == null) throw new IgniteException("Plugin is null."); } extensions = registry.createExtensionMap(); }
private void outputEntry(TraceEntry te) { ThreadData td = te.getThread(); if (td == null) return; // System.err.println("TRACE: " + te); BdynCallback cb = bdyn_factory.getCallback(te.getEntryLocation()); if (cb == null) return; if (cb.getCallbackType() == CallbackType.CONSTRUCTOR) { OutputTask ot = td.getCurrentTransaction(); if (ot == null) return; if (ot.isMainTask() && !BdynFactory.getOptions().useMainTask()) return; int i0 = te.getObject1(); if (i0 != 0) { // System.err.println("ASSOC TASK " + i0 + " " + te.getObject2() + " " + // ot.getTaskRoot().getDisplayName()); OutputTask ot1 = object_tasks.get(i0); if (ot1 == null) object_tasks.put(i0, ot); else if (ot1 != dummy_task && ot1 != ot) object_tasks.put(i0, dummy_task); } return; } td.beginTask(te); end_time = Math.max(end_time, te.getTime()); }
static { try { Map<String, Method> orderedMethods = new TreeMap<String, Method>(); for (Method m : MBeanServerConnection.class.getDeclaredMethods()) { orderedMethods.put(m.toGenericString(), m); } Method[] methods = orderedMethods.values().toArray(new Method[orderedMethods.size()]); Map<String, Method> asynchMethods = new TreeMap<String, Method>(); for (Method asynchMethod : AsynchJMXResponseListener.class.getDeclaredMethods()) { asynchMethods.put(asynchMethod.getName(), asynchMethod); } Map<Method, Byte> m2k = new HashMap<Method, Byte>(methods.length); Map<Byte, Method> k2m = new HashMap<Byte, Method>(methods.length); Map<Byte, Method> k2am = new HashMap<Byte, Method>(methods.length); for (int i = 0; i < methods.length; i++) { m2k.put(methods[i], (byte) i); k2m.put((byte) i, methods[i]); Method asynchMethod = asynchMethods.get(methods[i].getName() + "Response"); if (asynchMethod == null) throw new RuntimeException( "Failed to find asynch handler for [" + methods[i].toGenericString() + "]", new Throwable()); k2am.put((byte) i, asynchMethod); } methodToKey = Collections.unmodifiableMap(m2k); keyToMethod = Collections.unmodifiableMap(k2m); keyToAsynchMethod = Collections.unmodifiableMap(k2am); } catch (Exception ex) { throw new RuntimeException(ex); } }
public InputStream invokeClientInbound(HttpURLConnection httpConnection) throws IOException { // XXX fill this in... Map<String, DataHandler> attachments = new HashMap<String, DataHandler>(); Map<String, Object> httpProperties = new HashMap<String, Object>(); httpProperties.put(HTTP_RESPONSE_CODE, Integer.valueOf(httpConnection.getResponseCode())); httpProperties.put(HTTP_RESPONSE_HEADERS, httpConnection.getHeaderFields()); prepare(httpProperties, /*request=*/ false); if (!invokeInbound(httpConnection.getInputStream(), attachments)) { if (getProtocolException() != null) { reverseDirection(); invokeInboundFaultHandlers(); if (getRuntimeException() != null) throw getRuntimeException(); } else if (getRuntimeException() != null) { closeClient(); throw getRuntimeException(); } } // XXX closeClient(); return finish(); }
public static Map<String, String> sendPostRequest( String url, JSONObject params, Map<String, String> headers) throws IDPTokenManagerException { HttpPost httpPost = new HttpPost(url); HttpClient httpClient = getCertifiedHttpClient(); Map<String, String> responseParams = new HashMap<String, String>(); if (params != null) { try { httpPost.setEntity(new StringEntity(params.toString())); } catch (UnsupportedEncodingException e) { throw new IDPTokenManagerException("Invalid encoding type.", e); } } HttpPost httpPostWithHeaders = (HttpPost) buildHeaders(httpPost, headers, HTTP_METHODS.POST); try { HttpResponse response = httpClient.execute(httpPostWithHeaders); String status = String.valueOf(response.getStatusLine().getStatusCode()); responseParams.put(Constants.SERVER_RESPONSE_BODY, getResponseBody(response)); responseParams.put(Constants.SERVER_RESPONSE_STATUS, status); } catch (ClientProtocolException e) { throw new IDPTokenManagerException("Invalid client protocol.", e); } catch (IOException e) { responseParams.put(Constants.SERVER_RESPONSE_BODY, "Internal Server Error"); responseParams.put(Constants.SERVER_RESPONSE_STATUS, Constants.INTERNAL_SERVER_ERROR); throw new IDPTokenManagerException("Server connectivity failure.", e); } return responseParams; }