/*
 * 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
 * or http://www.opensolaris.org/os/licensing.
 * 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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */
package org.opensolaris.os.dtrace;

import java.io.Serializable;
import java.io.*;
import java.beans.*;

/**
 * Detail about one or more records dropped by DTrace (not reported to
 * {@link ConsumerListener#dataReceived(DataEvent e)
 * ConsumerListener.dataReceived()}) due to inadequte buffer space.
 * <p>
 * Immutable.  Supports persistence using {@link java.beans.XMLEncoder}.
 *
 * @see ConsumerListener#dataDropped(DropEvent e)
 *
 * @author Tom Erickson
 */
public final class Drop implements Serializable {
    static final long serialVersionUID = 26653827678657381L;

    static {
	try {
	    BeanInfo info = Introspector.getBeanInfo(Drop.class);
	    PersistenceDelegate persistenceDelegate =
		    new DefaultPersistenceDelegate(
		    new String[] {"CPU", "kind", "count", "total",
		    "defaultMessage"})
	    {
		protected Expression
		instantiate(Object oldInstance, Encoder out)
		{
		    Drop drop = (Drop)oldInstance;
		    return new Expression(oldInstance, oldInstance.getClass(),
			    "new", new Object[] { drop.getCPU(),
			    drop.getKind().name(), drop.getCount(),
			    drop.getTotal(), drop.getDefaultMessage() });
		}
	    };
	    BeanDescriptor d = info.getBeanDescriptor();
	    d.setValue("persistenceDelegate", persistenceDelegate);
	} catch (IntrospectionException e) {
	    e.printStackTrace();
	}
    }

    /**
     * Indicates what kind of buffer space experienced the data drop
     * (such as principal buffer or aggregation buffer) and possibly a
     * reason.
     */
    public enum Kind {
	/** Drop to principal buffer */
	PRINCIPAL("Principal buffer"),
	/** Drop to aggregation buffer */
	AGGREGATION("Aggregation"),
	/** Dynamic drop */
	DYNAMIC("Dynamic"),
	/** Dynamic drop due to rinsing */
	DYNRINSE("Dynamic (rinse)"),
	/** Dynamic drop due to dirtiness */
	DYNDIRTY("Dynamic (dirty)"),
	/** Speculative drop */
	SPEC("Speculation"),
	/** Speculative drop due to business */
	SPECBUSY("Speculation (busy)"),
	/** Speculative drop due to unavailability */
	SPECUNAVAIL("Speculation (unavailable)"),
	/** Stack string table overflow */
	STKSTROVERFLOW("Stack string table overflow"),
	/** Error in ERROR probe */
	DBLERROR("error in ERROR probe"),
	/** Unrecognized value from native DTrace library */
	UNKNOWN("Unknown");

	private String s;

	private
	Kind(String displayString)
	{
	    s = displayString;
	}

	/**
	 * Overridden to get the default display value.  To
	 * internationalize the display value, use {@link Enum#name()}
	 * instead as an I18N lookup key.
	 */
	public String
	toString()
	{
	    return s;
	}
    }

    /** @serial */
    private final int cpu;
    /** @serial */
    private final Kind kind;
    /** @serial */
    private final long count;
    /** @serial */
    private final long total;
    /** @serial */
    private final String defaultMessage;

    /**
     * Creates a {@code Drop} instance with the given CPU, drop kind,
     * drop counts, and default message.  Supports XML persistence.
     *
     * @param dropCPU cpu where drops occurred
     * @param dropKindName name of enumeration value indicating the kind
     * of buffer space where the drop occurred and possibly a reason
     * @param dropCount number of drops
     * @param totalDrops total number of drops since the source {@link
     * Consumer} started running
     * @param defaultDropMessage drop message provided by DTrace
     * @throws IllegalArgumentException if there is no {@code Drop.Kind}
     * value with the given name or if {@code dropCount} or {@code
     * totalDrops} is negative
     * @throws NullPointerException if the given {@code Drop.Kind} name
     * or default message is {@code null}
     */
    public
    Drop(int dropCPU, String dropKindName, long dropCount, long totalDrops,
	    String defaultDropMessage)
    {
	cpu = dropCPU;
	kind = Enum.valueOf(Kind.class, dropKindName);
	count = dropCount;
	total = totalDrops;
	defaultMessage = defaultDropMessage;
	validate();
    }

    private final void
    validate()
    {
	if (count < 0) {
	    throw new IllegalArgumentException("count is negative");
	}
	if (total < 0) {
	    throw new IllegalArgumentException("total is negative");
	}
	if (defaultMessage == null) {
	    throw new NullPointerException("default message is null");
	}
    }

    /**
     * Gets the CPU where the drops occurred.
     *
     * @return non-negative CPU ID, or a negative number if the CPU is
     * unknown
     */
    public int
    getCPU()
    {
	return cpu;
    }

    /**
     * Gets the kind of drop for all drops included in {@link
     * #getCount()}.
     *
     * @return non-null drop kind
     */
    public Kind
    getKind()
    {
	return kind;
    }

    /**
     * Gets the number of drops reported by this {@code Drop} instance.
     *
     * @return non-negative drop count
     */
    public long
    getCount()
    {
	return count;
    }

    /**
     * Gets the total number of drops since the source {@link Consumer}
     * started running.
     *
     * @return non-negative drop total since tracing started
     */
    public long
    getTotal()
    {
	return total;
    }

    /**
     * Gets the message provided by DTrace.
     *
     * @return non-null message provided by DTrace
     */
    public String
    getDefaultMessage()
    {
	return defaultMessage;
    }

    private void
    readObject(ObjectInputStream s)
	    throws IOException, ClassNotFoundException
    {
	s.defaultReadObject();
	// check class invariants
	try {
	    validate();
	} catch (Exception e) {
	    InvalidObjectException x = new InvalidObjectException(
		    e.getMessage());
	    x.initCause(e);
	    throw x;
	}
    }

    /**
     * Gets a string representation of this drop instance, 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()
    {
	StringBuilder buf = new StringBuilder();
	buf.append(Drop.class.getName());
	buf.append("[cpu = ");
	buf.append(cpu);
	buf.append(", kind = ");
	buf.append(kind);
	buf.append(", count = ");
	buf.append(count);
	buf.append(", total = ");
	buf.append(total);
	buf.append(", defaultMessage = ");
	buf.append(defaultMessage);
	buf.append(']');
	return buf.toString();
    }
}