AsteriskQueueEntryImpl.java

package org.asteriskjava.live.internal;

import java.util.Date;

import org.asteriskjava.live.AsteriskQueueEntry;
import org.asteriskjava.live.QueueEntryState;

/**
 * Default implementation of the AsteriskQueueEntry interface.
 *
 * @author gmi
 */
class AsteriskQueueEntryImpl extends AbstractLiveObject implements AsteriskQueueEntry
{
    private final AsteriskQueueImpl queue;
    private final AsteriskChannelImpl channel;
    private final Date dateJoined;

    private Date dateLeft;
    private QueueEntryState state;

    // the position as given by asterisk in the queue entry or join event.
    // we cannot work reliably with it because asterisk doesn't tell us when it shifts the entries.
    private int reportedPosition;

    // The position of this entry in our representation of the queue. Will be set
    // and maintained by the respective queue when the entry is added/removed/shifted
    private int position = POSITION_UNDETERMINED;

    AsteriskQueueEntryImpl(AsteriskServerImpl server, AsteriskQueueImpl queue,
                           AsteriskChannelImpl channel, int reportedPosition, Date dateJoined)
    {
        super(server);
        this.queue = queue;
        this.channel = channel;
        this.dateJoined = dateJoined;
        this.state = QueueEntryState.JOINED;
        this.reportedPosition = reportedPosition;
    }

    public String getChannelName()
    {
        return channel.getName();
    }

    public AsteriskQueueImpl getQueue()
    {
        return queue;
    }

    public AsteriskChannelImpl getChannel()
    {
        return channel;
    }

    public Date getDateJoined()
    {
        return dateJoined;
    }

    public Date getDateLeft()
    {
        return dateLeft;
    }

    /**
     * Sets the status to {@link QueueEntryState#LEFT} and dateLeft to the given date.
     *
     * @param dateLeft the date this member left the queue.
     */
    void left(Date dateLeft)
    {
        QueueEntryState oldState;
        synchronized (this)
        {
            oldState = this.state;
            this.dateLeft = dateLeft;
            this.state = QueueEntryState.LEFT;
        }
        firePropertyChange(PROPERTY_STATE, oldState, state);
    }

    public QueueEntryState getState()
    {
        return state;
    }

    /**
     * Gets the position as reported by Asterisk when the entry was created.
     * Currently we don't update this property as the entry shifts through the queue,
     * see getPosition() instead.
     *
     * @return the position of the entry in the respective queue, starting at 1
     */
    public int getReportedPosition()
    {
        return reportedPosition;
    }

    /**
     * Gets the position in the queue based on the queue's internal list
     * <p/>
     * As Asterisk doesn't send events when it shifts entries in the queue
     * we'll base our positions on our internal queue entries ordered list.
     * It should be coherent as entries are always added at the end of the queue
     * and we don't mind if it is different from asterisk's view as long as the
     * relative order stays the same. Most of the time the position will be the same
     * but right after asterisk removes an entry it could differ as the shift occurs
     * asynchronously in asterisk queues. As a consequence we might have temporary holes
     * in the asterisk numbering.
     *
     * @return the position of the entry in the respective queue, starting at 1
     */
    public int getPosition()
    {
        return position;
    }

    void setPosition(int position)
    {
        int oldPosition = this.position;
        this.position = position;
        firePropertyChange(PROPERTY_POSITION, oldPosition, position);
    }

    void setReportedPosition(int reportedPosition)
    {
        int oldPosition = this.reportedPosition;
        this.reportedPosition = reportedPosition;
        firePropertyChange(PROPERTY_REPORTED_POSITION, oldPosition, reportedPosition);
    }

    public String toString()
    {
        StringBuffer sb;
        int systemHashcode;

        sb = new StringBuffer("AsteriskQueueEntry[");

        synchronized (this)
        {
            sb.append("dateJoined='").append(getDateJoined()).append("',");
            sb.append("postition='").append(getPosition()).append("',");
            sb.append("dateLeft='").append(getDateLeft()).append("',");
            systemHashcode = System.identityHashCode(this);
        }
        sb.append("channel=AsteriskChannel[");
        synchronized (channel)
        {
            sb.append("id='").append(channel.getId()).append("',");
            sb.append("name='").append(channel.getName()).append("'],");
        }
        sb.append("systemHashcode=").append(systemHashcode);
        sb.append("]");

        return sb.toString();
    }
}