timeoutmanagerentry.java

High performance DB query

/*
 * @(#)$Id: TimeoutManagerEntry.java,v 1.4 2004/07/02 23:59:23 huebsch Exp $
 *
 * Copyright (c) 2001-2004 Regents of the University of California.
 * All rights reserved.
 *
 * This file is distributed under the terms in the attached BERKELEY-LICENSE
 * file. If you do not find these files, copies can be found by writing to:
 * Computer Science Division, Database Group, Universite of California,
 * 617 Soda Hall #1776, Berkeley, CA 94720-1776. Attention: Berkeley License
 *
 * Copyright (c) 2003-2004 Intel Corporation. All rights reserved.
 *
 * This file is distributed under the terms in the attached INTEL-LICENSE file.
 * If you do not find these files, copies can be found by writing to:
 * Intel Research Berkeley, 2150 Shattuck Avenue, Suite 1300,
 * Berkeley, CA, 94704.  Attention:  Intel License Inquiry.
 */


package util.timer.timeouts;

import util.FreeList;
import util.FreeListFactory;

/**
 * Class TimeoutManagerEntry
 *
 */
public class TimeoutManagerEntry implements Comparable {

    private Object item, key;
    private double timeout;
    private TimeoutManagerClient client;
    private static FreeList freeList =
        new FreeList(new TimeoutManagerEntryFactory());

    /**
     * Constructor TimeoutManagerEntry
     */
    protected TimeoutManagerEntry() {}

    private void init(Object item, Object key, double timeout,
                      TimeoutManagerClient client) {
        this.item = item;
        this.key = key;
        this.timeout = timeout;
        this.client = client;
    }

    /**
     * Method getItem
     * @return
     */
    public Object getItem() {
        return item;
    }

    /**
     * Method getKey
     * @return
     */
    public Object getKey() {
        return key;
    }

    /**
     * Method getTimeout
     * @return
     */
    public double getTimeout() {
        return timeout;
    }

    /**
     * Method getClient
     * @return
     */
    public TimeoutManagerClient getClient() {
        return client;
    }

    /**
     * Method equals
     *
     * @param other
     * @return
     */
    public boolean equals(Object other) {
        TimeoutManagerEntry otherEntry = (TimeoutManagerEntry) other;

        return (item.equals(otherEntry.item));
    }

    /**
     * Method compareTo
     *
     * @param other
     * @return
     */
    public int compareTo(Object other) {
        TimeoutManagerEntry otherEntry = (TimeoutManagerEntry) other;

        if (timeout > otherEntry.timeout) {
            return 1;
        }

        if (timeout < otherEntry.timeout) {
            return -1;
        }

        if (item instanceof Comparable) {
            return (((Comparable) item).compareTo(otherEntry.item));
        }

        if (this.hashCode() > other.hashCode()) {
            return 1;
        }

        if (this.hashCode() < other.hashCode()) {
            return -1;
        }

        return 0;
    }

    /**
     * Method allocate
     *
     * @param item
     * @param key
     * @param timeout
     * @param client
     * @return
     */
    public static TimeoutManagerEntry allocate(Object item, Object key,
                                               double timeout,
                                               TimeoutManagerClient client) {
        TimeoutManagerEntry theEntry =
            (TimeoutManagerEntry) freeList.allocate();

        theEntry.init(item, key, timeout, client);

        return theEntry;
    }

    /**
     * Method free
     *
     * @param theEntry
     */
    public static void free(TimeoutManagerEntry theEntry) {
        freeList.free(theEntry);
    }
}


/**
 * Class TimeoutManagerEntryFactory
 *
 */
class TimeoutManagerEntryFactory implements FreeListFactory {

    /**
     * Method create
     * @return
     */
    public Object create() {
        return new TimeoutManagerEntry();
    }
}