org.jivesoftware.smackx.muc.ConnectionDetachedPacketCollector Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of smack Show documentation
Smack is an Open Source XMPP (Jabber) client library for instant messaging and presence. This library provides the client side functionality as specified in the core XMPP specifications as related to the client side of said specifications.
The newest version!
/**
 * $RCSfile$
 * $Revision: 2779 $
 * $Date: 2005-09-05 17:00:45 -0300 (Mon, 05 Sep 2005) $
 *
 * Copyright 2003-2006 Jive Software.
 *
 * All rights reserved. Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.jivesoftware.smackx.muc;

import org.jivesoftware.smack.SmackConfiguration;
import org.jivesoftware.smack.packet.Packet;

import java.util.LinkedList;

/**
 * A variant of the {@link org.jivesoftware.smack.PacketCollector} class
 * that does not force attachment to a Connection
 * on creation and no filter is required. Used to collect message
 * packets targeted to a group chat room.
 *
 * @author Larry Kirschner
 */
class ConnectionDetachedPacketCollector {
    /**
     * Max number of packets that any one collector can hold. After the max is
     * reached, older packets will be automatically dropped from the queue as
     * new packets are added.
     */
    private int maxPackets = SmackConfiguration.getPacketCollectorSize();

    private LinkedList resultQueue;

    /**
     * Creates a new packet collector. If the packet filter is null, then
     * all packets will match this collector.
     */
    public ConnectionDetachedPacketCollector() {
        this.resultQueue = new LinkedList();
    }

    /**
     * Creates a new packet collector. If the packet filter is null, then
     * all packets will match this collector.
     */
    public ConnectionDetachedPacketCollector(int maxSize) {
        this.resultQueue = new LinkedList();
        maxPackets = maxSize;
    }

    /**
     * Polls to see if a packet is currently available and returns it, or
     * immediately returns null if no packets are currently in the
     * result queue.
     *
     * @return the next packet result, or null if there are no more
     *      results.
     */
    public synchronized Packet pollResult() {
        if (resultQueue.isEmpty()) {
            return null;
        }
        else {
            return resultQueue.removeLast();
        }
    }

    /**
     * Returns the next available packet. The method call will block (not return)
     * until a packet is available.
     *
     * @return the next available packet.
     */
    public synchronized Packet nextResult() {
        // Wait indefinitely until there is a result to return.
        while (resultQueue.isEmpty()) {
            try {
                wait();
            }
            catch (InterruptedException ie) {
                // Ignore.
            }
        }
        return resultQueue.removeLast();
    }

    /**
     * Returns the next available packet. The method call will block (not return)
     * until a packet is available or the timeout has elapased. If the
     * timeout elapses without a result, null will be returned.
     *
     * @param timeout the amount of time to wait for the next packet (in milleseconds).
     * @return the next available packet.
     */
    public synchronized Packet nextResult(long timeout) {
        // Wait up to the specified amount of time for a result.
        if (resultQueue.isEmpty()) {
            try {
                wait(timeout);
            }
            catch (InterruptedException ie) {
                // Ignore.
            }
        }
        // If still no result, return null.
        if (resultQueue.isEmpty()) {
            return null;
        }
        else {
            return resultQueue.removeLast();
        }
    }

    /**
     * Processes a packet to see if it meets the criteria for this packet collector.
     * If so, the packet is added to the result queue.
     *
     * @param packet the packet to process.
     */
    protected synchronized void processPacket(Packet packet) {
        if (packet == null) {
            return;
        }
        // If the max number of packets has been reached, remove the oldest one.
        if (resultQueue.size() == maxPackets) {
            resultQueue.removeLast();
        }
        // Add the new packet.
        resultQueue.addFirst(packet);
        // Notify waiting threads a result is available.
        notifyAll();
    }
}