Adds a new fisbone for the given stream
7391
public SkeletonFisbone addBoneForStream(int sid) {
        SkeletonFisbone bone = new SkeletonFisbone();
        bone.setSerialNumber(sid);
        fisbones.add(bone);

        if (sid == -1 || bonesByStream.containsKey(sid)) {
            throw new IllegalArgumentException("Invalid / duplicate sid " + sid);
        }
        bonesByStream.put(sid, bone);

        return bone;
    }
1191114
def add(self, path):
        '''
        
        '''
        with salt.utils.files.fopen(path, 'rb') as ifile:
            for chunk in iter(lambda: ifile.read(self.__buff), b''):
                self.__digest.update(chunk)
1241155
public void addFile(InputStream inputStream) {
        String name = "file";
        fileStreams.put(normalizeDuplicateName(name), inputStream);
    }
1338953
def build_stream(self, obj, stream: BytesIO, context=None) -> None:
        
        if context is None:
            context = Context()
        if not isinstance(context, Context):
            context = Context(context)
        try:
            self._build_stream(obj, stream, context)
        except Error:
            raise
        except Exception as exc:
            raise BuildingError(str(exc))
252785
@PublicEvolving
	public void add_sink(SinkFunction<PyObject> sink_func) throws IOException {
		stream.addSink(new PythonSinkFunction(sink_func));
	}
504164
public final static <T, R> Stream<R> flatMapStream(final Stream<T> stream, final Function<? super T, ? extends BaseStream<? extends R, ?>> fn) {
        return stream.flatMap(fn.andThen(bs -> {

            if (bs instanceof Stream)
                return (Stream<R>) bs;
            else
                return Streams.stream(bs.iterator());

        }));
    }
396552
public Promise<Void> replaceOwnStream(CountedReference<WebRTCMediaStream> stream) {
        return ask(new PeerNodeActor.ReplaceOwnStream(stream.acquire()));
    }
1198213
public void addNewStream(FixupStream fs) throws IOException
   {
      this.getFixupStreams().add(fs);

      SpoolFile f = SpoolFile.createTempFile("tempFile" + IdGenerator.generate(), ".tmp", tempDir);

      this.getListFile().add(f);
      this.getListRandomAccessFiles().add(PrivilegedFileHelper.randomAccessFile(f, "rw"));

   }
1351930
public static <IN> CassandraSinkBuilder<IN> addSink(org.apache.flink.streaming.api.scala.DataStream<IN> input) {
		return addSink(input.javaStream());
	}
188222
function(config, stream, extras, callback) {
    stream = stream.pipe(through.obj(function(file, enc, cb) {

      var contents = file.contents.toString();
      var changed = false;

      if(file.prev) {
        changed = true;
        file.prev.$el = file.prev.$el || cheerio.load(file.prev.contents.toString());
        var title = file.prev.$el('h1').first().text();
        contents = contents.replace(/MBINSERTPREVLABEL/g, title);
        var href = path.relative(path.dirname(file.relative), file.prev.relative);
        contents = contents.replace(/MBINSERTPREVHREF/g, href);
      }

      if(file.next) {
        changed = true;
        file.next.$el = file.next.$el || cheerio.load(file.next.contents.toString());
        var title = file.next.$el('h1').first().text();
        contents = contents.replace(/MBINSERTNEXTLABEL/g, title);
        var href = path.relative(path.dirname(file.relative), file.next.relative);
        contents = contents.replace(/MBINSERTNEXTHREF/g, href);
      }

      if(changed) {
        file.contents = new Buffer(contents);
        file.$el = undefined;
      }

      cb(null, file);

    }));
    callback(null, config, stream, extras);
  }
1250572
def FromStream(cls, stream, auto_transfer=True, total_size=None, **kwds):
        """"""
        return cls(stream, auto_transfer=auto_transfer, total_size=total_size,
                   **kwds)
700212
public function add($stream)
    {
        if (is_scalar($stream) || is_resource($stream)) {
            $stream = new Stream(['data' => $stream]);
        }

        if (!$stream->isReadable()) {
            throw new InvalidArgumentException("Cannot append on a non readable stream.");
        }

        // The stream is only seekable if all streams are seekable
        if (!$stream->isSeekable()) {
            $this->_seekable = false;
        }

        $this->_streams[] = $stream;
        return $this;
    }
770164
def add_from_datastream(self, source_ds):
        ''''''
        if source_ds.name != self.name:
            raise DataStreamError("Data from a different stream 'f{source_ds.name}' cannot be add to this stream")
        if self._data_runs is None:
            raise DataStreamError("Cannot add data to a resident datastream.")

        if self.cluster_count < source_ds.cluster_count:
            self.cluster_count = source_ds.cluster_count
        if self.size == 0 and source_ds.size:
            self.size = source_ds.size
            self.alloc_size = source_ds.alloc_size
        if source_ds._data_runs:
            self._data_runs += source_ds._data_runs
            self._data_runs_sorted = False
651104
function(track, stream) {
    stream.addTrack(track);
    stream.dispatchEvent(new window.MediaStreamTrackEvent('addtrack',
      {track: track}));
  }
165299
public BytesBuilder addChunk(@NonNull byte[] buffer, int offset, int length)
	{
		Objects.requireNonNull(buffer);

		out.write(buffer, offset, length);
		return this;
	}
885206
private void customizeStream(Number streamId, AbstractClientStream stream) {
        Integer buffer = streamBuffers.get(streamId.doubleValue());
        if (buffer != null) {
            stream.setClientBufferDuration(buffer);
        }
        stream.setName(createStreamName());
        stream.setConnection(this);
        stream.setScope(this.getScope());
        stream.setStreamId(streamId);
    }
381028
void addParentBuffer(StreamCharBuffer parent) {
        if (!notifyParentBuffersEnabled) return;

        if (parentBuffers==null) {
            parentBuffers=new HashSet<SoftReference<StreamCharBufferKey>>();
        }
        parentBuffers.add(new SoftReference<StreamCharBufferKey>(parent.bufferKey));
    }