/** Returns whether this JDBC data source can implement a given aggregate function. */ private static boolean canImplement(SqlAggFunction aggregation, SqlDialect sqlDialect) { switch (sqlDialect.getDatabaseProduct()) { case MYSQL: return MYSQL_AGG_FUNCS.contains(aggregation); default: return AGG_FUNCS.contains(aggregation); } }
/** * Get similarity of X submission to Y submission. * * @param xSubmission Submission to get similarities for * @param ySubmission Submission to get similarities relative to * @return Similarities of xSubmission to ySubmission * @throws NoSuchSubmissionException Thrown if either xSubmission or ySubmission are not present * in the matrix */ public AlgorithmResults getEntryFor(Submission xSubmission, Submission ySubmission) throws NoSuchSubmissionException { checkNotNull(xSubmission); checkNotNull(ySubmission); if (!xSubmissions.contains(xSubmission)) { throw new NoSuchSubmissionException( "X Submission with name " + xSubmission.getName() + " not found in similarity matrix!"); } else if (!ySubmissions.contains(ySubmission)) { throw new NoSuchSubmissionException( "Y Submission with name " + ySubmission.getName() + " not found in similarity matrix!"); } int xIndex = xSubmissions.indexOf(xSubmission); int yIndex = ySubmissions.indexOf(ySubmission); return entries[xIndex][yIndex]; }
/** * Gets the context of this event within a stream * * @return the context in struct form */ public StructDefinition getContext() { /* Most common case so far */ if (fStreamContext == null) { return fEventContext; } /* streamContext is not null, but the context of the event is null */ if (fEventContext == null) { return fStreamContext; } // TODO: cache if this is a performance issue /* The stream context and event context are assigned. */ StructDeclaration mergedDeclaration = new StructDeclaration(1); Builder<String> builder = ImmutableList.<String>builder(); List<Definition> fieldValues = new ArrayList<>(); /* Add fields from the stream */ for (String fieldName : fStreamContext.getFieldNames()) { Definition definition = fStreamContext.getDefinition(fieldName); mergedDeclaration.addField(fieldName, definition.getDeclaration()); builder.add(fieldName); fieldValues.add(definition); } ImmutableList<String> fieldNames = builder.build(); /* * Add fields from the event context, overwrite the stream ones if * needed. */ for (String fieldName : fEventContext.getFieldNames()) { Definition definition = fEventContext.getDefinition(fieldName); mergedDeclaration.addField(fieldName, definition.getDeclaration()); if (fieldNames.contains(fieldName)) { fieldValues.set((fieldNames.indexOf(fieldName)), definition); } else { builder.add(fieldName); fieldValues.add(definition); } } fieldNames = builder.build(); StructDefinition mergedContext = new StructDefinition( mergedDeclaration, this, "context", //$NON-NLS-1$ fieldNames, fieldValues.toArray(new Definition[fieldValues.size()])); return mergedContext; }
private ReferenceInfo newInfo( ColumnIdent column, DataType type, ColumnPolicy columnPolicy, ReferenceInfo.IndexType indexType) { RowGranularity granularity = RowGranularity.DOC; if (partitionedBy.contains(column)) { granularity = RowGranularity.PARTITION; } return new ReferenceInfo( new ReferenceIdent(ident, column), granularity, type, columnPolicy, indexType); }
private void addToolchainFlags(List<String> argv) { boolean fullyStatic = (linkStaticness == LinkStaticness.FULLY_STATIC); boolean mostlyStatic = (linkStaticness == LinkStaticness.MOSTLY_STATIC); boolean sharedLinkopts = linkTargetType == LinkTargetType.DYNAMIC_LIBRARY || linkopts.contains("-shared") || cppConfiguration.getLinkOptions().contains("-shared"); /* * For backwards compatibility, linkopts come _after_ inputFiles. * This is needed to allow linkopts to contain libraries and * positional library-related options such as * -Wl,--begin-group -lfoo -lbar -Wl,--end-group * or * -Wl,--as-needed -lfoo -Wl,--no-as-needed * * As for the relative order of the three different flavours of linkopts * (global defaults, per-target linkopts, and command-line linkopts), * we have no idea what the right order should be, or if anyone cares. */ argv.addAll(linkopts); // Extra toolchain link options based on the output's link staticness. if (fullyStatic) { argv.addAll(cppConfiguration.getFullyStaticLinkOptions(features, sharedLinkopts)); } else if (mostlyStatic) { argv.addAll(cppConfiguration.getMostlyStaticLinkOptions(features, sharedLinkopts)); } else { argv.addAll(cppConfiguration.getDynamicLinkOptions(features, sharedLinkopts)); } // Extra test-specific link options. if (useTestOnlyFlags) { argv.addAll(cppConfiguration.getTestOnlyLinkOptions()); } argv.addAll(cppConfiguration.getLinkOptions()); // -pie is not compatible with shared and should be // removed when the latter is part of the link command. Should we need to further // distinguish between shared libraries and executables, we could add additional // command line / CROSSTOOL flags that distinguish them. But as long as this is // the only relevant use case we're just special-casing it here. if (linkTargetType == LinkTargetType.DYNAMIC_LIBRARY) { Iterables.removeIf(argv, Predicates.equalTo("-pie")); } // Fission mode: debug info is in .dwo files instead of .o files. Inform the linker of this. if (!linkTargetType.isStaticLibraryLink() && cppConfiguration.useFission()) { argv.add("-Wl,--gdb-index"); } }
public boolean isTypeVariableInScope(String tvar) { if (typeParameters != null && typeParameters.contains(tvar)) { return true; } // We don't look at this.nominalType, b/c if this function is a generic // constructor, then typeParameters contains the relevant type variables. if (receiverType != null && receiverType.isUninstantiatedGenericType()) { RawNominalType rawType = receiverType.getRawNominalType(); if (rawType.getTypeParameters().contains(tvar)) { return true; } } return false; }
private void add( ColumnIdent column, DataType type, ColumnPolicy columnPolicy, ReferenceInfo.IndexType indexType, boolean partitioned) { ReferenceInfo info = newInfo(column, type, columnPolicy, indexType); // don't add it if there is a partitioned equivalent of this column if (partitioned || !(partitionedBy != null && partitionedBy.contains(column))) { if (info.ident().isColumn()) { columnsBuilder.add(info); } referencesBuilder.put(info.ident().columnIdent(), info); } if (partitioned) { partitionedByColumnsBuilder.add(info); } }
public static Map<String, BeanProperty> getNotNullValues( Class<? extends AbstractEntity> entityClass, AbstractDto dto) { try { List<String> entityFields = new ArrayList<String>(); Class beanClass = getOriginalClassFromJavassist(entityClass); for (Field fd : beanClass.getDeclaredFields()) { entityFields.add(fd.getName()); } HashMap<String, BeanProperty> mp = new HashMap<String, BeanProperty>(); Field[] fds = getOriginalClassFromJavassist(dto).getDeclaredFields(); for (Field fd : fds) { fd.setAccessible(true); if (!invalids.contains(fd.getName())) { Object value = Property.getPropertyValue(dto, fd.getName()); if (value != null) { System.out.println(fd.getName() + "|" + fd.getType() + "|" + value); if (fd.isAnnotationPresent(PropertyMap.class)) { String entityPropName = fd.getAnnotation(PropertyMap.class).propertyName(); if (entityFields.contains(entityPropName)) { mp.put(fd.getName(), new BeanProperty(entityPropName, fd.getType(), value)); } } else { if (entityFields.contains(fd.getName())) { mp.put(fd.getName(), new BeanProperty(fd.getName(), fd.getType(), value)); } } } } } return mp; } catch (Throwable e) { e.printStackTrace(); return null; } }
// merge the optionally existing xmlDocument with a lower priority xml file. private Optional<XmlDocument> merge( Optional<XmlDocument> xmlDocument, LoadedManifestInfo lowerPriorityDocument, MergingReport.Builder mergingReportBuilder) throws MergeFailureException { MergingReport.Result validationResult = PreValidator.validate(mergingReportBuilder, lowerPriorityDocument.getXmlDocument()); if (validationResult == MergingReport.Result.ERROR) { mergingReportBuilder.addMessage( lowerPriorityDocument.getXmlDocument().getSourceLocation(), 0, 0, MergingReport.Record.Severity.ERROR, "Validation failed, exiting"); return Optional.absent(); } Optional<XmlDocument> result; if (xmlDocument.isPresent()) { result = xmlDocument.get().merge(lowerPriorityDocument.getXmlDocument(), mergingReportBuilder); } else { mergingReportBuilder .getActionRecorder() .recordDefaultNodeAction(lowerPriorityDocument.getXmlDocument().getRootNode()); result = Optional.of(lowerPriorityDocument.getXmlDocument()); } // if requested, dump each intermediary merging stage into the report. if (mOptionalFeatures.contains(Invoker.Feature.KEEP_INTERMEDIARY_STAGES) && result.isPresent()) { mergingReportBuilder.addMergingStage(result.get().prettyPrint()); } return result; }
private void generateSingleMLBytecodeCompilation( Map<Path, ImmutableSortedSet<BuildRule>> sourceToRule, ImmutableList.Builder<SourcePath> cmoFiles, Path mlSource, ImmutableMap<Path, ImmutableList<Path>> sources, ImmutableList<Path> cycleDetector) { ImmutableList<Path> newCycleDetector = ImmutableList.<Path>builder().addAll(cycleDetector).add(mlSource).build(); if (cycleDetector.contains(mlSource)) { throw new HumanReadableException( "Dependency cycle detected: %s", Joiner.on(" -> ").join(newCycleDetector)); } if (sourceToRule.containsKey(mlSource)) { return; } ImmutableSortedSet.Builder<BuildRule> depsBuilder = ImmutableSortedSet.naturalOrder(); if (sources.containsKey(mlSource)) { for (Path dep : checkNotNull(sources.get(mlSource))) { generateSingleMLBytecodeCompilation(sourceToRule, cmoFiles, dep, sources, newCycleDetector); depsBuilder.addAll(checkNotNull(sourceToRule.get(dep))); } } ImmutableSortedSet<BuildRule> deps = depsBuilder.build(); String name = mlSource.toFile().getName(); BuildTarget buildTarget = createMLBytecodeCompileBuildTarget(params.getBuildTarget(), name); BuildRuleParams compileParams = params.copyWithChanges( buildTarget, Suppliers.ofInstance( ImmutableSortedSet.<BuildRule>naturalOrder() .addAll(params.getDeclaredDeps().get()) .addAll(deps) .addAll(ocamlContext.getBytecodeCompileDeps()) .build()), params.getExtraDeps()); String outputFileName = getMLBytecodeOutputName(name); Path outputPath = ocamlContext.getCompileBytecodeOutputDir().resolve(outputFileName); final ImmutableList<String> compileFlags = getCompileFlags(/* isBytecode */ true, /* excludeDeps */ false); BuildRule compileBytecode = new OCamlMLCompile( compileParams, pathResolver, new OCamlMLCompileStep.Args( cCompiler.getEnvironment(pathResolver), cCompiler.getCommandPrefix(pathResolver), ocamlContext.getOcamlBytecodeCompiler().get(), outputPath, mlSource, compileFlags)); resolver.addToIndex(compileBytecode); sourceToRule.put( mlSource, ImmutableSortedSet.<BuildRule>naturalOrder().add(compileBytecode).addAll(deps).build()); if (!outputFileName.endsWith(OCamlCompilables.OCAML_CMI)) { cmoFiles.add(new BuildTargetSourcePath(compileBytecode.getBuildTarget())); } }
@Override public boolean contains(@Nullable Object object) { return forwardList.contains(object); }
/** * Perform high level ordering of files merging and delegates actual merging to {@link * XmlDocument#merge(XmlDocument, com.android.manifmerger.MergingReport.Builder)} * * @return the merging activity report. * @throws MergeFailureException if the merging cannot be completed (for instance, if xml files * cannot be loaded). */ private MergingReport merge() throws MergeFailureException { // initiate a new merging report MergingReport.Builder mergingReportBuilder = new MergingReport.Builder(mLogger); SelectorResolver selectors = new SelectorResolver(); // load all the libraries xml files up front to have a list of all possible node:selector // values. List<LoadedManifestInfo> loadedLibraryDocuments = loadLibraries(selectors, mergingReportBuilder); // load the main manifest file to do some checking along the way. LoadedManifestInfo loadedMainManifestInfo = load( new ManifestInfo( mManifestFile.getName(), mManifestFile, XmlDocument.Type.MAIN, Optional.<String>absent() /* mainManifestPackageName */), selectors, mergingReportBuilder); // first do we have a package declaration in the main manifest ? Optional<XmlAttribute> mainPackageAttribute = loadedMainManifestInfo.getXmlDocument().getPackage(); if (!mainPackageAttribute.isPresent()) { mergingReportBuilder.addMessage( loadedMainManifestInfo.getXmlDocument().getSourceLocation(), 0, 0, MergingReport.Record.Severity.ERROR, String.format( "Main AndroidManifest.xml at %1$s manifest:package attribute " + "is not declared", loadedMainManifestInfo.getXmlDocument().getSourceLocation().print(true))); return mergingReportBuilder.build(); } // check for placeholders presence. Map<String, Object> finalPlaceHolderValues = mPlaceHolderValues; if (!mPlaceHolderValues.containsKey(APPLICATION_ID)) { finalPlaceHolderValues = ImmutableMap.<String, Object>builder() .putAll(mPlaceHolderValues) .put(PACKAGE_NAME, mainPackageAttribute.get().getValue()) .put(APPLICATION_ID, mainPackageAttribute.get().getValue()) .build(); } // perform system property injection performSystemPropertiesInjection(mergingReportBuilder, loadedMainManifestInfo.getXmlDocument()); // force the re-parsing of the xml as elements may have been added through system // property injection. loadedMainManifestInfo = new LoadedManifestInfo( loadedMainManifestInfo, loadedMainManifestInfo.getOriginalPackageName(), loadedMainManifestInfo.getXmlDocument().reparse()); // invariant : xmlDocumentOptional holds the higher priority document and we try to // merge in lower priority documents. Optional<XmlDocument> xmlDocumentOptional = Optional.absent(); for (File inputFile : mFlavorsAndBuildTypeFiles) { mLogger.info("Merging flavors and build manifest %s \n", inputFile.getPath()); LoadedManifestInfo overlayDocument = load( new ManifestInfo( null, inputFile, XmlDocument.Type.OVERLAY, Optional.of(mainPackageAttribute.get().getValue())), selectors, mergingReportBuilder); // check package declaration. Optional<XmlAttribute> packageAttribute = overlayDocument.getXmlDocument().getPackage(); // if both files declare a package name, it should be the same. if (loadedMainManifestInfo.getOriginalPackageName().isPresent() && packageAttribute.isPresent() && !loadedMainManifestInfo .getOriginalPackageName() .get() .equals(packageAttribute.get().getValue())) { // no suggestion for library since this is actually forbidden to change the // the package name per flavor. String message = mMergeType == MergeType.APPLICATION ? String.format( "Overlay manifest:package attribute declared at %1$s value=(%2$s)\n" + "\thas a different value=(%3$s) " + "declared in main manifest at %4$s\n" + "\tSuggestion: remove the overlay declaration at %5$s " + "\tand place it in the build.gradle:\n" + "\t\tflavorName {\n" + "\t\t\tapplicationId = \"%2$s\"\n" + "\t\t}", packageAttribute.get().printPosition(), packageAttribute.get().getValue(), mainPackageAttribute.get().getValue(), mainPackageAttribute.get().printPosition(), packageAttribute.get().getSourceLocation().print(true)) : String.format( "Overlay manifest:package attribute declared at %1$s value=(%2$s)\n" + "\thas a different value=(%3$s) " + "declared in main manifest at %4$s", packageAttribute.get().printPosition(), packageAttribute.get().getValue(), mainPackageAttribute.get().getValue(), mainPackageAttribute.get().printPosition()); mergingReportBuilder.addMessage( overlayDocument.getXmlDocument().getSourceLocation(), 0, 0, MergingReport.Record.Severity.ERROR, message); return mergingReportBuilder.build(); } overlayDocument .getXmlDocument() .getRootNode() .getXml() .setAttribute("package", mainPackageAttribute.get().getValue()); xmlDocumentOptional = merge(xmlDocumentOptional, overlayDocument, mergingReportBuilder); if (!xmlDocumentOptional.isPresent()) { return mergingReportBuilder.build(); } } mLogger.info("Merging main manifest %s\n", mManifestFile.getPath()); xmlDocumentOptional = merge(xmlDocumentOptional, loadedMainManifestInfo, mergingReportBuilder); if (!xmlDocumentOptional.isPresent()) { return mergingReportBuilder.build(); } // force main manifest package into resulting merged file when creating a library manifest. if (mMergeType == MergeType.LIBRARY) { // extract the package name... String mainManifestPackageName = loadedMainManifestInfo.getXmlDocument().getRootNode().getXml().getAttribute("package"); // save it in the selector instance. if (!Strings.isNullOrEmpty(mainManifestPackageName)) { xmlDocumentOptional .get() .getRootNode() .getXml() .setAttribute("package", mainManifestPackageName); } } for (LoadedManifestInfo libraryDocument : loadedLibraryDocuments) { mLogger.info("Merging library manifest " + libraryDocument.getLocation()); xmlDocumentOptional = merge(xmlDocumentOptional, libraryDocument, mergingReportBuilder); if (!xmlDocumentOptional.isPresent()) { return mergingReportBuilder.build(); } } // done with proper merging phase, now we need to trim unwanted elements, placeholder // substitution and system properties injection. ElementsTrimmer.trim(xmlDocumentOptional.get(), mergingReportBuilder); if (mergingReportBuilder.hasErrors()) { return mergingReportBuilder.build(); } // do one last placeholder substitution, this is useful as we don't stop the build // when a library failed a placeholder substitution, but the element might have // been overridden so the problem was transient. However, with the final document // ready, all placeholders values must have been provided. KeyBasedValueResolver<String> placeHolderValueResolver = new MapBasedKeyBasedValueResolver<String>(finalPlaceHolderValues); PlaceholderHandler placeholderHandler = new PlaceholderHandler(); placeholderHandler.visit( mMergeType, xmlDocumentOptional.get(), placeHolderValueResolver, mergingReportBuilder); if (mergingReportBuilder.hasErrors()) { return mergingReportBuilder.build(); } // perform system property injection. performSystemPropertiesInjection(mergingReportBuilder, xmlDocumentOptional.get()); XmlDocument finalMergedDocument = xmlDocumentOptional.get(); PostValidator.validate(finalMergedDocument, mergingReportBuilder); if (mergingReportBuilder.hasErrors()) { finalMergedDocument .getRootNode() .addMessage( mergingReportBuilder, MergingReport.Record.Severity.WARNING, "Post merge validation failed"); } // only remove tools annotations if we are packaging an application. if (mOptionalFeatures.contains(Invoker.Feature.REMOVE_TOOLS_DECLARATIONS)) { finalMergedDocument = ToolsInstructionsCleaner.cleanToolsReferences(finalMergedDocument, mLogger); } if (mOptionalFeatures.contains(Invoker.Feature.EXTRACT_FQCNS)) { extractFcqns(finalMergedDocument); } if (finalMergedDocument != null) { mergingReportBuilder.setMergedDocument(finalMergedDocument); } MergingReport mergingReport = mergingReportBuilder.build(); StdLogger stdLogger = new StdLogger(StdLogger.Level.INFO); mergingReport.log(stdLogger); stdLogger.verbose(mergingReport.getMergedDocument().get().prettyPrint()); if (mReportFile.isPresent()) { writeReport(mergingReport); } return mergingReport; }
/** Returns whether this handler applies to the given parameter string. */ @Override public boolean handles(String alias) { return aliases.contains(alias); }
@Override public void leavingState(final State state) throws OperationException { final DateTime utcNow = pluginControlPaymentAutomatonRunner.getClock().getUTCNow(); // Retrieve the associated payment transaction, if any PaymentTransactionModelDao paymentTransactionModelDaoCandidate = null; if (stateContext.getTransactionId() != null) { paymentTransactionModelDaoCandidate = paymentDao.getPaymentTransaction( stateContext.getTransactionId(), stateContext.getInternalCallContext()); Preconditions.checkNotNull( paymentTransactionModelDaoCandidate, "paymentTransaction cannot be null for id " + stateContext.getTransactionId()); } else if (stateContext.getPaymentTransactionExternalKey() != null) { final List<PaymentTransactionModelDao> paymentTransactionModelDaos = paymentDao.getPaymentTransactionsByExternalKey( stateContext.getPaymentTransactionExternalKey(), stateContext.getInternalCallContext()); if (!paymentTransactionModelDaos.isEmpty()) { paymentTransactionModelDaoCandidate = paymentTransactionModelDaos.get(paymentTransactionModelDaos.size() - 1); } } final PaymentTransactionModelDao paymentTransactionModelDao = paymentTransactionModelDaoCandidate != null && TRANSIENT_TRANSACTION_STATUSES.contains( paymentTransactionModelDaoCandidate.getTransactionStatus()) ? paymentTransactionModelDaoCandidate : null; if (stateContext.getPaymentId() != null && stateContext.getPaymentExternalKey() == null) { final PaymentModelDao payment = paymentDao.getPayment(stateContext.getPaymentId(), stateContext.getInternalCallContext()); Preconditions.checkNotNull( payment, "payment cannot be null for id " + stateContext.getPaymentId()); stateContext.setPaymentExternalKey(payment.getExternalKey()); stateContext.setPaymentMethodId(payment.getPaymentMethodId()); } else if (stateContext.getPaymentExternalKey() == null) { stateContext.setPaymentExternalKey(UUIDs.randomUUID().toString()); } if (paymentTransactionModelDao != null) { stateContext.setPaymentTransactionExternalKey( paymentTransactionModelDao.getTransactionExternalKey()); } else if (stateContext.getPaymentTransactionExternalKey() == null) { stateContext.setPaymentTransactionExternalKey(UUIDs.randomUUID().toString()); } if (stateContext.getPaymentMethodId() == null) { // Similar logic in PaymentAutomatonRunner stateContext.setPaymentMethodId(stateContext.getAccount().getPaymentMethodId()); } if (state.getName().equals(initialState.getName()) || state.getName().equals(retriedState.getName())) { try { final PaymentAttemptModelDao attempt; if (paymentTransactionModelDao != null && paymentTransactionModelDao.getAttemptId() != null) { attempt = pluginControlPaymentAutomatonRunner .getPaymentDao() .getPaymentAttempt( paymentTransactionModelDao.getAttemptId(), stateContext.getInternalCallContext()); Preconditions.checkNotNull( attempt, "attempt cannot be null for id " + paymentTransactionModelDao.getAttemptId()); } else { // // We don't serialize any properties at this stage to avoid serializing sensitive // information. // However, if after going through the control plugins, the attempt end up in RETRIED // state, // the properties will be serialized in the enteringState callback (any plugin that sets a // retried date is responsible to correctly remove sensitive information such as CVV, ...) // final byte[] serializedProperties = PluginPropertySerializer.serialize(ImmutableList.<PluginProperty>of()); attempt = new PaymentAttemptModelDao( stateContext.getAccount().getId(), stateContext.getPaymentMethodId(), utcNow, utcNow, stateContext.getPaymentExternalKey(), stateContext.getTransactionId(), stateContext.getPaymentTransactionExternalKey(), transactionType, initialState.getName(), stateContext.getAmount(), stateContext.getCurrency(), stateContext.getPaymentControlPluginNames(), serializedProperties); pluginControlPaymentAutomatonRunner .getPaymentDao() .insertPaymentAttemptWithProperties(attempt, stateContext.getInternalCallContext()); } stateContext.setAttemptId(attempt.getId()); } catch (final PluginPropertySerializerException e) { throw new OperationException(e); } } }