Get the set of topics associated with this OutputHandler
517799
public String[] getTopics()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getTopics");
      
    String[] topics = null;
    if (_subscriptionState != null)      
      topics = _subscriptionState.getTopics();
      
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())  
      SibTr.exit(tc, "getTopics", topics);
    return topics;
  }
1242036
def print_topics(self, Nwords=10):
        
        print('Topic\tTop %i words' % Nwords)
        for k, words in self.list_topics(Nwords):
            print(unicode(k).ljust(3) + '\t' + ' '.join(list(zip(*words))[0]))
961301
def get_topics(yaml_info):
    ''' 
    '''
    # Pull out the topic info
    names = []
    # Store all of the topics in a dictionary
    topics = yaml_info['topics']
    for topic in topics:
        names.append(topic['topic'])

    return names
1007872
function getIndexDetails(client, namespace, done) {
  var tasks = {
    client: attach.bind(null, client),
    namespace: attach.bind(null, namespace),
    getIndexes: ['client', 'namespace', getIndexes],
    getIndexStats: ['client', 'namespace', getIndexStats],
    getIndexSizes: ['client', 'namespace', getIndexSizes],
    indexes: [
      'getIndexes',
      'getIndexStats',
      'getIndexSizes',
      combineStatsAndIndexes
    ]
  };

  async.auto(tasks, function(err, results) {
    if (err) {
      // report error
      return done(err);
    }
    // all info was collected in indexes
    return done(null, results.indexes);
  });
}
750761
def topics(self):
        
        from .topic import Topic

        for topic in self.soup.find_all('a', class_='zm-item-tag'):
            yield Topic(Zhihu_URL + topic['href'], topic.text.replace('\n', ''),
                        session=self._session)
1021529
def _prepare_output(topics_with_wrong_rf, verbose):
    """"""
    out = {}
    topics_count = len(topics_with_wrong_rf)
    out['raw'] = {
        'topics_with_wrong_replication_factor_count': topics_count,
    }

    if topics_count == 0:
        out['message'] = 'All topics have proper replication factor.'
    else:
        out['message'] = (
            "{0} topic(s) have replication factor lower than specified min ISR + 1."
        ).format(topics_count)

        if verbose:
            lines = (
                "replication_factor={replication_factor} is lower than min_isr={min_isr} + 1 for {topic}"
                .format(
                    min_isr=topic['min_isr'],
                    topic=topic['topic'],
                    replication_factor=topic['replication_factor'],
                )
                for topic in topics_with_wrong_rf
            )
            out['verbose'] = "Topics:\n" + "\n".join(lines)
    if verbose:
        out['raw']['topics'] = topics_with_wrong_rf

    return out
197045
def get_unread_topics(context, topics, user):
    
    request = context.get('request', None)
    return TrackingHandler(request=request).get_unread_topics(topics, user)
1220982
@Override
    public synchronized Collection<IOutput> outputs()
    {
        if (null == outputs)
        {
            outputs = new ArrayList<IOutput>();
            final Iterator<Output> processInputs = service.getProcess().getOutputs().iterator();
            while (processInputs.hasNext())
            {
                outputs.add(new IOutput()
                {
                    private Output owlOutput = processInputs.next();

                    @Override
                    public String name()
                    {
                        return owlOutput.getName();
                    }

                    @Override
                    public ISemanticIdentifier getSemanticAnnotation()
                    {
                        //return new SemanticIdentifier(owlOutput.getType().getURI());
                        return new SemanticIdentifier(owlOutput.getParamType().getURI());
                    }
                });
            }
        }

        return outputs;
    }
625288
def get_all_topics(region=None, key=None, keyid=None, profile=None):
    '''
    
    '''
    cache_key = _cache_get_key()
    try:
        return __context__[cache_key]
    except KeyError:
        pass

    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
    __context__[cache_key] = {}
    # TODO: support >100 SNS topics (via NextToken)
    topics = conn.get_all_topics()
    for t in topics['ListTopicsResponse']['ListTopicsResult']['Topics']:
        short_name = t['TopicArn'].split(':')[-1]
        __context__[cache_key][short_name] = t['TopicArn']
    return __context__[cache_key]
629580
def create_handlers_map(prefix='.*'):
  
  return [
      (prefix + '/output', _BarrierHandler),
      (prefix + '/run', _PipelineHandler),
      (prefix + '/finalized', _PipelineHandler),
      (prefix + '/cleanup', _CleanupHandler),
      (prefix + '/abort', _PipelineHandler),
      (prefix + '/fanout', _FanoutHandler),
      (prefix + '/fanout_abort', _FanoutAbortHandler),
      (prefix + '/callback', _CallbackHandler),
      (prefix + '/rpc/tree', status_ui._TreeStatusHandler),
      (prefix + '/rpc/class_paths', status_ui._ClassPathListHandler),
      (prefix + '/rpc/list', status_ui._RootListHandler),
      (prefix + '(/.+)', status_ui._StatusUiHandler),
      ]
1228959
public String getTopicIds() {
    if (Token_Type.featOkTst && ((Token_Type)jcasType).casFeat_topicIds == null)
      jcasType.jcas.throwFeatMissing("topicIds", "de.julielab.jules.types.Token");
    return jcasType.ll_cas.ll_getStringValue(addr, ((Token_Type)jcasType).casFeatCode_topicIds);}
479340
def get_unknown_topics(self, lang):
        """"""
        return [topic['title']
                for topic in self.user_data.language_data[lang]['skills']
                if not topic['learned']]
5722
protected List<String> getTopicIds() {
        LinkedList<String> topicIds = new LinkedList<String>();
        for (final Entry<String, SpecTopic> specTopicEntry : topics.entrySet()) {
            topicIds.add(specTopicEntry.getKey());
        }
        return topicIds;
    }
406197
def _get_outputs(self):
        
        out_size = mx_uint()
        handles = ctypes.POINTER(NDArrayHandle)()
        check_call(_LIB.MXExecutorOutputs(self.handle,
                                          ctypes.byref(out_size), ctypes.byref(handles)))
        num_output = out_size.value
        outputs = [_ndarray_cls(NDArrayHandle(handles[i])) for i in range(num_output)]
        return outputs
1150053
def list_topics
      response = random_broker.fetch_metadata(topics: nil)
      response.topics.select do |topic|
        topic.topic_error_code == 0
      end.map(&:topic_name)
    end
806493
public final Set<MessageHandler> getHandlers() {
        Set<MessageHandler> msgHandlers = new HashSet<>();
        for (HandlerWrapper handler : handlers.values()) {
            msgHandlers.add(handler.getHandler());
        }
        return msgHandlers;
    }
794254
synchronized List<HandlerHolder> findHandlers(String topic) {
        List<HandlerHolder> handlers = new ArrayList<HandlerHolder>();

        List<HandlerHolder> discreteHandlers = discreteEventHandlers.get(topic);
        if (discreteHandlers != null) {
            handlers.addAll(discreteHandlers);
        }

        for (Map.Entry<String, List<HandlerHolder>> entry : wildcardEventHandlers.entrySet()) {
            if (topic.startsWith(entry.getKey())) {
                handlers.addAll(entry.getValue());
            }
        }

        return handlers;
    }