Constructor.
@param strQueueName Name of the queue.
@param strQueueType Type of queue - remote or local.
@param source usually the object sending or listening for the message, to reduce echos.
171785
public void init(String strQueueName, String strQueueType, Object source, Map<String,Object> properties)
    {
        if (strQueueName == null)
            if ((strQueueType == null)
                || (strQueueType.equals(MessageConstants.INTRANET_QUEUE)))
        {
            strQueueType = MessageConstants.INTRANET_QUEUE;
            strQueueName = MessageConstants.RECORD_QUEUE_NAME;
        }
        if (strQueueType == null)
            strQueueType = MessageConstants.INTERNET_QUEUE;
        m_strQueueName = strQueueName;
        m_strQueueType = strQueueType;
        m_source = source;
        
        m_mxProperties = this.createNameValueTree(null, properties);
    }
88356
public void setQueueList(List<String> queueList) throws RabbitmqCommunicateException
    {
        if (queueList == null || queueList.size() == 0)
        {
            String message = "QueueList is not defined.";
            throw new RabbitmqCommunicateException(message);
        }
        this.queueList = queueList;
    }
923518
@Override
    protected void initQueue(T queue, QueueSpec spec) throws Exception {
        queue.setKafkaClient(defaultKafkaClient).setProducerType(defaultProducerType)
                .setKafkaProducerProperties(defaultProducerProps)
                .setKafkaConsumerProperties(defaultConsumerProps);
        queue.setSendAsync(defaultSendAsync);

        String bootstrapServers = spec.getField(SPEC_FIELD_BOOTSTRAP_SERVERS);
        bootstrapServers = StringUtils.isBlank(bootstrapServers) ? defaultBootstrapServers
                : bootstrapServers;
        if (StringUtils.isBlank(bootstrapServers)) {
            throw new IllegalArgumentException(
                    "Empty or Invalid value for param [" + SPEC_FIELD_BOOTSTRAP_SERVERS + "]!");
        }
        queue.setKafkaBootstrapServers(bootstrapServers);

        String consumerGroupId = spec.getField(SPEC_FIELD_CONSUMER_GROUP_ID);
        consumerGroupId = StringUtils.isBlank(consumerGroupId) ? defaultConsumerGroupId
                : consumerGroupId;
        if (!StringUtils.isBlank(consumerGroupId)) {
            queue.setConsumerGroupId(consumerGroupId);
        }

        String topicName = spec.getField(SPEC_FIELD_TOPIC);
        topicName = StringUtils.isBlank(topicName) ? defaultTopicName : topicName;
        if (StringUtils.isBlank(topicName)) {
            throw new IllegalArgumentException(
                    "Empty or Invalid value for param [" + SPEC_FIELD_TOPIC + "]!");
        }
        queue.setTopicName(topicName);

        String producerTypeStr = spec.getField(SPEC_FIELD_PRODUCER_TYPE);
        if (!StringUtils.isBlank(producerTypeStr)) {
            try {
                ProducerType producerType = ProducerType.valueOf(producerTypeStr);
                if (producerType != null) {
                    queue.setProducerType(producerType);
                }
            } catch (Exception e) {
            }
        }

        Properties producerProps = spec.getField(SPEC_FIELD_PRODUCER_PROPERTIES, Properties.class);
        if (producerProps != null) {
            queue.setKafkaProducerProperties(producerProps);
        }

        Properties consumerProps = spec.getField(SPEC_FIELD_CONSUMER_PROPERTIES, Properties.class);
        if (consumerProps != null) {
            queue.setKafkaConsumerProperties(consumerProps);
        }

        Boolean sendAsync = spec.getField(SPEC_FIELD_SEND_ASYNC, Boolean.class);
        if (sendAsync != null) {
            queue.setSendAsync(sendAsync.booleanValue());
        }

        super.initQueue(queue, spec);
    }
629789
public static TaskQueue getInstance( ILogger logger, String strQueueName )
  {
    if( strQueueName == null )
    {
      return null;
    }

    TaskQueue taskQueue = QUEUE_MAP.get( strQueueName );
    if( taskQueue == null )
    {
      taskQueue = new TaskQueue( logger, strQueueName );
      QUEUE_MAP.put( strQueueName, taskQueue );
    }

    return taskQueue;
  }
785861
@Override
    public java.util.concurrent.Future<CreateQueueResult> createQueueAsync(String queueName,
            com.amazonaws.handlers.AsyncHandler<CreateQueueRequest, CreateQueueResult> asyncHandler) {

        return createQueueAsync(new CreateQueueRequest().withQueueName(queueName), asyncHandler);
    }
712665
@Override
    public java.util.concurrent.Future<CreateQueueResult> createQueueAsync(String queueName) {

        return createQueueAsync(new CreateQueueRequest().withQueueName(queueName));
    }
491561
public String getQueueName(boolean bDefaultIfNone)
    {
        String strName = null;
        Record recQueueName = ((ReferenceField)this.getField(MessageProcessInfo.QUEUE_NAME_ID)).getReference();
        if ((recQueueName != null) && (recQueueName.getEditMode() == DBConstants.EDIT_CURRENT))
            strName = recQueueName.getField(QueueName.CODE).toString();
        if ((strName == null) || (strName.length() == 0))
            if (bDefaultIfNone)
        {
            int iMessageInfoType = MessageInfoType.REQUEST_ID;
            Record recMessageInfo = ((ReferenceField)this.getField(MessageProcessInfo.MESSAGE_INFO_ID)).getReference();
            if ((recMessageInfo != null) && (recMessageInfo.getEditMode() == DBConstants.EDIT_CURRENT))
                iMessageInfoType = (int)recMessageInfo.getField(MessageInfo.MESSAGE_INFO_TYPE_ID).getValue();
            if (iMessageInfoType == MessageInfoType.REQUEST_ID)
                strName = MessageConstants.TRX_SEND_QUEUE;
            else
                strName = MessageConstants.TRX_RECEIVE_QUEUE;
        }
        return strName;
    }
186544
@Override
    public java.util.concurrent.Future<GetQueueUrlResult> getQueueUrlAsync(String queueName,
            com.amazonaws.handlers.AsyncHandler<GetQueueUrlRequest, GetQueueUrlResult> asyncHandler) {

        return getQueueUrlAsync(new GetQueueUrlRequest().withQueueName(queueName), asyncHandler);
    }
1342452
protected void appendSequence(final CharSequence sequence, final String name) {
        if (Strings.isNotEmpty(sequence)) {
            queueCurrentSequence();
            setCurrentSequence(new CharSequenceEntry(sequence, name));
        }
    }
470700
boolean isEnqueued(Reference<? extends T> reference) {
        synchronized (lock) {
            return reference.queueNext != null && reference.queueNext != sQueueNextUnenqueued;
        }
    }
1048619
function(source, callback) {
        callback = callback || noop;

        //if there's a queue
        if (queue[source] instanceof Array) {
            //just add it
            return queue[source].push(callback);
        }

        //otherwise there is not a queue
        //so let's create one
        queue[source] = [callback];

        var script = document.createElement('script');
        var head = document.getElementsByTagName('head')[0];

        script.async = 1;

        head.appendChild(script);

        script.onload = script.onreadystatechange = function( _, isAbort ) {
            if(isAbort || !script.readyState || /loaded|complete/.test(script.readyState) ) {
                script.onload = script.onreadystatechange = null;
                script = undefined;

                if(!isAbort) {
                    queue[source].forEach(function(callback) {
                        callback();
                    });

                    delete queue[source];
                }
            }
        };

        script.src = source;
    }
964003
public void init(RemoteTask server, BaseMessageQueue baseMessageQueue)
        throws RemoteException
    {
        super.init(baseMessageQueue);
        m_receiveQueue = server.createRemoteReceiveQueue(baseMessageQueue.getQueueName(), baseMessageQueue.getQueueType());
    }
377629
@Override
    public void setTemporaryQueueNamePrefix(String prefix) throws JMSException {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setTemporaryQueueNamePrefix", prefix);

        if (prefix != null && !prefix.equals("")) {
            jcaManagedConnectionFactory.setTemporaryQueueNamePrefix(prefix);
        }
        else {
            jcaManagedConnectionFactory.setTemporaryQueueNamePrefix(null);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setTemporaryQueueNamePrefix");
    }
360144
private final void initializeSyncQueue() {
        Node h;
        if (U.compareAndSwapObject(this, HEAD, null, (h = new Node())))
            tail = h;
    }
964678
@Override
    public Queue createQueue(String queueName) throws JMSException {
        checkClosed();
        return new SQSQueueDestination(queueName, amazonSQSClient.getQueueUrl(queueName).getQueueUrl());
    }
1036088
@Override
	public QueueConnection createQueueConnection(String userName, String password) throws JMSException
    {
        URI providerURL = getProviderURI();
        
        String scheme = providerURL.getScheme();
        if (scheme.equals(PacketTransportType.VM))
        {
            String engineName = providerURL.getHost();
            return FFMQEngine.getDeployedInstance(engineName).openQueueConnection(userName, password, clientID);
        }
        else 
        if (scheme.equals(PacketTransportType.TCP) ||
            scheme.equals(PacketTransportType.TCPS) ||
            scheme.equals(PacketTransportType.TCPNIO))
        {
            return new RemoteQueueConnection(providerURL, userName, password, clientID);
        }
        else
            throw new FFMQException("Unknown transport protocol : " + scheme,"INVALID_TRANSPORT_PROTOCOL");
    }
590636
public void updateQueuePointOutputHandler(
    SIBUuid8 newLocalisingMEUuid,
    OutputHandler outputHandler,
    SIBUuid8 existingUuid)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(
        tc,
        "updateQueuePointOutputHandler",
        new Object[] { newLocalisingMEUuid, outputHandler, existingUuid });

    synchronized(_queuePointOutputHandlers)
    {
      _queuePointOutputHandlers.remove(existingUuid);
      _queuePointOutputHandlers.put(newLocalisingMEUuid, outputHandler);
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "updateQueuePointOutputHandler");
  }