Returns the next node ID for the given message topic.

@param topicName the topic for which to return the next node ID
@return the next node ID for the given message topic
486320
private MemberId getNextMemberId(String topicName) {
    InternalTopic topic = topics.get(topicName);
    if (topic == null) {
      return null;
    }

    TopicIterator iterator = topic.iterator();
    if (iterator.hasNext()) {
      return iterator.next().memberId();
    }
    return null;
  }
32325
@Override
  public Node next() {
    Node cur = next;
    next = next.getNextSibling();
    return cur;
  }
821323
protected int getNextNode()
  {
    if (m_foundLast)
      return DTM.NULL;

    if (m_isFresh)
    {
      m_currentNode = m_traverser.first(m_root);
      m_isFresh = false;
    }
    // I shouldn't have to do this the check for current node, I think.
    // numbering\numbering24.xsl fails if I don't do this.  I think 
    // it occurs as the walkers are backing up. -sb
    else if(DTM.NULL != m_currentNode) 
    {
      m_currentNode = m_traverser.next(m_root, m_currentNode);
    }

    if (DTM.NULL == m_currentNode)
      this.m_foundLast = true;

    return m_currentNode;
  }
124195
public Class<? extends Message> getMessageClass(String topic) {
        return allTopics ? messageClassForAll : messageClassByTopic.get(topic);
    }
1265378
public static int getNode(BayesianReasonerShanksAgent agent, String nodeName)
            throws ShanksException {
        return ShanksAgentBayesianReasoningCapability.getNode(
                agent.getBayesianNetwork(), nodeName);
    }
222921
public int getNumPartitions(String topicName) {
        List<PartitionInfo> partitionList = getPartitionInfo(topicName);
        return partitionList != null ? partitionList.size() : 0;
    }
1320732
public String getTopic()
  {
    if (tc.isEntryEnabled())
    {
      SibTr.entry(tc, "getTopic");
      SibTr.exit(tc, "getTopic", topic);
    }

    return topic;
  }
1075279
public String getNameId() throws Exception {
		NodeList nodes = xmlDoc.getElementsByTagNameNS("urn:oasis:names:tc:SAML:2.0:assertion", "NameID");

		if (nodes.getLength() == 0) {
			throw new Exception("No name id found in document");
		}

		return nodes.item(0).getTextContent();
	}
288752
public String getNodeId(final String clusterId, final HttpServletRequest request)
    {
        if (clusterId == null)
        {
            return null;
        }
        if (_workerName != null)
        {
            return clusterId + '.' + _workerName;
        }
        return clusterId;
    }
449712
public TopicConnectionFactory getTopicConnectionFactory(String
      topicConnFactoryName) throws ServiceLocatorException {
    TopicConnectionFactory factory = null;
    try {
      if (cache.containsKey(topicConnFactoryName)) {
        factory = (TopicConnectionFactory) cache.get(topicConnFactoryName);
      } else {
        factory = (TopicConnectionFactory) ic.lookup(topicConnFactoryName);
        cache.put(topicConnFactoryName, factory);
      }
    } catch (NamingException ne) {
      throw new ServiceLocatorException(ne);
    } catch (Exception e) {
      throw new ServiceLocatorException(e);
    }
    return factory;
  }
107492
def get_node_by_name(self, nodename):
        
        for kind, nodes in self.nodes.items():
            for node in nodes:
                if node.name == nodename:
                    return node
        else:
            raise NodeNotFound(
                "Node `{0}` not found in cluster `{1}`"
                .format(nodename, self.name))
1302673
public String retrieveNonWildcardStem(String topic)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(
        tc,
        "retrieveNonWildcardStem",
        new Object[] { topic});

    String stem = null;

    int wildMany = topic.indexOf(MatchSpace.SUBTOPIC_DOUBLE_SEPARATOR_STRING);
    int wildOne = topic.indexOf(MatchSpace.SUBTOPIC_MATCHONE_CHAR);

    if( wildOne > -1)
    {
      if(wildMany > wildOne)
        stem = topic.substring(0, wildOne - 1); // Careful need to account for "/"
      else
      {
        if(wildMany > -1)
          stem = topic.substring(0,wildMany);
        else
          stem = topic.substring(0, wildOne - 1); // Careful need to account for "/"
      }
    }
    else
    {
      if(wildMany > -1)
      {
        stem = topic.substring(0,wildMany);
      }
      else
      {
        // No wildcards
        stem = topic;
      }
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "retrieveNonWildcardStem", stem);

    return stem;
  }
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;
    }
998020
public Node find(String nodeName)
	{
		// Sanity check
		if (IS_EMPTY.test(nodeName))
		{
			throw new IllegalArgumentException("The node name should not be empty");
		}
		Node _result = null;
		while (hasMoreAvailableElement() && (null == _result))
		{
			int _position = getPosition();
			Node _current = getSource().item(_position);
			_position++;
			setPosition(_position);

			if (nodeName.equals(_current.getNodeName()))
			{
				_result = _current;
			}
		}
		return _result;
	}
818965
public Node getCurrentNode()
  {

    if (!m_cacheNodes)
      throw new RuntimeException(
        XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_CANNOT_INDEX, null)); //"This NodeSet can not do indexing or counting functions!");

    int saved = m_next;
    Node n = (m_next < m_firstFree) ? elementAt(m_next) : null;
    m_next = saved; // HACK: I think this is a bit of a hack.  -sb
    return n;
  }
336959
def get_number_of_messages_in_topicpartition(self, topic_partition=None):
        

        if isinstance(topic_partition, TopicPartition):
            topic_partition = [topic_partition]

        number_of_messages = 0
        assignment = self.consumer.assignment()

        self.consumer.unsubscribe()
        for Partition in topic_partition:
            if not isinstance(Partition, TopicPartition):
                raise TypeError("topic_partition must be of type TopicPartition, create it with Create TopicPartition keyword.")

            self.assign_to_topic_partition(Partition)

            self.consumer.seek_to_end(Partition)
            end = self.consumer.position(Partition)
            self.consumer.seek_to_beginning(Partition)
            start = self.consumer.position(Partition)
            number_of_messages += end-start

        self.consumer.unsubscribe()
        self.consumer.assign(assignment)
        return number_of_messages
335103
public Node nextAvailableNode() {
        if (!isInit) {
            init();
        }
        currentNodeIndex++;
        if (currentNodeIndex >= allNodes.length) {
            currentNodeIndex = 0;
        }
        return currentNode();
    }