@return [Array<String>]
         a list of ‘topics’ that the certificate supports.

 @see https://developer.apple.com/library/ios/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/Chapters/APNsProviderAPI.html
438394
def topics
      if universal?
        ext = extension(UNIVERSAL_CERTIFICATE_EXTENSION)
        seq = OpenSSL::ASN1.decode(OpenSSL::ASN1.decode(ext.to_der).value[1].value)
        seq.select.with_index { |_, index| index.even? }.map(&:value)
      else
        [app_bundle_id]
      end
    end
1096980
function() {
            var result = [];
            var hostname = spec.env.allPublicNodeIds.publicHostname ||
                    $._.__ca_getAppFullName__();
            var start = spec.env.allPublicNodeIds.publicRangeStart;
            var end = spec.env.allPublicNodeIds.publicRangeEnd;
            for (var i = start; i<= end; i++) {
                result.push(hostname + ':' + i);
            }
            return result;
        }
1313682
public List<ITopicNode> getAllTopicNodes() {
        final ArrayList<ITopicNode> topicNodes = new ArrayList<ITopicNode>();
        for (final Entry<Integer, List<ITopicNode>> topicEntry : topics.entrySet()) {
            topicNodes.addAll(topicEntry.getValue());
        }

        return topicNodes;
    }
524009
def topics(self):
        
        topics = self.interface.publishers.copy()
        topics.update(self.interface.subscribers)
        return topics
1101682
def get_published_topics(subgraph='')
      code, message, topics = @proxy.getPublishedTopics(@caller_id, subgraph)
      if code == 1
        return topics
      elsif
        raise message
      end
    end
1020823
def topics(options = {})
      batches = Enumerator.new do |y|
        resp = @client.list_topics(options)
        resp.each_page do |page|
          batch = []
          page.data.topics.each do |t|
            batch << Topic.new(
              arn: t.topic_arn,
              client: @client
            )
          end
          y.yield(batch)
        end
      end
      Topic::Collection.new(batches)
    end
695408
public function getCertificatesAsArray()
    {
        // Iterate over certificates nodes and convert to an array
        $certificates = array();
        /** @var \AppserverIo\Appserver\Core\Api\Node\CertificateNode $certificateNode */
        foreach ($this->getCertificates() as $certificateNode) {
            // restructure to an array
            $certificates[] = array(
                'domain' => $certificateNode->getDomain(),
                'certPath' => $certificateNode->getCertPath()
            );
        }

        // return certificates array
        return $certificates;
    }
892700
def topic(id, options={})
      params = { :lang => @query_options[:lang], :limit => @query_options[:limit] }.merge(options)
      get(surl('topic') + id, params, format: :json).parsed_response
    end
544590
public Iterator<String> getChallengeRealms() {
		List<String> realms = new ArrayList<String>();
		final Response response = getResponse();
		if(response.getStatusCode() == SipServletResponse.SC_UNAUTHORIZED) {
			WWWAuthenticateHeader authenticateHeader = (WWWAuthenticateHeader) 
				response.getHeader(WWWAuthenticateHeader.NAME);
			realms.add(authenticateHeader.getRealm());
		} else if (response.getStatusCode() == SipServletResponse.SC_PROXY_AUTHENTICATION_REQUIRED) {
			ProxyAuthenticateHeader authenticateHeader = (ProxyAuthenticateHeader) 
				response.getHeader(ProxyAuthenticateHeader.NAME);
			realms.add(authenticateHeader.getRealm());
		}
		return realms.iterator();
	}
379755
public List<BreakpointMessageInterface> getBreakpointsEnabledList() {
		if (mode.equals(Mode.safe)) {
			return new ArrayList<>();
		}
		return getBreakpointsModel().getBreakpointsEnabledList();
	}
812791
public List<Certificate> getCertificates() throws CertificateException, IOException {
        final String methodName = "getCertificates";
        logger.entry(this, methodName);
        
        final String fileData = getPemFileData();

        final List<ByteBuf> certDataList = new ArrayList<ByteBuf>();
        final Matcher m = CERTIFICATE_PATTERN.matcher(fileData);
        int start = 0;
        while (m.find(start)) {            
            final ByteBuf base64CertData = Unpooled.copiedBuffer(m.group(1), Charset.forName("US-ASCII"));
            final ByteBuf certData = Base64.decode(base64CertData);
            base64CertData.release();
            certDataList.add(certData);
            start = m.end();
        }
        
        if (certDataList.isEmpty()) {
            final CertificateException exception = new CertificateException("No certificates found in PEM file: " + pemFile);
            logger.throwing(this,  methodName, exception);
            throw exception;
        }
        
        final CertificateFactory cf = CertificateFactory.getInstance("X.509");
        final List<Certificate> certificates = new ArrayList<Certificate>();

        try {
            for (ByteBuf certData: certDataList) {
                certificates.add(cf.generateCertificate(new ByteBufInputStream(certData)));
            }
        } finally {
            for (ByteBuf certData: certDataList) certData.release();
        }
        
        logger.exit(this, methodName, certificates);
        
        return certificates;
    }
104540
public Collection<TopicPartition> getTopicPartitions() {
        Collection<TopicPartitionGroup> topicPartitions = getTopicPartitionGroups();
        Set<TopicPartition> tps = new HashSet<TopicPartition>();
        if (topicPartitions != null) {
            for (TopicPartitionGroup g : topicPartitions) {
                tps.addAll(g.getTopicPartitions());
            }
        }
        return tps;
    }
374275
public String[] getTopics()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(this, tc, "getTopics");
            SibTr.exit(this, tc, "getTopics", topics);
        }
        return topics;
    }
792905
def topics(self):
        
        return set(node.tag for node in self.root.iter() if node.attrib)
773056
def describe_topic(name, region=None, key=None, keyid=None, profile=None):
    '''
    
    '''
    topics = list_topics(region=region, key=key, keyid=keyid, profile=profile)
    ret = {}
    for topic, arn in topics.items():
        if name in (topic, arn):
            ret = {'TopicArn': arn}
            ret['Attributes'] = get_topic_attributes(arn, region=region, key=key, keyid=keyid,
                    profile=profile)
            ret['Subscriptions'] = list_subscriptions_by_topic(arn, region=region, key=key,
                    keyid=keyid, profile=profile)
            # Grab extended attributes for the above subscriptions
            for sub in range(len(ret['Subscriptions'])):
                sub_arn = ret['Subscriptions'][sub]['SubscriptionArn']
                if not sub_arn.startswith('arn:aws:sns:'):
                    # Sometimes a sub is in e.g. PendingAccept or other
                    # wierd states and doesn't have an ARN yet
                    log.debug('Subscription with invalid ARN %s skipped...', sub_arn)
                    continue
                deets = get_subscription_attributes(SubscriptionArn=sub_arn, region=region,
                        key=key, keyid=keyid, profile=profile)
                ret['Subscriptions'][sub].update(deets)
    return ret
1112387
public Observable<Page<CertificateInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<CertificateInner>>, Page<CertificateInner>>() {
                @Override
                public Page<CertificateInner> call(ServiceResponse<Page<CertificateInner>> response) {
                    return response.body();
                }
            });
    }
1290317
def get_topics(self):
        
        headers, data = self._requester.requestJsonAndCheck(
            "GET",
            self.url + "/topics",
            headers={'Accept': Consts.mediaTypeTopicsPreview}
        )
        return data['names']