private org.exist.source.Source buildQuerySource(String query, Object[] params, String cookie) { Map<String, String> combinedMap = namespaceBindings.getCombinedMap(); for (Map.Entry<String, Document> entry : moduleMap.entrySet()) { combinedMap.put("<module> " + entry.getKey(), entry.getValue().path()); } for (Map.Entry<QName, Object> entry : bindings.entrySet()) { combinedMap.put( "<var> " + entry.getKey(), null); // don't care about values, as long as the same vars are bound } combinedMap.put("<posvars> " + params.length, null); combinedMap.put("<cookie>", cookie); // TODO: should include statically known documents and baseURI too? return new StringSourceWithMapKey(query, combinedMap); }
private void buildXQueryStaticContext(XQueryContext context, boolean importModules) throws XPathException { context.declareNamespaces(namespaceBindings.getCombinedMap()); for (Map.Entry<String, Document> entry : moduleMap.entrySet()) { context.importModule(entry.getKey(), null, "xmldb:exist:///db" + entry.getValue().path()); } }
private void buildXQueryDynamicContext( XQueryContext context, Object[] params, MutableDocumentSet docsToLock, boolean bindVariables) throws XPathException { context.setBackwardsCompatibility(false); context.setStaticallyKnownDocuments(docs); context.setBaseURI(baseUri == null ? new AnyURIValue("/db") : baseUri); if (bindVariables) { for (Map.Entry<QName, Object> entry : bindings.entrySet()) { context.declareVariable( new org.exist.dom.QName( entry.getKey().getLocalPart(), entry.getKey().getNamespaceURI(), entry.getKey().getPrefix()), convertValue(entry.getValue())); } if (params != null) for (int i = 0; i < params.length; i++) { Object convertedValue = convertValue(params[i]); if (docsToLock != null && convertedValue instanceof Sequence) { docsToLock.addAll(((Sequence) convertedValue).getDocumentSet()); } context.declareVariable("_" + (i + 1), convertedValue); } } }
private void putMap(String name, Map m) { _put(OBJECT, name); final int sizePos = _buf.getPosition(); _buf.writeInt(0); for (Map.Entry entry : (Set<Map.Entry>) m.entrySet()) _putObjectField(entry.getKey().toString(), entry.getValue()); _buf.write(EOO); _buf.writeInt(sizePos, _buf.getPosition() - sizePos); }
public static void main(String[] args) { long start = System.currentTimeMillis(); Scanner input = new Scanner(System.in); int numberOfTestCases = input.nextInt(); ArrayList<Integer> order = new ArrayList<Integer>(numberOfTestCases); int previousKey = -1; int previousValue = 0; int cycleNumber = 0; Map<Integer, Integer> testCases = new TreeMap<Integer, Integer>(); for (int i = 0; i < numberOfTestCases; i++) { int numberOfCycles = input.nextInt(); testCases.put(numberOfCycles, 1); order.add(numberOfCycles); } for (Map.Entry<Integer, Integer> entry : testCases.entrySet()) { int numberOfCycles; int initialHeight; if (previousKey == -1) { numberOfCycles = entry.getKey(); initialHeight = entry.getValue(); } else { numberOfCycles = entry.getKey() - previousKey; initialHeight = previousValue; } for (int i = 0; i < numberOfCycles; i++) { if (cycleNumber % 2 == 0) { initialHeight *= 2; } else { initialHeight += 1; } cycleNumber++; } entry.setValue(initialHeight); previousKey = entry.getKey(); previousValue = initialHeight; } for (Integer element : order) { System.out.println(testCases.get(element)); } long elapsed = System.currentTimeMillis() - start; System.out.println("time: " + elapsed); }
/** * Clone this query service, optionally overriding the clone's namespace and variable bindings. If * the namespace bindings override or variable bindings override is specified, then that object is * cloned and used for its respective purpose. If an override is not specified, the bindings are * cloned from the original query service. * * @param nsBindingsOverride the namespace bindings to clone, or <code>null</code> to clone from * the original * @param varBindingsOverride the variable bindings to clone, or <code>null</code> to clone from * the original * @return a clone of this query service with bindings optionally overridden */ public QueryService clone(NamespaceMap nsBindingsOverride, Map<QName, ?> varBindingsOverride) { try { QueryService that = (QueryService) super.clone(); that.namespaceBindings = nsBindingsOverride != null ? nsBindingsOverride.clone() : that.namespaceBindings.clone(); if (varBindingsOverride == null) { that.bindings = new HashMap<QName, Object>(that.bindings); } else { that.bindings = new HashMap<QName, Object>(); for (Map.Entry<QName, ?> entry : varBindingsOverride.entrySet()) { that.let(entry.getKey(), entry.getValue()); } } that.moduleMap = new TreeMap<String, Document>(moduleMap); return that; } catch (CloneNotSupportedException e) { throw new RuntimeException("unexpected exception", e); } }
static int lonelyInteger(int[] arr) { Map<Integer, Integer> occurrences = new HashMap<>(); for (int value : arr) { boolean alreadyExist = occurrences.containsKey(value); if (!alreadyExist) { occurrences.put(value, 0); } occurrences.put(value, occurrences.get(value) + 1); } int result = 0; for (java.util.Map.Entry<Integer, Integer> entry : occurrences.entrySet()) { if (entry.getValue().equals(1)) { result = entry.getKey(); } } return result; }
/** Enter a set of generated class files. */ private List<ClassSymbol> enterClassFiles(Map<String, JavaFileObject> classFiles) { ClassReader reader = ClassReader.instance(context); Names names = Names.instance(context); List<ClassSymbol> list = List.nil(); for (Map.Entry<String, JavaFileObject> entry : classFiles.entrySet()) { Name name = names.fromString(entry.getKey()); JavaFileObject file = entry.getValue(); if (file.getKind() != JavaFileObject.Kind.CLASS) throw new AssertionError(file); ClassSymbol cs; if (isPkgInfo(file, JavaFileObject.Kind.CLASS)) { Name packageName = Convert.packagePart(name); PackageSymbol p = reader.enterPackage(packageName); if (p.package_info == null) p.package_info = reader.enterClass(Convert.shortName(name), p); cs = p.package_info; if (cs.classfile == null) cs.classfile = file; } else cs = reader.enterClass(name, file); list = list.prepend(cs); } return list.reverse(); }
public static void extract_consequent(PptMap ppts) { // Retrieve Ppt objects in sorted order. // Use a custom comparator for a specific ordering Comparator<PptTopLevel> comparator = new Ppt.NameComparator(); TreeSet<PptTopLevel> ppts_sorted = new TreeSet<PptTopLevel>(comparator); ppts_sorted.addAll(ppts.asCollection()); for (PptTopLevel ppt : ppts_sorted) { extract_consequent_maybe(ppt, ppts); } PrintWriter pw = new PrintWriter(System.out, true); // All conditions at a program point. A TreeSet to enable // deterministic output. TreeSet<String> allConds = new TreeSet<String>(); for (String pptname : pptname_to_conditions.keySet()) { Map<String, Map<String, HashedConsequent>> cluster_to_conditions = pptname_to_conditions.get(pptname); for (Map.Entry</*@KeyFor("cluster_to_conditions")*/ String, Map<String, HashedConsequent>> entry : cluster_to_conditions.entrySet()) { String predicate = entry.getKey(); Map<String, HashedConsequent> conditions = entry.getValue(); StringBuffer conjunctionJava = new StringBuffer(); StringBuffer conjunctionDaikon = new StringBuffer(); StringBuffer conjunctionESC = new StringBuffer(); StringBuffer conjunctionSimplify = new StringBuffer("(AND "); int count = 0; for (Map.Entry</*@KeyFor("conditions")*/ String, HashedConsequent> entry2 : conditions.entrySet()) { count++; String condIndex = entry2.getKey(); HashedConsequent cond = entry2.getValue(); if (cond.fakeFor != null) { count--; continue; } String javaStr = cond.inv.format_using(OutputFormat.JAVA); String daikonStr = cond.inv.format_using(OutputFormat.DAIKON); String escStr = cond.inv.format_using(OutputFormat.ESCJAVA); String simplifyStr = cond.inv.format_using(OutputFormat.SIMPLIFY); allConds.add(combineDummy(condIndex, "<dummy> " + daikonStr, escStr, simplifyStr)); // allConds.add(condIndex); if (count > 0) { conjunctionJava.append(" && "); conjunctionDaikon.append(" and "); conjunctionESC.append(" && "); conjunctionSimplify.append(" "); } conjunctionJava.append(javaStr); conjunctionDaikon.append(daikonStr); conjunctionESC.append(escStr); conjunctionSimplify.append(simplifyStr); } conjunctionSimplify.append(")"); String conj = conjunctionJava.toString(); // Avoid inserting self-contradictory conditions such as "x == 1 && // x == 2", or conjunctions of only a single condition. if (count < 2 || contradict_inv_pattern.matcher(conj).find() || useless_inv_pattern_1.matcher(conj).find() || useless_inv_pattern_2.matcher(conj).find()) { // System.out.println("Suppressing: " + conj); } else { allConds.add( combineDummy( conjunctionJava.toString(), conjunctionDaikon.toString(), conjunctionESC.toString(), conjunctionSimplify.toString())); } } if (allConds.size() > 0) { pw.println(); pw.println("PPT_NAME " + pptname); for (String s : allConds) { pw.println(s); } } allConds.clear(); } pw.flush(); }
private void discoverAndRunProcs( Context context, Set<TypeElement> annotationsPresent, List<ClassSymbol> topLevelClasses, List<PackageSymbol> packageInfoFiles) { Map<String, TypeElement> unmatchedAnnotations = new HashMap<String, TypeElement>(annotationsPresent.size()); for (TypeElement a : annotationsPresent) { unmatchedAnnotations.put(a.getQualifiedName().toString(), a); } // Give "*" processors a chance to match if (unmatchedAnnotations.size() == 0) unmatchedAnnotations.put("", null); DiscoveredProcessors.ProcessorStateIterator psi = discoveredProcs.iterator(); // TODO: Create proper argument values; need past round // information to fill in this constructor. Note that the 1 // st round of processing could be the last round if there // were parse errors on the initial source files; however, we // are not doing processing in that case. Set<Element> rootElements = new LinkedHashSet<Element>(); rootElements.addAll(topLevelClasses); rootElements.addAll(packageInfoFiles); rootElements = Collections.unmodifiableSet(rootElements); RoundEnvironment renv = new JavacRoundEnvironment(false, false, rootElements, JavacProcessingEnvironment.this); while (unmatchedAnnotations.size() > 0 && psi.hasNext()) { ProcessorState ps = psi.next(); Set<String> matchedNames = new HashSet<String>(); Set<TypeElement> typeElements = new LinkedHashSet<TypeElement>(); for (Map.Entry<String, TypeElement> entry : unmatchedAnnotations.entrySet()) { String unmatchedAnnotationName = entry.getKey(); if (ps.annotationSupported(unmatchedAnnotationName)) { matchedNames.add(unmatchedAnnotationName); TypeElement te = entry.getValue(); if (te != null) typeElements.add(te); } } if (matchedNames.size() > 0 || ps.contributed) { boolean processingResult = callProcessor(ps.processor, typeElements, renv); ps.contributed = true; ps.removeSupportedOptions(unmatchedProcessorOptions); if (printProcessorInfo || verbose) { log.printNoteLines( "x.print.processor.info", ps.processor.getClass().getName(), matchedNames.toString(), processingResult); } if (processingResult) { unmatchedAnnotations.keySet().removeAll(matchedNames); } } } unmatchedAnnotations.remove(""); if (lint && unmatchedAnnotations.size() > 0) { // Remove annotations processed by javac unmatchedAnnotations.keySet().removeAll(platformAnnotations); if (unmatchedAnnotations.size() > 0) { log = Log.instance(context); log.warning("proc.annotations.without.processors", unmatchedAnnotations.keySet()); } } // Run contributing processors that haven't run yet psi.runContributingProcs(renv); // Debugging if (options.isSet("displayFilerState")) filer.displayState(); }
/** * Gets the <tt>contactDetails</tt> to be set on a <tt>SourceContact</tt>. * * @param entry <tt>GoogleContactsEntry</tt> * @return the <tt>contactDetails</tt> to be set on a <tt>SourceContact</tt> */ private List<ContactDetail> getContactDetails(GoogleContactsEntry entry) { List<ContactDetail> ret = new LinkedList<ContactDetail>(); List<String> homeMails = entry.getHomeMails(); List<String> workMails = entry.getWorkMails(); List<String> mobilePhones = entry.getMobilePhones(); List<String> homePhones = entry.getHomePhones(); List<String> workPhones = entry.getWorkPhones(); Map<String, GoogleContactsEntry.IMProtocol> ims = entry.getIMAddresses(); ContactDetail detail = null; for (String mail : homeMails) { List<Class<? extends OperationSet>> supportedOpSets = new ArrayList<Class<? extends OperationSet>>(1); // can be added as contacts supportedOpSets.add(OperationSetPersistentPresence.class); detail = new ContactDetail( mail, ContactDetail.Category.Email, new ContactDetail.SubCategory[] {ContactDetail.SubCategory.Home}); detail.setSupportedOpSets(supportedOpSets); ret.add(detail); } for (String mail : workMails) { List<Class<? extends OperationSet>> supportedOpSets = new ArrayList<Class<? extends OperationSet>>(1); // can be added as contacts supportedOpSets.add(OperationSetPersistentPresence.class); detail = new ContactDetail( mail, ContactDetail.Category.Email, new ContactDetail.SubCategory[] {ContactDetail.SubCategory.Work}); detail.setSupportedOpSets(supportedOpSets); ret.add(detail); } for (String homePhone : homePhones) { List<Class<? extends OperationSet>> supportedOpSets = new ArrayList<Class<? extends OperationSet>>(2); supportedOpSets.add(OperationSetBasicTelephony.class); // can be added as contacts supportedOpSets.add(OperationSetPersistentPresence.class); homePhone = PhoneNumberI18nService.normalize(homePhone); detail = new ContactDetail( homePhone, ContactDetail.Category.Phone, new ContactDetail.SubCategory[] {ContactDetail.SubCategory.Home}); detail.setSupportedOpSets(supportedOpSets); ret.add(detail); } for (String workPhone : workPhones) { List<Class<? extends OperationSet>> supportedOpSets = new ArrayList<Class<? extends OperationSet>>(2); supportedOpSets.add(OperationSetBasicTelephony.class); // can be added as contacts supportedOpSets.add(OperationSetPersistentPresence.class); workPhone = PhoneNumberI18nService.normalize(workPhone); detail = new ContactDetail( workPhone, ContactDetail.Category.Phone, new ContactDetail.SubCategory[] {ContactDetail.SubCategory.Work}); detail.setSupportedOpSets(supportedOpSets); ret.add(detail); } for (String mobilePhone : mobilePhones) { List<Class<? extends OperationSet>> supportedOpSets = new ArrayList<Class<? extends OperationSet>>(2); supportedOpSets.add(OperationSetBasicTelephony.class); // can be added as contacts supportedOpSets.add(OperationSetPersistentPresence.class); mobilePhone = PhoneNumberI18nService.normalize(mobilePhone); detail = new ContactDetail( mobilePhone, ContactDetail.Category.Phone, new ContactDetail.SubCategory[] {ContactDetail.SubCategory.Mobile}); detail.setSupportedOpSets(supportedOpSets); ret.add(detail); } for (Map.Entry<String, GoogleContactsEntry.IMProtocol> im : ims.entrySet()) { if (im.getValue() != GoogleContactsEntry.IMProtocol.OTHER) { ContactDetail.SubCategory imSubCat; switch (im.getValue()) { case AIM: imSubCat = ContactDetail.SubCategory.AIM; break; case ICQ: imSubCat = ContactDetail.SubCategory.ICQ; break; case YAHOO: imSubCat = ContactDetail.SubCategory.Yahoo; break; case JABBER: imSubCat = ContactDetail.SubCategory.Jabber; break; case MSN: imSubCat = ContactDetail.SubCategory.MSN; break; case GOOGLETALK: imSubCat = ContactDetail.SubCategory.GoogleTalk; break; default: imSubCat = null; break; } detail = new ContactDetail( im.getKey(), ContactDetail.Category.InstantMessaging, new ContactDetail.SubCategory[] {imSubCat}); setIMCapabilities(detail, im.getValue()); // can be added as contacts detail.getSupportedOperationSets().add(OperationSetPersistentPresence.class); ret.add(detail); } } return ret; }