Create a new remote send queue.
@param strQueueName The queue name.
@param strQueueType The queue type (see MessageConstants).
339220
public RemoteSendQueue createRemoteSendQueue(String strQueueName, String strQueueType) throws RemoteException
    {
        BaseTransport transport = this.createProxyTransport(CREATE_REMOTE_SEND_QUEUE);
        transport.addParam(MessageConstants.QUEUE_NAME, strQueueName);
        transport.addParam(MessageConstants.QUEUE_TYPE, strQueueType);
        String strID = (String)transport.sendMessageAndGetReply();
        return new SendQueueProxy(this, strID);
    }
185612
function Queue (name, redisClient) {
  this.hasQuit = false
  this._name = name
  this.redisClient = redisClient
  this._key = Queue.PREFIX + this.name
}
607123
public void queue(JFapByteBuffer bufferData,
                     int segmentType,
                     int requestNumber,
                     int priority,
                     SendListener sendListener,
                     Conversation conversation,
                     Connection connection,
                     int conversationId,
                     boolean pooledBuffers,
                     boolean partOfExchange,
                     long size,
                     boolean terminal,
                     ThrottlingPolicy throttlingPolicy)
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "queue");
      TransmissionDataIterator iterator =
         TransmissionDataIterator.allocateFromPool(connection,
                                                   bufferData,
                                                   priority,
                                                   pooledBuffers,
                                                   partOfExchange,
                                                   segmentType,
                                                   conversationId,
                                                   requestNumber,
                                                   conversation,
                                                   sendListener,
                                                   terminal,
                                                   (int)size);

      // begin F193735.3
      if (type == Conversation.ME)           meQueuedBytes += size;
      else if (type == Conversation.CLIENT)  clientQueuedBytes += size;
      // end F193735.3

      queueInternal(iterator, throttlingPolicy, terminal);

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "queue");
   }
964003
public void init(RemoteTask server, BaseMessageQueue baseMessageQueue)
        throws RemoteException
    {
        super.init(baseMessageQueue);
        m_receiveQueue = server.createRemoteReceiveQueue(baseMessageQueue.getQueueName(), baseMessageQueue.getQueueType());
    }
628431
@Override
	public synchronized QueueSession createQueueSession(boolean transacted, int acknowledgeMode) throws JMSException
    {
        checkNotClosed();
        LocalQueueSession session =  new LocalQueueSession(idProvider.createID(),this,engine,transacted,acknowledgeMode);
        registerSession(session);
        return session;
    }
197409
public AmqpChannel bindQueue(String queue, String exchange, String routingKey, boolean noWait, AmqpArguments arguments) {
        Object[] args = {0, queue, exchange, routingKey, noWait, arguments};
        WrappedByteBuffer bodyArg = null;
        HashMap<String, Object> headersArg = null;

        String methodName = "bindQueue";
        String methodId = "50" + "20";
        AmqpMethod amqpMethod = MethodLookup.LookupMethod(methodId);
        Object[] methodArguments = {this, amqpMethod, this.id, args, bodyArg, headersArg};

        boolean hasnowait = false;
        for (int i = 0; i < amqpMethod.allParameters.size(); i++) {
            String argname = amqpMethod.allParameters.get(i).name;
            if (argname == "noWait") {
                hasnowait = true;
                break;
            }
        }

        if (client.getReadyState() == ReadyState.OPEN) {
            asyncClient.enqueueAction(methodName, "channelWrite", methodArguments, null, null);
        }

        if (hasnowait && noWait) {
            asyncClient.enqueueAction("nowait", null, null, null, null);
        }
        return this;
    }
529660
public static BaseMessageHeader createMessageHeader(String strMessageHeaderClassName, String strQueueName, String strQueueType, Object source, Map<String,Object> properties)
    {
        BaseMessageHeader messageHeader = (BaseMessageHeader)ClassServiceUtility.getClassService().makeObjectFromClassName(strMessageHeaderClassName);
        if (messageHeader != null)
        	messageHeader.init(strQueueName, strQueueType, source, properties);
        return messageHeader;
    }
1311720
public static void emptyAndRemoveQueue( String strQueueName )
  {
    TaskQueue taskQueue = QUEUE_MAP.get( strQueueName );
    if( taskQueue != null )
    {
      taskQueue.emptyQueue();
      synchronized( taskQueue._queue )
      {
        taskQueue._shutdown = true;
        taskQueue._queue.notifyAll();
      }
      QUEUE_MAP.remove( strQueueName );
    }
  }
873650
function Queue(queueName, accessKey, secretKey, region) {
  if (!(this instanceof Queue)) return new Queue(queueName, accessKey, secretKey, region);
  var self = this;
  Object.defineProperty(this, '_sqs',{enumerable: false, configurable: false, writable: false,
    value: getSQS(accessKey, secretKey, region)});
  function setQueue(name) {
    debug('set queue: ' + name);
    var parsed;
    if (parsed = /([0-9]{12}\/([^\/]+))\/?$/.exec(name)) {
      self._sqs.setQueue('/' + parsed[1] + '/');
      self.name = parsed[2];
      if (self._init) delete self._init;
    } else if (typeof name === 'string') {
      self.name = name;
      Object.defineProperty(self, '_init',{enumerable: false, configurable: true, writable: true,
        value: getQueueURL(self, name).then(setQueue)});
      self.then = self._init.then;
      self.done = self._init.done;
    } else if (name && typeof name === 'object' && typeof name.then === 'function') {
      self.name = name.toString();
      Object.defineProperty(self, '_init',{enumerable: false, configurable: true, writable: true,
        value: name.then(setQueue)});
      self.then = self._init.then;
      self.done = self._init.done;
    } else {
      throw new Error(JSON.stringify(name) + ' is not a valid queue.');
    }
  }
  setQueue(queueName);
}
286172
@Override
    public java.util.concurrent.Future<ReceiveMessageResult> receiveMessageAsync(String queueUrl) {

        return receiveMessageAsync(new ReceiveMessageRequest().withQueueUrl(queueUrl));
    }
1350252
public QueuePublisher<String> createQueueTextPublisher(final String name)
    {
        Preconditions.checkState(connectionFactory != null, "connection factory was never injected!");
        return new QueuePublisher<String>(connectionFactory, amqpConfig, name, stringPublisherCallback);
    }
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;
  }
232437
func (s *CreateQueueInput) SetQueueName(v string) *CreateQueueInput {
	s.QueueName = &v
	return s
}
339626
@Override
    protected void initQueue(T queue, QueueSpec spec) throws Exception {
        queue.setUri(defaultUri).setQueueName(defaultQueueName).setUsername(defaultUsername)
                .setPassword(defaultPassword).setConnectionFactory(defaultConnectionFactory);

        String uri = spec.getField(SPEC_FIELD_URI);
        if (!StringUtils.isBlank(uri)) {
            queue.setUri(uri);
        }

        String queueName = spec.getField(SPEC_FIELD_QUEUE_NAME);
        if (!StringUtils.isBlank(uri)) {
            queue.setQueueName(queueName);
        }

        String username = spec.getField(SPEC_FIELD_USERNAME);
        if (!StringUtils.isBlank(username)) {
            queue.setUsername(username);
        }

        String password = spec.getField(SPEC_FIELD_PASSWORD);
        if (!StringUtils.isBlank(password)) {
            queue.setPassword(password);
        }

        super.initQueue(queue, spec);
    }
1324729
protected void putToQueue(IQueueMessage<ID, DATA> msg) throws QueueException.QueueIsFull {
        if (!queue.offer(msg)) {
            throw new QueueException.QueueIsFull(getBoundary());
        }
    }
1313196
public static DispatchQueue createBackgroundQueue(String name, DispatchQueueType type) {
		if (type == DispatchQueueType.Serial) {
			return new SerialDispatchQueue(name);
		}
		if (type == DispatchQueueType.Concurrent) {
			return new ConcurrentDispatchQueue(name);
		}

		throw new IllegalArgumentException("Unexpected queue type: " + type);
	}
922831
protected T createAndInitQueue(QueueSpec spec) throws Exception {
        T queue = createQueueInstance(spec);
        queue.setQueueName(spec.name);
        initQueue(queue, spec);
        return queue;
    }