Test if this queue exists in the AMQP store.

        Note: This doesn't work with redis as declaring queues has not effect
        except creating the exchange.

        :returns: True if the queue exists, else False.
        :rtype: bool
978781
def exists(self):
        
        try:
            queue = self.queue
            queue.queue_declare(passive=True)
        except NotFound:
            return False
        except ChannelError as e:
            if e.reply_code == '404':
                return False
            raise e
        return True
677484
def wait_for_exists(self, timeout=0, *args, **selectors):
        
        return self.device(**selectors).wait.exists(timeout=timeout)
640438
def exists(self, batch_id=None):
        
        try:
            self.model.objects.get(batch_id=batch_id)
        except self.model.DoesNotExist:
            return False
        return True
390969
def exists(self, pattern, **match_kwargs):
        
        ret = self.match(pattern, **match_kwargs)
        if ret is None:
            return None
        if not ret.matched:
            return None
        return ret
1333884
def exists?(header = self.class::DEFAULT_REQUEST_HEADER)
      retrieval_keys = self.class::UNIQUE_IDENTIFIERS.reject { |k| @data[k].nil? }
      raise IncompleteResource, "Must set resource #{self.class::UNIQUE_IDENTIFIERS.join(' or ')} before trying to retrieve!" if retrieval_keys.empty?
      retrieval_keys.each do |k|
        results = self.class.find_by(@client, { k => @data[k] }, self.class::BASE_URI, header)
        return true if results.size == 1
      end
      false
    end
445075
function (queueDef) {
  if (isString(queueDef)) {
    return true
  }
  if (isObject(queueDef) && isString(queueDef.name)) {
    return true
  }
  return false
}
185612
function Queue (name, redisClient) {
  this.hasQuit = false
  this._name = name
  this.redisClient = redisClient
  this._key = Queue.PREFIX + this.name
}
10366
def process_queue_item      #:nodoc:
      return false if @queue.empty?

      # Even though we just asked if the queue was empty, it
      # still could have had an item which by this statement
      # is now gone. For this reason we pass true to Queue#deq
      # because we will sleep indefinitely if it is empty.
      promise = @queue.deq(true)
      stat :dequeued, item_id: promise.object_id
      promise.work
      return true

    rescue ThreadError # this means the queue is empty
      false
    end
1115106
def exists(self):
        
        try:
            self.instance_admin_client.get_app_profile(self.name)
            return True
        # NOTE: There could be other exceptions that are returned to the user.
        except NotFound:
            return False
776045
def exists_type(self, using=None, **kwargs):
        
        return self._get_connection(using).indices.exists_type(index=self._name, **kwargs)
1185548
def exists(self, name):
        
        with self.pipe as pipe:
            return pipe.exists(self.redis_key(name))
587460
def has_connection(cls, pid, connection):
        
        with cls._lock:
            cls._ensure_pool_exists(pid)
            return connection in cls._pools[pid]
1274189
def has_frames(self, destination):
        
        return (destination in self.queue_metadata) and bool(self.queue_metadata[destination]['frames'])
476645
def exists(stream_name, region=None, key=None, keyid=None, profile=None):
    '''
    
    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
    r = {}

    stream = _get_basic_stream(stream_name, conn)
    if 'error' in stream:
        r['result'] = False
        r['error'] = stream['error']
    else:
        r['result'] = True

    return r
511957
def exists(self, query, **args):
        
        return bool(self.find(query, **args).limit(1).count())
553271
def create(self, qname):
        '''
        
        '''
        try:
            if self.exists(qname):
                log.error('Queues "%s" already exists. Nothing done.', qname)
                return True

            self.conn.create(qname)

            return True
        except pyrax.exceptions as err_msg:
            log.error('RackSpace API got some problems during creation: %s',
                      err_msg)
        return False
1357540
public boolean existsAnyBroker () {
        boolean result = false;

        synchronized ( this.brokerDetails ) {
            Iterator<PerBrokerInfo> iter = this.brokerDetails.values().iterator();

            while ( ( ! result ) && ( iter.hasNext() ) ) {
                result = iter.next().exists;
            }
        }

        return result;
    }