public static ObjectGraph objectGraphFrom(Object objectGraphProvider) {
        if (!(objectGraphProvider instanceof ObjectGraphProvider)) {
            throw new IllegalArgumentException(objectGraphProvider.getClass().getName() + " doesn't implement ObjectGraphProvider");
        }
        return ((ObjectGraphProvider) objectGraphProvider).getObjectGraph();
    }

package spork.inject;

import spork.inject.internal.ObjectGraphBuilderImpl;
import spork.inject.internal.ObjectGraphImpl;

public final class ObjectGraphs {

    private ObjectGraphs() {
    }

    /**
     * Builder for {@link ObjectGraph}.
     *
     * @return an implementation of {@link ObjectGraphBuilder} to help create an {@link ObjectGraph}
     */
    public static ObjectGraphBuilder builder() {
        return new ObjectGraphBuilderImpl();
    }

    /**
     * Builder for {@link ObjectGraph} that is linked to the specified parent {@link ObjectGraph}.
     *
     * @return an implementation of {@link ObjectGraphBuilder} to help create an {@link ObjectGraph}
     */
    public static ObjectGraphBuilder builder(ObjectGraph parentGraph) {
        if (!(parentGraph instanceof ObjectGraphImpl)) {
            throw new IllegalArgumentException("Provided ObjectGraph instance is not compatible");
        }
        return new ObjectGraphBuilderImpl((ObjectGraphImpl) parentGraph);
    }

    /**
     * Cast the given {@link Object} to an {@link ObjectGraphProvider} and return the {@link ObjectGraph}.
     * If the provided Object doesn't implement ObjectGraph, an IllegalArgumentException is thrown.
     *
     * This is a helper object for when one may assume that a given object is implementing ObjectGraphProvider.
     *
     * @return the ObjectGraph instance
     */


public Optional<Transformation> toIncomingTransformation(Nat nat, @Nullable Map<String, AddressBookEntry> addressBookEntryMap, Ip interfaceIp, @Nullable Transformation andThen, @Nullable Transformation orElse, Warnings warnings) {
        return rulesTransformation(nat, addressBookEntryMap, interfaceIp, andThen, orElse, warnings);
    }

package org.batfish.representation.juniper;

import static org.batfish.datamodel.transformation.Transformation.when;
import com.google.common.collect.Lists;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.annotation.ParametersAreNonnullByDefault;
import org.batfish.common.BatfishException;
import org.batfish.common.Warnings;
import org.batfish.datamodel.Ip;
import org.batfish.datamodel.acl.AclLineMatchExpr;
import org.batfish.datamodel.transformation.Transformation;
import org.batfish.datamodel.transformation.Transformation.Builder;
import org.batfish.representation.juniper.Nat.Type;

/**
 * Represents a Juniper nat rule set
 */
@ParametersAreNonnullByDefault
public final class NatRuleSet implements Serializable, Comparable<NatRuleSet> {

    private final NatPacketLocation _fromLocation;

    private final List<NatRule> _rules;

    private final NatPacketLocation _toLocation;

    private final String _name;

    public NatRuleSet(String name) {
        _name = name;
        _fromLocation = new NatPacketLocation();
        _rules = new ArrayList<>();
        _toLocation = new NatPacketLocation();
    }

    @Nonnull
    public NatPacketLocation getFromLocation() {
        return _fromLocation;
    }

    @Nonnull
    public List<NatRule> getRules() {
        return _rules;
    }

    @Nonnull
    public NatPacketLocation getToLocation() {
        return _toLocation;
    }

    @Nonnull
    public String getName() {
        return _name;
    }

    /* Sort NatRuleSet according to the following order:
   * 1. Source interface/destination interface
   * 2. Source zone/destination interface
   * 3. Source routing instance/destination interface
   * 4. Source interface/destination zone
   * 5. Source zone/destination zone
   * 6. Source routing instance/destination zone
   * 7. Source interface/destination routing instance
   * 8. Source zone/destination routing instance
   * 9. Source routing instance/destination routing instance
   */
    private static final Comparator<NatRuleSet> COMPARATOR = Comparator.comparing(NatRuleSet::getToLocation).thenComparing(NatRuleSet::getFromLocation);

    @Override
    public int compareTo(NatRuleSet o) {
        return COMPARATOR.compare(this, o);
    }

    /**
     * Convert to an outgoing {@link Transformation} in the vendor-independent model. The outgoing
     * transformation is installed on the egress interface, so we need to encode constraints on the
     * ingress interface using {@link AclLineMatchExpr ACL line match expressions}.
     *
     * @param interfaceIp The {@link Ip} address of the interface.
     * @param matchFromLocationExprs The {@link AclLineMatchExpr} to match traffic from each {@link
     *     NatPacketLocation}.
     * @param andThen The next {@link Transformation} to apply after any {@link NatRule} matches.
     * @param orElse The next {@link Transformation} to apply if no {@link NatRule} matches.
     */
    public Optional<Transformation> toOutgoingTransformation(Nat nat, Map<String, AddressBookEntry> addressBookEntryMap, Ip interfaceIp, Map<NatPacketLocation, AclLineMatchExpr> matchFromLocationExprs, @Nullable Transformation andThen, @Nullable Transformation orElse, Warnings warnings) {
        if (nat.getType() == Type.SOURCE) {
            AclLineMatchExpr matchFromLocation = matchFromLocationExprs.get(_fromLocation);
            if (matchFromLocation == null) {
                // non-existent NatPacketLocation
                return Optional.empty();
            }
            return rulesTransformation(nat, addressBookEntryMap, interfaceIp, andThen, orElse, warnings).map(rulesTransformation -> when(matchFromLocation).setAndThen(rulesTransformation).setOrElse(orElse).build());
        }
        if (nat.getType() == Type.STATIC) {
            return rulesTransformation(nat, addressBookEntryMap, interfaceIp, andThen, orElse, warnings);
        }
        throw new BatfishException("Not supported nat types for outgoing transformation: " + nat.getType());
    }

    /**
     * Convert to an incoming {@link Transformation} in the vendor-independent model. Since the
     * transformation is installed on the ingress interface, we don't need to use an {@link
     * AclLineMatchExpr} to match it.
     */

    private Optional<Transformation> rulesTransformation(Nat nat, @Nullable Map<String, AddressBookEntry> addressBookEntryMap, Ip interfaceIp, @Nullable Transformation andThen, @Nullable Transformation orElse, Warnings warnings) {
        Transformation transformation = orElse;
        for (NatRule rule : Lists.reverse(_rules)) {
            Optional<Builder> optionalBuilder = rule.toTransformationBuilder(nat, addressBookEntryMap, interfaceIp, warnings);
            if (optionalBuilder.isPresent()) {
                transformation = optionalBuilder.get().setAndThen(andThen).setOrElse(transformation).build();
            }
        }
        return Optional.ofNullable(transformation);
    }
}


public boolean supportsSample(String name);

package org.netbeans.modules.db.mysql.spi.sample;

import java.util.List;
import org.netbeans.api.db.explorer.DatabaseConnection;
import org.netbeans.api.db.explorer.DatabaseException;

/**
 * This interface defines an SPI for a module to provide support for
 * creating a sample database against a MySQL database
 *
 * @author David Van Couvering
 */
public interface SampleProvider {

    /**
     * The folder path to use when registering a sample provider
     */
    public static final String SAMPLE_PROVIDER_PATH = "Databases/MySQL/SampleProviders";

    /**
     * Create the sample database of the given name.  Note that the database connection
     * is for the sample database; this method need only create the tables and other database
     * objects, not the database itself.
     *
     * @param sampleName the name of the sample to create
     * @param dbconn the connection to use when creating the sample
     *
     * @throws DatabaseException if some error occurred when creating the database objects.  It
     * is not guaranteed that the database is in a "clean" state after a failure; the caller
     * should either clean up or notify the user so they can clean up.
     */
    public void create(String sampleName, DatabaseConnection conn) throws DatabaseException;

    /**
     * Determine if this provider knows how to create a sample of the given name
     *
     * @param name
     *   The name of the sample
     *
     * @return true if this provider knows how to create a sample with the given name
     */

    /**
     * Get the list of sample names this provider supports
     */
    public List<String> getSampleNames();
}


public abstract void setPhysicalResource(Resource physicalResource);

package org.apache.hadoop.yarn.server.api.protocolrecords;

import java.util.List;
import java.util.Set;
import org.apache.hadoop.yarn.api.records.ApplicationId;
import org.apache.hadoop.yarn.api.records.NodeAttribute;
import org.apache.hadoop.yarn.api.records.NodeId;
import org.apache.hadoop.yarn.api.records.NodeLabel;
import org.apache.hadoop.yarn.api.records.Resource;
import org.apache.hadoop.yarn.server.api.records.NodeStatus;
import org.apache.hadoop.yarn.util.Records;

public abstract class RegisterNodeManagerRequest {

    public static RegisterNodeManagerRequest newInstance(NodeId nodeId, int httpPort, Resource resource, String nodeManagerVersionId, List<NMContainerStatus> containerStatuses, List<ApplicationId> runningApplications) {
        return newInstance(nodeId, httpPort, resource, nodeManagerVersionId, containerStatuses, runningApplications, null);
    }

    public static RegisterNodeManagerRequest newInstance(NodeId nodeId, int httpPort, Resource resource, String nodeManagerVersionId, List<NMContainerStatus> containerStatuses, List<ApplicationId> runningApplications, Set<NodeLabel> nodeLabels) {
        return newInstance(nodeId, httpPort, resource, nodeManagerVersionId, containerStatuses, runningApplications, nodeLabels, null);
    }

    public static RegisterNodeManagerRequest newInstance(NodeId nodeId, int httpPort, Resource resource, String nodeManagerVersionId, List<NMContainerStatus> containerStatuses, List<ApplicationId> runningApplications, Set<NodeLabel> nodeLabels, Resource physicalResource) {
        return newInstance(nodeId, httpPort, resource, nodeManagerVersionId, containerStatuses, runningApplications, nodeLabels, physicalResource, null, null);
    }

    public static RegisterNodeManagerRequest newInstance(NodeId nodeId, int httpPort, Resource resource, String nodeManagerVersionId, List<NMContainerStatus> containerStatuses, List<ApplicationId> runningApplications, Set<NodeLabel> nodeLabels, Resource physicalResource, Set<NodeAttribute> nodeAttributes, NodeStatus nodeStatus) {
        RegisterNodeManagerRequest request = Records.newRecord(RegisterNodeManagerRequest.class);
        request.setHttpPort(httpPort);
        request.setResource(resource);
        request.setNodeId(nodeId);
        request.setNMVersion(nodeManagerVersionId);
        request.setContainerStatuses(containerStatuses);
        request.setRunningApplications(runningApplications);
        request.setNodeLabels(nodeLabels);
        request.setPhysicalResource(physicalResource);
        request.setNodeAttributes(nodeAttributes);
        request.setNodeStatus(nodeStatus);
        return request;
    }

    public abstract NodeId getNodeId();

    public abstract int getHttpPort();

    public abstract Resource getResource();

    public abstract String getNMVersion();

    public abstract List<NMContainerStatus> getNMContainerStatuses();

    public abstract Set<NodeLabel> getNodeLabels();

    public abstract void setNodeLabels(Set<NodeLabel> nodeLabels);

    /**
     * We introduce this here because currently YARN RM doesn't persist nodes info
     * for application running. When RM restart happened, we cannot determinate if
     * a node should do application cleanup (like log-aggregation, status update,
     * etc.) or not.
     * <p>
     * When we have this running application list in node manager register
     * request, we can recover nodes info for running applications. And then we
     * can take actions accordingly
     *
     * @return running application list in this node
     */
    public abstract List<ApplicationId> getRunningApplications();

    public abstract void setNodeId(NodeId nodeId);

    public abstract void setHttpPort(int port);

    public abstract void setResource(Resource resource);

    public abstract void setNMVersion(String version);

    public abstract void setContainerStatuses(List<NMContainerStatus> containerStatuses);

    /**
     * Setter for {@link RegisterNodeManagerRequest#getRunningApplications()}
     * @param runningApplications running application in this node
     */
    public abstract void setRunningApplications(List<ApplicationId> runningApplications);

    /**
     * Get the physical resources in the node to properly estimate resource
     * utilization.
     * @return Physical resources in the node.
     */
    public abstract Resource getPhysicalResource();

    /**
     * Set the physical resources in the node to properly estimate resource
     * utilization.
     * @param physicalResource Physical resources in the node.
     */

    public abstract List<LogAggregationReport> getLogAggregationReportsForApps();

    public abstract void setLogAggregationReportsForApps(List<LogAggregationReport> logAggregationReportsForApps);

    public abstract Set<NodeAttribute> getNodeAttributes();

    public abstract void setNodeAttributes(Set<NodeAttribute> nodeAttributes);

    /**
     * Get the status of the node.
     * @return The status of the node.
     */
    public abstract NodeStatus getNodeStatus();

    /**
     * Set the status of the node.
     * @param nodeStatus The status of the node.
     */
    public abstract void setNodeStatus(NodeStatus nodeStatus);
}


public void setRequired(String required) {
        this.required = required;
    }

/*
 * JBoss, Home of Professional Open Source
 * full listing of individual contributors.
 *
 */
package org.richfaces.demo.validator;

import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;
import javax.validation.constraints.Digits;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Pattern;
import org.hibernate.validator.constraints.NotEmpty;

@ManagedBean(name = "test")
@RequestScoped
public class Bean {

    public static final String FOO_VALUE = "fooValue";

    private String value = FOO_VALUE;

    private String required;

    private int intValue;

    private long longValue;

    private double doubleValue;

    private String email;

    private String numbers;

    /**
     * @return the value
     */
    public String getValue() {
        return value;
    }

    /**
     * @param value the value to set
     */
    public void setValue(String value) {
        this.value = value;
    }

    public String getRequired() {
        return this.required;
    }

    /**
     * <p class="changed_added_4_0">
     * </p>
     *
     * @param required the required to set
     */

public int getIntValue() {
        return this.intValue;
    }

    /**
     *

     *

     *
     * @param intValue the intValue to set
     */
    public void setIntValue(int intValue) {
        this.intValue = intValue;
    }

    public long getLongValue() {
        return this.longValue;
    }

    /**
     *

     *

     *
     * @param longValue the longValue to set
     */
    public void setLongValue(long longValue) {
        this.longValue = longValue;
    }

    public double getDoubleValue() {
        return this.doubleValue;
    }

    /**
     *

     *

     *
     * @param doubleValue the doubleValue to set
     */
    public void setDoubleValue(double doubleValue) {
        this.doubleValue = doubleValue;
    }

    public String getEmail() {
        return this.email;
    }

    /**
     *

     *

     *
     * @param email the email to set
     */
    public void setEmail(String email) {
        this.email = email;
    }

    @NotNull
    @NotEmpty
    @Digits(fraction = 0, integer = 2)
    @Pattern(regexp = "^[0-9-]+$", message = "must contain only numbers")
    public String getNumbers() {
        return this.numbers;
    }

    public void setNumbers(String numbers) {
        this.numbers = numbers;
    }
}


while (true) {
                if (i >= fieldName2.length()) {
                    break;
                }
                char ch = fieldName2.charAt(i);
                if ((ch < '0' || ch > '9') && ((ch < 'A' || ch > 'Z') && ((ch < 'a' || ch > 'z') && ch <= 128))) {
                    special = true;
                    break;
                }
                i++;
            }

package com.alibaba.fastjson.serializer;

public class SerialContext {

    public final int features;

    public final Object fieldName;

    public final Object object;

    public final SerialContext parent;

    public SerialContext(SerialContext parent2, Object object2, Object fieldName2, int features2, int fieldFeatures) {
        this.parent = parent2;
        this.object = object2;
        this.fieldName = fieldName2;
        this.features = features2;
    }

    public String toString() {
        if (this.parent == null) {
            return "$";
        }
        StringBuilder buf = new StringBuilder();
        toString(buf);
        return buf.toString();
    }

    /* access modifiers changed from: protected */
    public void toString(StringBuilder buf) {
        if (this.parent == null) {
            buf.append('$');
            return;
        }
        this.parent.toString(buf);
        if (this.fieldName == null) {
            buf.append(".null");
        } else if (this.fieldName instanceof Integer) {
            buf.append('[');
            buf.append(((Integer) this.fieldName).intValue());
            buf.append(']');
        } else {
            buf.append('.');
            String fieldName2 = this.fieldName.toString();
            boolean special = false;
            int i = 0;

            if (special) {
                for (int i2 = 0; i2 < fieldName2.length(); i2++) {
                    char ch2 = fieldName2.charAt(i2);
                    if (ch2 == '\\') {
                        buf.append('\\');
                        buf.append('\\');
                        buf.append('\\');
                    } else if ((ch2 < '0' || ch2 > '9') && ((ch2 < 'A' || ch2 > 'Z') && ((ch2 < 'a' || ch2 > 'z') && ch2 <= 128))) {
                        buf.append('\\');
                        buf.append('\\');
                    } else {
                        buf.append(ch2);
                    }
                    buf.append(ch2);
                }
                return;
            }
            buf.append(fieldName2);
        }
    }

    public SerialContext getParent() {
        return this.parent;
    }

    public Object getObject() {
        return this.object;
    }

    public Object getFieldName() {
        return this.fieldName;
    }

    public String getPath() {
        return toString();
    }
}


package org.openl.ie.constrainer;

/*
 * 320 Amboy Ave., Metuchen, NJ, 08840, USA, www.exigengroup.com
 *
 * The copyright to the computer program(s) herein
 * is the property of Exigen Group, USA. All rights reserved.
 * The program(s) may be used and/or copied only with
 * the written permission of Exigen Group
 * or in accordance with the terms and conditions
 * stipulated in the agreement/contract under which
 * the program(s) have been supplied.
 */
/**
 * An interface for the constrainer goal.
 *
 * @see Constraint
 * @see GoalImpl
 */
public interface Goal extends ConstrainerObject {

    /**
     * An implementation of the execution algorithm of this goal.
     *
     * Returns subgoal of this goal if there are any, null otherwise.
     */

    boolean toContinue(ChoicePointLabel label, boolean restore_flag);
}


public String getDictName() {
        return dictName;
    }

package org.apache.shenyu.admin.model.vo;

import org.apache.shenyu.admin.model.entity.ShenyuDictDO;
import org.apache.shenyu.common.utils.DateUtils;
import java.io.Serializable;
import java.util.Optional;

/**
 * this is shenyu dict view to web front.
 */
public class ShenyuDictVO implements Serializable {

    private static final long serialVersionUID = 5731120468713362319L;

    private String id;

    private String type;

    private String dictCode;

    private String dictName;

    private String dictValue;

    private String desc;

    private Integer sort;

    private Boolean enabled;

    private String dateCreated;

    private String dateUpdated;

    public ShenyuDictVO() {
    }

    public ShenyuDictVO(final String id, final String type, final String dictCode, final String dictName, final String dictValue, final String desc, final Integer sort, final Boolean enabled, final String dateCreated, final String dateUpdated) {
        this.id = id;
        this.type = type;
        this.dictCode = dictCode;
        this.dictName = dictName;
        this.dictValue = dictValue;
        this.desc = desc;
        this.sort = sort;
        this.enabled = enabled;
        this.dateCreated = dateCreated;
        this.dateUpdated = dateUpdated;
    }

    /**
     * Gets the value of id.
     *
     * @return the value of id
     */
    public String getId() {
        return id;
    }

    /**
     * Sets the id.
     *
     * @param id id
     */
    public void setId(final String id) {
        this.id = id;
    }

    /**
     * Gets the value of type.
     *
     * @return the value of type
     */
    public String getType() {
        return type;
    }

    /**
     * Sets the type.
     *
     * @param type type
     */
    public void setType(final String type) {
        this.type = type;
    }

    /**
     * Gets the value of dictCode.
     *
     * @return the value of dictCode
     */
    public String getDictCode() {
        return dictCode;
    }

    /**
     * Sets the dictCode.
     *
     * @param dictCode dictCode
     */
    public void setDictCode(final String dictCode) {
        this.dictCode = dictCode;
    }

    /**
     * Gets the value of dictName.
     *
     * @return the value of dictName
     */

    /**
     * Sets the dictName.
     *
     * @param dictName dictName
     */
    public void setDictName(final String dictName) {
        this.dictName = dictName;
    }

    /**
     * Gets the value of dictValue.
     *
     * @return the value of dictValue
     */
    public String getDictValue() {
        return dictValue;
    }

    /**
     * Sets the dictValue.
     *
     * @param dictValue dictValue
     */
    public void setDictValue(final String dictValue) {
        this.dictValue = dictValue;
    }

    /**
     * Gets the value of desc.
     *
     * @return the value of desc
     */
    public String getDesc() {
        return desc;
    }

    /**
     * Sets the desc.
     *
     * @param desc desc
     */
    public void setDesc(final String desc) {
        this.desc = desc;
    }

    /**
     * Gets the value of sort.
     *
     * @return the value of sort
     */
    public Integer getSort() {
        return sort;
    }

    /**
     * Sets the sort.
     *
     * @param sort sort
     */
    public void setSort(final Integer sort) {
        this.sort = sort;
    }

    /**
     * Gets the value of enabled.
     *
     * @return the value of enabled
     */
    public Boolean getEnabled() {
        return enabled;
    }

    /**
     * Sets the enabled.
     *
     * @param enabled enabled
     */
    public void setEnabled(final Boolean enabled) {
        this.enabled = enabled;
    }

    /**
     * Gets the value of dateCreated.
     *
     * @return the value of dateCreated
     */
    public String getDateCreated() {
        return dateCreated;
    }

    /**
     * Sets the dateCreated.
     *
     * @param dateCreated dateCreated
     */
    public void setDateCreated(final String dateCreated) {
        this.dateCreated = dateCreated;
    }

    /**
     * Gets the value of dateUpdated.
     *
     * @return the value of dateUpdated
     */
    public String getDateUpdated() {
        return dateUpdated;
    }

    /**
     * Sets the dateUpdated.
     *
     * @param dateUpdated dateUpdated
     */
    public void setDateUpdated(final String dateUpdated) {
        this.dateUpdated = dateUpdated;
    }

    /**
     * build {@linkplain ShenyuDictVO}.
     *
     * @param shenyuDictDO {@linkplain ShenyuDictDO}
     * @return {@linkplain ShenyuDictVO}
     */
    public static ShenyuDictVO buildShenyuDictVO(final ShenyuDictDO shenyuDictDO) {
        return Optional.ofNullable(shenyuDictDO).map(it -> new ShenyuDictVO(shenyuDictDO.getId(), shenyuDictDO.getType(), shenyuDictDO.getDictCode(), shenyuDictDO.getDictName(), shenyuDictDO.getDictValue(), shenyuDictDO.getDesc(), shenyuDictDO.getSort(), shenyuDictDO.getEnabled(), DateUtils.localDateTimeToString(shenyuDictDO.getDateCreated().toLocalDateTime()), DateUtils.localDateTimeToString(shenyuDictDO.getDateUpdated().toLocalDateTime()))).orElse(null);
    }
}


public static ImmutableAddressMetric of(final Set<Measurement> measurements) {
        return new ImmutableAddressMetric(ConditionChecker.checkNotNull(measurements, "measurements"));
    }

package org.eclipse.ditto.connectivity.model;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Stream;
import javax.annotation.concurrent.Immutable;
import org.eclipse.ditto.json.JsonFactory;
import org.eclipse.ditto.json.JsonField;
import org.eclipse.ditto.json.JsonKey;
import org.eclipse.ditto.json.JsonObject;
import org.eclipse.ditto.json.JsonObjectBuilder;
import org.eclipse.ditto.json.JsonPointer;
import org.eclipse.ditto.json.JsonValue;
import org.eclipse.ditto.base.model.common.ConditionChecker;
import org.eclipse.ditto.base.model.json.JsonSchemaVersion;

/**
 * Immutable implementation of {@link AddressMetric}.
 */
@Immutable
final class ImmutableAddressMetric implements AddressMetric {

    private static final JsonKey SUCCESS_KEY = JsonFactory.newKey("success");

    private static final JsonKey FAILURE_KEY = JsonFactory.newKey("failure");

    private final Set<Measurement> measurements;

    private ImmutableAddressMetric(final Set<Measurement> measurements) {
        this.measurements = Collections.unmodifiableSet(new HashSet<>(measurements));
    }

    /**
     * Creates a new {@code ImmutableAddressMetric} instance.
     *
     * @param measurements set of measurements for this address
     * @return a new instance of ImmutableAddressMetric
     */

    @Override
    public Set<Measurement> getMeasurements() {
        return measurements;
    }

    @Override
    public JsonObject toJson(final JsonSchemaVersion schemaVersion, final Predicate<JsonField> thePredicate) {
        if (measurements.isEmpty()) {
            return JsonFactory.nullObject();
        } else {
            final Predicate<JsonField> predicate = schemaVersion.and(thePredicate);
            final JsonObjectBuilder jsonObjectBuilder = JsonFactory.newObjectBuilder();
            jsonObjectBuilder.set(JsonFields.SCHEMA_VERSION, schemaVersion.toInt(), predicate);
            final List<Measurement> sortedMeasurements = new ArrayList<>(measurements);
            sortedMeasurements.sort(getMeasurementComparator());
            for (final Measurement measurement : sortedMeasurements) {
                final JsonPointer pointer = JsonFactory.newPointer(JsonFactory.newKey(measurement.getMetricType().getName()), measurement.isSuccess() ? SUCCESS_KEY : FAILURE_KEY);
                jsonObjectBuilder.set(pointer, measurement.toJson().getValue(pointer).orElse(JsonFactory.newObject()));
            }
            return jsonObjectBuilder.build();
        }
    }

    private static Comparator<Measurement> getMeasurementComparator() {
        final List<MetricType> sortedTypes = Arrays.asList(MetricType.values());
        Collections.sort(sortedTypes);
        return (m1, m2) -> {
            if (m1.equals(m2)) {
                return 0;
            } else {
                return calculateComparatorScore(sortedTypes, m1, m2);
            }
        };
    }

    private static int calculateComparatorScore(final List<MetricType> sortedTypes, final Measurement m1, final Measurement m2) {
        final int idx1 = sortedTypes.indexOf(m1.getMetricType());
        final int idx2 = sortedTypes.indexOf(m2.getMetricType());
        final int score;
        if (m1.isSuccess() && m2.isSuccess()) {
            score = 1;
        } else if (m1.isSuccess()) {
            score = 2;
        } else {
            score = 3;
        }
        if (idx1 < idx2) {
            return -score;
        } else if (idx1 == idx2) {
            return m1.isSuccess() ? -1 : 1;
        } else {
            return score;
        }
    }

    /**
     * Creates a new {@code AddressMetric} object from the specified JSON object.
     *
     * @param jsonObject a JSON object which provides the data for the AddressMetric to be created.
     * @return a new AddressMetric which is initialised with the extracted data from {@code jsonObject}.
     * @throws NullPointerException if {@code jsonObject} is {@code null}.
     * @throws org.eclipse.ditto.json.JsonParseException if {@code jsonObject} is not an appropriate JSON object.
     */
    public static AddressMetric fromJson(final JsonObject jsonObject) {
        final Set<Measurement> readMeasurements = new HashSet<>();
        jsonObject.stream().filter(field -> field.getValue().isObject()).forEach(f -> Stream.of(SUCCESS_KEY, FAILURE_KEY).map(key -> JsonFactory.newPointer(JsonFactory.newKey(f.getKeyName()), key)).map(jsonObject::get).filter(JsonValue::isObject).filter(o -> !o.isEmpty()).map(JsonValue::asObject).map(ImmutableMeasurement::fromJson).forEach(readMeasurements::add));
        return ImmutableAddressMetric.of(readMeasurements);
    }

    @Override
    public boolean equals(final Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof ImmutableAddressMetric)) {
            return false;
        }
        final ImmutableAddressMetric that = (ImmutableAddressMetric) o;
        return Objects.equals(measurements, that.measurements);
    }

    @Override
    public int hashCode() {
        return Objects.hash(measurements);
    }

    @Override
    public String toString() {
        return getClass().getSimpleName() + " [" + "measurements=" + measurements + "]";
    }

    /**
     * Convert an indexed address metric into a JSON field.
     *
     * @param key Key of the address metric; may be empty.
     * @param metric the address metric to convert.
     * @return a valid JSON field for the address metric.
     */
    static JsonField toJsonField(final String key, final AddressMetric metric) {
        final String nonemptyKey = key.isEmpty() ? "<empty>" : key;
        return JsonFactory.newField(JsonKey.of(nonemptyKey), metric.toJson());
    }
}


package com.hazelcast.splitbrainprotection;

import com.hazelcast.cluster.Member;
import com.hazelcast.internal.cluster.fd.PingFailureDetector;

/**
 * Split brain protection functions that need access to ICMP ping failure detector should implement this interface;
 * the instance of {@link PingFailureDetector} used by this member's
 * {@link com.hazelcast.internal.cluster.impl.ClusterHeartbeatManager} will be provided on initialization.
 */
public interface PingAware {

    /**
     * Notifies the {@link SplitBrainProtectionFunction} of ping loss.
     *
     * @param member member which was not pinged successfully
     */
    void onPingLost(Member member);

    /**
     * Notifies the {@link SplitBrainProtectionFunction} of a successful ping after one or more pings to that member were lost.
     *
     * @param member member which was pinged successfully
     */


public void reset() {
        super.reset();
        H1 = 0x67452301;
        H2 = 0xefcdab89;
        H3 = 0x98badcfe;
        H4 = 0x10325476;
        H5 = 0xc3d2e1f0;
        xOff = 0;
        for (int i = 0; i != X.length; i++) {
            X[i] = 0;
        }
    }

package org.bouncycastle.crypto.digests;

import org.bouncycastle.util.Memoable;
import org.bouncycastle.util.Pack;

/**
 * implementation of SHA-1 as outlined in "Handbook of Applied Cryptography", pages 346 - 349.
 *
 * It is interesting to ponder why the, apart from the extra IV, the other difference here from MD5
 * is the "endianness" of the word processing!
 */
public class SHA1Digest extends GeneralDigest implements EncodableDigest {

    private static final int DIGEST_LENGTH = 20;

    private int H1, H2, H3, H4, H5;

    private int[] X = new int[80];

    private int xOff;

    public SHA1Digest() {
        reset();
    }

    /**
     * Copy constructor.  This will copy the state of the provided
     * message digest.
     */
    public SHA1Digest(SHA1Digest t) {
        super(t);
        copyIn(t);
    }

    /**
     * State constructor - create a digest initialised with the state of a previous one.
     *
     * @param encodedState the encoded state from the originating digest.
     */
    public SHA1Digest(byte[] encodedState) {
        super(encodedState);
        H1 = Pack.bigEndianToInt(encodedState, 16);
        H2 = Pack.bigEndianToInt(encodedState, 20);
        H3 = Pack.bigEndianToInt(encodedState, 24);
        H4 = Pack.bigEndianToInt(encodedState, 28);
        H5 = Pack.bigEndianToInt(encodedState, 32);
        xOff = Pack.bigEndianToInt(encodedState, 36);
        for (int i = 0; i != xOff; i++) {
            X[i] = Pack.bigEndianToInt(encodedState, 40 + (i * 4));
        }
    }

    private void copyIn(SHA1Digest t) {
        H1 = t.H1;
        H2 = t.H2;
        H3 = t.H3;
        H4 = t.H4;
        H5 = t.H5;
        System.arraycopy(t.X, 0, X, 0, t.X.length);
        xOff = t.xOff;
    }

    public String getAlgorithmName() {
        return "SHA-1";
    }

    public int getDigestSize() {
        return DIGEST_LENGTH;
    }

    protected void processWord(byte[] in, int inOff) {
        // Note: Inlined for performance
        int n = in[inOff] << 24;
        n |= (in[++inOff] & 0xff) << 16;
        n |= (in[++inOff] & 0xff) << 8;
        n |= (in[++inOff] & 0xff);
        X[xOff] = n;
        if (++xOff == 16) {
            processBlock();
        }
    }

    protected void processLength(long bitLength) {
        if (xOff > 14) {
            processBlock();
        }
        X[14] = (int) (bitLength >>> 32);
        X[15] = (int) bitLength;
    }

    public int doFinal(byte[] out, int outOff) {
        finish();
        Pack.intToBigEndian(H1, out, outOff);
        Pack.intToBigEndian(H2, out, outOff + 4);
        Pack.intToBigEndian(H3, out, outOff + 8);
        Pack.intToBigEndian(H4, out, outOff + 12);
        Pack.intToBigEndian(H5, out, outOff + 16);
        reset();
        return DIGEST_LENGTH;
    }

    /**
     * reset the chaining variables
     */


package org.mule.runtime.module.extension.internal.loader.parser;

import org.mule.runtime.api.meta.model.ExternalLibraryModel;
import org.mule.runtime.api.meta.model.config.ConfigurationModel;
import org.mule.runtime.api.meta.model.deprecated.DeprecationModel;
import org.mule.runtime.module.extension.internal.loader.java.property.ConfigurationFactoryModelProperty;
import java.util.List;
import java.util.Optional;

/**
 * Parses the syntactic definition of a {@link ConfigurationModel} so that the semantics reflected in it can be extracted in a
 * uniform way, regardless of the actual syntax used by the extension developer.
 *
 * @see ExtensionModelParser
 * @since 4.5.0
 */
public interface ConfigurationModelParser extends AdditionalPropertiesModelParser {

    /**
     * @return the configuration's name
     */

    /**
     * @return the configuration's description
     */
    String getDescription();

    /**
     * @return the {@link ConfigurationFactoryModelProperty} used to create instances of the configuration
     */
    ConfigurationFactoryModelProperty getConfigurationFactoryModelProperty();

    /**
     * @return whether the configuration should be force to never support implicit definitions
     */
    boolean isForceNoExplicit();

    /**
     * @return a list with an {@link ExternalLibraryModel} per each external library defined at the configuration level.
     */
    List<ExternalLibraryModel> getExternalLibraryModels();

    /**
     * Returns a list with a {@link ParameterGroupModelParser} per each parameter group defined in the configuration. Each group is
     * listed in the same order as defined in the syntax.
     *
     * @return a list with the config's {@link ParameterGroupModelParser}
     */
    List<ParameterGroupModelParser> getParameterGroupParsers();

    /**
     * Returns a list with a {@link OperationModelParser} per each operation defined in the configuration. Each operation is listed
     * in the same order as defined in the syntax.
     *
     * @return a list with the config's {@link OperationModelParser}
     */
    List<OperationModelParser> getOperationParsers();

    /**
     * Returns a list with a {@link SourceModelParser} per each source defined in the configuration. Each source is listed in the
     * same order as defined in the syntax.
     *
     * @return a list with the config's {@link SourceModelParser}
     */
    List<SourceModelParser> getSourceModelParsers();

    /**
     * Returns a list with a {@link ConnectionProviderModelParser} per each connection provider defined in the configuration. Each
     * provider is listed in the same order as defined in the syntax.
     *
     * @return a list with the config's {@link OperationModelParser}
     */
    List<ConnectionProviderModelParser> getConnectionProviderModelParsers();

    /**
     * Returns a list with a {@link FunctionModelParser} per each function defined in the configuration. Each function is listed in
     * the same order as defined in the syntax.
     *
     * @return a list with the config's {@link FunctionModelParser}
     */
    List<FunctionModelParser> getFunctionModelParsers();

    /**
     * @return the configuration's {@link DeprecationModel} if one was defined
     */
    Optional<DeprecationModel> getDeprecationModel();
}


@CheckForNull
    String getCodeSnippet();

/*
 * SonarLint Core - Implementation
 * mailto:info AT sonarsource DOT com
 *
 */
package org.sonarsource.sonarlint.core.client.api.connected;

import javax.annotation.CheckForNull;
import org.sonarsource.sonarlint.core.client.api.common.IssueRangeAndMessage;

public interface ServerIssueLocation extends IssueRangeAndMessage {

    @CheckForNull
    String getFilePath();

    /**
     * The code snippet corresponding to the text range on the server.
     */


public V get(boolean[] markHolder) {
        Pair<V> pair = this.pair;
        markHolder[0] = pair.mark;
        return pair.reference;
    }

/*
 *
 *
 *
 *
 *
 * Written by Doug Lea with assistance from members of JCP JSR-166
 */
package java.util.concurrent.atomic;

/**
 * An {@code AtomicMarkableReference} maintains an object reference
 * along with a mark bit, that can be updated atomically.
 *
 * <p>Implementation note: This implementation maintains markable
 * references by creating internal objects representing "boxed"
 * [reference, boolean] pairs.
 *
 * @since 1.5
 * @author Doug Lea
 * @param <V> The type of object referred to by this reference
 */
public class AtomicMarkableReference<V> {

    private static class Pair<T> {

        final T reference;

        final boolean mark;

        private Pair(T reference, boolean mark) {
            this.reference = reference;
            this.mark = mark;
        }

        static <T> Pair<T> of(T reference, boolean mark) {
            return new Pair<T>(reference, mark);
        }
    }

    private volatile Pair<V> pair;

    /**
     * Creates a new {@code AtomicMarkableReference} with the given
     * initial values.
     *
     * @param initialRef the initial reference
     * @param initialMark the initial mark
     */
    public AtomicMarkableReference(V initialRef, boolean initialMark) {
        pair = Pair.of(initialRef, initialMark);
    }

    /**
     * Returns the current value of the reference.
     *
     * @return the current value of the reference
     */
    public V getReference() {
        return pair.reference;
    }

    /**
     * Returns the current value of the mark.
     *
     * @return the current value of the mark
     */
    public boolean isMarked() {
        return pair.mark;
    }

    /**
     * Returns the current values of both the reference and the mark.
     * Typical usage is {@code boolean[1] holder; ref = v.get(holder); }.
     *
     * @param markHolder an array of size of at least one. On return,
     * {@code markholder[0]} will hold the value of the mark.
     * @return the current value of the reference
     */

/**
     * Atomically sets the value of both the reference and mark
     * to the given update values if the
     * current reference is {@code ==} to the expected reference
     * and the current mark is equal to the expected mark.
     *
     *
May fail
     * spuriously and does not provide ordering guarantees, so is
     * only rarely an appropriate alternative to {@code compareAndSet}.
     *
     * @param expectedReference the expected value of the reference
     * @param newReference the new value for the reference
     * @param expectedMark the expected value of the mark
     * @param newMark the new value for the mark
     * @return {@code true} if successful
     */
    public boolean weakCompareAndSet(V expectedReference, V newReference, boolean expectedMark, boolean newMark) {
        return compareAndSet(expectedReference, newReference, expectedMark, newMark);
    }

    /**
     * Atomically sets the value of both the reference and mark
     * to the given update values if the
     * current reference is {@code ==} to the expected reference
     * and the current mark is equal to the expected mark.
     *
     * @param expectedReference the expected value of the reference
     * @param newReference the new value for the reference
     * @param expectedMark the expected value of the mark
     * @param newMark the new value for the mark
     * @return {@code true} if successful
     */
    public boolean compareAndSet(V expectedReference, V newReference, boolean expectedMark, boolean newMark) {
        Pair<V> current = pair;
        return expectedReference == current.reference && expectedMark == current.mark && ((newReference == current.reference && newMark == current.mark) || casPair(current, Pair.of(newReference, newMark)));
    }

    /**
     * Unconditionally sets the value of both the reference and mark.
     *
     * @param newReference the new value for the reference
     * @param newMark the new value for the mark
     */
    public void set(V newReference, boolean newMark) {
        Pair<V> current = pair;
        if (newReference != current.reference || newMark != current.mark)
            this.pair = Pair.of(newReference, newMark);
    }

    /**
     * Atomically sets the value of the mark to the given update value
     * if the current reference is {@code ==} to the expected
     * reference.  Any given invocation of this operation may fail
     * (return {@code false}) spuriously, but repeated invocation
     * when the current value holds the expected value and no other
     * thread is also attempting to set the value will eventually
     * succeed.
     *
     * @param expectedReference the expected value of the reference
     * @param newMark the new value for the mark
     * @return {@code true} if successful
     */
    public boolean attemptMark(V expectedReference, boolean newMark) {
        Pair<V> current = pair;
        return expectedReference == current.reference && (newMark == current.mark || casPair(current, Pair.of(expectedReference, newMark)));
    }

    // Unsafe mechanics
    private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();

    private static final long pairOffset = objectFieldOffset(UNSAFE, "pair", AtomicMarkableReference.class);

    private boolean casPair(Pair<V> cmp, Pair<V> val) {
        return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
    }

    static long objectFieldOffset(sun.misc.Unsafe UNSAFE, String field, Class<?> klazz) {
        try {
            return UNSAFE.objectFieldOffset(klazz.getDeclaredField(field));
        } catch (NoSuchFieldException e) {
            // Convert Exception to corresponding Error
            NoSuchFieldError error = new NoSuchFieldError(field);
            error.initCause(e);
            throw error;
        }
    }
}


public abstract int getNumberOfTaxonPairs(Taxa taxa);

/*

Disclaimer:  The Mesquite source code is lengthy and we are few.  There are no doubt inefficiencies and goofs in this code.
The commenting leaves much to be desired. Please approach this source code with the spirit of helping out.
Perhaps with your help we can be more than a few, and make Mesquite better.

Mesquite's web site is http://mesquiteproject.org

This source code and its compiled class files are free and modifiable under the terms of
*/
package mesquite.lib.duties;

import java.awt.*;
import mesquite.lib.*;

/**
 * Supplies taxa.
 */
public abstract class TaxonPairSource extends MesquiteModule implements ItemsSource {

    public Class getDutyClass() {
        return TaxonPairSource.class;
    }

    public String getDutyName() {
        return "Taxon Pair Source";
    }

    public String[] getDefaultModule() {
        return new String[] { "#StoredTaxonPairs" };
    }

    /**
     * Called to provoke any necessary initialization.  This helps prevent the module's intialization queries to the user from
     *   	happening at inopportune times (e.g., while a long chart calculation is in mid-progress)
     */
    public abstract void initialize(Taxa taxa);

    /**
     * Returns TaxonPair number iPair, and sets current Taxon number to iPair
     */
    public abstract TaxonPair getTaxonPair(Taxa taxa, int iPair);

    /**
     * Returns number of Taxons available.  If Taxons can be supplied indefinitely, returns MesquiteInteger.infinite
     */

    /**
     * returns name of item ic
     */
    public abstract String getTaxonPairName(Taxa taxa, int ic);

    /**
     * returns item numbered ic
     */
    public Object getItem(Taxa taxa, int ic) {
        return getTaxonPair(taxa, ic);
    }

    /**
     * returns number of pairs for given Taxa
     */
    public int getNumberOfItems(Taxa taxa) {
        return getNumberOfTaxonPairs(taxa);
    }

    /**
     * returns name of type of item, e.g. "Character", or "Taxon"
     */
    public String getItemTypeName() {
        return "Taxon Pair";
    }

    /**
     * returns name of type of item, e.g. "Characters", or "Taxa"
     */
    public String getItemTypeNamePlural() {
        return "Taxon Pairs";
    }

    public Selectionable getSelectionable() {
        return null;
    }

    public boolean isSubstantive() {
        return false;
    }

    ObjectSpecsSet partition;

    /**
     * zzzzzzzzzzzz
     */
    public void setEnableWeights(boolean enable) {
    }

    public boolean itemsHaveWeights(Taxa taxa) {
        return false;
    }

    public double getItemWeight(Taxa taxa, int ic) {
        return MesquiteDouble.unassigned;
    }

    public void prepareItemColors(Taxa taxa) {
        partition = null;
    }

    /**
     * zzzzzzzzzzzz
     */
    public Color getItemColor(Taxa taxa, int ic) {
        return null;
    }

    /**
     * zzzzzzzzzzzz
     */
    public String getItemName(Taxa taxa, int ic) {
        return getTaxonPairName(taxa, ic);
    }
}


public Control getControl() {
        if (c != null)
            return c;
        this.c = super.getControl();
        this.c.addDisposeListener(new DisposeListener() {

            public void widgetDisposed(DisposeEvent e) {
                settings.setAttribute(getToken(), (Integer) getValue());
            }
        });
        // einmal initial ausloesen
        this.listener.handleEvent(null);
        return this.c;
    }

/**
 * *******************************************************************
 *
 *  All rights reserved.
 *
 * ********************************************************************
 */
package de.willuhn.jameica.hbci.gui.input;

import java.rmi.RemoteException;
import java.util.Date;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import de.willuhn.jameica.gui.input.ScaleInput;
import de.willuhn.jameica.hbci.HBCI;
import de.willuhn.jameica.hbci.HBCIProperties;
import de.willuhn.jameica.system.Application;
import de.willuhn.jameica.system.Settings;
import de.willuhn.jameica.util.DateUtil;
import de.willuhn.logging.Logger;
import de.willuhn.util.I18N;

/**
 * Auswahlfeld fuer die Anzahl der anzuzeigenden Tage.
 */
public class UmsatzDaysInput extends ScaleInput {

    private final static I18N i18n = Application.getPluginLoader().getPlugin(HBCI.class).getResources().getI18N();

    private final static Settings settings = new Settings(UmsatzDaysInput.class);

    private final static String TOKEN_DEFAULT = "days";

    private Listener listener = new RangeListener();

    private String token = null;

    private Control c = null;

    public UmsatzDaysInput() throws RemoteException {
        // wir muessen das "-1" wieder zurueck auf 1000 mappen
        super(getDefaultDays() == -1 ? 1000 : getDefaultDays());
        this.setName(i18n.tr("Zeitraum"));
        // Damit wir das Datum noch hinzufuegen koennen
        this.setComment("");
        this.setScaling(1, 1000, 1, 10);
        this.addListener(this.listener);
    }

    /**
     * @see de.willuhn.jameica.gui.input.ScaleInput#getControl()
     */

    /**
     * Das Auswahlfeld kann sich den letzten Zeitraum merken.
     * Damit dann aber nicht auf allen Dialogen der gleiche zeitraum vorausgewaehlt ist,
     * kann man hier einen individuellen Freitext-Token uebergeben, der als Key fuer
     * das Speichern des zuletzt ausgewaehlten Zeitraumes verwendet wird. Ueberall dort,
     * wo also der gleiche Token verwendet wird, wird auch der gleiche Zeitraum
     * vorausgewaehlt. Der Text kann z.Bsp. "auswertungen" heissen. Wenn dieser
     * auf allen Dialogen der Auswertungen verwendet wird, wird dort dann auch ueberall
     * der gleiche Zeitraum vorausgewaehlt sein.
     * @param s der Restore-Token.
     */
    public void setRememberSelection(String s) {
        this.token = s;
        int value = settings.getInt(this.token, HBCIProperties.UMSATZ_DEFAULT_DAYS);
        this.setValue(value == -1 ? 1000 : value);
    }

    /**
     * Liefert den Store-Token.
     * @return der Store-Token.
     */
    private String getToken() {
        return this.token != null ? this.token : TOKEN_DEFAULT;
    }

    /**
     * Ueberschrieben, damit wir "-1" fuer "Alle Umsaetze" liefern koennen.
     * @see de.willuhn.jameica.gui.input.ScaleInput#getValue()
     */
    public Object getValue() {
        int i = (Integer) super.getValue();
        if (i > 999)
            return -1;
        return i;
    }

    /**
     * Liefert die Anzahl der standardmaessig anzuzeigenden Tage.
     * @return Standardmaessig anzuzeigende Tage.
     */
    public final static int getDefaultDays() {
        return settings.getInt(TOKEN_DEFAULT, HBCIProperties.UMSATZ_DEFAULT_DAYS);
    }

    /**
     * Hilfsklasse zum Aktualisieren des Kommentars hinter dem Zeitraum.
     */
    private class RangeListener implements Listener {

        public void handleEvent(Event event) {
            try {
                int start = ((Integer) getValue()).intValue();
                if (start == 1) {
                    setComment(i18n.tr("seit gestern"));
                } else if (start == -1) {
                    setComment(i18n.tr("Alle Umsätze"));
                } else if (start > 0) {
                    long d = start * 24l * 60l * 60l * 1000l;
                    Date date = DateUtil.startOfDay(new Date(System.currentTimeMillis() - d));
                    setComment(i18n.tr("ab {0} ({1} Tage)", HBCI.DATEFORMAT.format(date), Integer.toString(start)));
                } else {
                    setComment("");
                }
            } catch (Exception e) {
                Logger.error("unable to update comment", e);
            }
        }
    }
}
/**
 * ******************************************************************
 *  $Log: UmsatzDaysInput.java,v $
 *  Revision 1.7  2011/05/04 12:04:40  willuhn
 *  @N Zeitraum in Umsatzliste und Saldo-Chart kann jetzt freier und bequemer ueber einen Schieberegler eingestellt werden
 *  @B Dispose-Checks in Umsatzliste
 *
 *  Revision 1.6  2010-08-11 16:06:04  willuhn
 *  @N BUGZILLA 783 - Saldo-Chart ueber alle Konten
 * *******************************************************************
 */


public gov.nist.javax.sip.header.SIPHeader parse() throws java.text.ParseException {
        /*
        // Can't load method instructions: Load method exception: bogus opcode: 00e9 in method: gov.nist.javax.sip.parser.RSeqParser.parse():gov.nist.javax.sip.header.SIPHeader, dex:
        */
        throw new UnsupportedOperationException("Method not decompiled: gov.nist.javax.sip.parser.RSeqParser.parse():gov.nist.javax.sip.header.SIPHeader");
    }

package gov.nist.javax.sip.parser;

/*  JADX ERROR: NullPointerException in pass: ExtractFieldInit
    java.lang.NullPointerException
    	at jadx.core.utils.BlockUtils.isAllBlocksEmpty(BlockUtils.java:546)
    	at jadx.core.dex.visitors.ExtractFieldInit.getConstructorsList(ExtractFieldInit.java:221)
    	at jadx.core.dex.visitors.ExtractFieldInit.moveCommonFieldsInit(ExtractFieldInit.java:121)
    	at jadx.core.dex.visitors.ExtractFieldInit.visit(ExtractFieldInit.java:46)
    	at jadx.core.dex.visitors.DepthTraversal.visit(DepthTraversal.java:12)
    	at jadx.core.ProcessClass.process(ProcessClass.java:32)
    	at jadx.api.JadxDecompiler.processClass(JadxDecompiler.java:292)
    	at jadx.api.JavaClass.decompile(JavaClass.java:62)
    	at jadx.api.JadxDecompiler.lambda$appendSourcesSave$0(JadxDecompiler.java:200)
    */
public class RSeqParser extends HeaderParser {

    /*  JADX ERROR: Method load error
        jadx.core.utils.exceptions.DecodeException: Load method exception: bogus opcode: 0073 in method: gov.nist.javax.sip.parser.RSeqParser.<init>(gov.nist.javax.sip.parser.Lexer):void, dex:
        	at jadx.core.dex.nodes.MethodNode.load(MethodNode.java:118)
        	at jadx.core.dex.nodes.ClassNode.load(ClassNode.java:248)
        	at jadx.core.ProcessClass.process(ProcessClass.java:29)
        	at jadx.api.JadxDecompiler.processClass(JadxDecompiler.java:292)
        	at jadx.api.JavaClass.decompile(JavaClass.java:62)
        	at jadx.api.JadxDecompiler.lambda$appendSourcesSave$0(JadxDecompiler.java:200)
        Caused by: java.lang.IllegalArgumentException: bogus opcode: 0073
        	at com.android.dx.io.OpcodeInfo.get(OpcodeInfo.java:1227)
        	at com.android.dx.io.OpcodeInfo.getName(OpcodeInfo.java:1234)
        	at jadx.core.dex.instructions.InsnDecoder.decode(InsnDecoder.java:581)
        	at jadx.core.dex.instructions.InsnDecoder.process(InsnDecoder.java:74)
        	at jadx.core.dex.nodes.MethodNode.load(MethodNode.java:104)
        	... 5 more
        */
    protected RSeqParser(gov.nist.javax.sip.parser.Lexer r1) {
        /*
        // Can't load method instructions: Load method exception: bogus opcode: 0073 in method: gov.nist.javax.sip.parser.RSeqParser.<init>(gov.nist.javax.sip.parser.Lexer):void, dex:
        */
        throw new UnsupportedOperationException("Method not decompiled: gov.nist.javax.sip.parser.RSeqParser.<init>(gov.nist.javax.sip.parser.Lexer):void");
    }

    /*  JADX ERROR: Method load error
        jadx.core.utils.exceptions.DecodeException: Load method exception: bogus opcode: 0073 in method: gov.nist.javax.sip.parser.RSeqParser.<init>(java.lang.String):void, dex:
        	at jadx.core.dex.nodes.MethodNode.load(MethodNode.java:118)
        	at jadx.core.dex.nodes.ClassNode.load(ClassNode.java:248)
        	at jadx.core.ProcessClass.process(ProcessClass.java:29)
        	at jadx.api.JadxDecompiler.processClass(JadxDecompiler.java:292)
        	at jadx.api.JavaClass.decompile(JavaClass.java:62)
        	at jadx.api.JadxDecompiler.lambda$appendSourcesSave$0(JadxDecompiler.java:200)
        Caused by: java.lang.IllegalArgumentException: bogus opcode: 0073
        	at com.android.dx.io.OpcodeInfo.get(OpcodeInfo.java:1227)
        	at com.android.dx.io.OpcodeInfo.getName(OpcodeInfo.java:1234)
        	at jadx.core.dex.instructions.InsnDecoder.decode(InsnDecoder.java:581)
        	at jadx.core.dex.instructions.InsnDecoder.process(InsnDecoder.java:74)
        	at jadx.core.dex.nodes.MethodNode.load(MethodNode.java:104)
        	... 5 more
        */
    public RSeqParser(java.lang.String r1) {
        /*
        // Can't load method instructions: Load method exception: bogus opcode: 0073 in method: gov.nist.javax.sip.parser.RSeqParser.<init>(java.lang.String):void, dex:
        */
        throw new UnsupportedOperationException("Method not decompiled: gov.nist.javax.sip.parser.RSeqParser.<init>(java.lang.String):void");
    }

    /*  JADX ERROR: Method load error
        jadx.core.utils.exceptions.DecodeException: Load method exception: bogus opcode: 00e9 in method: gov.nist.javax.sip.parser.RSeqParser.parse():gov.nist.javax.sip.header.SIPHeader, dex:
        	at jadx.core.dex.nodes.MethodNode.load(MethodNode.java:118)
        	at jadx.core.dex.nodes.ClassNode.load(ClassNode.java:248)
        	at jadx.core.ProcessClass.process(ProcessClass.java:29)
        	at jadx.api.JadxDecompiler.processClass(JadxDecompiler.java:292)
        	at jadx.api.JavaClass.decompile(JavaClass.java:62)
        	at jadx.api.JadxDecompiler.lambda$appendSourcesSave$0(JadxDecompiler.java:200)
        Caused by: java.lang.IllegalArgumentException: bogus opcode: 00e9
        	at com.android.dx.io.OpcodeInfo.get(OpcodeInfo.java:1227)
        	at com.android.dx.io.OpcodeInfo.getName(OpcodeInfo.java:1234)
        	at jadx.core.dex.instructions.InsnDecoder.decode(InsnDecoder.java:581)
        	at jadx.core.dex.instructions.InsnDecoder.process(InsnDecoder.java:74)
        	at jadx.core.dex.nodes.MethodNode.load(MethodNode.java:104)
        	... 5 more
        */


public void setHighlightLineWidth(float width) {
        mHighlightLineWidth = width;
    }

package com.github.mikephil.charting.data;

import android.graphics.Color;
import com.github.mikephil.charting.interfaces.datasets.IBarLineScatterCandleBubbleDataSet;
import com.github.mikephil.charting.utils.Utils;
import java.util.List;

/**
 * Baseclass of all DataSets for Bar-, Line-, Scatter- and CandleStickChart.
 *
 * @author Philipp Jahoda
 */
public abstract class BarLineScatterCandleBubbleDataSet<T extends Entry> extends DataSet<T> implements IBarLineScatterCandleBubbleDataSet<T> {

    protected int mHighLightColor = Color.rgb(255, 187, 115);

    /**
     * the width of the highlight indicator lines
     */
    protected float mHighlightLineWidth = 0.5f;

    public BarLineScatterCandleBubbleDataSet(List<T> yVals, String label) {
        super(yVals, label);
    }

    /**
     * Sets the color that is used for drawing the highlight indicators. Dont
     * forget to resolve the color using getResources().getColor(...) or
     * Color.rgb(...).
     *
     * @param color
     */
    public void setHighLightColor(int color) {
        mHighLightColor = color;
    }

    @Override
    public int getHighLightColor() {
        return mHighLightColor;
    }

    /**
     * Sets the width of the highlight line in dp.
     *
     * @param width
     */

    @Override
    public float getHighlightLineWidth() {
        return mHighlightLineWidth;
    }
}


protected abstract TypeDeclaration resolveNativeType(AstNode node);

package org.fife.rsta.ac.js.resolver;

import java.io.IOException;
import org.fife.rsta.ac.js.SourceCompletionProvider;
import org.fife.rsta.ac.js.ast.jsType.JavaScriptType;
import org.fife.rsta.ac.js.ast.type.TypeDeclaration;
import org.fife.rsta.ac.js.completion.JSMethodData;
import org.mozilla.javascript.ast.AstNode;
import org.mozilla.javascript.ast.FunctionCall;

public abstract class JavaScriptResolver {

    protected SourceCompletionProvider provider;

    /**
     * Base JavaScriptResolver
     * @param provider SourceCompletionProvider
     */
    public JavaScriptResolver(SourceCompletionProvider provider) {
        this.provider = provider;
    }

    /**
     * Resolve node type to TypeDeclaration. Called instead of #compileText(String text) when document is already parsed
     * @param node AstNode to resolve
     * @return TypeDeclaration for node or null if not found.
     */
    public abstract TypeDeclaration resolveNode(AstNode node);

    /**
     * Resolve node type to TypeDeclaration. Called instead of #compileText(String text) when document is already parsed
     * @param text The type of node to resolve
     * @return TypeDeclaration for node or null if not found.
     */
    public abstract TypeDeclaration resolveParamNode(String text) throws IOException;

    /**
     * Compiles Text and resolves the type.
     * e.g
     * "Hello World".length; //resolve as a Number
     *
     * @param text to compile and resolve
     */
    public abstract JavaScriptType compileText(String text) throws IOException;

    /**
     * Resolve node type to TypeDeclaration
     * @param node AstNode to resolve
     * @return TypeDeclaration for node or null if not found.
     */

    /**
     * Get lookup string for function completions
     * @param method JSMethodData holding method information
     * @param name name of method
     * @return The lookup text.
     */
    public abstract String getLookupText(JSMethodData method, String name);

    /**
     * Returns same string format as {@link #getLookupText(JSMethodData, String)} but from AstNode Function
     * @param call
     * @param provider
     * @return The function name.
     */
    public abstract String getFunctionNameLookup(FunctionCall call, SourceCompletionProvider provider);
}


@Override
    protected void onStartLoading() {
        if (prefs != null) {
            deliverResult(prefs);
        }
        if (takeContentChanged() || prefs == null) {
            forceLoad();
        }
    }

package com.vogella.android.loader.preferences;

import android.content.AsyncTaskLoader;
import android.content.Context;
import android.content.SharedPreferences;
import android.preference.PreferenceManager;

public class SharedPreferencesLoader extends AsyncTaskLoader<SharedPreferences> implements SharedPreferences.OnSharedPreferenceChangeListener {

    private SharedPreferences prefs = null;

    public SharedPreferencesLoader(Context context) {
        super(context);
    }

    // Load the data asynchronously
    @Override
    public SharedPreferences loadInBackground() {
        prefs = PreferenceManager.getDefaultSharedPreferences(getContext());
        prefs.registerOnSharedPreferenceChangeListener(this);
        return (prefs);
    }

    @Override
    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
        // notify loader that content has changed
        onContentChanged();
    }

    /**
     * starts the loading of the data
     * once result is ready the onLoadFinished method is called
     * in the main thread. It loader was started earlier the result
     * is return directly
     *
     * method must be called from main thread.
     */

    public static void persist(final SharedPreferences.Editor editor) {
        editor.apply();
    }
}


@Override
    public long skip(final long n) throws IOException {
        throw exceptionSupplier.get();
    }

package org.apache.commons.io.input;

import java.io.IOException;
import java.io.Reader;
import java.util.function.Supplier;

/**
 * Always throws an {@link IOException} from all the {@link Reader} methods where the exception is declared.
 * <p>
 * This class is mostly useful for testing error handling.
 * </p>
 *
 * @since 2.7
 */
public class BrokenReader extends Reader {

    /**
     * A singleton instance using a default IOException.
     *
     * @since 2.12.0
     */
    public static final BrokenReader INSTANCE = new BrokenReader();

    /**
     * A supplier for the exception that is thrown by all methods of this class.
     */
    private final Supplier<IOException> exceptionSupplier;

    /**
     * Creates a new reader that always throws an {@link IOException}.
     */
    public BrokenReader() {
        this(() -> new IOException("Broken reader"));
    }

    /**
     * Creates a new reader that always throws the given exception.
     *
     * @param exception the exception to be thrown.
     */
    public BrokenReader(final IOException exception) {
        this(() -> exception);
    }

    /**
     * Creates a new reader that always throws an {@link IOException}
     *
     * @param exceptionSupplier a supplier for the exception to be thrown.
     * @since 2.12.0
     */
    public BrokenReader(final Supplier<IOException> exceptionSupplier) {
        this.exceptionSupplier = exceptionSupplier;
    }

    /**
     * Throws the configured exception.
     *
     * @throws IOException always thrown
     */
    @Override
    public void close() throws IOException {
        throw exceptionSupplier.get();
    }

    /**
     * Throws the configured exception.
     *
     * @param readAheadLimit ignored
     * @throws IOException always thrown
     */
    @Override
    public void mark(final int readAheadLimit) throws IOException {
        throw exceptionSupplier.get();
    }

    /**
     * Throws the configured exception.
     *
     * @param cbuf ignored
     * @param off  ignored
     * @param len  ignored
     * @return nothing
     * @throws IOException always thrown
     */
    @Override
    public int read(final char[] cbuf, final int off, final int len) throws IOException {
        throw exceptionSupplier.get();
    }

    /**
     * Throws the configured exception.
     *
     * @return nothing
     * @throws IOException always thrown
     */
    @Override
    public boolean ready() throws IOException {
        throw exceptionSupplier.get();
    }

    /**
     * Throws the configured exception.
     *
     * @throws IOException always thrown
     */
    @Override
    public synchronized void reset() throws IOException {
        throw exceptionSupplier.get();
    }

    /**
     * Throws the configured exception.
     *
     * @param n ignored
     * @return nothing
     * @throws IOException always thrown
     */


static Address parseAddress(String address) {
        String[] ss = address.split(":");
        if (ss.length != 3) {
            return null;
        }
        return new Address(ss[0], ss[1], ss[2]);
    }

package com.yiji.falcon.agent.plugins.plugin.http;

/*
 * 修订记录:
 * example@nnthink.com 2016-07-22 14:53 创建
 */
/**
 * 配置文件的地址解析
 * @author guqiu@yiji.com
 */
class AddressParse {

    static class Address {

        public String method;

        public String protocol;

        public String url;

        Address(String method, String protocol, String url) {
            this.method = method;
            this.protocol = protocol;
            this.url = url;
        }

        boolean isGetMethod() {
            return "get".equalsIgnoreCase(method);
        }

        boolean isPostMethod() {
            return "post".equalsIgnoreCase(method);
        }

        boolean isHttp() {
            return "http".equalsIgnoreCase(protocol);
        }

        boolean isHttps() {
            return "https".equalsIgnoreCase(protocol);
        }
    }

    /**
     * 根据地址字符串配置解析地址,返回地址对象
     * @param address
     * method:protocol:url格式的地址
     * @return
     * 解析失败返回null
     */