This function returns the relevant part from the process output.

@param   processOutput
The process output
@param   prefix
The prefix to look for in the output
@return  The relevant output part
428091
public static String getOutputPart(ProcessOutput processOutput,String prefix)
    {
        //get output
        String output=processOutput.getOutputText();

        if(output!=null)
        {
            //set flag
            boolean validOutput=false;

            int index=output.indexOf(prefix);
            if(index!=-1)
            {
                //get index
                index=index+prefix.length();
    
                if(output.length()>index)
                {
                    //get output
                    output=output.substring(index);
                    
                    output=output.trim();
                    index=output.indexOf("\n");
                    if(index!=-1)
                    {
                        output=output.substring(0,index);
                        output=output.trim();
                    }

                    if(output.length()>0)
                    {
                        //set flag
                        validOutput=true;
                    }
                }
            }
            
            if(!validOutput)
            {
                output=null;
            }
        }
        
        return output;
    }
834484
protected OutputStream getFilterOutput()
    {
    OutputStream target = getTarget();
    return target == null? System.out : target;
    }
837792
protected void stageOutput(final String output) {
        boolean print = getPhaseConfiguration().isVerbose();
        if (print) {
            output(INDENT + INDENT + output);
        }
    }
221734
public FunctionList prefix(final String prefix) {
        return filter(new Filter() {
            public boolean keep(Function m) {
                return m.getName().startsWith(prefix);
            }
        });
    }
1163368
protected ProcessOutput executeProcess(String command,FaxActionType faxActionType)
    {
        //execute process
        ProcessOutput processOutput=ProcessExecutorHelper.executeProcess(this,command);

        //validate process output
        this.processOutputValidator.validateProcessOutput(this,processOutput,faxActionType);
        
        return processOutput;
    }
970802
def GetWSAActionOutput(operation):
    """"""
    attr = operation.output.action
    if attr is not None:
        return attr
    targetNamespace = operation.getPortType().getTargetNamespace()
    ptName = operation.getPortType().name
    msgName = operation.output.name
    if not msgName:
        msgName = operation.name + 'Response'
    if targetNamespace.endswith('/'):
        return '%s%s/%s' %(targetNamespace, ptName, msgName)
    return '%s/%s/%s' %(targetNamespace, ptName, msgName)
612176
public static String getProcess(Long pipelineId, Long processId) {
        // 根据channelId , pipelineId构造path
        return MessageFormat.format(ArbitrateConstants.NODE_PROCESS_FORMAT, getChannelId(pipelineId),
                                    String.valueOf(pipelineId), getProcessNode(processId));
    }
890584
@Override
	protected void onFirstOutput() throws IOException
	{
		if(prefix != null && prefix.length() > 0)
		{
			print(prefix);
			prefix = null;	// no need to keep a ref
		}
	}
93994
def getOutput(self, command, env={}, path=None,
                  uid=None, gid=None, usePTY=0, childFDs=None):
        
        deferred = defer.Deferred()
        processProtocol = _SummaryProcessProtocol(deferred)
        self.execute(processProtocol, command, env,
                     path, uid, gid, usePTY, childFDs)
        @deferred.addCallback
        def getStdOut(tuple_):
            stdout, _stderr, _returnCode = tuple_
            return stdout
        return deferred
1199801
private JsonNode parseProcessOutput(String processOutput) {
        JsonNode credentialsJson = Jackson.jsonNodeOf(processOutput);

        if (!credentialsJson.isObject()) {
            throw new IllegalStateException("Process did not return a JSON object.");
        }

        JsonNode version = credentialsJson.get("Version");
        if (version == null || !version.isInt() || version.asInt() != 1) {
            throw new IllegalStateException("Unsupported credential version: " + version);
        }
        return credentialsJson;
    }
1319204
static String getOutputName(String resource)
    {
        final int secondToTheLastDot = resource.lastIndexOf('.', resource.length()-5), 
                slash = resource.lastIndexOf('/', secondToTheLastDot);
        
        return resource.substring(slash+1, secondToTheLastDot);
    }
445274
public int solve(int[] prefix, SolutionAcceptor<ColumnName> output) {
    List<Node<ColumnName>> choices = new ArrayList<Node<ColumnName>>();
    for(int i=0; i < prefix.length; ++i) {
      choices.add(advance(prefix[i]));
    }
    int result = search(choices, output);
    for(int i=prefix.length-1; i >=0; --i) {
      rollback(choices.get(i));
    }
    return result;
  }
1119775
public static ProcessOutput executeProcess(ConfigurationHolder configurationHolder,String command)
    {
        //get process executer class name
        String className=configurationHolder.getConfigurationValue(ProcessExecutor.PROCESS_EXECUTER_CLASS_NAME_PROPERTY_KEY);
        if(className==null)
        {
            className=DefaultProcessExecutor.class.getName();
        }
        
        //get process executer from cache
        ProcessExecutor processExecutor=ProcessExecutorHelper.PROCESS_EXECUTERS.get(className);
        if(processExecutor==null)
        {
            //create new process executer (no need to synchronize as it won't impact anything if we create more
            //than 1 process executer of same type)
            processExecutor=(ProcessExecutor)ReflectionHelper.createInstance(className);
            
            //put in cache
            ProcessExecutorHelper.PROCESS_EXECUTERS.put(className,processExecutor);
        }

        ProcessOutput processOutput=null;
        try
        {
            //execute process
            processOutput=processExecutor.executeProcess(configurationHolder,command);
        }
        catch(RuntimeException exception)
        {
            throw exception;
        }
        catch(Exception exception)
        {
            throw new FaxException("Error while invoking process, command: "+command,exception);
        }
        
        return processOutput;
    }
960729
@Override
    public String output() {
        String output = process.output();
        publisher.publish(new Returned(command, output));
        return output;
    }
1063808
protected ProcessOutputHandler createProcessOutputHandler()
    {
        //get process output handler
        String className=this.getConfigurationValue(FaxClientSpiConfigurationConstants.PROCESS_OUTPUT_HANDLER_PRE_FORMAT_PROPERTY_KEY);
        ProcessOutputHandler handler=null;
        if(className!=null)
        {
            //create new instance
            handler=(ProcessOutputHandler)ReflectionHelper.createInstance(className);
        }

        return handler;
    }
132518
public String lookupNamespace(final String prefix) {
        return this.namespaceTagHints.isEmpty() ? prefix : this.namespaceTagHints.get(prefix);
    }
1065161
function processOutputs(outputs) {
  var removeSourceMaps = require('./sourcemaps').removeSourceMaps;

  var offset = 0;

  var outputObj = {};

  var sources = outputObj.sources = [];
  var sourceMapsWithOffsets = outputObj.sourceMapsWithOffsets = [];

  outputs.forEach(function(output) {
    var source;
    if (typeof output == 'object') {
      source = output.source || '';
      var offset_ = output.sourceMapOffset || 0;
      var map = output.sourceMap;
      if (map) {
        sourceMapsWithOffsets.push([offset + offset_, map]);
      }
    }
    // NB perhaps we should enforce output is always an object down the chain?
    else if (typeof output == 'string') {
      source = output;
    }
    else {
      var format = output ? output.toString() : typeof output;
      throw new Error("Unexpected output format: " + format);
    }
    source = removeSourceMaps(source || '');
    offset += countLines(source);
    sources.push(source);
  });

  return outputObj;
}