Back to index...

	/*
	* Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package javax.management.monitor;

	import static com.sun.jmx.defaults.JmxProperties.MONITOR_LOGGER;
	import java.util.logging.Level;
	import javax.management.MBeanNotificationInfo;
	import javax.management.ObjectName;
	import static javax.management.monitor.Monitor.NumericalType.*;
	import static javax.management.monitor.MonitorNotification.*;

	/**
	* Defines a monitor MBean designed to observe the values of a gauge attribute.
	*
	* <P> A gauge monitor observes an attribute that is continuously
	* variable with time. A gauge monitor sends notifications as
	* follows:
	*
	* <UL>
	*
	* <LI> if the attribute value is increasing and becomes equal to or
	* greater than the high threshold value, a {@link
	* MonitorNotification#THRESHOLD_HIGH_VALUE_EXCEEDED threshold high
	* notification} is sent. The notify high flag must be set to
	* <CODE>true</CODE>.
	*
	* <BR>Subsequent crossings of the high threshold value do not cause
	* further notifications unless the attribute value becomes equal to
	* or less than the low threshold value.</LI>
	*
	* <LI> if the attribute value is decreasing and becomes equal to or
	* less than the low threshold value, a {@link
	* MonitorNotification#THRESHOLD_LOW_VALUE_EXCEEDED threshold low
	* notification} is sent. The notify low flag must be set to
	* <CODE>true</CODE>.
	*
	* <BR>Subsequent crossings of the low threshold value do not cause
	* further notifications unless the attribute value becomes equal to
	* or greater than the high threshold value.</LI>
	*
	* </UL>
	*
	* This provides a hysteresis mechanism to avoid repeated triggering
	* of notifications when the attribute value makes small oscillations
	* around the high or low threshold value.
	*
	* <P> If the gauge difference mode is used, the value of the derived
	* gauge is calculated as the difference between the observed gauge
	* values for two successive observations.
	*
	* <BR>The derived gauge value (V[t]) is calculated using the following method:
	* <UL>
	* <LI>V[t] = gauge[t] - gauge[t-GP]</LI>
	* </UL>
	*
	* This implementation of the gauge monitor requires the observed
	* attribute to be of the type integer or floating-point
	* (<CODE>Byte</CODE>, <CODE>Integer</CODE>, <CODE>Short</CODE>,
	* <CODE>Long</CODE>, <CODE>Float</CODE>, <CODE>Double</CODE>).
	*
	*
	* @since 1.5
	*/
	public class GaugeMonitor extends Monitor implements GaugeMonitorMBean {

	/*
	* ------------------------------------------
	* PACKAGE CLASSES
	* ------------------------------------------
	*/

	static class GaugeMonitorObservedObject extends ObservedObject {

	public GaugeMonitorObservedObject(ObjectName observedObject) {
	super(observedObject);
	}

	public final synchronized boolean getDerivedGaugeValid() {
	return derivedGaugeValid;
	}
	public final synchronized void setDerivedGaugeValid(
	boolean derivedGaugeValid) {
	this.derivedGaugeValid = derivedGaugeValid;
	}
	public final synchronized NumericalType getType() {
	return type;
	}
	public final synchronized void setType(NumericalType type) {
	this.type = type;
	}
	public final synchronized Number getPreviousScanGauge() {
	return previousScanGauge;
	}
	public final synchronized void setPreviousScanGauge(
	Number previousScanGauge) {
	this.previousScanGauge = previousScanGauge;
	}
	public final synchronized int getStatus() {
	return status;
	}
	public final synchronized void setStatus(int status) {
	this.status = status;
	}

	private boolean derivedGaugeValid;
	private NumericalType type;
	private Number previousScanGauge;
	private int status;
	}

	/*
	* ------------------------------------------
	* PRIVATE VARIABLES
	* ------------------------------------------
	*/

	/**
	* Gauge high threshold.
	*
	* <BR>The default value is a null Integer object.
	*/
	private Number highThreshold = INTEGER_ZERO;

	/**
	* Gauge low threshold.
	*
	* <BR>The default value is a null Integer object.
	*/
	private Number lowThreshold = INTEGER_ZERO;

	/**
	* Flag indicating if the gauge monitor notifies when exceeding
	* the high threshold.
	*
	* <BR>The default value is <CODE>false</CODE>.
	*/
	private boolean notifyHigh = false;

	/**
	* Flag indicating if the gauge monitor notifies when exceeding
	* the low threshold.
	*
	* <BR>The default value is <CODE>false</CODE>.
	*/
	private boolean notifyLow = false;

	/**
	* Flag indicating if the gauge difference mode is used. If the
	* gauge difference mode is used, the derived gauge is the
	* difference between two consecutive observed values. Otherwise,
	* the derived gauge is directly the value of the observed
	* attribute.
	*
	* <BR>The default value is set to <CODE>false</CODE>.
	*/
	private boolean differenceMode = false;

	private static final String[] types = {
	RUNTIME_ERROR,
	OBSERVED_OBJECT_ERROR,
	OBSERVED_ATTRIBUTE_ERROR,
	OBSERVED_ATTRIBUTE_TYPE_ERROR,
	THRESHOLD_ERROR,
	THRESHOLD_HIGH_VALUE_EXCEEDED,
	THRESHOLD_LOW_VALUE_EXCEEDED
	};

	private static final MBeanNotificationInfo[] notifsInfo = {
	new MBeanNotificationInfo(
	types,
	"javax.management.monitor.MonitorNotification",
	"Notifications sent by the GaugeMonitor MBean")
	};

	// Flags needed to implement the hysteresis mechanism.
	//
	private static final int RISING = 0;
	private static final int FALLING = 1;
	private static final int RISING_OR_FALLING = 2;

	/*
	* ------------------------------------------
	* CONSTRUCTORS
	* ------------------------------------------
	*/

	/**
	* Default constructor.
	*/
	public GaugeMonitor() {
	}

	/*
	* ------------------------------------------
	* PUBLIC METHODS
	* ------------------------------------------
	*/

	/**
	* Starts the gauge monitor.
	*/
	public synchronized void start() {
	if (isActive()) {
	MONITOR_LOGGER.logp(Level.FINER, GaugeMonitor.class.getName(),
	"start", "the monitor is already active");
	return;
	}
	// Reset values.
	//
	for (ObservedObject o : observedObjects) {
	final GaugeMonitorObservedObject gmo =
	(GaugeMonitorObservedObject) o;
	gmo.setStatus(RISING_OR_FALLING);
	gmo.setPreviousScanGauge(null);
	}
	doStart();
	}

	/**
	* Stops the gauge monitor.
	*/
	public synchronized void stop() {
	doStop();
	}

	// GETTERS AND SETTERS
	//--------------------

	/**
	* Gets the derived gauge of the specified object, if this object is
	* contained in the set of observed MBeans, or <code>null</code> otherwise.
	*
	* @param object the name of the MBean.
	*
	* @return The derived gauge of the specified object.
	*
	*/
	@Override
	public synchronized Number getDerivedGauge(ObjectName object) {
	return (Number) super.getDerivedGauge(object);
	}

	/**
	* Gets the derived gauge timestamp of the specified object, if
	* this object is contained in the set of observed MBeans, or
	* <code>0</code> otherwise.
	*
	* @param object the name of the object whose derived gauge
	* timestamp is to be returned.
	*
	* @return The derived gauge timestamp of the specified object.
	*
	*/
	@Override
	public synchronized long getDerivedGaugeTimeStamp(ObjectName object) {
	return super.getDerivedGaugeTimeStamp(object);
	}

	/**
	* Returns the derived gauge of the first object in the set of
	* observed MBeans.
	*
	* @return The derived gauge.
	*
	* @deprecated As of JMX 1.2, replaced by
	* {@link #getDerivedGauge(ObjectName)}
	*/
	@Deprecated
	public synchronized Number getDerivedGauge() {
	if (observedObjects.isEmpty()) {
	return null;
	} else {
	return (Number) observedObjects.get(0).getDerivedGauge();
	}
	}

	/**
	* Gets the derived gauge timestamp of the first object in the set
	* of observed MBeans.
	*
	* @return The derived gauge timestamp.
	*
	* @deprecated As of JMX 1.2, replaced by
	* {@link #getDerivedGaugeTimeStamp(ObjectName)}
	*/
	@Deprecated
	public synchronized long getDerivedGaugeTimeStamp() {
	if (observedObjects.isEmpty()) {
	return 0;
	} else {
	return observedObjects.get(0).getDerivedGaugeTimeStamp();
	}
	}

	/**
	* Gets the high threshold value common to all observed MBeans.
	*
	* @return The high threshold value.
	*
	* @see #setThresholds
	*/
	public synchronized Number getHighThreshold() {
	return highThreshold;
	}

	/**
	* Gets the low threshold value common to all observed MBeans.
	*
	* @return The low threshold value.
	*
	* @see #setThresholds
	*/
	public synchronized Number getLowThreshold() {
	return lowThreshold;
	}

	/**
	* Sets the high and the low threshold values common to all
	* observed MBeans.
	*
	* @param highValue The high threshold value.
	* @param lowValue The low threshold value.
	*
	* @exception IllegalArgumentException The specified high/low
	* threshold is null or the low threshold is greater than the high
	* threshold or the high threshold and the low threshold are not
	* of the same type.
	*
	* @see #getHighThreshold
	* @see #getLowThreshold
	*/
	public synchronized void setThresholds(Number highValue, Number lowValue)
	throws IllegalArgumentException {

	if ((highValue == null) \|\| (lowValue == null)) {
	throw new IllegalArgumentException("Null threshold value");
	}

	if (highValue.getClass() != lowValue.getClass()) {
	throw new IllegalArgumentException("Different type " +
	"threshold values");
	}

	if (isFirstStrictlyGreaterThanLast(lowValue, highValue,
	highValue.getClass().getName())) {
	throw new IllegalArgumentException("High threshold less than " +
	"low threshold");
	}

	if (highThreshold.equals(highValue) && lowThreshold.equals(lowValue))
	return;
	highThreshold = highValue;
	lowThreshold = lowValue;

	// Reset values.
	//
	int index = 0;
	for (ObservedObject o : observedObjects) {
	resetAlreadyNotified(o, index++, THRESHOLD_ERROR_NOTIFIED);
	final GaugeMonitorObservedObject gmo =
	(GaugeMonitorObservedObject) o;
	gmo.setStatus(RISING_OR_FALLING);
	}
	}

	/**
	* Gets the high notification's on/off switch value common to all
	* observed MBeans.
	*
	* @return <CODE>true</CODE> if the gauge monitor notifies when
	* exceeding the high threshold, <CODE>false</CODE> otherwise.
	*
	* @see #setNotifyHigh
	*/
	public synchronized boolean getNotifyHigh() {
	return notifyHigh;
	}

	/**
	* Sets the high notification's on/off switch value common to all
	* observed MBeans.
	*
	* @param value The high notification's on/off switch value.
	*
	* @see #getNotifyHigh
	*/
	public synchronized void setNotifyHigh(boolean value) {
	if (notifyHigh == value)
	return;
	notifyHigh = value;
	}

	/**
	* Gets the low notification's on/off switch value common to all
	* observed MBeans.
	*
	* @return <CODE>true</CODE> if the gauge monitor notifies when
	* exceeding the low threshold, <CODE>false</CODE> otherwise.
	*
	* @see #setNotifyLow
	*/
	public synchronized boolean getNotifyLow() {
	return notifyLow;
	}

	/**
	* Sets the low notification's on/off switch value common to all
	* observed MBeans.
	*
	* @param value The low notification's on/off switch value.
	*
	* @see #getNotifyLow
	*/
	public synchronized void setNotifyLow(boolean value) {
	if (notifyLow == value)
	return;
	notifyLow = value;
	}

	/**
	* Gets the difference mode flag value common to all observed MBeans.
	*
	* @return <CODE>true</CODE> if the difference mode is used,
	* <CODE>false</CODE> otherwise.
	*
	* @see #setDifferenceMode
	*/
	public synchronized boolean getDifferenceMode() {
	return differenceMode;
	}

	/**
	* Sets the difference mode flag value common to all observed MBeans.
	*
	* @param value The difference mode flag value.
	*
	* @see #getDifferenceMode
	*/
	public synchronized void setDifferenceMode(boolean value) {
	if (differenceMode == value)
	return;
	differenceMode = value;

	// Reset values.
	//
	for (ObservedObject o : observedObjects) {
	final GaugeMonitorObservedObject gmo =
	(GaugeMonitorObservedObject) o;
	gmo.setStatus(RISING_OR_FALLING);
	gmo.setPreviousScanGauge(null);
	}
	}

	/**
	* Returns a <CODE>NotificationInfo</CODE> object containing the
	* name of the Java class of the notification and the notification
	* types sent by the gauge monitor.
	*/
	@Override
	public MBeanNotificationInfo[] getNotificationInfo() {
	return notifsInfo.clone();
	}

	/*
	* ------------------------------------------
	* PRIVATE METHODS
	* ------------------------------------------
	*/

	/**
	* Updates the derived gauge attribute of the observed object.
	*
	* @param scanGauge The value of the observed attribute.
	* @param o The observed object.
	* @return <CODE>true</CODE> if the derived gauge value is valid,
	* <CODE>false</CODE> otherwise. The derived gauge value is
	* invalid when the differenceMode flag is set to
	* <CODE>true</CODE> and it is the first notification (so we
	* haven't 2 consecutive values to update the derived gauge).
	*/
	private synchronized boolean updateDerivedGauge(
	Object scanGauge, GaugeMonitorObservedObject o) {

	boolean is_derived_gauge_valid;

	// The gauge difference mode is used.
	//
	if (differenceMode) {

	// The previous scan gauge has been initialized.
	//
	if (o.getPreviousScanGauge() != null) {
	setDerivedGaugeWithDifference((Number)scanGauge, o);
	is_derived_gauge_valid = true;
	}
	// The previous scan gauge has not been initialized.
	// We cannot update the derived gauge...
	//
	else {
	is_derived_gauge_valid = false;
	}
	o.setPreviousScanGauge((Number)scanGauge);
	}
	// The gauge difference mode is not used.
	//
	else {
	o.setDerivedGauge((Number)scanGauge);
	is_derived_gauge_valid = true;
	}

	return is_derived_gauge_valid;
	}

	/**
	* Updates the notification attribute of the observed object
	* and notifies the listeners only once if the notify flag
	* is set to <CODE>true</CODE>.
	* @param o The observed object.
	*/
	private synchronized MonitorNotification updateNotifications(
	GaugeMonitorObservedObject o) {

	MonitorNotification n = null;

	// Send high notification if notifyHigh is true.
	// Send low notification if notifyLow is true.
	//
	if (o.getStatus() == RISING_OR_FALLING) {
	if (isFirstGreaterThanLast((Number)o.getDerivedGauge(),
	highThreshold,
	o.getType())) {
	if (notifyHigh) {
	n = new MonitorNotification(
	THRESHOLD_HIGH_VALUE_EXCEEDED,
	this,
	0,
	0,
	"",
	null,
	null,
	null,
	highThreshold);
	}
	o.setStatus(FALLING);
	} else if (isFirstGreaterThanLast(lowThreshold,
	(Number)o.getDerivedGauge(),
	o.getType())) {
	if (notifyLow) {
	n = new MonitorNotification(
	THRESHOLD_LOW_VALUE_EXCEEDED,
	this,
	0,
	0,
	"",
	null,
	null,
	null,
	lowThreshold);
	}
	o.setStatus(RISING);
	}
	} else {
	if (o.getStatus() == RISING) {
	if (isFirstGreaterThanLast((Number)o.getDerivedGauge(),
	highThreshold,
	o.getType())) {
	if (notifyHigh) {
	n = new MonitorNotification(
	THRESHOLD_HIGH_VALUE_EXCEEDED,
	this,
	0,
	0,
	"",
	null,
	null,
	null,
	highThreshold);
	}
	o.setStatus(FALLING);
	}
	} else if (o.getStatus() == FALLING) {
	if (isFirstGreaterThanLast(lowThreshold,
	(Number)o.getDerivedGauge(),
	o.getType())) {
	if (notifyLow) {
	n = new MonitorNotification(
	THRESHOLD_LOW_VALUE_EXCEEDED,
	this,
	0,
	0,
	"",
	null,
	null,
	null,
	lowThreshold);
	}
	o.setStatus(RISING);
	}
	}
	}

	return n;
	}

	/**
	* Sets the derived gauge when the differenceMode flag is set to
	* <CODE>true</CODE>. Both integer and floating-point types are
	* allowed.
	*
	* @param scanGauge The value of the observed attribute.
	* @param o The observed object.
	*/
	private synchronized void setDerivedGaugeWithDifference(
	Number scanGauge, GaugeMonitorObservedObject o) {
	Number prev = o.getPreviousScanGauge();
	Number der;
	switch (o.getType()) {
	case INTEGER:
	der = Integer.valueOf(((Integer)scanGauge).intValue() -
	((Integer)prev).intValue());
	break;
	case BYTE:
	der = Byte.valueOf((byte)(((Byte)scanGauge).byteValue() -
	((Byte)prev).byteValue()));
	break;
	case SHORT:
	der = Short.valueOf((short)(((Short)scanGauge).shortValue() -
	((Short)prev).shortValue()));
	break;
	case LONG:
	der = Long.valueOf(((Long)scanGauge).longValue() -
	((Long)prev).longValue());
	break;
	case FLOAT:
	der = Float.valueOf(((Float)scanGauge).floatValue() -
	((Float)prev).floatValue());
	break;
	case DOUBLE:
	der = Double.valueOf(((Double)scanGauge).doubleValue() -
	((Double)prev).doubleValue());
	break;
	default:
	// Should never occur...
	MONITOR_LOGGER.logp(Level.FINEST, GaugeMonitor.class.getName(),
	"setDerivedGaugeWithDifference",
	"the threshold type is invalid");
	return;
	}
	o.setDerivedGauge(der);
	}

	/**
	* Tests if the first specified Number is greater than or equal to
	* the last. Both integer and floating-point types are allowed.
	*
	* @param greater The first Number to compare with the second.
	* @param less The second Number to compare with the first.
	* @param type The number type.
	* @return <CODE>true</CODE> if the first specified Number is
	* greater than or equal to the last, <CODE>false</CODE>
	* otherwise.
	*/
	private boolean isFirstGreaterThanLast(Number greater,
	Number less,
	NumericalType type) {

	switch (type) {
	case INTEGER:
	case BYTE:
	case SHORT:
	case LONG:
	return (greater.longValue() >= less.longValue());
	case FLOAT:
	case DOUBLE:
	return (greater.doubleValue() >= less.doubleValue());
	default:
	// Should never occur...
	MONITOR_LOGGER.logp(Level.FINEST, GaugeMonitor.class.getName(),
	"isFirstGreaterThanLast",
	"the threshold type is invalid");
	return false;
	}
	}

	/**
	* Tests if the first specified Number is strictly greater than the last.
	* Both integer and floating-point types are allowed.
	*
	* @param greater The first Number to compare with the second.
	* @param less The second Number to compare with the first.
	* @param className The number class name.
	* @return <CODE>true</CODE> if the first specified Number is
	* strictly greater than the last, <CODE>false</CODE> otherwise.
	*/
	private boolean isFirstStrictlyGreaterThanLast(Number greater,
	Number less,
	String className) {

	if (className.equals("java.lang.Integer") \|\|
	className.equals("java.lang.Byte") \|\|
	className.equals("java.lang.Short") \|\|
	className.equals("java.lang.Long")) {

	return (greater.longValue() > less.longValue());
	}
	else if (className.equals("java.lang.Float") \|\|
	className.equals("java.lang.Double")) {

	return (greater.doubleValue() > less.doubleValue());
	}
	else {
	// Should never occur...
	MONITOR_LOGGER.logp(Level.FINEST, GaugeMonitor.class.getName(),
	"isFirstStrictlyGreaterThanLast",
	"the threshold type is invalid");
	return false;
	}
	}

	/*
	* ------------------------------------------
	* PACKAGE METHODS
	* ------------------------------------------
	*/

	/**
	* Factory method for ObservedObject creation.
	*
	* @since 1.6
	*/
	@Override
	ObservedObject createObservedObject(ObjectName object) {
	final GaugeMonitorObservedObject gmo =
	new GaugeMonitorObservedObject(object);
	gmo.setStatus(RISING_OR_FALLING);
	gmo.setPreviousScanGauge(null);
	return gmo;
	}

	/**
	* This method globally sets the derived gauge type for the given
	* "object" and "attribute" after checking that the type of the
	* supplied observed attribute value is one of the value types
	* supported by this monitor.
	*/
	@Override
	synchronized boolean isComparableTypeValid(ObjectName object,
	String attribute,
	Comparable<?> value) {
	final GaugeMonitorObservedObject o =
	(GaugeMonitorObservedObject) getObservedObject(object);
	if (o == null)
	return false;

	// Check that the observed attribute is either of type
	// "Integer" or "Float".
	//
	if (value instanceof Integer) {
	o.setType(INTEGER);
	} else if (value instanceof Byte) {
	o.setType(BYTE);
	} else if (value instanceof Short) {
	o.setType(SHORT);
	} else if (value instanceof Long) {
	o.setType(LONG);
	} else if (value instanceof Float) {
	o.setType(FLOAT);
	} else if (value instanceof Double) {
	o.setType(DOUBLE);
	} else {
	return false;
	}
	return true;
	}

	@Override
	synchronized Comparable<?> getDerivedGaugeFromComparable(
	ObjectName object,
	String attribute,
	Comparable<?> value) {
	final GaugeMonitorObservedObject o =
	(GaugeMonitorObservedObject) getObservedObject(object);
	if (o == null)
	return null;

	// Update the derived gauge attributes and check the
	// validity of the new value. The derived gauge value
	// is invalid when the differenceMode flag is set to
	// true and it is the first notification, i.e. we
	// haven't got 2 consecutive values to update the
	// derived gauge.
	//
	o.setDerivedGaugeValid(updateDerivedGauge(value, o));

	return (Comparable<?>) o.getDerivedGauge();
	}

	@Override
	synchronized void onErrorNotification(MonitorNotification notification) {
	final GaugeMonitorObservedObject o = (GaugeMonitorObservedObject)
	getObservedObject(notification.getObservedObject());
	if (o == null)
	return;

	// Reset values.
	//
	o.setStatus(RISING_OR_FALLING);
	o.setPreviousScanGauge(null);
	}

	@Override
	synchronized MonitorNotification buildAlarmNotification(
	ObjectName object,
	String attribute,
	Comparable<?> value) {
	final GaugeMonitorObservedObject o =
	(GaugeMonitorObservedObject) getObservedObject(object);
	if (o == null)
	return null;

	// Notify the listeners if the updated derived
	// gauge value is valid.
	//
	final MonitorNotification alarm;
	if (o.getDerivedGaugeValid())
	alarm = updateNotifications(o);
	else
	alarm = null;
	return alarm;
	}

	/**
	* Tests if the threshold high and threshold low are both of the
	* same type as the gauge. Both integer and floating-point types
	* are allowed.
	*
	* Note:
	* If the optional lowThreshold or highThreshold have not been
	* initialized, their default value is an Integer object with
	* a value equal to zero.
	*
	* @param object The observed object.
	* @param attribute The observed attribute.
	* @param value The sample value.
	* @return <CODE>true</CODE> if type is the same,
	* <CODE>false</CODE> otherwise.
	*/
	@Override
	synchronized boolean isThresholdTypeValid(ObjectName object,
	String attribute,
	Comparable<?> value) {
	final GaugeMonitorObservedObject o =
	(GaugeMonitorObservedObject) getObservedObject(object);
	if (o == null)
	return false;

	Class<? extends Number> c = classForType(o.getType());
	return (isValidForType(highThreshold, c) &&
	isValidForType(lowThreshold, c));
	}
	}

Back to index...