49: class Stream : public Print

63:     Stream() {_timeout=1000;}

23: #define Stream_h

2:   Stream.h - base class for character-based streams.

22: #ifndef Stream_h

114:   // Stream and used parseFloat/Int with a custom ignore character. To keep

24: class Stream {

44: class MemoryStream : public Stream {

46:     MemoryStream(void* buffer, size_t size, jobject buf) :

63: class FileStream : public Stream {

65:     FileStream(FILE* fd) : mFd(fd) {}

74: class JavaInputStream : public Stream {

76:     JavaInputStream(JNIEnv* env, jobject inputStream, jbyteArray byteArray) :

87:     const jobject mInputStream;

26:     Stream();

27:     virtual ~Stream();

78:             mInputStream(inputStream),

92: jint JavaStream_OnLoad(JNIEnv* env);

38: class Stream : public Print

53:     Stream() {_timeout=1000;}

23: #define Stream_h

2:   Stream.h - base class for character-based streams.

22: #ifndef Stream_h

38: class Stream : public Print

54:     Stream() {_timeout=1000;}

23: #define Stream_h

48:     ~Stream(){}

2:   Stream.h - base class for character-based streams.

22: #ifndef Stream_h

31: public interface Stream {

35:    * which the solutions are returned depends on the implementations of {@code Stream} used.

37:   Stream mplus(Stream s2);

44:   Stream bind(Goal goal);

55:   Stream rest();

26: public abstract class Stream<T> implements Iterator<T> {

38: class Stream : public Print

53:     Stream() {_timeout=1000;}

23: #define Stream_h

2:   Stream.h - base class for character-based streams.

22: #ifndef Stream_h

26: class Stream : public Print

21: #define Stream_h

2:   Stream.h - base class for character-based streams.

20: #ifndef Stream_h

731:     Stream("stream", cl::Required,

641: cl::opt<bool> StreamMetadata(

645: cl::opt<bool> StreamDirectory(

649: cl::opt<bool> PdbStream("pdb-stream",

656: cl::opt<bool> DbiStream("dbi-stream",

660: cl::opt<bool> TpiStream("tpi-stream",

664: cl::opt<bool> IpiStream("ipi-stream",

668: cl::opt<bool> PublicsStream("publics-stream",

1356: static void exportStream() {

387:     DumpStreamData("stream-data", cl::CommaSeparated, cl::ZeroOrMore,

454: cl::opt<bool> DumpStreams("streams",

457: cl::opt<bool> DumpStreamBlocks(

591: cl::opt<bool> DumpNamedStreams("named-streams",

368: cl::OptionCategory DbiBytes("Dbi Stream Options");

369: cl::OptionCategory PdbBytes("PDB Stream Options");

650:                         cl::desc("Dump the PDB Stream (Stream 1)"),

657:                         cl::desc("Dump the DBI Stream Headers (Stream 2)"),

661:                         cl::desc("Dump the TPI Stream (Stream 3)"),

665:                         cl::desc("Dump the IPI Stream (Stream 5)"),

669:                             cl::desc("Dump the Publics Stream"),

1064:   auto &Stream = outs();

1066:                             ? Stream.has_colors()

1068:   LinePrinter Printer(2, UseColor, Stream);

1368:     if (to_integer(opts::exportstream::Stream, Index)) {

1381:     Index = ExitOnErr(IS.getNamedStreamIndex(opts::exportstream::Stream));

1382:     outs() << "Dumping contents of stream '" << opts::exportstream::Stream

53: #include "llvm/DebugInfo/PDB/Native/InfoStream.h"

61: #include "llvm/DebugInfo/PDB/Native/TpiStream.h"

75: #include "llvm/Support/BinaryByteStream.h"

713:                clEnumValN(InputFileType::PDBStream, "pdb-stream",

715:                clEnumValN(InputFileType::DBIStream, "dbi-stream",

719:                clEnumValN(InputFileType::ModuleStream, "mod-stream",

773:     ExitOnErr(Builder.getMsfBuilder().addStream(0));

783:   pdb::yaml::PdbInfoStream DefaultInfoStream;

784:   pdb::yaml::PdbDbiStream DefaultDbiStream;

785:   pdb::yaml::PdbTpiStream DefaultTpiStream;

786:   pdb::yaml::PdbTpiStream DefaultIpiStream;

788:   const auto &Info = YamlObj.PdbStream.getValueOr(DefaultInfoStream);

798:   const auto &Dbi = YamlObj.DbiStream.getValueOr(DefaultDbiStream);

814:       const auto &ModiStream = *MI.Modi;

815:       for (auto Symbol : ModiStream.Symbols) {

833:   const auto &Tpi = YamlObj.TpiStream.getValueOr(DefaultTpiStream);

841:   const auto &Ipi = YamlObj.IpiStream.getValueOr(DefaultIpiStream);

1304:     if (File.hasPDBTpiStream()) {

1305:       auto &Tpi = ExitOnErr(File.getPDBTpiStream());

1309:     if (File.hasPDBIpiStream()) {

1310:       auto &Ipi = ExitOnErr(File.getPDBIpiStream());

1322:     ExitOnErr(Builder.getMsfBuilder().addStream(0));

1360:   std::unique_ptr<MappedBlockStream> SourceStream;

1380:     InfoStream &IS = cantFail(File.getPDBInfoStream());

1386:   SourceStream = File.createIndexedStream(Index);

1388:       FileOutputBuffer::create(OutFileName, SourceStream->getLength()));

1389:   FileBufferByteStream DestStream(std::move(OutFile), llvm::support::little);

1390:   BinaryStreamWriter Writer(DestStream);

1391:   ExitOnErr(Writer.writeStreamRef(*SourceStream));

1392:   ExitOnErr(DestStream.commit());

1479:       opts::pdb2yaml::StreamMetadata = true;

1480:       opts::pdb2yaml::StreamDirectory = true;

1481:       opts::pdb2yaml::PdbStream = true;

1483:       opts::pdb2yaml::DbiStream = true;

1484:       opts::pdb2yaml::TpiStream = true;

1485:       opts::pdb2yaml::IpiStream = true;

1486:       opts::pdb2yaml::PublicsStream = true;

1499:       opts::pdb2yaml::DbiStream = true;

1566:     exportStream();

45: #include "llvm/DebugInfo/CodeView/TypeStreamMerger.h"

52: #include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"

54: #include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"

62: #include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h"

772:   for (uint32_t I = 0; I < kSpecialStreamCount; ++I)

1321:   for (uint32_t I = 0; I < kSpecialStreamCount; ++I)

1369:       if (Index >= File.getNumStreams()) {

1463:       opts::dump::DumpStreams = true;

1464:       opts::dump::DumpStreamBlocks = true;

65: 	Stream() (io.ReadCloser, error)

662: func (r *Request) Stream() (io.ReadCloser, error) {

658: // Stream formats and executes the request, and offers streaming of the response.

918: 			klog.V(2).Infof("Stream error %#v when reading response body, may be caused by closed connection.", err)

624: 	objectDecoder, streamingSerializer, framer, err := r.c.content.Negotiator.StreamDecoder(mediaType, params)

910: 		case http2.StreamError:

632: 	return watch.NewStreamWatcher(

671: HH_INLINE void Stream(const V256<T>& v, T* const HH_RESTRICT to) {

674: HH_INLINE void Stream(const V256<float>& v, float* const HH_RESTRICT to) {

677: HH_INLINE void Stream(const V256<double>& v, double* const HH_RESTRICT to) {

191:   BitstreamCursor Stream;

190:   std::unique_ptr<BitstreamReader> StreamFile;

3416: std::error_code BitcodeReader::InitStream() {

3441: std::error_code BitcodeReader::InitLazyStream() {

192:   std::unique_ptr<DataStreamer> LazyStreamer;

3422: std::error_code BitcodeReader::InitStreamFromBuffer() {

838:   if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))

850:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();

865:     switch (Stream.readRecord(Entry.ID, Record)) {

896:   if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW))

913:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();

931:     switch (Stream.readRecord(Entry.ID, Record)) {

1105:   if (Stream.EnterSubBlock(TYPE_BLOCK_ID_OLD_3_0))

1115:   BitstreamCursor StartOfTypeBlockCursor(Stream);

1126:     unsigned Code = Stream.ReadCode();

1138:         Stream = StartOfTypeBlockCursor;

1142:       if (Stream.ReadBlockEnd())

1149:       Stream.ReadSubBlockID();

1150:       if (Stream.SkipBlock())

1156:       Stream.ReadAbbrevRecord();

1163:     switch (Stream.readRecord(Code, Record)) {

1294:   if (Stream.EnterSubBlock(TYPE_SYMTAB_BLOCK_ID_OLD_3_0))

1302:     unsigned Code = Stream.ReadCode();

1304:       if (Stream.ReadBlockEnd())

1311:       Stream.ReadSubBlockID();

1312:       if (Stream.SkipBlock())

1318:       Stream.ReadAbbrevRecord();

1324:     switch (Stream.readRecord(Code, Record)) {

1345:   if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))

1353:     unsigned Code = Stream.ReadCode();

1355:       if (Stream.ReadBlockEnd())

1361:       Stream.ReadSubBlockID();

1362:       if (Stream.SkipBlock())

1368:       Stream.ReadAbbrevRecord();

1374:     switch (Stream.readRecord(Code, Record)) {

1407:   if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))

1414:     unsigned Code = Stream.ReadCode();

1416:       if (Stream.ReadBlockEnd())

1423:       Stream.ReadSubBlockID();

1424:       if (Stream.SkipBlock())

1430:       Stream.ReadAbbrevRecord();

1437:     Code = Stream.readRecord(Code, Record);

1449:       Code = Stream.ReadCode();

1452:       unsigned NextBitCode = Stream.readRecord(Code, Record);

1626:   if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))

1635:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();

1657:     unsigned BitCode = Stream.readRecord(Entry.ID, Record);

1961:   if (Stream.ReadBlockEnd())

1988:   uint64_t CurBit = Stream.GetCurrentBitNo();

1992:   if (Stream.SkipBlock())

2028:     Stream.JumpToBit(NextUnreadBit);

2029:   else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))

2037:   while (!Stream.AtEndOfStream()) {

2038:     unsigned Code = Stream.ReadCode();

2040:       if (Stream.ReadBlockEnd())

2073:       switch (Stream.ReadSubBlockID()) {

2075:         if (Stream.SkipBlock())

2079:         if (Stream.ReadBlockInfoBlock())

2132:           NextUnreadBit = Stream.GetCurrentBitNo();

2142:       Stream.ReadAbbrevRecord();

2147:     switch (Stream.readRecord(Code, Record)) {

2347:   if (Stream.Read(8) != 'B' ||

2348:       Stream.Read(8) != 'C' ||

2349:       Stream.Read(4) != 0x0 ||

2350:       Stream.Read(4) != 0xC ||

2351:       Stream.Read(4) != 0xE ||

2352:       Stream.Read(4) != 0xD)

2358:     if (Stream.AtEndOfStream())

2362:       Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);

2373:         if (Stream.ReadBlockInfoBlock())

2387:         if (Stream.SkipBlock())

2398:       if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 &&

2399:           Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a &&

2400:           Stream.AtEndOfStream())

2409:   if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))

2417:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();

2431:     switch (Stream.readRecord(Entry.ID, Record)) {

2459:   if (Stream.Read(8) != 'B' ||

2460:       Stream.Read(8) != 'C' ||

2461:       Stream.Read(4) != 0x0 ||

2462:       Stream.Read(4) != 0xC ||

2463:       Stream.Read(4) != 0xE ||

2464:       Stream.Read(4) != 0xD)

2470:     BitstreamEntry Entry = Stream.advance();

2483:       if (Stream.SkipBlock())

2488:       Stream.skipRecord(Entry.ID);

2496:   if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))

2501:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();

2516:     switch (Stream.readRecord(Entry.ID, Record)) {

2543:   if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))

2563:     unsigned Code = Stream.ReadCode();

2565:       if (Stream.ReadBlockEnd())

2571:       switch (Stream.ReadSubBlockID()) {

2573:         if (Stream.SkipBlock())

2598:       Stream.ReadAbbrevRecord();

2605:     unsigned BitCode = Stream.readRecord(Code, Record);

3332:   Stream.JumpToBit(DFII->second);

3436:   Stream.init(&*StreamFile);

3448:   Stream.init(&*StreamFile);

354:   std::error_code InitStream();

356:   std::error_code InitLazyStream();

2343:   if (std::error_code EC = InitStream())

2455:   if (std::error_code EC = InitStream())

3418:     return InitLazyStream();

3435:   StreamFile.reset(new BitstreamReader(BufPtr, BufEnd));

3444:   auto OwnedBytes = llvm::make_unique<StreamingMemoryObject>(

3446:   StreamingMemoryObject &Bytes = *OwnedBytes;

3447:   StreamFile = llvm::make_unique<BitstreamReader>(std::move(OwnedBytes));

355:   std::error_code InitStreamFromBuffer();

395:       TheModule(nullptr), Buffer(buffer), LazyStreamer(nullptr),

2131:         if (LazyStreamer && SeenValueSymbolTable) {

2299:         if (LazyStreamer)

2383:         if (LazyStreamer)

3417:   if (LazyStreamer)

3419:   return InitStreamFromBuffer();

3445:       std::move(LazyStreamer));

165: type Stream struct {

309: func newContextWithStream(ctx context.Context, stream *Stream) context.Context {

314: func StreamFromContext(ctx context.Context) (s *Stream, ok bool) {

391: 	NewStream(ctx context.Context, callHdr *CallHdr) (*Stream, error)

397: 	CloseStream(stream *Stream, err error)

427: func StreamErrorf(c codes.Code, format string, a ...interface{}) StreamError {

455: type StreamError struct {

417: 	HandleStreams(func(*Stream))

164: // Stream represents an RPC in the transport layer.

167: 	// nil for client side Stream.

208: func (s *Stream) RecvCompress() string {

213: func (s *Stream) SetSendCompress(str string) {

220: func (s *Stream) Header() (metadata.MD, error) {

232: func (s *Stream) Trailer() metadata.MD {

240: func (s *Stream) ServerTransport() ServerTransport {

245: func (s *Stream) Context() context.Context {

250: func (s *Stream) TraceContext(tr trace.Trace) {

255: func (s *Stream) Method() string {

260: func (s *Stream) StatusCode() codes.Code {

265: func (s *Stream) StatusDesc() string {

275: func (s *Stream) SetTrailer(md metadata.MD) error {

285: func (s *Stream) write(m recvMsg) {

289: // Read reads all the data available for this Stream from the transport and

293: func (s *Stream) Read(p []byte) (n int, err error) {

304: // The key to save transport.Stream in the context.

315: 	s, ok = ctx.Value(streamKey).(*Stream)

388: 	Write(s *Stream, data []byte, opts *Options) error

390: 	// NewStream creates a Stream for an RPC.

411: 	WriteStatus(s *Stream, statusCode codes.Code, statusDesc string) error

413: 	Write(s *Stream, data []byte, opts *Options) error

415: 	WriteHeader(s *Stream, md metadata.MD) error

159: 	streamWriteDone             // EndStream sent

160: 	streamReadDone              // EndStream received

307: // newContextWithStream creates a new context from ctx and attaches stream

313: // StreamFromContext returns the stream saved in ctx.

393: 	// CloseStream clears the footprint of a stream when the stream is

395: 	// CloseStream is called. Must be called when a stream is finished

426: // StreamErrorf creates an StreamError with the specified error code and description.

428: 	return StreamError{

454: // StreamError is an error that only affects one stream within a connection.

460: func (e StreamError) Error() string {

464: // ContextErr converts the error from context package into a StreamError.

465: func ContextErr(err error) StreamError {

468: 		return StreamErrorf(codes.DeadlineExceeded, "%v", err)

470: 		return StreamErrorf(codes.Canceled, "%v", err)

476: // If it receives from ctx.Done, it returns 0, the StreamError for ctx.Err.

161: 	streamDone                  // sendDone and recvDone or RSTStreamFrame is sent or received.

330: func NewServerTransport(protocol string, conn net.Conn, maxStreams uint32, authInfo credentials.AuthInfo) (ServerTransport, error) {

331: 	return newHTTP2Server(conn, maxStreams, authInfo)

416: 	// HandleStreams receives incoming streams using the given handler.

664:     Stream("stream", cl::Required,

570: cl::opt<bool> StreamMetadata(

574: cl::opt<bool> StreamDirectory(

578: cl::opt<bool> PdbStream("pdb-stream",

585: cl::opt<bool> DbiStream("dbi-stream",

589: cl::opt<bool> TpiStream("tpi-stream",

593: cl::opt<bool> IpiStream("ipi-stream",

1229: static void exportStream() {

338:     DumpStreamData("stream-data", cl::CommaSeparated, cl::ZeroOrMore,

405: cl::opt<bool> DumpStreams("streams",

408: cl::opt<bool> DumpStreamBlocks(

520: cl::opt<bool> DumpNamedStreams("named-streams",

319: cl::OptionCategory DbiBytes("Dbi Stream Options");

320: cl::OptionCategory PdbBytes("PDB Stream Options");

579:                         cl::desc("Dump the PDB Stream (Stream 1)"),

586:                         cl::desc("Dump the DBI Stream Headers (Stream 2)"),

590:                         cl::desc("Dump the TPI Stream (Stream 3)"),

594:                         cl::desc("Dump the IPI Stream (Stream 5)"),

891:     llvm::raw_string_ostream Stream(CompressionStr);

892:     Stream << IS->getCompression();

911:     WithColor(Printer, PDB_ColorItem::LiteralValue).get() << Stream.str();

937:   auto &Stream = outs();

939:                             ? Stream.has_colors()

941:   LinePrinter Printer(2, UseColor, Stream);

1241:     if (to_integer(opts::exportstream::Stream, Index)) {

1254:     Index = ExitOnErr(IS.getNamedStreamIndex(opts::exportstream::Stream));

1255:     outs() << "Dumping contents of stream '" << opts::exportstream::Stream

56: #include "llvm/DebugInfo/PDB/Native/InfoStream.h"

64: #include "llvm/DebugInfo/PDB/Native/TpiStream.h"

76: #include "llvm/Support/BinaryByteStream.h"

646:                clEnumValN(InputFileType::PDBStream, "pdb-stream",

648:                clEnumValN(InputFileType::DBIStream, "dbi-stream",

652:                clEnumValN(InputFileType::ModuleStream, "mod-stream",

706:     ExitOnErr(Builder.getMsfBuilder().addStream(0));

716:   pdb::yaml::PdbInfoStream DefaultInfoStream;

717:   pdb::yaml::PdbDbiStream DefaultDbiStream;

718:   pdb::yaml::PdbTpiStream DefaultTpiStream;

719:   pdb::yaml::PdbTpiStream DefaultIpiStream;

721:   const auto &Info = YamlObj.PdbStream.getValueOr(DefaultInfoStream);

731:   const auto &Dbi = YamlObj.DbiStream.getValueOr(DefaultDbiStream);

747:       const auto &ModiStream = *MI.Modi;

748:       for (auto Symbol : ModiStream.Symbols) {

766:   const auto &Tpi = YamlObj.TpiStream.getValueOr(DefaultTpiStream);

774:   const auto &Ipi = YamlObj.IpiStream.getValueOr(DefaultIpiStream);

1179:     if (File.hasPDBTpiStream()) {

1180:       auto &Tpi = ExitOnErr(File.getPDBTpiStream());

1184:     if (File.hasPDBIpiStream()) {

1185:       auto &Ipi = ExitOnErr(File.getPDBIpiStream());

1197:     ExitOnErr(Builder.getMsfBuilder().addStream(0));

1233:   std::unique_ptr<MappedBlockStream> SourceStream;

1253:     InfoStream &IS = cantFail(File.getPDBInfoStream());

1259:   SourceStream = MappedBlockStream::createIndexedStream(

1262:       FileOutputBuffer::create(OutFileName, SourceStream->getLength()));

1263:   FileBufferByteStream DestStream(std::move(OutFile), llvm::support::little);

1264:   BinaryStreamWriter Writer(DestStream);

1265:   ExitOnErr(Writer.writeStreamRef(*SourceStream));

1266:   ExitOnErr(DestStream.commit());

1352:       opts::pdb2yaml::StreamMetadata = true;

1353:       opts::pdb2yaml::StreamDirectory = true;

1354:       opts::pdb2yaml::PdbStream = true;

1356:       opts::pdb2yaml::DbiStream = true;

1357:       opts::pdb2yaml::TpiStream = true;

1358:       opts::pdb2yaml::IpiStream = true;

1371:       opts::pdb2yaml::DbiStream = true;

1436:     exportStream();

47: #include "llvm/DebugInfo/CodeView/TypeStreamMerger.h"

55: #include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"

57: #include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"

65: #include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h"

705:   for (uint32_t I = 0; I < kSpecialStreamCount; ++I)

1196:   for (uint32_t I = 0; I < kSpecialStreamCount; ++I)

1242:       if (Index >= File.getNumStreams()) {

1336:       opts::dump::DumpStreams = true;

1337:       opts::dump::DumpStreamBlocks = true;

1751:     WORD Stream;

2188: type Stream struct {

316: type StreamStatus int32

319: 	StreamStatus_STREAM_ENABLING StreamStatus = 1

320: 	StreamStatus_STREAM_ACTIVE   StreamStatus = 2

323: var StreamStatus_name = map[int32]string{

327: var StreamStatus_value = map[string]int32{

790: type StreamSpecification struct {

791: 	EnableStream     *bool  `protobuf:"varint,1,req,name=enable_stream" json:"enable_stream,omitempty"`

801: func (m *StreamSpecification) GetEnableStream() bool {

815: type StreamDetails struct {

816: 	EnableStream     *bool   `protobuf:"varint,1,req,name=enable_stream" json:"enable_stream,omitempty"`

817: 	StreamId         *string `protobuf:"bytes,2,opt,name=stream_id" json:"stream_id,omitempty"`

828: func (m *StreamDetails) GetEnableStream() bool {

871: 	StreamSpec         *StreamSpecification `protobuf:"bytes,5,opt,name=stream_spec" json:"stream_spec,omitempty"`

937: 	StreamSpec         *StreamSpecification `protobuf:"bytes,4,opt,name=stream_spec" json:"stream_spec,omitempty"`

977: 	StreamDetails             *StreamDetails             `protobuf:"bytes,3,opt,name=stream_details" json:"stream_details,omitempty"`

1030: 	StreamDetails             *StreamDetails             `protobuf:"bytes,5,opt,name=stream_details" json:"stream_details,omitempty"`

2189: 	StreamId         *string `protobuf:"bytes,1,req,name=stream_id" json:"stream_id,omitempty"`

2222: 	Streams          []*Stream `protobuf:"bytes,1,rep,name=streams" json:"streams,omitempty"`

2238: type StreamShard struct {

2272: 	StreamId              *string `protobuf:"bytes,1,req,name=stream_id" json:"stream_id,omitempty"`

2305: 	StreamId         *string        `protobuf:"bytes,1,req,name=stream_id" json:"stream_id,omitempty"`

2309: 	StreamStatus     *StreamStatus  `protobuf:"varint,5,req,name=stream_status,enum=otsprotocol.StreamStatus" json:"stream_status,omitempty"`

2370: 	StreamId         *string `protobuf:"bytes,1,req,name=stream_id" json:"stream_id,omitempty"`

2461: 	StreamRecords     []*GetStreamRecordResponse_StreamRecord `protobuf:"bytes,1,rep,name=stream_records" json:"stream_records,omitempty"`

2485: type GetStreamRecordResponse_StreamRecord struct {

835: func (m *StreamDetails) GetStreamId() string {

909: func (m *CreateTableRequest) GetStreamSpec() *StreamSpecification {

967: func (m *UpdateTableRequest) GetStreamSpec() *StreamSpecification {

1000: func (m *UpdateTableResponse) GetStreamDetails() *StreamDetails {

1069: func (m *DescribeTableResponse) GetStreamDetails() *StreamDetails {

2171: type ListStreamRequest struct {

2200: func (m *Stream) GetStreamId() string {

2221: type ListStreamResponse struct {

2231: func (m *ListStreamResponse) GetStreams() []*Stream {

2271: type DescribeStreamRequest struct {

2283: func (m *DescribeStreamRequest) GetStreamId() string {

2304: type DescribeStreamResponse struct {

2320: func (m *DescribeStreamResponse) GetStreamId() string {

2348: func (m *DescribeStreamResponse) GetStreamStatus() StreamStatus {

2382: func (m *GetShardIteratorRequest) GetStreamId() string {

2435: type GetStreamRecordRequest struct {

2460: type GetStreamRecordResponse struct {

2471: func (m *GetStreamRecordResponse) GetStreamRecords() []*GetStreamRecordResponse_StreamRecord {

2195: func (m *Stream) Reset()                    { *m = Stream{} }

2196: func (m *Stream) String() string            { return proto.CompactTextString(m) }

2197: func (*Stream) ProtoMessage()               {}

2198: func (*Stream) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{50} }

2207: func (m *Stream) GetTableName() string {

2214: func (m *Stream) GetCreationTime() int64 {

2925: 	proto.RegisterType((*Stream)(nil), "otsprotocol.Stream")

332: func (x StreamStatus) Enum() *StreamStatus {

333: 	p := new(StreamStatus)

337: func (x StreamStatus) String() string {

338: 	return proto.EnumName(StreamStatus_name, int32(x))

340: func (x *StreamStatus) UnmarshalJSON(data []byte) error {

341: 	value, err := proto.UnmarshalJSONEnum(StreamStatus_value, data, "StreamStatus")

345: 	*x = StreamStatus(value)

348: func (StreamStatus) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{8} }

796: func (m *StreamSpecification) Reset()                    { *m = StreamSpecification{} }

797: func (m *StreamSpecification) String() string            { return proto.CompactTextString(m) }

798: func (*StreamSpecification) ProtoMessage()               {}

799: func (*StreamSpecification) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{10} }

802: 	if m != nil && m.EnableStream != nil {

803: 		return *m.EnableStream

808: func (m *StreamSpecification) GetExpirationTime() int32 {

823: func (m *StreamDetails) Reset()                    { *m = StreamDetails{} }

824: func (m *StreamDetails) String() string            { return proto.CompactTextString(m) }

825: func (*StreamDetails) ProtoMessage()               {}

826: func (*StreamDetails) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{11} }

829: 	if m != nil && m.EnableStream != nil {

830: 		return *m.EnableStream

836: 	if m != nil && m.StreamId != nil {

837: 		return *m.StreamId

842: func (m *StreamDetails) GetExpirationTime() int32 {

849: func (m *StreamDetails) GetLastEnableTime() int64 {

911: 		return m.StreamSpec

969: 		return m.StreamSpec

1002: 		return m.StreamDetails

1071: 		return m.StreamDetails

2201: 	if m != nil && m.StreamId != nil {

2202: 		return *m.StreamId

2233: 		return m.Streams

2245: func (m *StreamShard) Reset()                    { *m = StreamShard{} }

2246: func (m *StreamShard) String() string            { return proto.CompactTextString(m) }

2247: func (*StreamShard) ProtoMessage()               {}

2248: func (*StreamShard) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{52} }

2250: func (m *StreamShard) GetShardId() string {

2257: func (m *StreamShard) GetParentId() string {

2264: func (m *StreamShard) GetParentSiblingId() string {

2284: 	if m != nil && m.StreamId != nil {

2285: 		return *m.StreamId

2310: 	Shards           []*StreamShard `protobuf:"bytes,6,rep,name=shards" json:"shards,omitempty"`

2321: 	if m != nil && m.StreamId != nil {

2322: 		return *m.StreamId

2349: 	if m != nil && m.StreamStatus != nil {

2350: 		return *m.StreamStatus

2352: 	return StreamStatus_STREAM_ENABLING

2355: func (m *DescribeStreamResponse) GetShards() []*StreamShard {

2383: 	if m != nil && m.StreamId != nil {

2384: 		return *m.StreamId

2473: 		return m.StreamRecords

2491: func (m *GetStreamRecordResponse_StreamRecord) Reset()         { *m = GetStreamRecordResponse_StreamRecord{} }

2492: func (m *GetStreamRecordResponse_StreamRecord) String() string { return proto.CompactTextString(m) }

2493: func (*GetStreamRecordResponse_StreamRecord) ProtoMessage()    {}

2494: func (*GetStreamRecordResponse_StreamRecord) Descriptor() ([]byte, []int) {

2498: func (m *GetStreamRecordResponse_StreamRecord) GetActionType() ActionType {

2505: func (m *GetStreamRecordResponse_StreamRecord) GetRecord() []byte {

2885: 	proto.RegisterType((*StreamSpecification)(nil), "otsprotocol.StreamSpecification")

2886: 	proto.RegisterType((*StreamDetails)(nil), "otsprotocol.StreamDetails")

2927: 	proto.RegisterType((*StreamShard)(nil), "otsprotocol.StreamShard")

2934: 	proto.RegisterType((*GetStreamRecordResponse_StreamRecord)(nil), "otsprotocol.GetStreamRecordResponse.StreamRecord")

2958: 	proto.RegisterEnum("otsprotocol.StreamStatus", StreamStatus_name, StreamStatus_value)

2176: func (m *ListStreamRequest) Reset()                    { *m = ListStreamRequest{} }

2177: func (m *ListStreamRequest) String() string            { return proto.CompactTextString(m) }

2178: func (*ListStreamRequest) ProtoMessage()               {}

2179: func (*ListStreamRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{49} }

2181: func (m *ListStreamRequest) GetTableName() string {

2226: func (m *ListStreamResponse) Reset()                    { *m = ListStreamResponse{} }

2227: func (m *ListStreamResponse) String() string            { return proto.CompactTextString(m) }

2228: func (*ListStreamResponse) ProtoMessage()               {}

2229: func (*ListStreamResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{51} }

2278: func (m *DescribeStreamRequest) Reset()                    { *m = DescribeStreamRequest{} }

2279: func (m *DescribeStreamRequest) String() string            { return proto.CompactTextString(m) }

2280: func (*DescribeStreamRequest) ProtoMessage()               {}

2281: func (*DescribeStreamRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{53} }

2290: func (m *DescribeStreamRequest) GetInclusiveStartShardId() string {

2297: func (m *DescribeStreamRequest) GetShardLimit() int32 {

2315: func (m *DescribeStreamResponse) Reset()                    { *m = DescribeStreamResponse{} }

2316: func (m *DescribeStreamResponse) String() string            { return proto.CompactTextString(m) }

2317: func (*DescribeStreamResponse) ProtoMessage()               {}

2318: func (*DescribeStreamResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{54} }

2327: func (m *DescribeStreamResponse) GetExpirationTime() int32 {

2334: func (m *DescribeStreamResponse) GetTableName() string {

2341: func (m *DescribeStreamResponse) GetCreationTime() int64 {

2362: func (m *DescribeStreamResponse) GetNextShardId() string {

2441: func (m *GetStreamRecordRequest) Reset()                    { *m = GetStreamRecordRequest{} }

2442: func (m *GetStreamRecordRequest) String() string            { return proto.CompactTextString(m) }

2443: func (*GetStreamRecordRequest) ProtoMessage()               {}

2444: func (*GetStreamRecordRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{57} }

2446: func (m *GetStreamRecordRequest) GetShardIterator() string {

2453: func (m *GetStreamRecordRequest) GetLimit() int32 {

2466: func (m *GetStreamRecordResponse) Reset()                    { *m = GetStreamRecordResponse{} }

2467: func (m *GetStreamRecordResponse) String() string            { return proto.CompactTextString(m) }

2468: func (*GetStreamRecordResponse) ProtoMessage()               {}

2469: func (*GetStreamRecordResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{58} }

2478: func (m *GetStreamRecordResponse) GetNextShardIterator() string {

2924: 	proto.RegisterType((*ListStreamRequest)(nil), "otsprotocol.ListStreamRequest")

2926: 	proto.RegisterType((*ListStreamResponse)(nil), "otsprotocol.ListStreamResponse")

2928: 	proto.RegisterType((*DescribeStreamRequest)(nil), "otsprotocol.DescribeStreamRequest")

2929: 	proto.RegisterType((*DescribeStreamResponse)(nil), "otsprotocol.DescribeStreamResponse")

2932: 	proto.RegisterType((*GetStreamRecordRequest)(nil), "otsprotocol.GetStreamRecordRequest")

2933: 	proto.RegisterType((*GetStreamRecordResponse)(nil), "otsprotocol.GetStreamRecordResponse")

2305:    function Stream

2323:    function Stream (Socket : Socket_Type) return Stream_Access is

225:    type Stream_Socket_Stream_Type is new Root_Stream_Type with record

229:    type Stream_Socket_Stream_Access is

241:    procedure Stream_Write

2335:    procedure Stream_Write

205:    type Datagram_Socket_Stream_Type is new Root_Stream_Type with record

211:    type Datagram_Socket_Stream_Access is

75:              (Socket_Stream   => SOSC.SOCK_STREAM,

203:    --  Types needed for Datagram_Socket_Stream_Type

212:      access all Datagram_Socket_Stream_Type;

215:      (Stream : in out Datagram_Socket_Stream_Type;

216:       Item   : out Ada.Streams.Stream_Element_Array;

217:       Last   : out Ada.Streams.Stream_Element_Offset);

220:      (Stream : in out Datagram_Socket_Stream_Type;

221:       Item   : Ada.Streams.Stream_Element_Array);

223:    --  Types needed for Stream_Socket_Stream_Type

230:      access all Stream_Socket_Stream_Type;

233:      (Stream : in out Stream_Socket_Stream_Type;

234:       Item   : out Ada.Streams.Stream_Element_Array;

235:       Last   : out Ada.Streams.Stream_Element_Offset);

238:      (Stream : in out Stream_Socket_Stream_Type;

239:       Item   : Ada.Streams.Stream_Element_Array);

243:       Item   : Ada.Streams.Stream_Element_Array;

245:    --  Common implementation for the Write operation of Datagram_Socket_Stream_

246:    --  Type and Stream_Socket_Stream_Type.

831:       Mode   : Mode_Type   := Socket_Stream)

919:      (Stream : not null Stream_Access) return Sock_Addr_Type

922:       if Stream.all in Datagram_Socket_Stream_Type then

923:          return Datagram_Socket_Stream_Type (Stream.all).From;

925:          return Get_Peer_Name (Stream_Socket_Stream_Type (Stream.all).Socket);

1672:      (Stream : in out Datagram_Socket_Stream_Type;

1673:       Item   : out Ada.Streams.Stream_Element_Array;

1674:       Last   : out Ada.Streams.Stream_Element_Offset)

1676:       First : Ada.Streams.Stream_Element_Offset          := Item'First;

1677:       Index : Ada.Streams.Stream_Element_Offset          := First - 1;

1678:       Max   : constant Ada.Streams.Stream_Element_Offset := Item'Last;

1683:            (Stream.Socket,

1686:             Stream.From);

1704:      (Stream : in out Stream_Socket_Stream_Type;

1705:       Item   : out Ada.Streams.Stream_Element_Array;

1706:       Last   : out Ada.Streams.Stream_Element_Offset)

1708:       pragma Warnings (Off, Stream);

1710:       First : Ada.Streams.Stream_Element_Offset          := Item'First;

1711:       Index : Ada.Streams.Stream_Element_Offset          := First - 1;

1712:       Max   : constant Ada.Streams.Stream_Element_Offset := Item'Last;

1716:          Receive_Socket (Stream.Socket, Item (First .. Max), Index);

1734:       Item   : out Ada.Streams.Stream_Element_Array;

1735:       Last   : out Ada.Streams.Stream_Element_Offset;

1757:       Item   : out Ada.Streams.Stream_Element_Array;

1758:       Last   : out Ada.Streams.Stream_Element_Offset;

1793:       Count  : out Ada.Streams.Stream_Element_Count;

1825:       Count := Ada.Streams.Stream_Element_Count (Res);

2005:       Item   : Ada.Streams.Stream_Element_Array;

2006:       Last   : out Ada.Streams.Stream_Element_Offset;

2019:       Item   : Ada.Streams.Stream_Element_Array;

2020:       Last   : out Ada.Streams.Stream_Element_Offset;

2035:       Item   : Ada.Streams.Stream_Element_Array;

2036:       Last   : out Ada.Streams.Stream_Element_Offset;

2083:       Count  : out Ada.Streams.Stream_Element_Count;

2129:          Count := Count + Ada.Streams.Stream_Element_Count (Res);

2302:    -- Stream --

2307:       Send_To : Sock_Addr_Type) return Stream_Access

2309:       S : Datagram_Socket_Stream_Access;

2312:       S        := new Datagram_Socket_Stream_Type;

2316:       return Stream_Access (S);

2317:    end Stream;

2320:    -- Stream --

2324:       S : Stream_Socket_Stream_Access;

2326:       S := new Stream_Socket_Stream_Type;

2328:       return Stream_Access (S);

2329:    end Stream;

2332:    -- Stream_Write --

2337:       Item   : Ada.Streams.Stream_Element_Array;

2340:       First : Ada.Streams.Stream_Element_Offset;

2341:       Index : Ada.Streams.Stream_Element_Offset;

2342:       Max   : constant Ada.Streams.Stream_Element_Offset := Item'Last;

2366:    end Stream_Write;

2590:      (Stream : in out Datagram_Socket_Stream_Type;

2591:       Item   : Ada.Streams.Stream_Element_Array)

2594:       Stream_Write (Stream.Socket, Item, To => Stream.To'Unrestricted_Access);

2602:      (Stream : in out Stream_Socket_Stream_Type;

2603:       Item   : Ada.Streams.Stream_Element_Array)

2606:       Stream_Write (Stream.Socket, Item, To => null);

32: with Ada.Streams;              use Ada.Streams;

161: class Stream {

163:     virtual ~Stream() {}

173: class SocketStream : public Stream {

308: class SSLSocketStream : public Stream {

1388: inline SocketStream::SocketStream(socket_t sock): sock_(sock)

1392: inline SocketStream::~SocketStream()

2221: inline SSLSocketStream::SSLSocketStream(socket_t sock, SSL* ssl)

2226: inline SSLSocketStream::~SSLSocketStream()

221:     bool process_request(Stream& strm, bool last_connection, bool& connection_close);

237:     void write_response(Stream& strm, bool last_connection, const Request& req, Response& res);

292:     bool process_request(Stream& strm, Request& req, Response& res, bool& connection_close);

301:     bool read_response_line(Stream& strm, Response& res);

302:     void write_request(Stream& strm, Request& req);

386:     stream_line_reader(Stream& strm, char* fixed_buffer, size_t fixed_buffer_size)

442:     Stream& strm_;

761: inline bool read_headers(Stream& strm, Headers& headers)

788: inline bool read_content_with_length(Stream& strm, std::string& out, size_t len, Progress progress)

808: inline bool read_content_without_length(Stream& strm, std::string& out)

824: inline bool read_content_chunked(Stream& strm, std::string& out)

870: bool read_content(Stream& strm, T& x, Progress progress = Progress())

890: inline void write_headers(Stream& strm, const T& info)

1358: inline void Stream::write_format(const char* fmt, const Args& ...args)

1539: inline void Server::write_response(Stream& strm, bool last_connection, const Request& req, Response& res)

1750: inline bool Server::process_request(Stream& strm, bool last_connection, bool& connection_close)

1837:         [this](Stream& strm, bool last_connection, bool& connection_close) {

1881: inline bool Client::read_response_line(Stream& strm, Response& res)

1917: inline void Client::write_request(Stream& strm, Request& req)

1964: inline bool Client::process_request(Stream& strm, Request& req, Response& res, bool& connection_close)

2001:         [&](Stream& strm, bool /*last_connection*/, bool& connection_close) {

2292:         [this](Stream& strm, bool last_connection, bool& connection_close) {

2325:         [&](Stream& strm, bool /*last_connection*/, bool& connection_close) {

175:     SocketStream(socket_t sock);

176:     virtual ~SocketStream();

310:     SSLSocketStream(socket_t sock, SSL* ssl);

311:     virtual ~SSLSocketStream();

510:             SocketStream strm(sock);

522:         SocketStream strm(sock);

1396: inline int SocketStream::read(char* ptr, size_t size)

1401: inline int SocketStream::write(const char* ptr, size_t size)

1406: inline int SocketStream::write(const char* ptr)

1411: inline std::string SocketStream::get_remote_addr() {

2179:             SSLSocketStream strm(sock, ssl);

2191:         SSLSocketStream strm(sock, ssl);

2230: inline int SSLSocketStream::read(char* ptr, size_t size)

2235: inline int SSLSocketStream::write(const char* ptr, size_t size)

2240: inline int SSLSocketStream::write(const char* ptr)

2245: inline std::string SSLSocketStream::get_remote_addr() {

157:   var Stream = require("stream").Stream

159:   var Stream = function () {}

249:   return Stream.prototype.on.call(me, ev, handler)

167: function createStream (strict, opt) {

174:   Stream.apply(this)

213: SAXStream.prototype = Object.create(Stream.prototype,

6: sax.SAXStream = SAXStream

7: sax.createStream = createStream

168:   return new SAXStream(strict, opt)

171: function SAXStream (strict, opt) {

172:   if (!(this instanceof SAXStream)) return new SAXStream(strict, opt)

214:   { constructor: { value: SAXStream } })

216: SAXStream.prototype.write = function (data) {

232: SAXStream.prototype.end = function (chunk) {

238: SAXStream.prototype.on = function (ev, handler) {

136:         FILE*          Stream;                   // File stream or NULL if holded in memory

488:     if (it8 -> FileStack[it8 ->IncludeSP]->Stream) {

490:         it8 ->ch = fgetc(it8 ->FileStack[it8 ->IncludeSP]->Stream);

492:         if (feof(it8 -> FileStack[it8 ->IncludeSP]->Stream))  {

496:                 fclose(it8 ->FileStack[it8->IncludeSP--]->Stream);

936:                 FileNest->Stream = fopen(FileNest->FileName, "rt");

937:                 if (FileNest->Stream == NULL) {

2368:      it8 ->FileStack[0]->Stream = fopen(cFileName, "rt");

2370:      if (!it8 ->FileStack[0]->Stream) {

2381:             fclose(it8 ->FileStack[0]->Stream);

2389:     if (fclose(it8 ->FileStack[0]->Stream)!= 0) {

585: 	Stream           *bool   `protobuf:"varint,2,opt,name=stream" json:"stream,omitempty"`

775: 	Stream       *bool                       `protobuf:"varint,8,opt,name=stream" json:"stream,omitempty"`

602: func (m *RpbListBucketsReq) GetStream() bool {

843: func (m *RpbIndexReq) GetStream() bool {

603: 	if m != nil && m.Stream != nil {

604: 		return *m.Stream

844: 	if m != nil && m.Stream != nil {

845: 		return *m.Stream

143:         Stream = 1 // Not currently supported in the Unity Plugin.

175:     llvm::BitstreamWriter &Stream;

215:   llvm::BitstreamWriter &Stream;

174:   class StreamSubBlockGuard {

178:     StreamSubBlockGuard(llvm::BitstreamWriter &Stream_, BlockId ID)

188:     ~StreamSubBlockGuard() { Stream.ExitBlock(); }

142:   ClangDocBitcodeWriter(llvm::BitstreamWriter &Stream) : Stream(Stream) {

179:         : Stream(Stream_) {

182:       Stream.EnterSubblock(ID, BitCodeConstants::SubblockIDSize);

185:     StreamSubBlockGuard(const StreamSubBlockGuard &) = delete;

186:     StreamSubBlockGuard &operator=(const StreamSubBlockGuard &) = delete;

162:         FILE*          Stream;                   // File stream or NULL if holded in memory

514:     if (it8 -> FileStack[it8 ->IncludeSP]->Stream) {

516:         it8 ->ch = fgetc(it8 ->FileStack[it8 ->IncludeSP]->Stream);

518:         if (feof(it8 -> FileStack[it8 ->IncludeSP]->Stream))  {

522:                 fclose(it8 ->FileStack[it8->IncludeSP--]->Stream);

962:                 FileNest->Stream = fopen(FileNest->FileName, "rt");

963:                 if (FileNest->Stream == NULL) {

2394:      it8 ->FileStack[0]->Stream = fopen(cFileName, "rt");

2396:      if (!it8 ->FileStack[0]->Stream) {

2407:             fclose(it8 ->FileStack[0]->Stream);

2415:     if (fclose(it8 ->FileStack[0]->Stream)!= 0) {

709: HH_INLINE void Stream(const V128<T>& v, T* const HH_RESTRICT to) {

712: HH_INLINE void Stream(const V128<float>& v, float* const HH_RESTRICT to) {

715: HH_INLINE void Stream(const V128<double>& v, double* const HH_RESTRICT to) {

167: type Stream struct {

339: func newContextWithStream(ctx context.Context, stream *Stream) context.Context {

344: func StreamFromContext(ctx context.Context) (s *Stream, ok bool) {

454: 	NewStream(ctx context.Context, callHdr *CallHdr) (*Stream, error)

460: 	CloseStream(stream *Stream, err error)

562: type StreamError struct {

361: 	MaxStreams   uint32

482: 	HandleStreams(func(*Stream), func(context.Context, string) context.Context)

558: 	ErrStreamDrain = streamErrorf(codes.Unavailable, "the server stops accepting new RPCs")

166: // Stream represents an RPC in the transport layer.

169: 	// nil for client side Stream.

178: 	// cancel is always nil for client side Stream.

220: func (s *Stream) RecvCompress() string {

225: func (s *Stream) SetSendCompress(str string) {

231: func (s *Stream) Done() <-chan struct{} {

237: func (s *Stream) GoAway() <-chan struct{} {

244: func (s *Stream) Header() (metadata.MD, error) {

258: func (s *Stream) Trailer() metadata.MD {

266: func (s *Stream) ServerTransport() ServerTransport {

271: func (s *Stream) Context() context.Context {

276: func (s *Stream) Method() string {

281: func (s *Stream) StatusCode() codes.Code {

286: func (s *Stream) StatusDesc() string {

292: func (s *Stream) SetHeader(md metadata.MD) error {

307: func (s *Stream) SetTrailer(md metadata.MD) error {

317: func (s *Stream) write(m recvMsg) {

321: // Read reads all the data available for this Stream from the transport and

325: func (s *Stream) Read(p []byte) (n int, err error) {

334: // The key to save transport.Stream in the context.

345: 	s, ok = ctx.Value(streamKey{}).(*Stream)

451: 	Write(s *Stream, data []byte, opts *Options) error

453: 	// NewStream creates a Stream for an RPC.

479: // Write methods for a given Stream will be called serially.

486: 	WriteHeader(s *Stream, md metadata.MD) error

490: 	Write(s *Stream, data []byte, opts *Options) error

495: 	WriteStatus(s *Stream, statusCode codes.Code, statusDesc string) error

161: 	streamWriteDone             // EndStream sent

162: 	streamReadDone              // EndStream received

337: // newContextWithStream creates a new context from ctx and attaches stream

343: // StreamFromContext returns the stream saved in ctx.

456: 	// CloseStream clears the footprint of a stream when the stream is

458: 	// CloseStream is called. Must be called when a stream is finished

509: // streamErrorf creates an StreamError with the specified error code and description.

510: func streamErrorf(c codes.Code, format string, a ...interface{}) StreamError {

511: 	return StreamError{

561: // StreamError is an error that only affects one stream within a connection.

567: func (e StreamError) Error() string {

571: // ContextErr converts the error from context package into a StreamError.

572: func ContextErr(err error) StreamError {

583: // If it receives from ctx.Done, it returns 0, the StreamError for ctx.Err.

585: // it return the StreamError for ctx.Err.

145: 		return 0, ErrStreamDrain

249: 		return nil, ErrStreamDrain

481: 	// HandleStreams receives incoming streams using the given handler.

556: 	// ErrStreamDrain indicates that the stream is rejected by the server because

586: // If it receives from goAway, it returns 0, ErrStreamDrain.

602: 		return 0, ErrStreamDrain

2743:     protected class Stream : IStream

2749:       internal Stream()

2754:       internal Stream(DriveProxy.API.DriveService.Stream stream)

585:     IStream Stream { get; }

3167:       public IStream Stream

2760:       internal DriveProxy.API.DriveService.Stream _Stream

3160:       protected IStream _Stream = null;

66:     event IStreamEventHandler OnQueueStartedStream;

71:     event IStreamEventHandler OnQueueFinishedStream;

591:   public interface IStream

902:     private static void State_QueuedStream(DriveProxy.API.DriveService.State sender,

918:     private static void State_FinishedStream(DriveProxy.API.DriveService.State sender,

953:     public static IStream CreateStream()

1256:       public event IStreamEventHandler OnQueueStartedStream = null;

1257:       public event IStreamEventHandler OnQueueFinishedStream = null;

2293:       public void InvokeQueueStartedStream(object sender, IStreamEventArgs e)

2307:       public void InvokeQueueFinishedStream(object sender, IStreamEventArgs e)

3158:     protected class StreamEventArgs : IStreamEventArgs

3162:       public StreamEventArgs(IStream stream)

578:   public delegate void IStreamEventHandler(object sender, IStreamEventArgs e);

583:   public interface IStreamEventArgs

574:   ///   A delegate handler for Stream Events.

581:   ///   Arguments supplied for Stream Events.

903:                                            DriveProxy.API.DriveService.Stream stream)

909:           _DriveService.InvokeQueueStartedStream(sender, new StreamEventArgs(new Stream(stream)));

919:                                              DriveProxy.API.DriveService.Stream stream)

925:           _DriveService.InvokeQueueFinishedStream(sender, new StreamEventArgs(new Stream(stream)));

957:         return new Stream();

1755:           var tempStream = stream as Stream;

1775:           tempStream._Stream = copyStream;

1813:           var tempStream = stream as Stream;

1836:           tempStream._Stream = downloadStream;

1850:           var tempStream = stream as Stream;

1869:           tempStream._Stream = insertStream;

1924:           var tempStream = stream as Stream;

1944:           tempStream._Stream = moveStream;

1982:           var tempStream = stream as Stream;

2003:           tempStream._Stream = renameStream;

2041:           var tempStream = stream as Stream;

2064:           tempStream._Stream = uploadStream;

2102:           var tempStream = stream as Stream;

2121:           tempStream._Stream = trashStream;

2159:           var tempStream = stream as Stream;

2178:           tempStream._Stream = untrashStream;

2747:       private DriveProxy.API.DriveService.Stream _stream;

2757:         _Stream = stream;

2785:           if (_Stream == null)

2795:           _File._FileInfo = _Stream.FileInfo;

2805:           if (_Stream == null)

2810:           return _Stream.Type;

2818:           if (_Stream == null)

2823:           return _Stream.FileId;

2831:           if (_Stream == null)

2836:           return _Stream.FilePath;

2844:           if (_Stream == null)

2849:           return _Stream.FileName;

2857:           if (_Stream == null)

2862:           return _Stream.Title;

2870:           if (_Stream == null)

2875:           return _Stream.MimeType;

2883:           if (_Stream == null)

2888:           return _Stream.IsFolder;

2896:           if (_Stream == null)

2901:           return _Stream.NotStarted;

2909:           if (_Stream == null)

2914:           return _Stream.Queued;

2922:           if (_Stream == null)

2927:           return _Stream.Starting;

2935:           if (_Stream == null)

2940:           return _Stream.Processing;

2948:           if (_Stream == null)

2953:           return _Stream.Cancelling;

2961:           if (_Stream == null)

2966:           return _Stream.Cancelled;

2974:           if (_Stream == null)

2979:           return _Stream.Completed;

2987:           if (_Stream == null)

2992:           return _Stream.Failed;

3000:           if (_Stream == null)

3005:           return _Stream.Started;

3013:           if (_Stream == null)

3018:           return _Stream.Processed;

3026:           if (_Stream == null)

3031:           return _Stream.Finished;

3039:           if (_Stream == null)

3044:           return _Stream.BytesProcessed;

3052:           if (_Stream == null)

3057:           return _Stream.TotalBytes;

3065:           if (_Stream == null)

3070:           return _Stream.ExceptionMessage;

3078:           if (_Stream == null)

3083:           return _Stream.PercentCompleted;

3091:           if (_Stream == null)

3096:           return _Stream.RemainingTime;

3107:         if (_Stream == null)

3112:         _Stream.Cancel();

3115:       private void stream_OnProgressStarted(DriveProxy.API.DriveService.Stream stream)

3129:       private void stream_OnProgressChanged(DriveProxy.API.DriveService.Stream stream)

3143:       private void stream_OnProgressFinished(DriveProxy.API.DriveService.Stream stream)

3164:         _Stream = stream;

3169:         get { return _Stream; }

200:     /// <param name="stream">The CopyStream for the requested file.</param>

203:     void CopyFile(IStream stream, string parentId, string fileId);

208:     /// <param name="stream">The CopyStream for the requested file.</param>

211:     void CopyFile(IStream stream, string parentId, IFile file);

216:     /// <param name="stream">The DownloadStream for the requested file.</param>

220:     void DownloadFile(IStream stream, string fileId, int chunkSize = 0, bool checkIfAlreadyDownloaded = true);

225:     /// <param name="stream">The DownloadStream for the requested file.</param>

229:     void DownloadFile(IStream stream, IFile file, int chunkSize = 0, bool checkIfAlreadyDownloaded = true);

234:     /// <param name="stream">The InsertStream for the new file.</param>

238:     void InsertFile(IStream stream, string parentId, string title, bool isFolder);

243:     /// <param name="stream">The InsertStream for the new file.</param>

247:     void InsertFile(IStream stream, IFile parent, string title, bool isFolder);

252:     /// <param name="stream">The MoveStream for the requested file.</param>

255:     void MoveFile(IStream stream, string parentId, string fileId);

260:     /// <param name="stream">The MoveStream for the requested file.</param>

263:     void MoveFile(IStream stream, string parentId, IFile file);

268:     /// <param name="stream">The RenameStream for the requested file.</param>

271:     void RenameFile(IStream stream, string fileId, string title);

276:     /// <param name="stream">The RenameStream for the requested file.</param>

279:     void RenameFile(IStream stream, IFile file, string title);

284:     /// <param name="stream">The UploadStream for the requested file.</param>

291:     void UploadFile(IStream stream, string fileId, int chunkSize = 0, bool checkIfAlreadyUploaded = true);

296:     /// <param name="stream">The UploadStream for the requested file.</param>

303:     void UploadFile(IStream stream, IFile file, int chunkSize = 0, bool checkIfAlreadyUploaded = true);

308:     /// <param name="stream">The TrashStream for the requested file.</param>

310:     void TrashFile(IStream stream, string fileId);

315:     /// <param name="stream">The TrashStream for the requested file.</param>

317:     void TrashFile(IStream stream, IFile file);

322:     /// <param name="stream">The UntrashStream for the requested file.</param>

324:     void UntrashFile(IStream stream, string fileId);

329:     /// <param name="stream">The UntrashStream for the requested file.</param>

331:     void UntrashFile(IStream stream, IFile file);

601:     StreamType Type { get; }

869:           DriveProxy.API.DriveService.State.OnQueuedStream +=

870:             State_QueuedStream;

871:           DriveProxy.API.DriveService.State.OnFinishedStream +=

872:             State_FinishedStream;

950:     ///   Creates a new IStream object.

952:     /// <returns>IStream object (see IStream for more information)</returns>

1727:       public void CopyFile(IStream stream, string parentId, string fileId)

1751:       public void CopyFile(IStream stream, string parentId, IFile file)

1757:           if (tempStream == null)

1759:             throw new Exception("IStream is null or an unexpected type.");

1770:           var copyStream = new API.DriveService.CopyStream();

1772:           copyStream.Init(parentId, tempFile._FileInfo);

1774:           tempStream._Service = this;

1777:           _service.CopyFile(copyStream);

1785:       public void DownloadFile(IStream stream, string fileId, int chunkSize = 0, bool checkIfAlreadyDownloaded = true)

1809:       public void DownloadFile(IStream stream, IFile file, int chunkSize = 0, bool checkIfAlreadyDownloaded = true)

1815:           if (tempStream == null)

1817:             throw new Exception("IStream is null or an unexpected type.");

1827:           var downloadStream = new API.DriveService.DownloadStream();

1828:           var parameters = new API.DriveService.DownloadStream.Parameters();

1833:           downloadStream.Init(tempFile._FileInfo, parameters);

1835:           tempStream._Service = this;

1838:           _service.DownloadFile(downloadStream);

1846:       public void InsertFile(IStream stream, string parentId, string title, bool isFolder)

1852:           if (tempStream == null)

1854:             throw new Exception("IStream is null or an unexpected type.");

1857:           var insertStream = new API.DriveService.InsertStream();

1866:           insertStream.Init(parentId, title, mimeType);

1868:           tempStream._Service = this;

1871:           _service.InsertFile(insertStream);

1879:       public void InsertFile(IStream stream, IFile parent, string title, bool isFolder)

1896:       public void MoveFile(IStream stream, string parentId, string fileId)

1920:       public void MoveFile(IStream stream, string parentId, IFile file)

1926:           if (tempStream == null)

1928:             throw new Exception("IStream is null or an unexpected type.");

1939:           var moveStream = new API.DriveService.MoveStream();

1941:           moveStream.Init(parentId, tempFile._FileInfo);

1943:           tempStream._Service = this;

1946:           _service.MoveFile(moveStream);

1954:       public void RenameFile(IStream stream, string fileId, string title)

1978:       public void RenameFile(IStream stream, IFile file, string title)

1984:           if (tempStream == null)

1986:             throw new Exception("IStream is null or an unexpected type.");

1997:           var renameStream = new API.DriveService.RenameStream();

2000:           renameStream.Init(tempFile._FileInfo, title, tempFile.MimeType);

2002:           tempStream._Service = this;

2005:           _service.RenameFile(renameStream);

2013:       public void UploadFile(IStream stream, string fileId, int chunkSize = 0, bool checkIfAlreadyUploaded = true)

2037:       public void UploadFile(IStream stream, IFile file, int chunkSize = 0, bool checkIfAlreadyUploaded = true)

2043:           if (tempStream == null)

2045:             throw new Exception("IStream is null or an unexpected type.");

2055:           var uploadStream = new API.DriveService.UploadStream();

2056:           var parameters = new API.DriveService.UploadStream.Parameters();

2061:           uploadStream.Init(tempFile._FileInfo, parameters);

2063:           tempStream._Service = this;

2066:           _service.UploadFile(uploadStream);

2074:       public void TrashFile(IStream stream, string fileId)

2098:       public void TrashFile(IStream stream, IFile file)

2104:           if (tempStream == null)

2106:             throw new Exception("IStream is null or an unexpected type.");

2116:           var trashStream = new API.DriveService.TrashStream();

2118:           trashStream.Init(tempFile._FileInfo);

2120:           tempStream._Service = this;

2123:           _service.TrashFile(trashStream);

2131:       public void UntrashFile(IStream stream, string fileId)

2155:       public void UntrashFile(IStream stream, IFile file)

2161:           if (tempStream == null)

2163:             throw new Exception("IStream is null or an unexpected type.");

2173:           var untrashStream = new API.DriveService.UntrashStream();

2175:           untrashStream.Init(tempFile._FileInfo);

2177:           tempStream._Service = this;

2180:           _service.UntrashFile(untrashStream);

2297:           if (OnQueueStartedStream != null)

2299:             OnQueueStartedStream(sender, e);

2311:           if (OnQueueFinishedStream != null)

2313:             OnQueueFinishedStream(sender, e);

2801:       public StreamType Type

2807:             return StreamType.Unknown;

3121:             OnProgressStarted(this, new StreamEventArgs(this));

3135:             OnProgressChanged(this, new StreamEventArgs(this));

3149:             OnProgressFinished(this, new StreamEventArgs(this));

721:     event IStreamEventHandler OnProgressStarted;

726:     event IStreamEventHandler OnProgressChanged;

731:     event IStreamEventHandler OnProgressFinished;

2777:       public event IStreamEventHandler OnProgressStarted = null;

2778:       public event IStreamEventHandler OnProgressChanged = null;

2779:       public event IStreamEventHandler OnProgressFinished = null;

229:   function Stream() {

26:     var stream = new Stream();

40:       var master = callback ? new Stub(callback) : new Stream();

233:   Stream.prototype.flush = function() {

252:   Stream.prototype.emit = function(type, data) {

260:   Stream.prototype.on = function(type, callback) {

6:   , Stream = require("stream").Stream

49: nopt.typeDefs.Stream = { type: Stream, validate: validateStream }

42: function validateStream (data, k, val) {

43:   if (!(val instanceof Stream)) return false

72:     case Stream:

73:       log.warn("invalid config", "Must be an instance of the Stream class")

272:   , logstream : Stream

1188: ### Stream

20: : Support for asynchronous programming, with classes such as Future and Stream.

995: provides alternatives: [Future][] and [Stream][] objects. A

997: future. A Stream is a way to get a sequence of values, such as events.

998: Future, Stream, and more are in the

1002:   You don't always need to use the Future or Stream APIs directly. The Dart

1018:   Stream APIs, because dart:core exports those classes.

1190: Stream objects appear throughout Dart APIs, representing sequences of

1198: instead of using the Stream API.

1201: It uses Stream's `listen()` method

1279: In this example, the `onClick` property is a Stream object provided by

1323: or the Stream API.

1334:   Stream<List<int>> inputStream = config.openRead();

1350: If you use the Stream API,

1358: Stream<List<int>> inputStream = config.openRead();

1375: For some examples of using Future and Stream in command-line apps,

1569: `utf8.decoder` to the Stream `transform()` method:

1670: [Stream]: {{site.dart_api}}/{{site.data.pkg-vers.SDK.channel}}/dart-async/Stream-class.html

1304: var lines = inputStream

1315:   PENDING: add onDone and onError. (See "Streaming file contents".)

1336:   var lines = inputStream

1360: inputStream

1574:     [!utf8.decoder!].bind(inputStream).transform(LineSplitter());

562: func (r *Request) Stream() (io.ReadCloser, error) {

64: 	Stream() (io.ReadCloser, error)

558: // Stream formats and executes the request, and offers streaming of the response.

779: 			glog.V(2).Infof("Stream error %#v when reading response body, may be caused by closed connection.", err)

780: 			streamErr := fmt.Errorf("Stream error %#v when reading response body, may be caused by closed connection. Please retry.", err)

536: 	decoder := streaming.NewDecoder(framer, r.serializers.StreamingSerializer)

771: 		case http2.StreamError:

537: 	return watch.NewStreamWatcher(restclientwatch.NewDecoder(decoder, r.serializers.Decoder)), nil

98:   class Stream

457: class Stream_from_string : public Import::Stream

460:   Stream_from_string(const std::string& str)

487: class Stream_from_buffer : public Import::Stream