Gets the parameters attribute of the LargestChainDescriptor object.

@return The parameters value
@see #setParameters
767270
@Override
    public Object[] getParameters() {
        // return the parameters as used for the descriptor calculation
        Object[] params = new Object[2];
        params[0] = checkAromaticity;
        params[1] = checkRingSystem;
        return params;
    }
971215
public Set<Map.Entry<Buffer, Buffer>> getAllParameters() {
        consumeUntil(null);
        if (this.paramMap != null) {
            return this.paramMap.entrySet();
        }
        return null;
    }
106693
@Override
    public Set<String> getAvailableQueryAttributes() {
        final IUsernameAttributeProvider usernameAttributeProvider =
                super.getUsernameAttributeProvider();
        return Collections.singleton(usernameAttributeProvider.getUsernameAttribute());
    }
285514
@Override
    public Set<SingularAttribute<? super X, ?>> getIdClassAttributes()
    {
        if (isIdClass)
        {
            return idClassAttributes;
        }
        else if (getSuperClazzType() != null
        /*
         * && getSuperClazzType().getJavaType().isAssignableFrom(
         * AbstractIdentifiableType.class)
         */)
        {
            idClassAttributes = ((AbstractIdentifiableType) getSuperClazzType()).getIdClassAttributes();
        }

        throw new IllegalArgumentException("The identifiable type does not have an id class");
    }
504429
@Override
    public Map<String, String> defaultParameters() {
        Map<String, String> dp = new HashMap<>();
        dp.put("0", "jdi");
        for (int i = 1; i <= 9; ++i) {
            dp.put("" + i, "");
        }
        return dp;
    }
1236452
@Override
    public String parameters() {
        StringBuilder result = new StringBuilder();
        Iterator<Pair> it = xy.iterator();
        while (it.hasNext()) {
            Pair pair = it.next();
            result.append(String.format("%s %s",
                    Op.str(pair.getX()), Op.str(pair.getY())));
            if (it.hasNext()) {
                result.append(" ");
            }
        }
        if (!Op.isEq(height, 1.0)) {
            result.append(String.format(" %s", Op.str(height)));
        }
        return result.toString();
    }
635151
public List<Parameter> getAllParameters() {
        List<Parameter> ret = new ArrayList<Parameter>();

        // Parameters within statements
        if (statements != null) {
            for (final Statement stmt : statements)
                ret.addAll(stmt.getAllParameters());
        }

        // Parameters within nested statement groups
        if (statementGroups != null) {
            for (final StatementGroup sg : statementGroups)
                ret.addAll(sg.getAllParameters());
        }

        return ret;
    }
689309
@Override
    public void setParameters(Object[] params) throws CDKException {
        if (params.length > 1) {
            throw new CDKException("BondCount only expects one parameter");
        }
        if (!(params[0] instanceof String)) {
            throw new CDKException("The parameter must be of type IBond.Order");
        }
        String bondType = (String) params[0];
        if (bondType.length() > 1 || !"sdtq".contains(bondType)) {
            throw new CDKException("The only allowed values for this parameter are 's', 'd', 't', 'q' and ''.");
        }
        // ok, all should be fine
        order = bondType;
    }
961687
@Override
    public Map<String, List<String>> toParameters() {
        final Map<String, List<String>> outParams = new LinkedHashMap<>();
        outParams.put("resource", Collections.singletonList(resource));
        outParams.put("grant_type", Collections.singletonList(GRANT_TYPE) );
        outParams.put("code", Collections.singletonList(deviceCode.getDeviceCode()));

        return outParams;
    }
1286782
@Override
    public String[] getParameterNames() {
        String[] params = new String[3];
        params[0] = "maxIterations";
        params[1] = "lpeChecker";
        params[2] = "maxResonStruc";
        return params;
    }
192893
public Parameters parameters() {
        Parameters ps = new DefaultParameters()
                .setTimeLimit(timeout)
                .doRepair(repair)
                .doOptimize(optimize);

        if (single()) {
            ps.setVerbosity(verbosity);
        }
        if (chunk) {
            ps.setEnvironmentFactory(mo -> new EnvironmentBuilder().fromChunk().build());
        }
        return ps;
    }
437662
@Override
    public Object[] getParameters() {
        // return the parameters as used for the descriptor calculation
        Object[] params = new Object[2];
        params[0] = includeTerminals;
        params[1] = excludeAmides;
        return params;
    }
5771
public int getNumParameters() {
        int count = 0;
        for (Iterator<String> i = parameterSignatureIterator(); i.hasNext();) {
            i.next();
            ++count;
        }
        return count;
    }
1206696
public TreeSet<HtmlParameter> getCookieParams() {
		TreeSet<HtmlParameter> set = new TreeSet<>();
		
	    if (! this.getRequestHeader().isEmpty()) {
	    	set.addAll(this.getRequestHeader().getCookieParams());
        }
	    if (! this.getResponseHeader().isEmpty()) {
	    	set.addAll(this.getResponseHeader().getCookieParams());
	    }

		return set;
	}
807203
@Override
    public Set<Attribute<X, ?>> getDeclaredAttributes()
    {
        Set<Attribute<X, ?>> attributes = new HashSet<Attribute<X, ?>>();

        if (declaredSingluarAttribs != null)
        {
            attributes.addAll(declaredSingluarAttribs.values());
        }
        if (declaredPluralAttributes != null)
        {
            attributes.addAll(declaredPluralAttributes.values());
        }

        return attributes;
    }
606757
public Set<Parameter> getAllParameters() {
        final Set<Parameter> ret = new HashSet<Parameter>();
        for (final Term term : getAllTerms()) {
            List<Parameter> params = term.getParameters();
            if (params == null) {
                continue;
            }
            ret.addAll(params);
        }
        return ret;
    }
119153
public Object[] getValuesArray() {
        this.assertIncorrectOrder();

        Object[] params = new Object[this.order.size()];

        String parameterName = null;
        for (int i = 0; i < this.order.size(); i++) {
            parameterName = this.getNameByPosition(i);

            params[i] = this.getValue(parameterName);
        }

        return params;
    }