Creates a queue for specified queue client.
If queue exists, it will be updated.
320570
public QueueModel create() throws IOException {
        String url = "queues/" + name;
        IronReader reader = client.put(url, "{}");
        QueueContainer container = gson.fromJson(reader.reader, QueueContainer.class);
        reader.close();
        return container.getQueue();
    }
1139056
@Override
	public TemporaryQueue createTemporaryQueue() throws JMSException
    { 	
    	externalAccessLock.readLock().lock();
    	try
		{
	        checkNotClosed();
	        String queueName = "TEMP-QUEUE-"+UUIDProvider.getInstance().getShortUUID();
	        engine.createTemporaryQueue(queueName);
	        connection.registerTemporaryQueue(queueName);
	        
	        return new TemporaryQueueRef(connection,queueName);
		}
    	finally
    	{
    		externalAccessLock.readLock().unlock();
    	}
    }
94556
@Override
	public QueueReceiver createReceiver(Queue queue, String messageSelector) throws JMSException
    {
    	externalAccessLock.readLock().lock();
    	try
		{
	        checkNotClosed();
	        LocalQueueReceiver receiver = new LocalQueueReceiver(engine,this,queue,messageSelector,idProvider.createID());
	        registerConsumer(receiver);
	        receiver.initDestination();
	        return receiver;
		}
    	finally
    	{
    		externalAccessLock.readLock().unlock();
    	}
    }
478609
static <B extends ProcessBuilder> QueueBuilder<B> newQueueBuilder(Queue parent_queue, Class<B> process_builder_class)
    {
        return new QueueBuilder<B>(parent_queue, process_builder_class);
    }
712715
public DistributedQueue<T>      buildQueue()
    {
        return new DistributedQueue<T>
        (
            client,
            consumer,
            serializer,
            queuePath,
            factory,
            executor,
            Integer.MAX_VALUE,
            false,
            lockPath,
            maxItems,
            putInBackground,
            finalFlushMs
        );
    }
1255761
def setup_queue(self):
        
        logger.debug("Declaring queue %s" % self._queue)
        self._channel.queue_declare(self.on_queue_declareok, self._queue, durable=True)
922831
protected T createAndInitQueue(QueueSpec spec) throws Exception {
        T queue = createQueueInstance(spec);
        queue.setQueueName(spec.name);
        initQueue(queue, spec);
        return queue;
    }
506502
private static com.enioka.jqm.api.Queue getQueue(Queue queue)
    {
        com.enioka.jqm.api.Queue q = new com.enioka.jqm.api.Queue();

        q.setDescription(queue.getDescription());
        q.setId(queue.getId());
        q.setName(queue.getName());

        return q;
    }
1028334
public Queue<B> newQueue()
    {
        return new Queue<B>(parent_queue, queue_restriction, index, process_builder_class, process_server_class,
            default_occurence, default_visibility, default_access, default_resilience, default_output, implementation_options);
    }
1335979
def create_queue(self, credentials):
        
        if credentials:
            session = self.session or aiohttp.ClientSession(loop=self.event_loop)
            return Queue(
                options={
                    'credentials': credentials,
                    'rootUrl': self.config['taskcluster_root_url'],
                },
                session=session
            )
1040898
private Queue<PoolSchedulable> createPoolQueue(
      ScheduleComparator comparator) {
    int initCapacity =
        snapshotPools.size() == 0 ? 1 : snapshotPools.size();
    Queue<PoolSchedulable> poolQueue =
        new PriorityQueue<PoolSchedulable>(initCapacity, comparator);
    poolQueue.addAll(snapshotPools);
    return poolQueue;
  }
1005668
function createQueue(name, options) {
  options = options || {};
  var attributes = [];
  function attr(name, value) { attributes.push({name: name, value: value}); }
  if (options.delay != null)
    attr('DelaySeconds', seconds(options.delay, 'delay', 0, 900));
  if (options.messageRetentionPeriod != null)
    attr('MessageRetentionPeriod', seconds(options.messageRetention, 'messageRetention', 60, 1209600));
  if (options.pollDuration != null)
    attr('ReceiveMessageWaitTimeSeconds', seconds(options.pollDuration, 'pollDuration', 0, 20));
  else
    attr('ReceiveMessageWaitTimeSeconds', 20);
  if (options.visibilityTimeout != null)
    attr('VisibilityTimeout', seconds(options.visibilityTimeout, 'visibilityTimeout', 0, 43200));
  if (options.maxMessageSize != null)
    attr('MaximumMessageSize', bytes(options.maxMessageSize, 'MaximumMessageSize', 1024, 65536));

  var query = {};
  query.QueueName = name;
  for (var i = 0; i < attributes.length; i++) {
    query['Attribute.' + (i+1) + '.Name'] = attributes[i].name;
    query['Attribute.' + (i+1) + '.Value'] = attributes[i].value;
  }
  var queueURL = call(this, 'CreateQueue', query)
    .then(function (res) {
      return res.CreateQueueResult.QueueUrl;
    });
  queueURL.toString = function () { return name; };
  return Queue(queueURL, this._keys.accessKey, this._keys.secretKey, this._keys.region);
}
985304
def create_queue_service(self):
        '''
        
        '''
        try:
            from azure.storage.queue.queueservice import QueueService
            return QueueService(self.account_name, self.account_key,
                                sas_token=self.sas_token,
                                is_emulated=self.is_emulated)
        except ImportError:
            raise Exception('The package azure-storage-queue is required. '
                            + 'Please install it using "pip install azure-storage-queue"')
673102
public static <E1> ConcurrentConveyorSingleQueue<E1> concurrentConveyorSingleQueue(
            E1 submitterGoneItem, QueuedPipe<E1> queue
    ) {
        return new ConcurrentConveyorSingleQueue<E1>(submitterGoneItem, queue);
    }
497220
def _process_queue(self):
        '''
        
        '''
        if len(self._queue):
            args, kwargs = self._queue.popleft()
            self.publish(*args, **kwargs)
42121
public <P extends ProcessBuilder> QueueBuilder<P> newQueueBuilder(Class<P> process_builder_class)
    {
        return QueueFactory.newQueueBuilder(this, process_builder_class);
    }
445473
public Mailbox createMailbox(MailboxesQueue queue) {
        if (mailboxCreator != null) {
            return mailboxCreator.createMailbox(queue);
        } else {
            return new Mailbox(queue);
        }
    }