TargetStreamManager.
770968
@Override
    public void setCompletedPrefix(long newPrefix)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setCompletedPrefix", Long.valueOf(newPrefix));

        // If the completedPrefix is updated then update the 
        // other control variables.
        //We synchronize to ensure the saftey
        synchronized (oststream) //defect 256036
        {
            if (oststream.setCompletedPrefix(newPrefix) == true)
            {
                doubtHorizon = newPrefix + 1;
                unknownHorizon = newPrefix;

                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    SibTr.debug(tc, "doubtHorizon:" + doubtHorizon + " unknownHorizon:" + unknownHorizon);
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "setCompletedPrefix");
    }
144717
@Override
    public DataByteOutput<T> target(final T target) {
        return (DataByteOutput<T>) super.target(target);
    }
883430
public void addStreamEscape(Stream source, Location target) {
        StreamEscape streamEscape = new StreamEscape(source, target);
        streamEscapeSet.add(streamEscape);
        if (FindOpenStream.DEBUG) {
            System.out.println("Adding potential stream escape " + streamEscape);
        }
    }
1106435
private static <ReqT, RespT> ServerCallHandler<ReqT, RespT> asyncStreamingRequestCall(
      StreamingRequestMethod<ReqT, RespT> method) {
    return new StreamingServerCallHandler<>(method);
  }
1337331
public void setTarget(Map<String, Object> target) {
        removeEntriesStartingWith(TARGET);
        eventMap.putAll(target);
    }
1070920
def stream_request(self, request, out_future):
        """"""
        request.close_argstreams()

        def on_done(future):
            if future.exception() and out_future.running():
                out_future.set_exc_info(future.exc_info())
            request.close_argstreams(force=True)

        stream_future = self._stream(request, self.request_message_factory)
        stream_future.add_done_callback(on_done)
        return stream_future
1368279
public void reconstituteTargetStreams(StreamSet streamSet)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "reconstituteTargetStreams", streamSet);

    _targetStreamManager.reconstituteStreamSet(streamSet);

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "reconstituteTargetStreams");
  }
218166
public static void closeStreams(Process self) {
        try { self.getErrorStream().close(); } catch (IOException ignore) {}
        try { self.getInputStream().close(); } catch (IOException ignore) {}
        try { self.getOutputStream().close(); } catch (IOException ignore) {}
    }
585577
function transform (stream, target) {
  return stream
  .pipe($.plumber(::console.error))
  .pipe($.sourcemaps.init())
    .pipe($.babel({/** see .babelrc **/}))
  .pipe($.sourcemaps.write())
  .pipe($.plumber.stop())
  .pipe(gulp.dest(target))
}
510570
public void updateTargetCellule(SIBUuid8 targetMEUuid) throws SIResourceException 
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "updateTargetCellule", targetMEUuid);
     
    this.targetMEUuid = targetMEUuid;
    
    sourceStreamManager.updateTargetCellule(targetMEUuid);

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "updateTargetCellule");
   
   }
259941
public void updateStream(String scope, String streamName, Duration latency) {
        DYNAMIC_LOGGER.incCounterValue(globalMetricName(UPDATE_STREAM), 1);
        DYNAMIC_LOGGER.incCounterValue(UPDATE_STREAM, 1, streamTags(scope, streamName));
        updateStreamLatency.reportSuccessValue(latency.toMillis());
    }
843460
def ApplicationReceiving(self, app, streams):
        """"""

        # we should only proceed if we are in TCP mode
        if stype != socket.SOCK_STREAM:
            return

        # handle all streams
        for stream in streams:
            # read object from the stream
            obj = StreamRead(stream)
            if obj:
                if obj[0] == cmdData:
                    # data were received, reroute it to the tunnel based on the tunnel ID
                    try:
                        TCPTunnel.threads[obj[1]].send(obj[2])
                    except KeyError:
                        pass
                elif obj[0] == cmdConnect:
                    # a connection request received, connect the socket
                    n = obj[1]
                    sock = socket.socket(type=stype)
                    try:
                        sock.connect(addr)
                        # start the tunnel thread
                        TCPTunnel(sock, stream, n).start()
                    except socket.error, e:
                        # connection failed, send an error report back through the stream
                        print 'error (%s): %s' % (n, e)
                        StreamWrite(stream, cmdError, n, tuple(e))
                        StreamWrite(stream, cmdDisconnect, n)
                elif obj[0] == cmdDisconnect:
                    # an disconnection request received, close the tunnel
                    try:
                        TCPTunnel.threads[obj[1]].close()
                    except KeyError:
                        pass
                elif obj[0] == cmdError:
                    # connection failed on the other side, display the error
                    print 'error (%s): %s' % obj[1:2]
1051563
public TargetStreamControl getControlAdapter()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "getControlAdapter");

    TargetStreamControl targetStreamControl = 
        new TargetStreamControl(remoteEngineUUID, this, streamSetUUID, 
        getReliability(), getPriority());
        
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(tc, "getControlAdapter", targetStreamControl);
    return targetStreamControl;    
  }
1311579
public void setStreamSource(InstanceStream stream) {
		this.streamSource = new StreamSource(stream);
		firstInstance = streamSource.nextInstance().getData();
	}
151128
@Nullable
    public final Target findTargetFor(@Nullable final String targetPath) {
        if (targets == null) {
            return null;
        }
        if (targetPath == null) {
            return null;
        }
        for (final Target target : targets) {
            if (target.matches(targetPath)) {
                return target;
            }
        }
        return null;
    }
581031
function handleStream(target, encoding, cb) {
		if (target.isNull()) {
			return cb(null, target);
		}

		if (target.isStream()) {
			return cb(error(target.path + ': Streams not supported for target templates!'));
		}

		try {
			const tagsRegExp = getRegExpTags(opt, null);
			target.contents = processContent(target, opt, tagsRegExp, [target.path]);
			this.push(target);
			return cb();
		} catch (err) {
			this.emit('error', err);
			return cb();
		}
	}
1125037
def _get_event_stream(self):
        """"""
        self.__event_handle = threading.Event()
        event_thread = threading.Thread(target=self.thread_function)
        event_thread.start()