Gets information about who is consuming the outputs of the specified component,
and how.

@return Map from stream id to component id to the Grouping used.
340033
public Map<String, Map<String, TopologyAPI.Grouping>> getTargets(String componentId) {
    Map<String, Map<String, TopologyAPI.Grouping>> retVal =
        new HashMap<>();
    if (!outputs.containsKey(componentId)) {
      return retVal;
    }
    for (TopologyAPI.OutputStream ostream : outputs.get(componentId)) {
      Map<String, TopologyAPI.Grouping> targetMap =
          new HashMap<>();
      for (Map.Entry<String, List<TopologyAPI.InputStream>> e : inputs.entrySet()) {
        String targetComponentId = e.getKey();
        for (TopologyAPI.InputStream is : e.getValue()) {
          if (areStreamsEqual(ostream.getStream(), is.getStream())) {
            targetMap.put(targetComponentId, is.getGtype());
          }
        }
      }
      retVal.put(ostream.getStream().getId(), targetMap);
    }
    return retVal;
  }
665050
public static ComponentsMultiThread getComponentsMultiThread() {
    TransactionLogger instance = getInstance();
    if (instance == null) {
      return null;
    }

    return instance.componentsMultiThread;
  }
169280
public InputStream getContent() {
        switch(contentType){
            case EMPTY:
                throw new RuntimeException("There is not Content available to analyze");
            case FILE:
                if(consumed)
                    try {
                        contentStream = Optional.of((InputStream) new FileInputStream(contentFile.get()));
                    } catch (FileNotFoundException e) {
                        throw new RuntimeException(e);
                    }
                break;
                case STRING:
                    if (consumed) {
                        if (contentEncoding.isPresent()) {
                            try {
                                contentStream = Optional.of(IOUtils.toInputStream(contentString.get(), contentEncoding.get()));
                            } catch (IOException e) {
                                throw new RuntimeException(e);
                            }
                        } else {
                            contentStream = Optional.of(IOUtils.toInputStream(contentString.get()));
                        }
                    }
                    break;
                case INPUTSTREAM:
                    if (consumed) {
                        throw new RuntimeException("The Content Stream to be analyzed has been already consumed");
                    }
                    break;
                default:
                    break;
        }
        
        consumed = true;
        return contentStream.get();
    }
383629
public StreamState getStreamState()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "getStreamState");
    StreamState returnState = _sourceStream.getStreamState();
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(tc, "getStreamState", returnState);
    return returnState;
  }
155866
public Map<String, Map<String, Grouping>> getTargets(String componentId) {
        Map<String, Map<String, Grouping>> ret = new HashMap<>();
        for (String otherComponentId : getComponentIds()) {
            Map<GlobalStreamId, Grouping> inputs = getComponentCommon(otherComponentId).get_inputs();
            for (GlobalStreamId id : inputs.keySet()) {
                if (id.get_componentId().equals(componentId)) {
                    Map<String, Grouping> curr = ret.get(id.get_streamId());
                    if (curr == null)
                        curr = new HashMap<>();
                    curr.put(otherComponentId, inputs.get(id));
                    ret.put(id.get_streamId(), curr);
                }
            }
        }
        return ret;
    }
456946
public Constituent getMap() {
    if (PTBConstituent_Type.featOkTst && ((PTBConstituent_Type)jcasType).casFeat_map == null)
      jcasType.jcas.throwFeatMissing("map", "de.julielab.jules.types.PTBConstituent");
    return (Constituent)(jcasType.ll_cas.ll_getFSForRef(jcasType.ll_cas.ll_getRefValue(addr, ((PTBConstituent_Type)jcasType).casFeatCode_map)));}
1060577
public String getUsage()
    {
        Set<Option> set = new HashSet<>();
        StringBuilder sb = new StringBuilder();
        sb.append("usage: ");
        boolean n1 = false;
        for (Entry<String,List<Option>> e : groups.entrySet())
        {
            if (n1)
            {
                sb.append("|");
            }
            n1 = true;
            sb.append("[");
            boolean n2 = false;
            for (Option opt : e.getValue())
            {
                if (n2)
                {
                    sb.append(" ");
                }
                n2 = true;
                append(sb, opt);
                set.add(opt);
            }
            sb.append("]");
        }
        for (Option opt : map.values())
        {
            if (!set.contains(opt))
            {
                sb.append(" ");
                append(sb, opt);
            }
        }
        for (int ii=0;ii<names.size();ii++)
        {
            sb.append(" <").append(names.get(ii)).append(">");
            if (types.get(ii).isArray())
            {
                sb.append("...");
            }
        }
        return sb.toString();
    }
690833
@Override
    public Collection<SegmentProperties> getActiveSegments() {
        ensureRunning();
        logRequest("getActiveSegments");

        // To reduce locking in the metadata, we first get the list of Segment Ids, then we fetch their metadata
        // one by one. This only locks the metadata on the first call and, individually, on each call to getStreamSegmentMetadata.
        return this.metadata.getAllStreamSegmentIds()
                .stream()
                .map(this.metadata::getStreamSegmentMetadata)
                .filter(Objects::nonNull)
                .map(SegmentMetadata::getSnapshot)
                .collect(Collectors.toList());
    }
130354
public SIBUuid12 getStreamID()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "getStreamID");  
    SIBUuid12 returnValue = aiStream.getStreamId();   
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(tc, "getStreamID", returnValue);
    return returnValue;
  }
581261
public Map<String, Object> toMap() {
        HashMap<String, Object> map = new HashMap<>();

        map.put("id", id);
        map.put("pipelineName", pipelineName);
        map.put("stageName", stageName);
        map.put("myCheckin", myCheckin);
        map.put("event", event.toString());

        return map;
    }
363901
public Map<String, Object> getOutboundConnectionInfo() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "getOutboundConnectionInfo");
        return this.outboundConnectionInfo;
    }
528184
private Map<String, String> getMapping() {
    if (this.attributesMapping != null && this.lastReload != null && this.lastReload.equals(this.attributeResolverService
      .getLastSuccessfulReloadInstant())) {
      return this.attributesMapping;
    }
    // Reload.
    ServiceableComponent<AttributeResolver> component = null;
    Map<String, String> am = null;
    try {
      // Get date before we get the component. That way we'll not leak changes.
      final DateTime when = this.attributeResolverService.getLastSuccessfulReloadInstant();
      component = this.attributeResolverService.getServiceableComponent();
      if (null == component) {
        if (!captiveServiceReloadFailed) {
          logger.error("Invalid AttributeResolver configuration");
        }
        captiveServiceReloadFailed = true;
      }
      else {
        final AttributeResolver attributeResolver = component.getComponent();
        am = new HashMap<>();

        Map<String, AttributeDefinition> map = attributeResolver.getAttributeDefinitions();
        for (Map.Entry<String, AttributeDefinition> entry : map.entrySet()) {
          String name = null;
          Set<AttributeEncoder<?>> encoders = entry.getValue().getAttributeEncoders();
          for (AttributeEncoder<?> encoder : encoders) {
            if (encoder instanceof SAML2AttributeEncoder) {
              name = ((SAML2AttributeEncoder<?>) encoder).getName();
              if (name != null) {
                break;
              }
            }
          }
          if (name != null) {
            logger.debug("Adding mapping between SAML2 attribute '{}' and id '{}'", name, entry.getKey());
            am.put(name, entry.getKey());
          }
          else {
            logger.debug("No mapping to SAML2 attribute for attribute id '{}'", entry.getKey());
          }
        }

        captiveServiceReloadFailed = false;
        lastReload = when;
      }
    }
    finally {
      if (null != component) {
        component.unpinComponent();
      }
    }

    this.attributesMapping = am;
    return am;
  }
336506
public java.util.Map<java.lang.String, org.tensorflow.framework.TensorInfo> getOutputsMap() {
    return internalGetOutputs().getMap();
  }
929119
public StateSnapshot.StateKeyGroupWriter partitionByKeyGroup() {
		if (computedResult == null) {
			reportAllElementKeyGroups();
			int outputNumberOfElements = buildHistogramByAccumulatingCounts();
			executePartitioning(outputNumberOfElements);
		}
		return computedResult;
	}
933273
public static Map<String, Map<String, MkGrouper>> outbound_components(
            TopologyContext topology_context, WorkerData workerData) {
        Map<String, Map<String, MkGrouper>> rr = new HashMap<>();

        // <Stream_id,<component,Grouping>>
        Map<String, Map<String, Grouping>> output_groupings = topology_context.getThisTargets();
        for (Entry<String, Map<String, Grouping>> entry : output_groupings.entrySet()) {
            String stream_id = entry.getKey();
            Map<String, Grouping> component_grouping = entry.getValue();

            Fields out_fields = topology_context.getThisOutputFields(stream_id);

            Map<String, MkGrouper> componentGrouper = new HashMap<>();
            for (Entry<String, Grouping> cg : component_grouping.entrySet()) {
                String component = cg.getKey();
                Grouping tgrouping = cg.getValue();

                List<Integer> outTasks = topology_context.getComponentTasks(component);
                // ATTENTION: If topology set one component parallelism as 0
                // so we don't need send tuple to it
                if (outTasks.size() > 0) {
                    MkGrouper grouper = new MkGrouper(
                            topology_context, out_fields, tgrouping, component, stream_id, workerData);
                    componentGrouper.put(component, grouper);
                }
                LOG.info("outbound_components, {}-{} for task-{} on {}",
                        component, outTasks, topology_context.getThisTaskId(), stream_id);
            }
            if (componentGrouper.size() > 0) {
                rr.put(stream_id, componentGrouper);
            }
        }
        return rr;
    }
245917
public JSConsumerSet getConsumerSet()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    { 
      SibTr.entry(tc, "getConsumerSet");
      SibTr.exit(tc, "getConsumerSet", consumerSet);
    }
    return consumerSet;
  }
680295
public Stream partition(Grouping grouping) {
        if (_node instanceof PartitionNode) {
            return each(new Fields(), new TrueFilter()).partition(grouping);
        } else {
            return _topology.addSourcedNode(this, new PartitionNode(_node.streamId, _name, getOutputFields(), grouping));
        }
    }