/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*
* ident "%Z%%M% %I% %E% SMI"
*/
/**
* A single key-value pair in a DTrace aggregation.
* <p>
* Immutable. Supports persistence using {@link java.beans.XMLEncoder}.
*
* @see Aggregation
* @author Tom Erickson
*/
static {
try {
{
/*
* Need to prevent DefaultPersistenceDelegate from using
* overridden equals() method, resulting in a
* StackOverFlowError. Revert to PersistenceDelegate
* implementation. See
* 477019&tstart=135
*/
protected boolean
{
}
};
} catch (IntrospectionException e) {
}
}
/** @serial */
/** @serial */
/** @serial */
private int ordinal;
/**
* Creates an aggregation record with the given key and value.
* Supports XML persistence.
*
* @see #AggregationRecord(Tuple tupleKey, AggregationValue
* recordValue, int n)
*/
public
{
//
// Called by native code, but public to support backwardly
// compatible XML encoding.
//
value = recordValue;
validate();
}
/**
* Creates an aggregation record with the given key, value, and
* ordinal. Supports XML persistence.
*
* @param tupleKey aggregation tuple, may be empty (see {@link
* Tuple#EMPTY}) to indicate that this record's value belongs to an
* unkeyed aggregation declared without square brackets, for
* example: <pre> {@code @a = count();}</pre>
* @param recordValue aggregated value associated with the given
* tuple
* @param n ordinal from zero (first) to n-1 (last) within the
* {@link Aggregate} containing this record
* @throws NullPointerException if the given key or value is
* {@code null}
* @throws IllegalArgumentException if the given ordinal is negative
*/
public
{
value = recordValue;
ordinal = n;
validate();
}
private final void
validate()
{
throw new NullPointerException("key is null");
}
throw new NullPointerException("value is null");
}
if (ordinal < 0) {
throw new IllegalArgumentException("ordinal is negative");
}
}
/**
* Gets the multi-element key associated with {@link
* #getValue()}.
*
* @return non-null, possibly empty tuple
* @see Aggregation#getRecord(Tuple key)
*/
public Tuple
getTuple()
{
return tuple;
}
/**
* Gets the value associated with {@link #getTuple()}. Values
* generated by the DTrace actions {@code count()}, {@code sum()},
* {@code avg()}, {@code min()}, and {@code max()} are of type
* {@link Long}. Values generated by the DTrace actions {@code
* quantize(}) and {@code lquantize()} are of type {@link
* Distribution}.
*
* @return non-null value keyed to {@link #getTuple()}
*/
public AggregationValue
getValue()
{
return value;
}
/**
* Gets the ordinal generated when this AggregationRecord was added
* to its containing {@link Aggregate} by the native DTrace library,
* from zero (first) to n-1 (last). The sequence described by an
* aggregate's record ordinals reflects the setting of the {@link
* Option#aggsortkey aggsortkey}, {@link Option#aggsortkeypos
* aggsortkeypos}, {@link Option#aggsortpos aggsortpos}, and {@link
* Option#aggsortrev aggsortrev} DTrace options and matches the way
* that the records would be ordered by {@code dtrace(1M)}.
*
* @return non-negative ordinal from zero (first) to n-1 (last)
* within the {@code Aggregate} containing this record
* @see Aggregate#getOrderedRecords()
*/
public int
{
return ordinal;
}
/**
* Package level access; called by Aggregate
*/
void
setOrdinal(int n)
{
if (n < 0) {
throw new IllegalArgumentException("ordinal is negative");
}
ordinal = n;
}
/**
* Compares the specified object with this aggregation record for
* equality. Defines equality as having the same tuple and value.
*
* @return {@code true} if and only if the specified object is an
* {@code AggregationRecord} and both records have equal tuples as
* defined by {@link Tuple#equals(Object o)} and equal values as
* defined by the implementation of {@link AggregationValue}
*/
public boolean
{
if (o instanceof AggregationRecord) {
AggregationRecord r = (AggregationRecord)o;
}
return false;
}
/**
* Overridden to ensure that equal records have equal hash codes.
*/
public int
hashCode()
{
int hash = 17;
return hash;
}
private void
throws IOException, ClassNotFoundException
{
s.defaultReadObject();
// Check class invariants
try {
validate();
} catch (Exception e) {
e.getMessage());
x.initCause(e);
throw x;
}
}
/**
* Gets a string representation of this aggregation record useful
* for logging and not intended for display. The exact details of
* the representation are unspecified and subject to change, but the
* following format may be regarded as typical:
* <pre><code>
* class-name[property1 = value1, property2 = value2]
* </code></pre>
*/
public String
toString()
{
}
}