* For a particular class we are keeping track
     * of all the methods with the same name.
     *
     * @param method The method
     */
    void add(Method method) {
        String methodName = method.getName();

        List<Method> l = get(methodName);

        if (l == null) {
            l = new ArrayList<>();
            methodByNameMap.put(methodName, l);
        }

        l.add(method);
    }

            return null;
        }
        validate(form, messages -> {}, this::asListHtml);
        verifyTokenKeep(this::asListHtml);
        return asStream(file.getName()).contentTypeOctetStream().stream(out -> {
            try (FileInputStream fis = new FileInputStream(file)) {
                out.write(fis);
            }
        });
    }

    @Execute

    @Override
    public final boolean cancel(boolean mayInterruptIfRunning) {
      return super.cancel(mayInterruptIfRunning);
    }
  }

  private static final Logger log = Logger.getLogger(AbstractFuture.class.getName());

  private State state;
  private V value;
  private @Nullable Future<? extends V> delegate;
  private @Nullable Throwable throwable;
  private boolean mayInterruptIfRunning;
  private List<Listener> listeners;

	return m.RunWithValue(value, func(stmt *gorm.Statement) error {
		constraint, table := m.GuessConstraintInterfaceAndTable(stmt, name)
		if constraint != nil {
			name = constraint.GetName()
		}
		return m.DB.Exec("ALTER TABLE ? DROP CONSTRAINT ?", clause.Table{Name: table}, clause.Column{Name: name}).Error
	})
}

// HasConstraint check has constraint or not

        }

        public Build getBuild() {
            return build;
        }

        public String getArtifactId() {
            return artifactId;
        }

        public String getName() {
            return name;
        }

        public String getVersion() {
            return version;
        }

        public Dependency[] getDependenciesAsArray() {

                if ( log.isTraceEnabled() ) {
                    log.trace(
                        String.format("%s costs %d avail %d (%s)", chain.getClass().getName(), cost, this.credits.availablePermits(), this.name));
                }
                if ( ( next == null || chain.allowChain(next) ) && totalSize + size < maxSize && this.credits.tryAcquire(cost) ) {

            return searchers;
        }
        final RankFusionSearcher[] availableSearchers = Arrays.stream(searchers)
                .filter(searcher -> availableSearcherNameSet.contains(searcher.getName())).toArray(n -> new RankFusionSearcher[n]);
        if (availableSearchers.length == 0) {
            if (logger.isDebugEnabled()) {
                logger.debug("No available searchers from {}", availableSearcherNameSet);

            throw new CrawlingAccessException("No response body.");
        }

        final ResultData resultData = new ResultData();
        resultData.setTransformerName(getName());
        try {
            resultData.setData(SerializeUtil.fromObjectToBinary(generateData(responseData)));
        } catch (final Exception e) {
            throw new CrawlingAccessException("Could not serialize object", e);

        if (crawlerThread != null) {
            try {
                crawlerThread.join();
            } catch (final Exception e) {
                logger.info("Interrupted a crawling process: {}", crawlerThread.getName());
            }
        }
    }

                try {
                    final Auth auth = new Auth(getSettings(), request, response);
                    final LogoutRequestParams logoutRequestParams = new LogoutRequestParams(samlUser.getSessionIndex(), samlUser.getName(),
                            samlUser.getNameIdFormat(), samlUser.getNameidNameQualifier(), samlUser.getNameidSPNameQualifier());
                    return auth.logout(null, logoutRequestParams, true);