Fired when Queue is declared

@param e
8925
private void fireOnDeclareQueue(ChannelEvent e) {
        List<EventListener> listeners = changes.getListenerList(AMQP);
        for (EventListener listener : listeners) {
            ChannelListener amqpListener = (ChannelListener)listener;
            amqpListener.onDeclareQueue(e);
        }
    }
566
public void queueEvent(Runnable r) {
                synchronized (this) {
                        mEventQueue.add(r);
                        synchronized (sGLThreadManager) {
                                mEventsWaiting = true;
                                sGLThreadManager.notifyAll();
                        }
                }
        }
401482
private void fireOnUnbind(ChannelEvent e) {
        List<EventListener> listeners = changes.getListenerList(AMQP);
        for (EventListener listener : listeners) {
            ChannelListener amqpListener = (ChannelListener)listener;
            amqpListener.onUnbind(e);
        }
    }
591534
private void fireOnConsumeBasic(ChannelEvent e) {
        List<EventListener> listeners = changes.getListenerList(AMQP);
        for (EventListener listener : listeners) {
            ChannelListener amqpListener = (ChannelListener)listener;
            amqpListener.onConsumeBasic(e);
        }
    }
823554
private void fireOnDeleteExchange(ChannelEvent e) {
        List<EventListener> listeners = changes.getListenerList(AMQP);
        for (EventListener listener : listeners) {
            ChannelListener amqpListener = (ChannelListener)listener;
            amqpListener.onDeleteExchange(e);
        }
    }
967422
public void set(final Exception e) {
		if (this.value.compareAndSet(null, e)) {
			this.listeners.clear();
			this.cdl.countDown();
		}
	}
448207
@Inject
    public void setQueue(EventQueue queue) {
        if (epi == null) {
            MessageToEventMapper mapper = new MessageToEventMapper();
            mapper.setMaxContentLength(maxContentLength);

            epi = new EventProducerInterceptor(mapper, queue);
        }
    }
858166
protected void trigger(GwtEvent<?> e, Function callback, Element element) {
    trigger(e, callback, element, eventBus);
  }
40806
@Subscribe
    public void onThumbnailWritten(ThumbnailWrittenEvent e) {
        try {
            queueOrSubmitUpload(keyForFilename("thumb.jpg"), e.getThumbnailFile());
        } catch (Exception ex) {
            Log.i(TAG, "Error writing thumbanil");
            ex.printStackTrace();
        }
    }
700620
protected void processQueue() {
        try {
            QueueItem item = queue.take();
            client.addMultipleCounterDataPoints(item.tenantId, item.data);
        } catch (InterruptedException e) {
            // TODO better logging of this unlikely error
            e.printStackTrace();
            return;
        }
    }
495501
def on_input_queue_declare(self, queue):
        
        self.in_channel.queue_bind(callback=None,
                                   exchange='input_exc',
                                   queue=self.INPUT_QUEUE_NAME,
                                   routing_key="#")
652471
function( e )
        {
            var event      = new Event( aType );
            event.target   = self;
            event.srcEvent = e;

            aHandler( event );
        }
376703
private void handleQueueEntryEvent(QueueEntryEvent event)
    {
        final AsteriskQueueImpl queue = getInternalQueueByName(event.getQueue());
        final AsteriskChannelImpl channel = channelManager.getChannelImplByName(event.getChannel());

        if (queue == null)
        {
            logger.error("Ignored QueueEntryEvent for unknown queue " + event.getQueue());
            return;
        }
        if (channel == null)
        {
            logger.error("Ignored QueueEntryEvent for unknown channel " + event.getChannel());
            return;
        }

        if (queue.getEntry(event.getChannel()) != null)
        {
            logger.debug("Ignored duplicate queue entry during population in queue " + event.getQueue() + " for channel "
                    + event.getChannel());
            return;
        }

        // Asterisk gives us an initial position but doesn't tell us when he
        // shifts the others
        // We won't use this data for ordering until there is a appropriate
        // event in AMI.
        // (and refreshing the whole queue is too intensive and suffers
        // incoherencies
        // due to asynchronous shift that leaves holes if requested too fast)
        int reportedPosition = event.getPosition();

        queue.createNewEntry(channel, reportedPosition, event.getDateReceived());
    }
869328
@Override
	public void executeBatch(OperationsQueue queue) {
		if ( batchableGridDialect != null ) {
			batchableGridDialect.executeBatch( queue );
		}
		else if ( groupingByEntityGridDialect != null ) {
			groupingByEntityGridDialect.executeBatch( queue );
		}
	}
689122
public void objectTerminated(Object object, Exception e)
	{
		// Allows to unblock all terminating threads
		synchronized (terminatedLock)
		{
			if (terminated)
			{
				return;
			}
			terminated = true;
		}

		engine.removeTerminationListener(this);
		if (streamManager != null)
		{
			streamManager.removeTerminationListener(this);
		}
		if (notificationManager != null)
		{
			notificationManager.removeTerminationListener(this);
		}

		// Request terminate
		requestTerminateImpl(object);

		try
		{
			waitTerminatedImpl(object);
		} catch (InterruptedException ex)
		{
			// OK, interrrputed
		}
		fireObjectTerminated(e);
	}
987989
public void add(E e) {
    // resize when needed
    if(size + 1 > queue.length) {
      resize(size + 1);
    }
    // final int pos = size;
    this.size += 1;
    heapifyUp(size - 1, e);
    heapModified();
  }
860071
@Override
    protected void initQueue(T queue, QueueSpec spec) throws Exception {
        queue.setEphemeralDisabled(getDefaultEphemeralDisabled())
                .setEphemeralMaxSize(getDefaultEphemeralMaxSize());
        Boolean ephemeralDisabled = spec.getField(QueueSpec.FIELD_EPHEMERAL_DISABLED,
                Boolean.class);
        if (ephemeralDisabled != null) {
            queue.setEphemeralDisabled(ephemeralDisabled.booleanValue());
        }
        Integer maxEphemeralSize = spec.getField(QueueSpec.FIELD_EPHEMERAL_MAX_SIZE, Integer.class);
        if (maxEphemeralSize != null) {
            queue.setEphemeralMaxSize(maxEphemeralSize.intValue());
        }

        queue.setRedisHostAndPort(getDefaultHostAndPort()).setRedisPassword(getDefaultPassword())
                .setJedisConnector(getDefaultJedisConnector());
        String redisHostAndPort = spec.getField(SPEC_FIELD_HOST_AND_PORT);
        if (!StringUtils.isBlank(redisHostAndPort)) {
            queue.setRedisHostAndPort(redisHostAndPort);
        }
        String redisPassword = spec.getField(SPEC_FIELD_PASSWORD);
        if (!StringUtils.isBlank(redisPassword)) {
            queue.setRedisPassword(redisPassword);
        }

        queue.setRedisHashName(getDefaultHashName()).setRedisListName(getDefaultListName())
                .setRedisSortedSetName(getDefaultSortedSetName());
        String redisHashName = spec.getField(SPEC_FIELD_HASH_NAME);
        String redisListName = spec.getField(SPEC_FIELD_LIST_NAME);
        String redisSortedSetName = spec.getField(SPEC_FIELD_SORTED_SET_NAME);
        if (!StringUtils.isBlank(redisHashName) && !StringUtils.isBlank(redisListName)
                && !StringUtils.isBlank(redisSortedSetName)) {
            queue.setRedisHashName(redisHashName);
            queue.setRedisListName(redisListName);
            queue.setRedisSortedSetName(redisSortedSetName);
        } else if (!StringUtils.isBlank(redisHashName) || !StringUtils.isBlank(redisListName)
                || !StringUtils.isBlank(redisSortedSetName)) {
            throw new IllegalArgumentException("Either supply all parameters ["
                    + SPEC_FIELD_HASH_NAME + "], [" + SPEC_FIELD_LIST_NAME + "] and ["
                    + SPEC_FIELD_SORTED_SET_NAME + "] or none at all!");
        }

        super.initQueue(queue, spec);
    }