~ubuntu-branches/ubuntu/wily/grpc/wily

internal static pb::FieldAccess.FieldAccessorTable<global::grpc.testing.Payload, global::grpc.testing.Payload.Builder> internal__static_grpc_testing_Payload__FieldAccessorTable;

internal static pbd::MessageDescriptor internal__static_grpc_testing_SimpleRequest__Descriptor;

internal static pb::FieldAccess.FieldAccessorTable<global::grpc.testing.SimpleRequest, global::grpc.testing.SimpleRequest.Builder> internal__static_grpc_testing_SimpleRequest__FieldAccessorTable;

internal static pbd::MessageDescriptor internal__static_grpc_testing_SimpleResponse__Descriptor;

internal static pb::FieldAccess.FieldAccessorTable<global::grpc.testing.SimpleResponse, global::grpc.testing.SimpleResponse.Builder> internal__static_grpc_testing_SimpleResponse__FieldAccessorTable;

internal static pbd::MessageDescriptor internal__static_grpc_testing_StreamingInputCallRequest__Descriptor;

internal static pb::FieldAccess.FieldAccessorTable<global::grpc.testing.StreamingInputCallRequest, global::grpc.testing.StreamingInputCallRequest.Builder> internal__static_grpc_testing_StreamingInputCallRequest__FieldAccessorTable;

internal static pbd::MessageDescriptor internal__static_grpc_testing_StreamingInputCallResponse__Descriptor;

internal static pb::FieldAccess.FieldAccessorTable<global::grpc.testing.StreamingInputCallResponse, global::grpc.testing.StreamingInputCallResponse.Builder> internal__static_grpc_testing_StreamingInputCallResponse__FieldAccessorTable;

internal static pbd::MessageDescriptor internal__static_grpc_testing_ResponseParameters__Descriptor;

internal static pb::FieldAccess.FieldAccessorTable<global::grpc.testing.ResponseParameters, global::grpc.testing.ResponseParameters.Builder> internal__static_grpc_testing_ResponseParameters__FieldAccessorTable;

internal static pbd::MessageDescriptor internal__static_grpc_testing_StreamingOutputCallRequest__Descriptor;

internal static pb::FieldAccess.FieldAccessorTable<global::grpc.testing.StreamingOutputCallRequest, global::grpc.testing.StreamingOutputCallRequest.Builder> internal__static_grpc_testing_StreamingOutputCallRequest__FieldAccessorTable;

internal static pbd::MessageDescriptor internal__static_grpc_testing_StreamingOutputCallResponse__Descriptor;

internal static pb::FieldAccess.FieldAccessorTable<global::grpc.testing.StreamingOutputCallResponse, global::grpc.testing.StreamingOutputCallResponse.Builder> internal__static_grpc_testing_StreamingOutputCallResponse__FieldAccessorTable;

#endregion

#region Descriptor

public static pbd::FileDescriptor Descriptor {

get { return descriptor; }

}

private static pbd::FileDescriptor descriptor;

static Messages() {

byte[] descriptorData = global::System.Convert.FromBase64String(

string.Concat(

"Cg5tZXNzYWdlcy5wcm90bxIMZ3JwYy50ZXN0aW5nIkAKB1BheWxvYWQSJwoE",

"dHlwZRgBIAEoDjIZLmdycGMudGVzdGluZy5QYXlsb2FkVHlwZRIMCgRib2R5",

"GAIgASgMIrEBCg1TaW1wbGVSZXF1ZXN0EjAKDXJlc3BvbnNlX3R5cGUYASAB",

"KA4yGS5ncnBjLnRlc3RpbmcuUGF5bG9hZFR5cGUSFQoNcmVzcG9uc2Vfc2l6",

"ZRgCIAEoBRImCgdwYXlsb2FkGAMgASgLMhUuZ3JwYy50ZXN0aW5nLlBheWxv",

"YWQSFQoNZmlsbF91c2VybmFtZRgEIAEoCBIYChBmaWxsX29hdXRoX3Njb3Bl",

"GAUgASgIIl8KDlNpbXBsZVJlc3BvbnNlEiYKB3BheWxvYWQYASABKAsyFS5n",

"cnBjLnRlc3RpbmcuUGF5bG9hZBIQCgh1c2VybmFtZRgCIAEoCRITCgtvYXV0",

"aF9zY29wZRgDIAEoCSJDChlTdHJlYW1pbmdJbnB1dENhbGxSZXF1ZXN0EiYK",

"B3BheWxvYWQYASABKAsyFS5ncnBjLnRlc3RpbmcuUGF5bG9hZCI9ChpTdHJl",

"YW1pbmdJbnB1dENhbGxSZXNwb25zZRIfChdhZ2dyZWdhdGVkX3BheWxvYWRf",

"c2l6ZRgBIAEoBSI3ChJSZXNwb25zZVBhcmFtZXRlcnMSDAoEc2l6ZRgBIAEo",

"BRITCgtpbnRlcnZhbF91cxgCIAEoBSK1AQoaU3RyZWFtaW5nT3V0cHV0Q2Fs",

"bFJlcXVlc3QSMAoNcmVzcG9uc2VfdHlwZRgBIAEoDjIZLmdycGMudGVzdGlu",

"Zy5QYXlsb2FkVHlwZRI9ChNyZXNwb25zZV9wYXJhbWV0ZXJzGAIgAygLMiAu",

"Z3JwYy50ZXN0aW5nLlJlc3BvbnNlUGFyYW1ldGVycxImCgdwYXlsb2FkGAMg",

"ASgLMhUuZ3JwYy50ZXN0aW5nLlBheWxvYWQiRQobU3RyZWFtaW5nT3V0cHV0",

"Q2FsbFJlc3BvbnNlEiYKB3BheWxvYWQYASABKAsyFS5ncnBjLnRlc3Rpbmcu",

"UGF5bG9hZCo/CgtQYXlsb2FkVHlwZRIQCgxDT01QUkVTU0FCTEUQABISCg5V",

"TkNPTVBSRVNTQUJMRRABEgoKBlJBTkRPTRAC"));

pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {

descriptor = root;

internal__static_grpc_testing_Payload__Descriptor = Descriptor.MessageTypes[0];

internal__static_grpc_testing_Payload__FieldAccessorTable =

new pb::FieldAccess.FieldAccessorTable<global::grpc.testing.Payload, global::grpc.testing.Payload.Builder>(internal__static_grpc_testing_Payload__Descriptor,

new string[] { "Type", "Body", });

internal__static_grpc_testing_SimpleRequest__Descriptor = Descriptor.MessageTypes[1];

internal__static_grpc_testing_SimpleRequest__FieldAccessorTable =

new pb::FieldAccess.FieldAccessorTable<global::grpc.testing.SimpleRequest, global::grpc.testing.SimpleRequest.Builder>(internal__static_grpc_testing_SimpleRequest__Descriptor,

new string[] { "ResponseType", "ResponseSize", "Payload", "FillUsername", "FillOauthScope", });

internal__static_grpc_testing_SimpleResponse__Descriptor = Descriptor.MessageTypes[2];

internal__static_grpc_testing_SimpleResponse__FieldAccessorTable =

new pb::FieldAccess.FieldAccessorTable<global::grpc.testing.SimpleResponse, global::grpc.testing.SimpleResponse.Builder>(internal__static_grpc_testing_SimpleResponse__Descriptor,

new string[] { "Payload", "Username", "OauthScope", });

internal__static_grpc_testing_StreamingInputCallRequest__Descriptor = Descriptor.MessageTypes[3];

internal__static_grpc_testing_StreamingInputCallRequest__FieldAccessorTable =

new pb::FieldAccess.FieldAccessorTable<global::grpc.testing.StreamingInputCallRequest, global::grpc.testing.StreamingInputCallRequest.Builder>(internal__static_grpc_testing_StreamingInputCallRequest__Descriptor,

new string[] { "Payload", });

internal__static_grpc_testing_StreamingInputCallResponse__Descriptor = Descriptor.MessageTypes[4];

internal__static_grpc_testing_StreamingInputCallResponse__FieldAccessorTable =

new pb::FieldAccess.FieldAccessorTable<global::grpc.testing.StreamingInputCallResponse, global::grpc.testing.StreamingInputCallResponse.Builder>(internal__static_grpc_testing_StreamingInputCallResponse__Descriptor,

new string[] { "AggregatedPayloadSize", });

internal__static_grpc_testing_ResponseParameters__Descriptor = Descriptor.MessageTypes[5];

internal__static_grpc_testing_ResponseParameters__FieldAccessorTable =

new pb::FieldAccess.FieldAccessorTable<global::grpc.testing.ResponseParameters, global::grpc.testing.ResponseParameters.Builder>(internal__static_grpc_testing_ResponseParameters__Descriptor,

new string[] { "Size", "IntervalUs", });

internal__static_grpc_testing_StreamingOutputCallRequest__Descriptor = Descriptor.MessageTypes[6];

internal__static_grpc_testing_StreamingOutputCallRequest__FieldAccessorTable =

new pb::FieldAccess.FieldAccessorTable<global::grpc.testing.StreamingOutputCallRequest, global::grpc.testing.StreamingOutputCallRequest.Builder>(internal__static_grpc_testing_StreamingOutputCallRequest__Descriptor,

new string[] { "ResponseType", "ResponseParameters", "Payload", });

internal__static_grpc_testing_StreamingOutputCallResponse__Descriptor = Descriptor.MessageTypes[7];

internal__static_grpc_testing_StreamingOutputCallResponse__FieldAccessorTable =

new pb::FieldAccess.FieldAccessorTable<global::grpc.testing.StreamingOutputCallResponse, global::grpc.testing.StreamingOutputCallResponse.Builder>(internal__static_grpc_testing_StreamingOutputCallResponse__Descriptor,

new string[] { "Payload", });

return null;

100

};

101

pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,

102

new pbd::FileDescriptor[] {

103

}, assigner);

104

}

105

#endregion

106

107

}

108

#region Enums

109

public enum PayloadType {

110

COMPRESSABLE = 0,

111

UNCOMPRESSABLE = 1,

112

RANDOM = 2,

113

}

114

115

#endregion

116

117

#region Messages

118

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

119

public sealed partial class Payload : pb::GeneratedMessage<Payload, Payload.Builder> {

120

private Payload() { }

121

private static readonly Payload defaultInstance = new Payload().MakeReadOnly();

122

private static readonly string[] _payloadFieldNames = new string[] { "body", "type" };

123

private static readonly uint[] _payloadFieldTags = new uint[] { 18, 8 };

124

public static Payload DefaultInstance {

125

get { return defaultInstance; }

126

}

127

128

public override Payload DefaultInstanceForType {

129

get { return DefaultInstance; }

130

}

131

132

protected override Payload ThisMessage {

133

get { return this; }

134

}

135

136

public static pbd::MessageDescriptor Descriptor {

137

get { return global::grpc.testing.Messages.internal__static_grpc_testing_Payload__Descriptor; }

138

}

139

140

protected override pb::FieldAccess.FieldAccessorTable<Payload, Payload.Builder> InternalFieldAccessors {

141

get { return global::grpc.testing.Messages.internal__static_grpc_testing_Payload__FieldAccessorTable; }

142

}

143

144

public const int TypeFieldNumber = 1;

145

private bool hasType;

146

private global::grpc.testing.PayloadType type_ = global::grpc.testing.PayloadType.COMPRESSABLE;

147

public bool HasType {

148

get { return hasType; }

149

}

150

public global::grpc.testing.PayloadType Type {

151

get { return type_; }

152

}

153

154

public const int BodyFieldNumber = 2;

155

private bool hasBody;

156

private pb::ByteString body_ = pb::ByteString.Empty;

157

public bool HasBody {

158

get { return hasBody; }

159

}

160

public pb::ByteString Body {

161

get { return body_; }

162

}

163

164

public override bool IsInitialized {

165

get {

166

return true;

167

}

168

}

169

170

public override void WriteTo(pb::ICodedOutputStream output) {

171

int size = SerializedSize;

172

string[] field_names = _payloadFieldNames;

173

if (hasType) {

174

output.WriteEnum(1, field_names[1], (int) Type, Type);

175

}

176

if (hasBody) {

177

output.WriteBytes(2, field_names[0], Body);

178

}

179

UnknownFields.WriteTo(output);

180

}

181

182

private int memoizedSerializedSize = -1;

183

public override int SerializedSize {

184

get {

185

int size = memoizedSerializedSize;

186

if (size != -1) return size;

187

188

size = 0;

189

if (hasType) {

190

size += pb::CodedOutputStream.ComputeEnumSize(1, (int) Type);

191

}

192

if (hasBody) {

193

size += pb::CodedOutputStream.ComputeBytesSize(2, Body);

194

}

195

size += UnknownFields.SerializedSize;

196

memoizedSerializedSize = size;

197

return size;

198

}

199

}

200

201

public static Payload ParseFrom(pb::ByteString data) {

202

return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();

203

}

204

public static Payload ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {

205

return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();

206

}

207

public static Payload ParseFrom(byte[] data) {

208

return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();

209

}

210

public static Payload ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {

211

return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();

212

}

213

public static Payload ParseFrom(global::System.IO.Stream input) {

214

return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();

215

}

216

public static Payload ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {

217

return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();

218

}

219

public static Payload ParseDelimitedFrom(global::System.IO.Stream input) {

220

return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();

221

}

222

public static Payload ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {

223

return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();

224

}

225

public static Payload ParseFrom(pb::ICodedInputStream input) {

226

return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();

227

}

228

public static Payload ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {

229

return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();

230

}

231

private Payload MakeReadOnly() {

232

return this;

233

}

234

235

public static Builder CreateBuilder() { return new Builder(); }

236

public override Builder ToBuilder() { return CreateBuilder(this); }

237

public override Builder CreateBuilderForType() { return new Builder(); }

238

public static Builder CreateBuilder(Payload prototype) {

239

return new Builder(prototype);

240

}

241

242

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

243

public sealed partial class Builder : pb::GeneratedBuilder<Payload, Builder> {

244

protected override Builder ThisBuilder {

245

get { return this; }

246

}

247

public Builder() {

248

result = DefaultInstance;

249

resultIsReadOnly = true;

250

}

251

internal Builder(Payload cloneFrom) {

252

result = cloneFrom;

253

resultIsReadOnly = true;

254

}

255

256

private bool resultIsReadOnly;

257

private Payload result;

258

259

private Payload PrepareBuilder() {

260

if (resultIsReadOnly) {

261

Payload original = result;

262

result = new Payload();

263

resultIsReadOnly = false;

264

MergeFrom(original);

265

}

266

return result;

267

}

268

269

public override bool IsInitialized {

270

get { return result.IsInitialized; }

271

}

272

273

protected override Payload MessageBeingBuilt {

274

get { return PrepareBuilder(); }

275

}

276

277

public override Builder Clear() {

278

result = DefaultInstance;

279

resultIsReadOnly = true;

280

return this;

281

}

282

283

public override Builder Clone() {

284

if (resultIsReadOnly) {

285

return new Builder(result);

286

} else {

287

return new Builder().MergeFrom(result);

288

}

289

}

290

291

public override pbd::MessageDescriptor DescriptorForType {

292

get { return global::grpc.testing.Payload.Descriptor; }

293

}

294

295

public override Payload DefaultInstanceForType {

296

get { return global::grpc.testing.Payload.DefaultInstance; }

297

}

298

299

public override Payload BuildPartial() {

300

if (resultIsReadOnly) {

301

return result;

302

}

303

resultIsReadOnly = true;

304

return result.MakeReadOnly();

305

}

306

307

public override Builder MergeFrom(pb::IMessage other) {

308

if (other is Payload) {

309

return MergeFrom((Payload) other);

310

} else {

311

base.MergeFrom(other);

312

return this;

313

}

314

}

315

316

public override Builder MergeFrom(Payload other) {

317

if (other == global::grpc.testing.Payload.DefaultInstance) return this;

318

PrepareBuilder();

319

if (other.HasType) {

320

Type = other.Type;

321

}

322

if (other.HasBody) {

323

Body = other.Body;

324

}

325

this.MergeUnknownFields(other.UnknownFields);

326

return this;

327

}

328

329

public override Builder MergeFrom(pb::ICodedInputStream input) {

330

return MergeFrom(input, pb::ExtensionRegistry.Empty);

331

}

332

333

public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {

334

PrepareBuilder();

335

pb::UnknownFieldSet.Builder unknownFields = null;

336

uint tag;

337

string field_name;

338

while (input.ReadTag(out tag, out field_name)) {

339

if(tag == 0 && field_name != null) {

340

int field_ordinal = global::System.Array.BinarySearch(_payloadFieldNames, field_name, global::System.StringComparer.Ordinal);

341

if(field_ordinal >= 0)

342

tag = _payloadFieldTags[field_ordinal];

343

else {

344

if (unknownFields == null) {

345

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

346

}

347

ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);

348

continue;

349

}

350

}

351

switch (tag) {

352

case 0: {

353

throw pb::InvalidProtocolBufferException.InvalidTag();

354

}

355

default: {

356

if (pb::WireFormat.IsEndGroupTag(tag)) {

357

if (unknownFields != null) {

358

this.UnknownFields = unknownFields.Build();

359

}

360

return this;

361

}

362

if (unknownFields == null) {

363

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

364

}

365

ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);

366

break;

367

}

368

case 8: {

369

object unknown;

370

if(input.ReadEnum(ref result.type_, out unknown)) {

371

result.hasType = true;

372

} else if(unknown is int) {

373

if (unknownFields == null) {

374

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

375

}

376

unknownFields.MergeVarintField(1, (ulong)(int)unknown);

377

}

378

break;

379

}

380

case 18: {

381

result.hasBody = input.ReadBytes(ref result.body_);

382

break;

383

}

384

}

385

}

386

387

if (unknownFields != null) {

388

this.UnknownFields = unknownFields.Build();

389

}

390

return this;

391

}

392

393

394

public bool HasType {

395

get { return result.hasType; }

396

}

397

public global::grpc.testing.PayloadType Type {

398

get { return result.Type; }

399

set { SetType(value); }

400

}

401

public Builder SetType(global::grpc.testing.PayloadType value) {

402

PrepareBuilder();

403

result.hasType = true;

404

result.type_ = value;

405

return this;

406

}

407

public Builder ClearType() {

408

PrepareBuilder();

409

result.hasType = false;

410

result.type_ = global::grpc.testing.PayloadType.COMPRESSABLE;

411

return this;

412

}

413

414

public bool HasBody {

415

get { return result.hasBody; }

416

}

417

public pb::ByteString Body {

418

get { return result.Body; }

419

set { SetBody(value); }

420

}

421

public Builder SetBody(pb::ByteString value) {

422

pb::ThrowHelper.ThrowIfNull(value, "value");

423

PrepareBuilder();

424

result.hasBody = true;

425

result.body_ = value;

426

return this;

427

}

428

public Builder ClearBody() {

429

PrepareBuilder();

430

result.hasBody = false;

431

result.body_ = pb::ByteString.Empty;

432

return this;

433

}

434

}

435

static Payload() {

436

object.ReferenceEquals(global::grpc.testing.Messages.Descriptor, null);

437

}

438

}

439

440

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

441

public sealed partial class SimpleRequest : pb::GeneratedMessage<SimpleRequest, SimpleRequest.Builder> {

442

private SimpleRequest() { }

443

private static readonly SimpleRequest defaultInstance = new SimpleRequest().MakeReadOnly();

444

private static readonly string[] _simpleRequestFieldNames = new string[] { "fill_oauth_scope", "fill_username", "payload", "response_size", "response_type" };

445

private static readonly uint[] _simpleRequestFieldTags = new uint[] { 40, 32, 26, 16, 8 };

446

public static SimpleRequest DefaultInstance {

447

get { return defaultInstance; }

448

}

449

450

public override SimpleRequest DefaultInstanceForType {

451

get { return DefaultInstance; }

452

}

453

454

protected override SimpleRequest ThisMessage {

455

get { return this; }

456

}

457

458

public static pbd::MessageDescriptor Descriptor {

459

get { return global::grpc.testing.Messages.internal__static_grpc_testing_SimpleRequest__Descriptor; }

460

}

461

462

protected override pb::FieldAccess.FieldAccessorTable<SimpleRequest, SimpleRequest.Builder> InternalFieldAccessors {

463

get { return global::grpc.testing.Messages.internal__static_grpc_testing_SimpleRequest__FieldAccessorTable; }

464

}

465

466

public const int ResponseTypeFieldNumber = 1;

467

private bool hasResponseType;

468

private global::grpc.testing.PayloadType responseType_ = global::grpc.testing.PayloadType.COMPRESSABLE;

469

public bool HasResponseType {

470

get { return hasResponseType; }

471

}

472

public global::grpc.testing.PayloadType ResponseType {

473

get { return responseType_; }

474

}

475

476

public const int ResponseSizeFieldNumber = 2;

477

private bool hasResponseSize;

478

private int responseSize_;

479

public bool HasResponseSize {

480

get { return hasResponseSize; }

481

}

482

public int ResponseSize {

483

get { return responseSize_; }

484

}

485

486

public const int PayloadFieldNumber = 3;

487

private bool hasPayload;

488

private global::grpc.testing.Payload payload_;

489

public bool HasPayload {

490

get { return hasPayload; }

491

}

492

public global::grpc.testing.Payload Payload {

493

get { return payload_ ?? global::grpc.testing.Payload.DefaultInstance; }

494

}

495

496

public const int FillUsernameFieldNumber = 4;

497

private bool hasFillUsername;

498

private bool fillUsername_;

499

public bool HasFillUsername {

500

get { return hasFillUsername; }

501

}

502

public bool FillUsername {

503

get { return fillUsername_; }

504

}

505

506

public const int FillOauthScopeFieldNumber = 5;

507

private bool hasFillOauthScope;

508

private bool fillOauthScope_;

509

public bool HasFillOauthScope {

510

get { return hasFillOauthScope; }

511

}

512

public bool FillOauthScope {

513

get { return fillOauthScope_; }

514

}

515

516

public override bool IsInitialized {

517

get {

518

return true;

519

}

520

}

521

522

public override void WriteTo(pb::ICodedOutputStream output) {

523

int size = SerializedSize;

524

string[] field_names = _simpleRequestFieldNames;

525

if (hasResponseType) {

526

output.WriteEnum(1, field_names[4], (int) ResponseType, ResponseType);

527

}

528

if (hasResponseSize) {

529

output.WriteInt32(2, field_names[3], ResponseSize);

530

}

531

if (hasPayload) {

532

output.WriteMessage(3, field_names[2], Payload);

533

}

534

if (hasFillUsername) {

535

output.WriteBool(4, field_names[1], FillUsername);

536

}

537

if (hasFillOauthScope) {

538

output.WriteBool(5, field_names[0], FillOauthScope);

539

}

540

UnknownFields.WriteTo(output);

541

}

542

543

private int memoizedSerializedSize = -1;

544

public override int SerializedSize {

545

get {

546

int size = memoizedSerializedSize;

547

if (size != -1) return size;

548

549

size = 0;

550

if (hasResponseType) {

551

size += pb::CodedOutputStream.ComputeEnumSize(1, (int) ResponseType);

552

}

553

if (hasResponseSize) {

554

size += pb::CodedOutputStream.ComputeInt32Size(2, ResponseSize);

555

}

556

if (hasPayload) {

557

size += pb::CodedOutputStream.ComputeMessageSize(3, Payload);

558

}

559

if (hasFillUsername) {

560

size += pb::CodedOutputStream.ComputeBoolSize(4, FillUsername);

561

}

562

if (hasFillOauthScope) {

563

size += pb::CodedOutputStream.ComputeBoolSize(5, FillOauthScope);

564

}

565

size += UnknownFields.SerializedSize;

566

memoizedSerializedSize = size;

567

return size;

568

}

569

}

570

571

public static SimpleRequest ParseFrom(pb::ByteString data) {

572

return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();

573

}

574

public static SimpleRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {

575

return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();

576

}

577

public static SimpleRequest ParseFrom(byte[] data) {

578

return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();

579

}

580

public static SimpleRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {

581

return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();

582

}

583

public static SimpleRequest ParseFrom(global::System.IO.Stream input) {

584

return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();

585

}

586

public static SimpleRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {

587

return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();

588

}

589

public static SimpleRequest ParseDelimitedFrom(global::System.IO.Stream input) {

590

return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();

591

}

592

public static SimpleRequest ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {

593

return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();

594

}

595

public static SimpleRequest ParseFrom(pb::ICodedInputStream input) {

596

return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();

597

}

598

public static SimpleRequest ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {

599

return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();

600

}

601

private SimpleRequest MakeReadOnly() {

602

return this;

603

}

604

605

public static Builder CreateBuilder() { return new Builder(); }

606

public override Builder ToBuilder() { return CreateBuilder(this); }

607

public override Builder CreateBuilderForType() { return new Builder(); }

608

public static Builder CreateBuilder(SimpleRequest prototype) {

609

return new Builder(prototype);

610

}

611

612

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

613

public sealed partial class Builder : pb::GeneratedBuilder<SimpleRequest, Builder> {

614

protected override Builder ThisBuilder {

615

get { return this; }

616

}

617

public Builder() {

618

result = DefaultInstance;

619

resultIsReadOnly = true;

620

}

621

internal Builder(SimpleRequest cloneFrom) {

622

result = cloneFrom;

623

resultIsReadOnly = true;

624

}

625

626

private bool resultIsReadOnly;

627

private SimpleRequest result;

628

629

private SimpleRequest PrepareBuilder() {

630

if (resultIsReadOnly) {

631

SimpleRequest original = result;

632

result = new SimpleRequest();

633

resultIsReadOnly = false;

634

MergeFrom(original);

635

}

636

return result;

637

}

638

639

public override bool IsInitialized {

640

get { return result.IsInitialized; }

641

}

642

643

protected override SimpleRequest MessageBeingBuilt {

644

get { return PrepareBuilder(); }

645

}

646

647

public override Builder Clear() {

648

result = DefaultInstance;

649

resultIsReadOnly = true;

650

return this;

651

}

652

653

public override Builder Clone() {

654

if (resultIsReadOnly) {

655

return new Builder(result);

656

} else {

657

return new Builder().MergeFrom(result);

658

}

659

}

660

661

public override pbd::MessageDescriptor DescriptorForType {

662

get { return global::grpc.testing.SimpleRequest.Descriptor; }

663

}

664

665

public override SimpleRequest DefaultInstanceForType {

666

get { return global::grpc.testing.SimpleRequest.DefaultInstance; }

667

}

668

669

public override SimpleRequest BuildPartial() {

670

if (resultIsReadOnly) {

671

return result;

672

}

673

resultIsReadOnly = true;

674

return result.MakeReadOnly();

675

}

676

677

public override Builder MergeFrom(pb::IMessage other) {

678

if (other is SimpleRequest) {

679

return MergeFrom((SimpleRequest) other);

680

} else {

681

base.MergeFrom(other);

682

return this;

683

}

684

}

685

686

public override Builder MergeFrom(SimpleRequest other) {

687

if (other == global::grpc.testing.SimpleRequest.DefaultInstance) return this;

688

PrepareBuilder();

689

if (other.HasResponseType) {

690

ResponseType = other.ResponseType;

691

}

692

if (other.HasResponseSize) {

693

ResponseSize = other.ResponseSize;

694

}

695

if (other.HasPayload) {

696

MergePayload(other.Payload);

697

}

698

if (other.HasFillUsername) {

699

FillUsername = other.FillUsername;

700

}

701

if (other.HasFillOauthScope) {

702

FillOauthScope = other.FillOauthScope;

703

}

704

this.MergeUnknownFields(other.UnknownFields);

705

return this;

706

}

707

708

public override Builder MergeFrom(pb::ICodedInputStream input) {

709

return MergeFrom(input, pb::ExtensionRegistry.Empty);

710

}

711

712

public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {

713

PrepareBuilder();

714

pb::UnknownFieldSet.Builder unknownFields = null;

715

uint tag;

716

string field_name;

717

while (input.ReadTag(out tag, out field_name)) {

718

if(tag == 0 && field_name != null) {

719

int field_ordinal = global::System.Array.BinarySearch(_simpleRequestFieldNames, field_name, global::System.StringComparer.Ordinal);

720

if(field_ordinal >= 0)

721

tag = _simpleRequestFieldTags[field_ordinal];

722

else {

723

if (unknownFields == null) {

724

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

725

}

726

ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);

727

continue;

728

}

729

}

730

switch (tag) {

731

case 0: {

732

throw pb::InvalidProtocolBufferException.InvalidTag();

733

}

734

default: {

735

if (pb::WireFormat.IsEndGroupTag(tag)) {

736

if (unknownFields != null) {

737

this.UnknownFields = unknownFields.Build();

738

}

739

return this;

740

}

741

if (unknownFields == null) {

742

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

743

}

744

ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);

745

break;

746

}

747

case 8: {

748

object unknown;

749

if(input.ReadEnum(ref result.responseType_, out unknown)) {

750

result.hasResponseType = true;

751

} else if(unknown is int) {

752

if (unknownFields == null) {

753

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

754

}

755

unknownFields.MergeVarintField(1, (ulong)(int)unknown);

756

}

757

break;

758

}

759

case 16: {

760

result.hasResponseSize = input.ReadInt32(ref result.responseSize_);

761

break;

762

}

763

case 26: {

764

global::grpc.testing.Payload.Builder subBuilder = global::grpc.testing.Payload.CreateBuilder();

765

if (result.hasPayload) {

766

subBuilder.MergeFrom(Payload);

767

}

768

input.ReadMessage(subBuilder, extensionRegistry);

769

Payload = subBuilder.BuildPartial();

770

break;

771

}

772

case 32: {

773

result.hasFillUsername = input.ReadBool(ref result.fillUsername_);

774

break;

775

}

776

case 40: {

777

result.hasFillOauthScope = input.ReadBool(ref result.fillOauthScope_);

778

break;

779

}

780

}

781

}

782

783

if (unknownFields != null) {

784

this.UnknownFields = unknownFields.Build();

785

}

786

return this;

787

}

788

789

790

public bool HasResponseType {

791

get { return result.hasResponseType; }

792

}

793

public global::grpc.testing.PayloadType ResponseType {

794

get { return result.ResponseType; }

795

set { SetResponseType(value); }

796

}

797

public Builder SetResponseType(global::grpc.testing.PayloadType value) {

798

PrepareBuilder();

799

result.hasResponseType = true;

800

result.responseType_ = value;

801

return this;

802

}

803

public Builder ClearResponseType() {

804

PrepareBuilder();

805

result.hasResponseType = false;

806

result.responseType_ = global::grpc.testing.PayloadType.COMPRESSABLE;

807

return this;

808

}

809

810

public bool HasResponseSize {

811

get { return result.hasResponseSize; }

812

}

813

public int ResponseSize {

814

get { return result.ResponseSize; }

815

set { SetResponseSize(value); }

816

}

817

public Builder SetResponseSize(int value) {

818

PrepareBuilder();

819

result.hasResponseSize = true;

820

result.responseSize_ = value;

821

return this;

822

}

823

public Builder ClearResponseSize() {

824

PrepareBuilder();

825

result.hasResponseSize = false;

826

result.responseSize_ = 0;

827

return this;

828

}

829

830

public bool HasPayload {

831

get { return result.hasPayload; }

832

}

833

public global::grpc.testing.Payload Payload {

834

get { return result.Payload; }

835

set { SetPayload(value); }

836

}

837

public Builder SetPayload(global::grpc.testing.Payload value) {

838

pb::ThrowHelper.ThrowIfNull(value, "value");

839

PrepareBuilder();

840

result.hasPayload = true;

841

result.payload_ = value;

842

return this;

843

}

844

public Builder SetPayload(global::grpc.testing.Payload.Builder builderForValue) {

845

pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");

846

PrepareBuilder();

847

result.hasPayload = true;

848

result.payload_ = builderForValue.Build();

849

return this;

850

}

851

public Builder MergePayload(global::grpc.testing.Payload value) {

852

pb::ThrowHelper.ThrowIfNull(value, "value");

853

PrepareBuilder();

854

if (result.hasPayload &&

855

result.payload_ != global::grpc.testing.Payload.DefaultInstance) {

856

result.payload_ = global::grpc.testing.Payload.CreateBuilder(result.payload_).MergeFrom(value).BuildPartial();

857

} else {

858

result.payload_ = value;

859

}

860

result.hasPayload = true;

861

return this;

862

}

863

public Builder ClearPayload() {

864

PrepareBuilder();

865

result.hasPayload = false;

866

result.payload_ = null;

867

return this;

868

}

869

870

public bool HasFillUsername {

871

get { return result.hasFillUsername; }

872

}

873

public bool FillUsername {

874

get { return result.FillUsername; }

875

set { SetFillUsername(value); }

876

}

877

public Builder SetFillUsername(bool value) {

878

PrepareBuilder();

879

result.hasFillUsername = true;

880

result.fillUsername_ = value;

881

return this;

882

}

883

public Builder ClearFillUsername() {

884

PrepareBuilder();

885

result.hasFillUsername = false;

886

result.fillUsername_ = false;

887

return this;

888

}

889

890

public bool HasFillOauthScope {

891

get { return result.hasFillOauthScope; }

892

}

893

public bool FillOauthScope {

894

get { return result.FillOauthScope; }

895

set { SetFillOauthScope(value); }

896

}

897

public Builder SetFillOauthScope(bool value) {

898

PrepareBuilder();

899

result.hasFillOauthScope = true;

900

result.fillOauthScope_ = value;

901

return this;

902

}

903

public Builder ClearFillOauthScope() {

904

PrepareBuilder();

905

result.hasFillOauthScope = false;

906

result.fillOauthScope_ = false;

907

return this;

908

}

909

}

910

static SimpleRequest() {

911

object.ReferenceEquals(global::grpc.testing.Messages.Descriptor, null);

912

}

913

}

914

915

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

916

public sealed partial class SimpleResponse : pb::GeneratedMessage<SimpleResponse, SimpleResponse.Builder> {

917

private SimpleResponse() { }

918

private static readonly SimpleResponse defaultInstance = new SimpleResponse().MakeReadOnly();

919

private static readonly string[] _simpleResponseFieldNames = new string[] { "oauth_scope", "payload", "username" };

920

private static readonly uint[] _simpleResponseFieldTags = new uint[] { 26, 10, 18 };

921

public static SimpleResponse DefaultInstance {

922

get { return defaultInstance; }

923

}

924

925

public override SimpleResponse DefaultInstanceForType {

926

get { return DefaultInstance; }

927

}

928

929

protected override SimpleResponse ThisMessage {

930

get { return this; }

931

}

932

933

public static pbd::MessageDescriptor Descriptor {

934

get { return global::grpc.testing.Messages.internal__static_grpc_testing_SimpleResponse__Descriptor; }

935

}

936

937

protected override pb::FieldAccess.FieldAccessorTable<SimpleResponse, SimpleResponse.Builder> InternalFieldAccessors {

938

get { return global::grpc.testing.Messages.internal__static_grpc_testing_SimpleResponse__FieldAccessorTable; }

939

}

940

941

public const int PayloadFieldNumber = 1;

942

private bool hasPayload;

943

private global::grpc.testing.Payload payload_;

944

public bool HasPayload {

945

get { return hasPayload; }

946

}

947

public global::grpc.testing.Payload Payload {

948

get { return payload_ ?? global::grpc.testing.Payload.DefaultInstance; }

949

}

950

951

public const int UsernameFieldNumber = 2;

952

private bool hasUsername;

953

private string username_ = "";

954

public bool HasUsername {

955

get { return hasUsername; }

956

}

957

public string Username {

958

get { return username_; }

959

}

960

961

public const int OauthScopeFieldNumber = 3;

962

private bool hasOauthScope;

963

private string oauthScope_ = "";

964

public bool HasOauthScope {

965

get { return hasOauthScope; }

966

}

967

public string OauthScope {

968

get { return oauthScope_; }

969

}

970

971

public override bool IsInitialized {

972

get {

973

return true;

974

}

975

}

976

977

public override void WriteTo(pb::ICodedOutputStream output) {

978

int size = SerializedSize;

979

string[] field_names = _simpleResponseFieldNames;

980

if (hasPayload) {

981

output.WriteMessage(1, field_names[1], Payload);

982

}

983

if (hasUsername) {

984

output.WriteString(2, field_names[2], Username);

985

}

986

if (hasOauthScope) {

987

output.WriteString(3, field_names[0], OauthScope);

988

}

989

UnknownFields.WriteTo(output);

990

}

991

992

private int memoizedSerializedSize = -1;

993

public override int SerializedSize {

994

get {

995

int size = memoizedSerializedSize;

996

if (size != -1) return size;

997

998

size = 0;

999

if (hasPayload) {

1000

size += pb::CodedOutputStream.ComputeMessageSize(1, Payload);

1001

}

1002

if (hasUsername) {

1003

size += pb::CodedOutputStream.ComputeStringSize(2, Username);

1004

}

1005

if (hasOauthScope) {

1006

size += pb::CodedOutputStream.ComputeStringSize(3, OauthScope);

1007

}

1008

size += UnknownFields.SerializedSize;

1009

memoizedSerializedSize = size;

1010

return size;

1011

}

1012

}

1013

1014

public static SimpleResponse ParseFrom(pb::ByteString data) {

1015

return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();

1016

}

1017

public static SimpleResponse ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {

1018

return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();

1019

}

1020

public static SimpleResponse ParseFrom(byte[] data) {

1021

return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();

1022

}

1023

public static SimpleResponse ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {

1024

return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();

1025

}

1026

public static SimpleResponse ParseFrom(global::System.IO.Stream input) {

1027

return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();

1028

}

1029

public static SimpleResponse ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {

1030

return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();

1031

}

1032

public static SimpleResponse ParseDelimitedFrom(global::System.IO.Stream input) {

1033

return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();

1034

}

1035

public static SimpleResponse ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {

1036

return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();

1037

}

1038

public static SimpleResponse ParseFrom(pb::ICodedInputStream input) {

1039

return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();

1040

}

1041

public static SimpleResponse ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {

1042

return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();

1043

}

1044

private SimpleResponse MakeReadOnly() {

1045

return this;

1046

}

1047

1048

public static Builder CreateBuilder() { return new Builder(); }

1049

public override Builder ToBuilder() { return CreateBuilder(this); }

1050

public override Builder CreateBuilderForType() { return new Builder(); }

1051

public static Builder CreateBuilder(SimpleResponse prototype) {

1052

return new Builder(prototype);

1053

}

1054

1055

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

1056

public sealed partial class Builder : pb::GeneratedBuilder<SimpleResponse, Builder> {

1057

protected override Builder ThisBuilder {

1058

get { return this; }

1059

}

1060

public Builder() {

1061

result = DefaultInstance;

1062

resultIsReadOnly = true;

1063

}

1064

internal Builder(SimpleResponse cloneFrom) {

1065

result = cloneFrom;

1066

resultIsReadOnly = true;

1067

}

1068

1069

private bool resultIsReadOnly;

1070

private SimpleResponse result;

1071

1072

private SimpleResponse PrepareBuilder() {

1073

if (resultIsReadOnly) {

1074

SimpleResponse original = result;

1075

result = new SimpleResponse();

1076

resultIsReadOnly = false;

1077

MergeFrom(original);

1078

}

1079

return result;

1080

}

1081

1082

public override bool IsInitialized {

1083

get { return result.IsInitialized; }

1084

}

1085

1086

protected override SimpleResponse MessageBeingBuilt {

1087

get { return PrepareBuilder(); }

1088

}

1089

1090

public override Builder Clear() {

1091

result = DefaultInstance;

1092

resultIsReadOnly = true;

1093

return this;

1094

}

1095

1096

public override Builder Clone() {

1097

if (resultIsReadOnly) {

1098

return new Builder(result);

1099

} else {

1100

return new Builder().MergeFrom(result);

1101

}

1102

}

1103

1104

public override pbd::MessageDescriptor DescriptorForType {

1105

get { return global::grpc.testing.SimpleResponse.Descriptor; }

1106

}

1107

1108

public override SimpleResponse DefaultInstanceForType {

1109

get { return global::grpc.testing.SimpleResponse.DefaultInstance; }

1110

}

1111

1112

public override SimpleResponse BuildPartial() {

1113

if (resultIsReadOnly) {

1114

return result;

1115

}

1116

resultIsReadOnly = true;

1117

return result.MakeReadOnly();

1118

}

1119

1120

public override Builder MergeFrom(pb::IMessage other) {

1121

if (other is SimpleResponse) {

1122

return MergeFrom((SimpleResponse) other);

1123

} else {

1124

base.MergeFrom(other);

1125

return this;

1126

}

1127

}

1128

1129

public override Builder MergeFrom(SimpleResponse other) {

1130

if (other == global::grpc.testing.SimpleResponse.DefaultInstance) return this;

1131

PrepareBuilder();

1132

if (other.HasPayload) {

1133

MergePayload(other.Payload);

1134

}

1135

if (other.HasUsername) {

1136

Username = other.Username;

1137

}

1138

if (other.HasOauthScope) {

1139

OauthScope = other.OauthScope;

1140

}

1141

this.MergeUnknownFields(other.UnknownFields);

1142

return this;

1143

}

1144

1145

public override Builder MergeFrom(pb::ICodedInputStream input) {

1146

return MergeFrom(input, pb::ExtensionRegistry.Empty);

1147

}

1148

1149

public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {

1150

PrepareBuilder();

1151

pb::UnknownFieldSet.Builder unknownFields = null;

1152

uint tag;

1153

string field_name;

1154

while (input.ReadTag(out tag, out field_name)) {

1155

if(tag == 0 && field_name != null) {

1156

int field_ordinal = global::System.Array.BinarySearch(_simpleResponseFieldNames, field_name, global::System.StringComparer.Ordinal);

1157

if(field_ordinal >= 0)

1158

tag = _simpleResponseFieldTags[field_ordinal];

1159

else {

1160

if (unknownFields == null) {

1161

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

1162

}

1163

ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);

1164

continue;

1165

}

1166

}

1167

switch (tag) {

1168

case 0: {

1169

throw pb::InvalidProtocolBufferException.InvalidTag();

1170

}

1171

default: {

1172

if (pb::WireFormat.IsEndGroupTag(tag)) {

1173

if (unknownFields != null) {

1174

this.UnknownFields = unknownFields.Build();

1175

}

1176

return this;

1177

}

1178

if (unknownFields == null) {

1179

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

1180

}

1181

ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);

1182

break;

1183

}

1184

case 10: {

1185

global::grpc.testing.Payload.Builder subBuilder = global::grpc.testing.Payload.CreateBuilder();

1186

if (result.hasPayload) {

1187

subBuilder.MergeFrom(Payload);

1188

}

1189

input.ReadMessage(subBuilder, extensionRegistry);

1190

Payload = subBuilder.BuildPartial();

1191

break;

1192

}

1193

case 18: {

1194

result.hasUsername = input.ReadString(ref result.username_);

1195

break;

1196

}

1197

case 26: {

1198

result.hasOauthScope = input.ReadString(ref result.oauthScope_);

1199

break;

1200

}

1201

}

1202

}

1203

1204

if (unknownFields != null) {

1205

this.UnknownFields = unknownFields.Build();

1206

}

1207

return this;

1208

}

1209

1210

1211

public bool HasPayload {

1212

get { return result.hasPayload; }

1213

}

1214

public global::grpc.testing.Payload Payload {

1215

get { return result.Payload; }

1216

set { SetPayload(value); }

1217

}

1218

public Builder SetPayload(global::grpc.testing.Payload value) {

1219

pb::ThrowHelper.ThrowIfNull(value, "value");

1220

PrepareBuilder();

1221

result.hasPayload = true;

1222

result.payload_ = value;

1223

return this;

1224

}

1225

public Builder SetPayload(global::grpc.testing.Payload.Builder builderForValue) {

1226

pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");

1227

PrepareBuilder();

1228

result.hasPayload = true;

1229

result.payload_ = builderForValue.Build();

1230

return this;

1231

}

1232

public Builder MergePayload(global::grpc.testing.Payload value) {

1233

pb::ThrowHelper.ThrowIfNull(value, "value");

1234

PrepareBuilder();

1235

if (result.hasPayload &&

1236

result.payload_ != global::grpc.testing.Payload.DefaultInstance) {

1237

result.payload_ = global::grpc.testing.Payload.CreateBuilder(result.payload_).MergeFrom(value).BuildPartial();

1238

} else {

1239

result.payload_ = value;

1240

}

1241

result.hasPayload = true;

1242

return this;

1243

}

1244

public Builder ClearPayload() {

1245

PrepareBuilder();

1246

result.hasPayload = false;

1247

result.payload_ = null;

1248

return this;

1249

}

1250

1251

public bool HasUsername {

1252

get { return result.hasUsername; }

1253

}

1254

public string Username {

1255

get { return result.Username; }

1256

set { SetUsername(value); }

1257

}

1258

public Builder SetUsername(string value) {

1259

pb::ThrowHelper.ThrowIfNull(value, "value");

1260

PrepareBuilder();

1261

result.hasUsername = true;

1262

result.username_ = value;

1263

return this;

1264

}

1265

public Builder ClearUsername() {

1266

PrepareBuilder();

1267

result.hasUsername = false;

1268

result.username_ = "";

1269

return this;

1270

}

1271

1272

public bool HasOauthScope {

1273

get { return result.hasOauthScope; }

1274

}

1275

public string OauthScope {

1276

get { return result.OauthScope; }

1277

set { SetOauthScope(value); }

1278

}

1279

public Builder SetOauthScope(string value) {

1280

pb::ThrowHelper.ThrowIfNull(value, "value");

1281

PrepareBuilder();

1282

result.hasOauthScope = true;

1283

result.oauthScope_ = value;

1284

return this;

1285

}

1286

public Builder ClearOauthScope() {

1287

PrepareBuilder();

1288

result.hasOauthScope = false;

1289

result.oauthScope_ = "";

1290

return this;

1291

}

1292

}

1293

static SimpleResponse() {

1294

object.ReferenceEquals(global::grpc.testing.Messages.Descriptor, null);

1295

}

1296

}

1297

1298

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

1299

public sealed partial class StreamingInputCallRequest : pb::GeneratedMessage<StreamingInputCallRequest, StreamingInputCallRequest.Builder> {

1300

private StreamingInputCallRequest() { }

1301

private static readonly StreamingInputCallRequest defaultInstance = new StreamingInputCallRequest().MakeReadOnly();

1302

private static readonly string[] _streamingInputCallRequestFieldNames = new string[] { "payload" };

1303

private static readonly uint[] _streamingInputCallRequestFieldTags = new uint[] { 10 };

1304

public static StreamingInputCallRequest DefaultInstance {

1305

get { return defaultInstance; }

1306

}

1307

1308

public override StreamingInputCallRequest DefaultInstanceForType {

1309

get { return DefaultInstance; }

1310

}

1311

1312

protected override StreamingInputCallRequest ThisMessage {

1313

get { return this; }

1314

}

1315

1316

public static pbd::MessageDescriptor Descriptor {

1317

get { return global::grpc.testing.Messages.internal__static_grpc_testing_StreamingInputCallRequest__Descriptor; }

1318

}

1319

1320

protected override pb::FieldAccess.FieldAccessorTable<StreamingInputCallRequest, StreamingInputCallRequest.Builder> InternalFieldAccessors {

1321

get { return global::grpc.testing.Messages.internal__static_grpc_testing_StreamingInputCallRequest__FieldAccessorTable; }

1322

}

1323

1324

public const int PayloadFieldNumber = 1;

1325

private bool hasPayload;

1326

private global::grpc.testing.Payload payload_;

1327

public bool HasPayload {

1328

get { return hasPayload; }

1329

}

1330

public global::grpc.testing.Payload Payload {

1331

get { return payload_ ?? global::grpc.testing.Payload.DefaultInstance; }

1332

}

1333

1334

public override bool IsInitialized {

1335

get {

1336

return true;

1337

}

1338

}

1339

1340

public override void WriteTo(pb::ICodedOutputStream output) {

1341

int size = SerializedSize;

1342

string[] field_names = _streamingInputCallRequestFieldNames;

1343

if (hasPayload) {

1344

output.WriteMessage(1, field_names[0], Payload);

1345

}

1346

UnknownFields.WriteTo(output);

1347

}

1348

1349

private int memoizedSerializedSize = -1;

1350

public override int SerializedSize {

1351

get {

1352

int size = memoizedSerializedSize;

1353

if (size != -1) return size;

1354

1355

size = 0;

1356

if (hasPayload) {

1357

size += pb::CodedOutputStream.ComputeMessageSize(1, Payload);

1358

}

1359

size += UnknownFields.SerializedSize;

1360

memoizedSerializedSize = size;

1361

return size;

1362

}

1363

}

1364

1365

public static StreamingInputCallRequest ParseFrom(pb::ByteString data) {

1366

return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();

1367

}

1368

public static StreamingInputCallRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {

1369

return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();

1370

}

1371

public static StreamingInputCallRequest ParseFrom(byte[] data) {

1372

return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();

1373

}

1374

public static StreamingInputCallRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {

1375

return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();

1376

}

1377

public static StreamingInputCallRequest ParseFrom(global::System.IO.Stream input) {

1378

return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();

1379

}

1380

public static StreamingInputCallRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {

1381

return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();

1382

}

1383

public static StreamingInputCallRequest ParseDelimitedFrom(global::System.IO.Stream input) {

1384

return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();

1385

}

1386

public static StreamingInputCallRequest ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {

1387

return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();

1388

}

1389

public static StreamingInputCallRequest ParseFrom(pb::ICodedInputStream input) {

1390

return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();

1391

}

1392

public static StreamingInputCallRequest ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {

1393

return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();

1394

}

1395

private StreamingInputCallRequest MakeReadOnly() {

1396

return this;

1397

}

1398

1399

public static Builder CreateBuilder() { return new Builder(); }

1400

public override Builder ToBuilder() { return CreateBuilder(this); }

1401

public override Builder CreateBuilderForType() { return new Builder(); }

1402

public static Builder CreateBuilder(StreamingInputCallRequest prototype) {

1403

return new Builder(prototype);

1404

}

1405

1406

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

1407

public sealed partial class Builder : pb::GeneratedBuilder<StreamingInputCallRequest, Builder> {

1408

protected override Builder ThisBuilder {

1409

get { return this; }

1410

}

1411

public Builder() {

1412

result = DefaultInstance;

1413

resultIsReadOnly = true;

1414

}

1415

internal Builder(StreamingInputCallRequest cloneFrom) {

1416

result = cloneFrom;

1417

resultIsReadOnly = true;

1418

}

1419

1420

private bool resultIsReadOnly;

1421

private StreamingInputCallRequest result;

1422

1423

private StreamingInputCallRequest PrepareBuilder() {

1424

if (resultIsReadOnly) {

1425

StreamingInputCallRequest original = result;

1426

result = new StreamingInputCallRequest();

1427

resultIsReadOnly = false;

1428

MergeFrom(original);

1429

}

1430

return result;

1431

}

1432

1433

public override bool IsInitialized {

1434

get { return result.IsInitialized; }

1435

}

1436

1437

protected override StreamingInputCallRequest MessageBeingBuilt {

1438

get { return PrepareBuilder(); }

1439

}

1440

1441

public override Builder Clear() {

1442

result = DefaultInstance;

1443

resultIsReadOnly = true;

1444

return this;

1445

}

1446

1447

public override Builder Clone() {

1448

if (resultIsReadOnly) {

1449

return new Builder(result);

1450

} else {

1451

return new Builder().MergeFrom(result);

1452

}

1453

}

1454

1455

public override pbd::MessageDescriptor DescriptorForType {

1456

get { return global::grpc.testing.StreamingInputCallRequest.Descriptor; }

1457

}

1458

1459

public override StreamingInputCallRequest DefaultInstanceForType {

1460

get { return global::grpc.testing.StreamingInputCallRequest.DefaultInstance; }

1461

}

1462

1463

public override StreamingInputCallRequest BuildPartial() {

1464

if (resultIsReadOnly) {

1465

return result;

1466

}

1467

resultIsReadOnly = true;

1468

return result.MakeReadOnly();

1469

}

1470

1471

public override Builder MergeFrom(pb::IMessage other) {

1472

if (other is StreamingInputCallRequest) {

1473

return MergeFrom((StreamingInputCallRequest) other);

1474

} else {

1475

base.MergeFrom(other);

1476

return this;

1477

}

1478

}

1479

1480

public override Builder MergeFrom(StreamingInputCallRequest other) {

1481

if (other == global::grpc.testing.StreamingInputCallRequest.DefaultInstance) return this;

1482

PrepareBuilder();

1483

if (other.HasPayload) {

1484

MergePayload(other.Payload);

1485

}

1486

this.MergeUnknownFields(other.UnknownFields);

1487

return this;

1488

}

1489

1490

public override Builder MergeFrom(pb::ICodedInputStream input) {

1491

return MergeFrom(input, pb::ExtensionRegistry.Empty);

1492

}

1493

1494

public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {

1495

PrepareBuilder();

1496

pb::UnknownFieldSet.Builder unknownFields = null;

1497

uint tag;

1498

string field_name;

1499

while (input.ReadTag(out tag, out field_name)) {

1500

if(tag == 0 && field_name != null) {

1501

int field_ordinal = global::System.Array.BinarySearch(_streamingInputCallRequestFieldNames, field_name, global::System.StringComparer.Ordinal);

1502

if(field_ordinal >= 0)

1503

tag = _streamingInputCallRequestFieldTags[field_ordinal];

1504

else {

1505

if (unknownFields == null) {

1506

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

1507

}

1508

ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);

1509

continue;

1510

}

1511

}

1512

switch (tag) {

1513

case 0: {

1514

throw pb::InvalidProtocolBufferException.InvalidTag();

1515

}

1516

default: {

1517

if (pb::WireFormat.IsEndGroupTag(tag)) {

1518

if (unknownFields != null) {

1519

this.UnknownFields = unknownFields.Build();

1520

}

1521

return this;

1522

}

1523

if (unknownFields == null) {

1524

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

1525

}

1526

ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);

1527

break;

1528

}

1529

case 10: {

1530

global::grpc.testing.Payload.Builder subBuilder = global::grpc.testing.Payload.CreateBuilder();

1531

if (result.hasPayload) {

1532

subBuilder.MergeFrom(Payload);

1533

}

1534

input.ReadMessage(subBuilder, extensionRegistry);

1535

Payload = subBuilder.BuildPartial();

1536

break;

1537

}

1538

}

1539

}

1540

1541

if (unknownFields != null) {

1542

this.UnknownFields = unknownFields.Build();

1543

}

1544

return this;

1545

}

1546

1547

1548

public bool HasPayload {

1549

get { return result.hasPayload; }

1550

}

1551

public global::grpc.testing.Payload Payload {

1552

get { return result.Payload; }

1553

set { SetPayload(value); }

1554

}

1555

public Builder SetPayload(global::grpc.testing.Payload value) {

1556

pb::ThrowHelper.ThrowIfNull(value, "value");

1557

PrepareBuilder();

1558

result.hasPayload = true;

1559

result.payload_ = value;

1560

return this;

1561

}

1562

public Builder SetPayload(global::grpc.testing.Payload.Builder builderForValue) {

1563

pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");

1564

PrepareBuilder();

1565

result.hasPayload = true;

1566

result.payload_ = builderForValue.Build();

1567

return this;

1568

}

1569

public Builder MergePayload(global::grpc.testing.Payload value) {

1570

pb::ThrowHelper.ThrowIfNull(value, "value");

1571

PrepareBuilder();

1572

if (result.hasPayload &&

1573

result.payload_ != global::grpc.testing.Payload.DefaultInstance) {

1574

result.payload_ = global::grpc.testing.Payload.CreateBuilder(result.payload_).MergeFrom(value).BuildPartial();

1575

} else {

1576

result.payload_ = value;

1577

}

1578

result.hasPayload = true;

1579

return this;

1580

}

1581

public Builder ClearPayload() {

1582

PrepareBuilder();

1583

result.hasPayload = false;

1584

result.payload_ = null;

1585

return this;

1586

}

1587

}

1588

static StreamingInputCallRequest() {

1589

object.ReferenceEquals(global::grpc.testing.Messages.Descriptor, null);

1590

}

1591

}

1592

1593

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

1594

public sealed partial class StreamingInputCallResponse : pb::GeneratedMessage<StreamingInputCallResponse, StreamingInputCallResponse.Builder> {

1595

private StreamingInputCallResponse() { }

1596

private static readonly StreamingInputCallResponse defaultInstance = new StreamingInputCallResponse().MakeReadOnly();

1597

private static readonly string[] _streamingInputCallResponseFieldNames = new string[] { "aggregated_payload_size" };

1598

private static readonly uint[] _streamingInputCallResponseFieldTags = new uint[] { 8 };

1599

public static StreamingInputCallResponse DefaultInstance {

1600

get { return defaultInstance; }

1601

}

1602

1603

public override StreamingInputCallResponse DefaultInstanceForType {

1604

get { return DefaultInstance; }

1605

}

1606

1607

protected override StreamingInputCallResponse ThisMessage {

1608

get { return this; }

1609

}

1610

1611

public static pbd::MessageDescriptor Descriptor {

1612

get { return global::grpc.testing.Messages.internal__static_grpc_testing_StreamingInputCallResponse__Descriptor; }

1613

}

1614

1615

protected override pb::FieldAccess.FieldAccessorTable<StreamingInputCallResponse, StreamingInputCallResponse.Builder> InternalFieldAccessors {

1616

get { return global::grpc.testing.Messages.internal__static_grpc_testing_StreamingInputCallResponse__FieldAccessorTable; }

1617

}

1618

1619

public const int AggregatedPayloadSizeFieldNumber = 1;

1620

private bool hasAggregatedPayloadSize;

1621

private int aggregatedPayloadSize_;

1622

public bool HasAggregatedPayloadSize {

1623

get { return hasAggregatedPayloadSize; }

1624

}

1625

public int AggregatedPayloadSize {

1626

get { return aggregatedPayloadSize_; }

1627

}

1628

1629

public override bool IsInitialized {

1630

get {

1631

return true;

1632

}

1633

}

1634

1635

public override void WriteTo(pb::ICodedOutputStream output) {

1636

int size = SerializedSize;

1637

string[] field_names = _streamingInputCallResponseFieldNames;

1638

if (hasAggregatedPayloadSize) {

1639

output.WriteInt32(1, field_names[0], AggregatedPayloadSize);

1640

}

1641

UnknownFields.WriteTo(output);

1642

}

1643

1644

private int memoizedSerializedSize = -1;

1645

public override int SerializedSize {

1646

get {

1647

int size = memoizedSerializedSize;

1648

if (size != -1) return size;

1649

1650

size = 0;

1651

if (hasAggregatedPayloadSize) {

1652

size += pb::CodedOutputStream.ComputeInt32Size(1, AggregatedPayloadSize);

1653

}

1654

size += UnknownFields.SerializedSize;

1655

memoizedSerializedSize = size;

1656

return size;

1657

}

1658

}

1659

1660

public static StreamingInputCallResponse ParseFrom(pb::ByteString data) {

1661

return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();

1662

}

1663

public static StreamingInputCallResponse ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {

1664

return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();

1665

}

1666

public static StreamingInputCallResponse ParseFrom(byte[] data) {

1667

return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();

1668

}

1669

public static StreamingInputCallResponse ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {

1670

return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();

1671

}

1672

public static StreamingInputCallResponse ParseFrom(global::System.IO.Stream input) {

1673

return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();

1674

}

1675

public static StreamingInputCallResponse ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {

1676

return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();

1677

}

1678

public static StreamingInputCallResponse ParseDelimitedFrom(global::System.IO.Stream input) {

1679

return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();

1680

}

1681

public static StreamingInputCallResponse ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {

1682

return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();

1683

}

1684

public static StreamingInputCallResponse ParseFrom(pb::ICodedInputStream input) {

1685

return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();

1686

}

1687

public static StreamingInputCallResponse ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {

1688

return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();

1689

}

1690

private StreamingInputCallResponse MakeReadOnly() {

1691

return this;

1692

}

1693

1694

public static Builder CreateBuilder() { return new Builder(); }

1695

public override Builder ToBuilder() { return CreateBuilder(this); }

1696

public override Builder CreateBuilderForType() { return new Builder(); }

1697

public static Builder CreateBuilder(StreamingInputCallResponse prototype) {

1698

return new Builder(prototype);

1699

}

1700

1701

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

1702

public sealed partial class Builder : pb::GeneratedBuilder<StreamingInputCallResponse, Builder> {

1703

protected override Builder ThisBuilder {

1704

get { return this; }

1705

}

1706

public Builder() {

1707

result = DefaultInstance;

1708

resultIsReadOnly = true;

1709

}

1710

internal Builder(StreamingInputCallResponse cloneFrom) {

1711

result = cloneFrom;

1712

resultIsReadOnly = true;

1713

}

1714

1715

private bool resultIsReadOnly;

1716

private StreamingInputCallResponse result;

1717

1718

private StreamingInputCallResponse PrepareBuilder() {

1719

if (resultIsReadOnly) {

1720

StreamingInputCallResponse original = result;

1721

result = new StreamingInputCallResponse();

1722

resultIsReadOnly = false;

1723

MergeFrom(original);

1724

}

1725

return result;

1726

}

1727

1728

public override bool IsInitialized {

1729

get { return result.IsInitialized; }

1730

}

1731

1732

protected override StreamingInputCallResponse MessageBeingBuilt {

1733

get { return PrepareBuilder(); }

1734

}

1735

1736

public override Builder Clear() {

1737

result = DefaultInstance;

1738

resultIsReadOnly = true;

1739

return this;

1740

}

1741

1742

public override Builder Clone() {

1743

if (resultIsReadOnly) {

1744

return new Builder(result);

1745

} else {

1746

return new Builder().MergeFrom(result);

1747

}

1748

}

1749

1750

public override pbd::MessageDescriptor DescriptorForType {

1751

get { return global::grpc.testing.StreamingInputCallResponse.Descriptor; }

1752

}

1753

1754

public override StreamingInputCallResponse DefaultInstanceForType {

1755

get { return global::grpc.testing.StreamingInputCallResponse.DefaultInstance; }

1756

}

1757

1758

public override StreamingInputCallResponse BuildPartial() {

1759

if (resultIsReadOnly) {

1760

return result;

1761

}

1762

resultIsReadOnly = true;

1763

return result.MakeReadOnly();

1764

}

1765

1766

public override Builder MergeFrom(pb::IMessage other) {

1767

if (other is StreamingInputCallResponse) {

1768

return MergeFrom((StreamingInputCallResponse) other);

1769

} else {

1770

base.MergeFrom(other);

1771

return this;

1772

}

1773

}

1774

1775

public override Builder MergeFrom(StreamingInputCallResponse other) {

1776

if (other == global::grpc.testing.StreamingInputCallResponse.DefaultInstance) return this;

1777

PrepareBuilder();

1778

if (other.HasAggregatedPayloadSize) {

1779

AggregatedPayloadSize = other.AggregatedPayloadSize;

1780

}

1781

this.MergeUnknownFields(other.UnknownFields);

1782

return this;

1783

}

1784

1785

public override Builder MergeFrom(pb::ICodedInputStream input) {

1786

return MergeFrom(input, pb::ExtensionRegistry.Empty);

1787

}

1788

1789

public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {

1790

PrepareBuilder();

1791

pb::UnknownFieldSet.Builder unknownFields = null;

1792

uint tag;

1793

string field_name;

1794

while (input.ReadTag(out tag, out field_name)) {

1795

if(tag == 0 && field_name != null) {

1796

int field_ordinal = global::System.Array.BinarySearch(_streamingInputCallResponseFieldNames, field_name, global::System.StringComparer.Ordinal);

1797

if(field_ordinal >= 0)

1798

tag = _streamingInputCallResponseFieldTags[field_ordinal];

1799

else {

1800

if (unknownFields == null) {

1801

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

1802

}

1803

ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);

1804

continue;

1805

}

1806

}

1807

switch (tag) {

1808

case 0: {

1809

throw pb::InvalidProtocolBufferException.InvalidTag();

1810

}

1811

default: {

1812

if (pb::WireFormat.IsEndGroupTag(tag)) {

1813

if (unknownFields != null) {

1814

this.UnknownFields = unknownFields.Build();

1815

}

1816

return this;

1817

}

1818

if (unknownFields == null) {

1819

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

1820

}

1821

ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);

1822

break;

1823

}

1824

case 8: {

1825

result.hasAggregatedPayloadSize = input.ReadInt32(ref result.aggregatedPayloadSize_);

1826

break;

1827

}

1828

}

1829

}

1830

1831

if (unknownFields != null) {

1832

this.UnknownFields = unknownFields.Build();

1833

}

1834

return this;

1835

}

1836

1837

1838

public bool HasAggregatedPayloadSize {

1839

get { return result.hasAggregatedPayloadSize; }

1840

}

1841

public int AggregatedPayloadSize {

1842

get { return result.AggregatedPayloadSize; }

1843

set { SetAggregatedPayloadSize(value); }

1844

}

1845

public Builder SetAggregatedPayloadSize(int value) {

1846

PrepareBuilder();

1847

result.hasAggregatedPayloadSize = true;

1848

result.aggregatedPayloadSize_ = value;

1849

return this;

1850

}

1851

public Builder ClearAggregatedPayloadSize() {

1852

PrepareBuilder();

1853

result.hasAggregatedPayloadSize = false;

1854

result.aggregatedPayloadSize_ = 0;

1855

return this;

1856

}

1857

}

1858

static StreamingInputCallResponse() {

1859

object.ReferenceEquals(global::grpc.testing.Messages.Descriptor, null);

1860

}

1861

}

1862

1863

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

1864

public sealed partial class ResponseParameters : pb::GeneratedMessage<ResponseParameters, ResponseParameters.Builder> {

1865

private ResponseParameters() { }

1866

private static readonly ResponseParameters defaultInstance = new ResponseParameters().MakeReadOnly();

1867

private static readonly string[] _responseParametersFieldNames = new string[] { "interval_us", "size" };

1868

private static readonly uint[] _responseParametersFieldTags = new uint[] { 16, 8 };

1869

public static ResponseParameters DefaultInstance {

1870

get { return defaultInstance; }

1871

}

1872

1873

public override ResponseParameters DefaultInstanceForType {

1874

get { return DefaultInstance; }

1875

}

1876

1877

protected override ResponseParameters ThisMessage {

1878

get { return this; }

1879

}

1880

1881

public static pbd::MessageDescriptor Descriptor {

1882

get { return global::grpc.testing.Messages.internal__static_grpc_testing_ResponseParameters__Descriptor; }

1883

}

1884

1885

protected override pb::FieldAccess.FieldAccessorTable<ResponseParameters, ResponseParameters.Builder> InternalFieldAccessors {

1886

get { return global::grpc.testing.Messages.internal__static_grpc_testing_ResponseParameters__FieldAccessorTable; }

1887

}

1888

1889

public const int SizeFieldNumber = 1;

1890

private bool hasSize;

1891

private int size_;

1892

public bool HasSize {

1893

get { return hasSize; }

1894

}

1895

public int Size {

1896

get { return size_; }

1897

}

1898

1899

public const int IntervalUsFieldNumber = 2;

1900

private bool hasIntervalUs;

1901

private int intervalUs_;

1902

public bool HasIntervalUs {

1903

get { return hasIntervalUs; }

1904

}

1905

public int IntervalUs {

1906

get { return intervalUs_; }

1907

}

1908

1909

public override bool IsInitialized {

1910

get {

1911

return true;

1912

}

1913

}

1914

1915

public override void WriteTo(pb::ICodedOutputStream output) {

1916

int size = SerializedSize;

1917

string[] field_names = _responseParametersFieldNames;

1918

if (hasSize) {

1919

output.WriteInt32(1, field_names[1], Size);

1920

}

1921

if (hasIntervalUs) {

1922

output.WriteInt32(2, field_names[0], IntervalUs);

1923

}

1924

UnknownFields.WriteTo(output);

1925

}

1926

1927

private int memoizedSerializedSize = -1;

1928

public override int SerializedSize {

1929

get {

1930

int size = memoizedSerializedSize;

1931

if (size != -1) return size;

1932

1933

size = 0;

1934

if (hasSize) {

1935

size += pb::CodedOutputStream.ComputeInt32Size(1, Size);

1936

}

1937

if (hasIntervalUs) {

1938

size += pb::CodedOutputStream.ComputeInt32Size(2, IntervalUs);

1939

}

1940

size += UnknownFields.SerializedSize;

1941

memoizedSerializedSize = size;

1942

return size;

1943

}

1944

}

1945

1946

public static ResponseParameters ParseFrom(pb::ByteString data) {

1947

return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();

1948

}

1949

public static ResponseParameters ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {

1950

return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();

1951

}

1952

public static ResponseParameters ParseFrom(byte[] data) {

1953

return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();

1954

}

1955

public static ResponseParameters ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {

1956

return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();

1957

}

1958

public static ResponseParameters ParseFrom(global::System.IO.Stream input) {

1959

return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();

1960

}

1961

public static ResponseParameters ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {

1962

return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();

1963

}

1964

public static ResponseParameters ParseDelimitedFrom(global::System.IO.Stream input) {

1965

return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();

1966

}

1967

public static ResponseParameters ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {

1968

return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();

1969

}

1970

public static ResponseParameters ParseFrom(pb::ICodedInputStream input) {

1971

return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();

1972

}

1973

public static ResponseParameters ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {

1974

return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();

1975

}

1976

private ResponseParameters MakeReadOnly() {

1977

return this;

1978

}

1979

1980

public static Builder CreateBuilder() { return new Builder(); }

1981

public override Builder ToBuilder() { return CreateBuilder(this); }

1982

public override Builder CreateBuilderForType() { return new Builder(); }

1983

public static Builder CreateBuilder(ResponseParameters prototype) {

1984

return new Builder(prototype);

1985

}

1986

1987

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

1988

public sealed partial class Builder : pb::GeneratedBuilder<ResponseParameters, Builder> {

1989

protected override Builder ThisBuilder {

1990

get { return this; }

1991

}

1992

public Builder() {

1993

result = DefaultInstance;

1994

resultIsReadOnly = true;

1995

}

1996

internal Builder(ResponseParameters cloneFrom) {

1997

result = cloneFrom;

1998

resultIsReadOnly = true;

1999

}

2000

2001

private bool resultIsReadOnly;

2002

private ResponseParameters result;

2003

2004

private ResponseParameters PrepareBuilder() {

2005

if (resultIsReadOnly) {

2006

ResponseParameters original = result;

2007

result = new ResponseParameters();

2008

resultIsReadOnly = false;

2009

MergeFrom(original);

2010

}

2011

return result;

2012

}

2013

2014

public override bool IsInitialized {

2015

get { return result.IsInitialized; }

2016

}

2017

2018

protected override ResponseParameters MessageBeingBuilt {

2019

get { return PrepareBuilder(); }

2020

}

2021

2022

public override Builder Clear() {

2023

result = DefaultInstance;

2024

resultIsReadOnly = true;

2025

return this;

2026

}

2027

2028

public override Builder Clone() {

2029

if (resultIsReadOnly) {

2030

return new Builder(result);

2031

} else {

2032

return new Builder().MergeFrom(result);

2033

}

2034

}

2035

2036

public override pbd::MessageDescriptor DescriptorForType {

2037

get { return global::grpc.testing.ResponseParameters.Descriptor; }

2038

}

2039

2040

public override ResponseParameters DefaultInstanceForType {

2041

get { return global::grpc.testing.ResponseParameters.DefaultInstance; }

2042

}

2043

2044

public override ResponseParameters BuildPartial() {

2045

if (resultIsReadOnly) {

2046

return result;

2047

}

2048

resultIsReadOnly = true;

2049

return result.MakeReadOnly();

2050

}

2051

2052

public override Builder MergeFrom(pb::IMessage other) {

2053

if (other is ResponseParameters) {

2054

return MergeFrom((ResponseParameters) other);

2055

} else {

2056

base.MergeFrom(other);

2057

return this;

2058

}

2059

}

2060

2061

public override Builder MergeFrom(ResponseParameters other) {

2062

if (other == global::grpc.testing.ResponseParameters.DefaultInstance) return this;

2063

PrepareBuilder();

2064

if (other.HasSize) {

2065

Size = other.Size;

2066

}

2067

if (other.HasIntervalUs) {

2068

IntervalUs = other.IntervalUs;

2069

}

2070

this.MergeUnknownFields(other.UnknownFields);

2071

return this;

2072

}

2073

2074

public override Builder MergeFrom(pb::ICodedInputStream input) {

2075

return MergeFrom(input, pb::ExtensionRegistry.Empty);

2076

}

2077

2078

public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {

2079

PrepareBuilder();

2080

pb::UnknownFieldSet.Builder unknownFields = null;

2081

uint tag;

2082

string field_name;

2083

while (input.ReadTag(out tag, out field_name)) {

2084

if(tag == 0 && field_name != null) {

2085

int field_ordinal = global::System.Array.BinarySearch(_responseParametersFieldNames, field_name, global::System.StringComparer.Ordinal);

2086

if(field_ordinal >= 0)

2087

tag = _responseParametersFieldTags[field_ordinal];

2088

else {

2089

if (unknownFields == null) {

2090

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

2091

}

2092

ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);

2093

continue;

2094

}

2095

}

2096

switch (tag) {

2097

case 0: {

2098

throw pb::InvalidProtocolBufferException.InvalidTag();

2099

}

2100

default: {

2101

if (pb::WireFormat.IsEndGroupTag(tag)) {

2102

if (unknownFields != null) {

2103

this.UnknownFields = unknownFields.Build();

2104

}

2105

return this;

2106

}

2107

if (unknownFields == null) {

2108

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

2109

}

2110

ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);

2111

break;

2112

}

2113

case 8: {

2114

result.hasSize = input.ReadInt32(ref result.size_);

2115

break;

2116

}

2117

case 16: {

2118

result.hasIntervalUs = input.ReadInt32(ref result.intervalUs_);

2119

break;

2120

}

2121

}

2122

}

2123

2124

if (unknownFields != null) {

2125

this.UnknownFields = unknownFields.Build();

2126

}

2127

return this;

2128

}

2129

2130

2131

public bool HasSize {

2132

get { return result.hasSize; }

2133

}

2134

public int Size {

2135

get { return result.Size; }

2136

set { SetSize(value); }

2137

}

2138

public Builder SetSize(int value) {

2139

PrepareBuilder();

2140

result.hasSize = true;

2141

result.size_ = value;

2142

return this;

2143

}

2144

public Builder ClearSize() {

2145

PrepareBuilder();

2146

result.hasSize = false;

2147

result.size_ = 0;

2148

return this;

2149

}

2150

2151

public bool HasIntervalUs {

2152

get { return result.hasIntervalUs; }

2153

}

2154

public int IntervalUs {

2155

get { return result.IntervalUs; }

2156

set { SetIntervalUs(value); }

2157

}

2158

public Builder SetIntervalUs(int value) {

2159

PrepareBuilder();

2160

result.hasIntervalUs = true;

2161

result.intervalUs_ = value;

2162

return this;

2163

}

2164

public Builder ClearIntervalUs() {

2165

PrepareBuilder();

2166

result.hasIntervalUs = false;

2167

result.intervalUs_ = 0;

2168

return this;

2169

}

2170

}

2171

static ResponseParameters() {

2172

object.ReferenceEquals(global::grpc.testing.Messages.Descriptor, null);

2173

}

2174

}

2175

2176

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

2177

public sealed partial class StreamingOutputCallRequest : pb::GeneratedMessage<StreamingOutputCallRequest, StreamingOutputCallRequest.Builder> {

2178

private StreamingOutputCallRequest() { }

2179

private static readonly StreamingOutputCallRequest defaultInstance = new StreamingOutputCallRequest().MakeReadOnly();

2180

private static readonly string[] _streamingOutputCallRequestFieldNames = new string[] { "payload", "response_parameters", "response_type" };

2181

private static readonly uint[] _streamingOutputCallRequestFieldTags = new uint[] { 26, 18, 8 };

2182

public static StreamingOutputCallRequest DefaultInstance {

2183

get { return defaultInstance; }

2184

}

2185

2186

public override StreamingOutputCallRequest DefaultInstanceForType {

2187

get { return DefaultInstance; }

2188

}

2189

2190

protected override StreamingOutputCallRequest ThisMessage {

2191

get { return this; }

2192

}

2193

2194

public static pbd::MessageDescriptor Descriptor {

2195

get { return global::grpc.testing.Messages.internal__static_grpc_testing_StreamingOutputCallRequest__Descriptor; }

2196

}

2197

2198

protected override pb::FieldAccess.FieldAccessorTable<StreamingOutputCallRequest, StreamingOutputCallRequest.Builder> InternalFieldAccessors {

2199

get { return global::grpc.testing.Messages.internal__static_grpc_testing_StreamingOutputCallRequest__FieldAccessorTable; }

2200

}

2201

2202

public const int ResponseTypeFieldNumber = 1;

2203

private bool hasResponseType;

2204

private global::grpc.testing.PayloadType responseType_ = global::grpc.testing.PayloadType.COMPRESSABLE;

2205

public bool HasResponseType {

2206

get { return hasResponseType; }

2207

}

2208

public global::grpc.testing.PayloadType ResponseType {

2209

get { return responseType_; }

2210

}

2211

2212

public const int ResponseParametersFieldNumber = 2;

2213

private pbc::PopsicleList<global::grpc.testing.ResponseParameters> responseParameters_ = new pbc::PopsicleList<global::grpc.testing.ResponseParameters>();

2214

public scg::IList<global::grpc.testing.ResponseParameters> ResponseParametersList {

2215

get { return responseParameters_; }

2216

}

2217

public int ResponseParametersCount {

2218

get { return responseParameters_.Count; }

2219

}

2220

public global::grpc.testing.ResponseParameters GetResponseParameters(int index) {

2221

return responseParameters_[index];

2222

}

2223

2224

public const int PayloadFieldNumber = 3;

2225

private bool hasPayload;

2226

private global::grpc.testing.Payload payload_;

2227

public bool HasPayload {

2228

get { return hasPayload; }

2229

}

2230

public global::grpc.testing.Payload Payload {

2231

get { return payload_ ?? global::grpc.testing.Payload.DefaultInstance; }

2232

}

2233

2234

public override bool IsInitialized {

2235

get {

2236

return true;

2237

}

2238

}

2239

2240

public override void WriteTo(pb::ICodedOutputStream output) {

2241

int size = SerializedSize;

2242

string[] field_names = _streamingOutputCallRequestFieldNames;

2243

if (hasResponseType) {

2244

output.WriteEnum(1, field_names[2], (int) ResponseType, ResponseType);

2245

}

2246

if (responseParameters_.Count > 0) {

2247

output.WriteMessageArray(2, field_names[1], responseParameters_);

2248

}

2249

if (hasPayload) {

2250

output.WriteMessage(3, field_names[0], Payload);

2251

}

2252

UnknownFields.WriteTo(output);

2253

}

2254

2255

private int memoizedSerializedSize = -1;

2256

public override int SerializedSize {

2257

get {

2258

int size = memoizedSerializedSize;

2259

if (size != -1) return size;

2260

2261

size = 0;

2262

if (hasResponseType) {

2263

size += pb::CodedOutputStream.ComputeEnumSize(1, (int) ResponseType);

2264

}

2265

foreach (global::grpc.testing.ResponseParameters element in ResponseParametersList) {

2266

size += pb::CodedOutputStream.ComputeMessageSize(2, element);

2267

}

2268

if (hasPayload) {

2269

size += pb::CodedOutputStream.ComputeMessageSize(3, Payload);

2270

}

2271

size += UnknownFields.SerializedSize;

2272

memoizedSerializedSize = size;

2273

return size;

2274

}

2275

}

2276

2277

public static StreamingOutputCallRequest ParseFrom(pb::ByteString data) {

2278

return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();

2279

}

2280

public static StreamingOutputCallRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {

2281

return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();

2282

}

2283

public static StreamingOutputCallRequest ParseFrom(byte[] data) {

2284

return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();

2285

}

2286

public static StreamingOutputCallRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {

2287

return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();

2288

}

2289

public static StreamingOutputCallRequest ParseFrom(global::System.IO.Stream input) {

2290

return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();

2291

}

2292

public static StreamingOutputCallRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {

2293

return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();

2294

}

2295

public static StreamingOutputCallRequest ParseDelimitedFrom(global::System.IO.Stream input) {

2296

return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();

2297

}

2298

public static StreamingOutputCallRequest ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {

2299

return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();

2300

}

2301

public static StreamingOutputCallRequest ParseFrom(pb::ICodedInputStream input) {

2302

return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();

2303

}

2304

public static StreamingOutputCallRequest ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {

2305

return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();

2306

}

2307

private StreamingOutputCallRequest MakeReadOnly() {

2308

responseParameters_.MakeReadOnly();

2309

return this;

2310

}

2311

2312

public static Builder CreateBuilder() { return new Builder(); }

2313

public override Builder ToBuilder() { return CreateBuilder(this); }

2314

public override Builder CreateBuilderForType() { return new Builder(); }

2315

public static Builder CreateBuilder(StreamingOutputCallRequest prototype) {

2316

return new Builder(prototype);

2317

}

2318

2319

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

2320

public sealed partial class Builder : pb::GeneratedBuilder<StreamingOutputCallRequest, Builder> {

2321

protected override Builder ThisBuilder {

2322

get { return this; }

2323

}

2324

public Builder() {

2325

result = DefaultInstance;

2326

resultIsReadOnly = true;

2327

}

2328

internal Builder(StreamingOutputCallRequest cloneFrom) {

2329

result = cloneFrom;

2330

resultIsReadOnly = true;

2331

}

2332

2333

private bool resultIsReadOnly;

2334

private StreamingOutputCallRequest result;

2335

2336

private StreamingOutputCallRequest PrepareBuilder() {

2337

if (resultIsReadOnly) {

2338

StreamingOutputCallRequest original = result;

2339

result = new StreamingOutputCallRequest();

2340

resultIsReadOnly = false;

2341

MergeFrom(original);

2342

}

2343

return result;

2344

}

2345

2346

public override bool IsInitialized {

2347

get { return result.IsInitialized; }

2348

}

2349

2350

protected override StreamingOutputCallRequest MessageBeingBuilt {

2351

get { return PrepareBuilder(); }

2352

}

2353

2354

public override Builder Clear() {

2355

result = DefaultInstance;

2356

resultIsReadOnly = true;

2357

return this;

2358

}

2359

2360

public override Builder Clone() {

2361

if (resultIsReadOnly) {

2362

return new Builder(result);

2363

} else {

2364

return new Builder().MergeFrom(result);

2365

}

2366

}

2367

2368

public override pbd::MessageDescriptor DescriptorForType {

2369

get { return global::grpc.testing.StreamingOutputCallRequest.Descriptor; }

2370

}

2371

2372

public override StreamingOutputCallRequest DefaultInstanceForType {

2373

get { return global::grpc.testing.StreamingOutputCallRequest.DefaultInstance; }

2374

}

2375

2376

public override StreamingOutputCallRequest BuildPartial() {

2377

if (resultIsReadOnly) {

2378

return result;

2379

}

2380

resultIsReadOnly = true;

2381

return result.MakeReadOnly();

2382

}

2383

2384

public override Builder MergeFrom(pb::IMessage other) {

2385

if (other is StreamingOutputCallRequest) {

2386

return MergeFrom((StreamingOutputCallRequest) other);

2387

} else {

2388

base.MergeFrom(other);

2389

return this;

2390

}

2391

}

2392

2393

public override Builder MergeFrom(StreamingOutputCallRequest other) {

2394

if (other == global::grpc.testing.StreamingOutputCallRequest.DefaultInstance) return this;

2395

PrepareBuilder();

2396

if (other.HasResponseType) {

2397

ResponseType = other.ResponseType;

2398

}

2399

if (other.responseParameters_.Count != 0) {

2400

result.responseParameters_.Add(other.responseParameters_);

2401

}

2402

if (other.HasPayload) {

2403

MergePayload(other.Payload);

2404

}

2405

this.MergeUnknownFields(other.UnknownFields);

2406

return this;

2407

}

2408

2409

public override Builder MergeFrom(pb::ICodedInputStream input) {

2410

return MergeFrom(input, pb::ExtensionRegistry.Empty);

2411

}

2412

2413

public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {

2414

PrepareBuilder();

2415

pb::UnknownFieldSet.Builder unknownFields = null;

2416

uint tag;

2417

string field_name;

2418

while (input.ReadTag(out tag, out field_name)) {

2419

if(tag == 0 && field_name != null) {

2420

int field_ordinal = global::System.Array.BinarySearch(_streamingOutputCallRequestFieldNames, field_name, global::System.StringComparer.Ordinal);

2421

if(field_ordinal >= 0)

2422

tag = _streamingOutputCallRequestFieldTags[field_ordinal];

2423

else {

2424

if (unknownFields == null) {

2425

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

2426

}

2427

ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);

2428

continue;

2429

}

2430

}

2431

switch (tag) {

2432

case 0: {

2433

throw pb::InvalidProtocolBufferException.InvalidTag();

2434

}

2435

default: {

2436

if (pb::WireFormat.IsEndGroupTag(tag)) {

2437

if (unknownFields != null) {

2438

this.UnknownFields = unknownFields.Build();

2439

}

2440

return this;

2441

}

2442

if (unknownFields == null) {

2443

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

2444

}

2445

ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);

2446

break;

2447

}

2448

case 8: {

2449

object unknown;

2450

if(input.ReadEnum(ref result.responseType_, out unknown)) {

2451

result.hasResponseType = true;

2452

} else if(unknown is int) {

2453

if (unknownFields == null) {

2454

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

2455

}

2456

unknownFields.MergeVarintField(1, (ulong)(int)unknown);

2457

}

2458

break;

2459

}

2460

case 18: {

2461

input.ReadMessageArray(tag, field_name, result.responseParameters_, global::grpc.testing.ResponseParameters.DefaultInstance, extensionRegistry);

2462

break;

2463

}

2464

case 26: {

2465

global::grpc.testing.Payload.Builder subBuilder = global::grpc.testing.Payload.CreateBuilder();

2466

if (result.hasPayload) {

2467

subBuilder.MergeFrom(Payload);

2468

}

2469

input.ReadMessage(subBuilder, extensionRegistry);

2470

Payload = subBuilder.BuildPartial();

2471

break;

2472

}

2473

}

2474

}

2475

2476

if (unknownFields != null) {

2477

this.UnknownFields = unknownFields.Build();

2478

}

2479

return this;

2480

}

2481

2482

2483

public bool HasResponseType {

2484

get { return result.hasResponseType; }

2485

}

2486

public global::grpc.testing.PayloadType ResponseType {

2487

get { return result.ResponseType; }

2488

set { SetResponseType(value); }

2489

}

2490

public Builder SetResponseType(global::grpc.testing.PayloadType value) {

2491

PrepareBuilder();

2492

result.hasResponseType = true;

2493

result.responseType_ = value;

2494

return this;

2495

}

2496

public Builder ClearResponseType() {

2497

PrepareBuilder();

2498

result.hasResponseType = false;

2499

result.responseType_ = global::grpc.testing.PayloadType.COMPRESSABLE;

2500

return this;

2501

}

2502

2503

public pbc::IPopsicleList<global::grpc.testing.ResponseParameters> ResponseParametersList {

2504

get { return PrepareBuilder().responseParameters_; }

2505

}

2506

public int ResponseParametersCount {

2507

get { return result.ResponseParametersCount; }

2508

}

2509

public global::grpc.testing.ResponseParameters GetResponseParameters(int index) {

2510

return result.GetResponseParameters(index);

2511

}

2512

public Builder SetResponseParameters(int index, global::grpc.testing.ResponseParameters value) {

2513

pb::ThrowHelper.ThrowIfNull(value, "value");

2514

PrepareBuilder();

2515

result.responseParameters_[index] = value;

2516

return this;

2517

}

2518

public Builder SetResponseParameters(int index, global::grpc.testing.ResponseParameters.Builder builderForValue) {

2519

pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");

2520

PrepareBuilder();

2521

result.responseParameters_[index] = builderForValue.Build();

2522

return this;

2523

}

2524

public Builder AddResponseParameters(global::grpc.testing.ResponseParameters value) {

2525

pb::ThrowHelper.ThrowIfNull(value, "value");

2526

PrepareBuilder();

2527

result.responseParameters_.Add(value);

2528

return this;

2529

}

2530

public Builder AddResponseParameters(global::grpc.testing.ResponseParameters.Builder builderForValue) {

2531

pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");

2532

PrepareBuilder();

2533

result.responseParameters_.Add(builderForValue.Build());

2534

return this;

2535

}

2536

public Builder AddRangeResponseParameters(scg::IEnumerable<global::grpc.testing.ResponseParameters> values) {

2537

PrepareBuilder();

2538

result.responseParameters_.Add(values);

2539

return this;

2540

}

2541

public Builder ClearResponseParameters() {

2542

PrepareBuilder();

2543

result.responseParameters_.Clear();

2544

return this;

2545

}

2546

2547

public bool HasPayload {

2548

get { return result.hasPayload; }

2549

}

2550

public global::grpc.testing.Payload Payload {

2551

get { return result.Payload; }

2552

set { SetPayload(value); }

2553

}

2554

public Builder SetPayload(global::grpc.testing.Payload value) {

2555

pb::ThrowHelper.ThrowIfNull(value, "value");

2556

PrepareBuilder();

2557

result.hasPayload = true;

2558

result.payload_ = value;

2559

return this;

2560

}

2561

public Builder SetPayload(global::grpc.testing.Payload.Builder builderForValue) {

2562

pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");

2563

PrepareBuilder();

2564

result.hasPayload = true;

2565

result.payload_ = builderForValue.Build();

2566

return this;

2567

}

2568

public Builder MergePayload(global::grpc.testing.Payload value) {

2569

pb::ThrowHelper.ThrowIfNull(value, "value");

2570

PrepareBuilder();

2571

if (result.hasPayload &&

2572

result.payload_ != global::grpc.testing.Payload.DefaultInstance) {

2573

result.payload_ = global::grpc.testing.Payload.CreateBuilder(result.payload_).MergeFrom(value).BuildPartial();

2574

} else {

2575

result.payload_ = value;

2576

}

2577

result.hasPayload = true;

2578

return this;

2579

}

2580

public Builder ClearPayload() {

2581

PrepareBuilder();

2582

result.hasPayload = false;

2583

result.payload_ = null;

2584

return this;

2585

}

2586

}

2587

static StreamingOutputCallRequest() {

2588

object.ReferenceEquals(global::grpc.testing.Messages.Descriptor, null);

2589

}

2590

}

2591

2592

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

2593

public sealed partial class StreamingOutputCallResponse : pb::GeneratedMessage<StreamingOutputCallResponse, StreamingOutputCallResponse.Builder> {

2594

private StreamingOutputCallResponse() { }

2595

private static readonly StreamingOutputCallResponse defaultInstance = new StreamingOutputCallResponse().MakeReadOnly();

2596

private static readonly string[] _streamingOutputCallResponseFieldNames = new string[] { "payload" };

2597

private static readonly uint[] _streamingOutputCallResponseFieldTags = new uint[] { 10 };

2598

public static StreamingOutputCallResponse DefaultInstance {

2599

get { return defaultInstance; }

2600

}

2601

2602

public override StreamingOutputCallResponse DefaultInstanceForType {

2603

get { return DefaultInstance; }

2604

}

2605

2606

protected override StreamingOutputCallResponse ThisMessage {

2607

get { return this; }

2608

}

2609

2610

public static pbd::MessageDescriptor Descriptor {

2611

get { return global::grpc.testing.Messages.internal__static_grpc_testing_StreamingOutputCallResponse__Descriptor; }

2612

}

2613

2614

protected override pb::FieldAccess.FieldAccessorTable<StreamingOutputCallResponse, StreamingOutputCallResponse.Builder> InternalFieldAccessors {

2615

get { return global::grpc.testing.Messages.internal__static_grpc_testing_StreamingOutputCallResponse__FieldAccessorTable; }

2616

}

2617

2618

public const int PayloadFieldNumber = 1;

2619

private bool hasPayload;

2620

private global::grpc.testing.Payload payload_;

2621

public bool HasPayload {

2622

get { return hasPayload; }

2623

}

2624

public global::grpc.testing.Payload Payload {

2625

get { return payload_ ?? global::grpc.testing.Payload.DefaultInstance; }

2626

}

2627

2628

public override bool IsInitialized {

2629

get {

2630

return true;

2631

}

2632

}

2633

2634

public override void WriteTo(pb::ICodedOutputStream output) {

2635

int size = SerializedSize;

2636

string[] field_names = _streamingOutputCallResponseFieldNames;

2637

if (hasPayload) {

2638

output.WriteMessage(1, field_names[0], Payload);

2639

}

2640

UnknownFields.WriteTo(output);

2641

}

2642

2643

private int memoizedSerializedSize = -1;

2644

public override int SerializedSize {

2645

get {

2646

int size = memoizedSerializedSize;

2647

if (size != -1) return size;

2648

2649

size = 0;

2650

if (hasPayload) {

2651

size += pb::CodedOutputStream.ComputeMessageSize(1, Payload);

2652

}

2653

size += UnknownFields.SerializedSize;

2654

memoizedSerializedSize = size;

2655

return size;

2656

}

2657

}

2658

2659

public static StreamingOutputCallResponse ParseFrom(pb::ByteString data) {

2660

return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();

2661

}

2662

public static StreamingOutputCallResponse ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {

2663

return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();

2664

}

2665

public static StreamingOutputCallResponse ParseFrom(byte[] data) {

2666

return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();

2667

}

2668

public static StreamingOutputCallResponse ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {

2669

return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();

2670

}

2671

public static StreamingOutputCallResponse ParseFrom(global::System.IO.Stream input) {

2672

return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();

2673

}

2674

public static StreamingOutputCallResponse ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {

2675

return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();

2676

}

2677

public static StreamingOutputCallResponse ParseDelimitedFrom(global::System.IO.Stream input) {

2678

return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();

2679

}

2680

public static StreamingOutputCallResponse ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {

2681

return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();

2682

}

2683

public static StreamingOutputCallResponse ParseFrom(pb::ICodedInputStream input) {

2684

return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();

2685

}

2686

public static StreamingOutputCallResponse ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {

2687

return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();

2688

}

2689

private StreamingOutputCallResponse MakeReadOnly() {

2690

return this;

2691

}

2692

2693

public static Builder CreateBuilder() { return new Builder(); }

2694

public override Builder ToBuilder() { return CreateBuilder(this); }

2695

public override Builder CreateBuilderForType() { return new Builder(); }

2696

public static Builder CreateBuilder(StreamingOutputCallResponse prototype) {

2697

return new Builder(prototype);

2698

}

2699

2700

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

2701

public sealed partial class Builder : pb::GeneratedBuilder<StreamingOutputCallResponse, Builder> {

2702

protected override Builder ThisBuilder {

2703

get { return this; }

2704

}

2705

public Builder() {

2706

result = DefaultInstance;

2707

resultIsReadOnly = true;

2708

}

2709

internal Builder(StreamingOutputCallResponse cloneFrom) {

2710

result = cloneFrom;

2711

resultIsReadOnly = true;

2712

}

2713

2714

private bool resultIsReadOnly;

2715

private StreamingOutputCallResponse result;

2716

2717

private StreamingOutputCallResponse PrepareBuilder() {

2718

if (resultIsReadOnly) {

2719

StreamingOutputCallResponse original = result;

2720

result = new StreamingOutputCallResponse();

2721

resultIsReadOnly = false;

2722

MergeFrom(original);

2723

}

2724

return result;

2725

}

2726

2727

public override bool IsInitialized {

2728

get { return result.IsInitialized; }

2729

}

2730

2731

protected override StreamingOutputCallResponse MessageBeingBuilt {

2732

get { return PrepareBuilder(); }

2733

}

2734

2735

public override Builder Clear() {

2736

result = DefaultInstance;

2737

resultIsReadOnly = true;

2738

return this;

2739

}

2740

2741

public override Builder Clone() {

2742

if (resultIsReadOnly) {

2743

return new Builder(result);

2744

} else {

2745

return new Builder().MergeFrom(result);

2746

}

2747

}

2748

2749

public override pbd::MessageDescriptor DescriptorForType {

2750

get { return global::grpc.testing.StreamingOutputCallResponse.Descriptor; }

2751

}

2752

2753

public override StreamingOutputCallResponse DefaultInstanceForType {

2754

get { return global::grpc.testing.StreamingOutputCallResponse.DefaultInstance; }

2755

}

2756

2757

public override StreamingOutputCallResponse BuildPartial() {

2758

if (resultIsReadOnly) {

2759

return result;

2760

}

2761

resultIsReadOnly = true;

2762

return result.MakeReadOnly();

2763

}

2764

2765

public override Builder MergeFrom(pb::IMessage other) {

2766

if (other is StreamingOutputCallResponse) {

2767

return MergeFrom((StreamingOutputCallResponse) other);

2768

} else {

2769

base.MergeFrom(other);

2770

return this;

2771

}

2772

}

2773

2774

public override Builder MergeFrom(StreamingOutputCallResponse other) {

2775

if (other == global::grpc.testing.StreamingOutputCallResponse.DefaultInstance) return this;

2776

PrepareBuilder();

2777

if (other.HasPayload) {

2778

MergePayload(other.Payload);

2779

}

2780

this.MergeUnknownFields(other.UnknownFields);

2781

return this;

2782

}

2783

2784

public override Builder MergeFrom(pb::ICodedInputStream input) {

2785

return MergeFrom(input, pb::ExtensionRegistry.Empty);

2786

}

2787

2788

public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {

2789

PrepareBuilder();

2790

pb::UnknownFieldSet.Builder unknownFields = null;

2791

uint tag;

2792

string field_name;

2793

while (input.ReadTag(out tag, out field_name)) {

2794

if(tag == 0 && field_name != null) {

2795

int field_ordinal = global::System.Array.BinarySearch(_streamingOutputCallResponseFieldNames, field_name, global::System.StringComparer.Ordinal);

2796

if(field_ordinal >= 0)

2797

tag = _streamingOutputCallResponseFieldTags[field_ordinal];

2798

else {

2799

if (unknownFields == null) {

2800

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

2801

}

2802

ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);

2803

continue;

2804

}

2805

}

2806

switch (tag) {

2807

case 0: {

2808

throw pb::InvalidProtocolBufferException.InvalidTag();

2809

}

2810

default: {

2811

if (pb::WireFormat.IsEndGroupTag(tag)) {

2812

if (unknownFields != null) {

2813

this.UnknownFields = unknownFields.Build();

2814

}

2815

return this;

2816

}

2817

if (unknownFields == null) {

2818

unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);

2819

}

2820

ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);

2821

break;

2822

}

2823

case 10: {

2824

global::grpc.testing.Payload.Builder subBuilder = global::grpc.testing.Payload.CreateBuilder();

2825

if (result.hasPayload) {

2826

subBuilder.MergeFrom(Payload);

2827

}

2828

input.ReadMessage(subBuilder, extensionRegistry);

2829

Payload = subBuilder.BuildPartial();

2830

break;

2831

}

2832

}

2833

}

2834

2835

if (unknownFields != null) {

2836

this.UnknownFields = unknownFields.Build();

2837

}

2838

return this;

2839

}

2840

2841

2842

public bool HasPayload {

2843

get { return result.hasPayload; }

2844

}

2845

public global::grpc.testing.Payload Payload {

2846

get { return result.Payload; }

2847

set { SetPayload(value); }

2848

}

2849

public Builder SetPayload(global::grpc.testing.Payload value) {

2850

pb::ThrowHelper.ThrowIfNull(value, "value");

2851

PrepareBuilder();

2852

result.hasPayload = true;

2853

result.payload_ = value;

2854

return this;

2855

}

2856

public Builder SetPayload(global::grpc.testing.Payload.Builder builderForValue) {

2857

pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");

2858

PrepareBuilder();

2859

result.hasPayload = true;

2860

result.payload_ = builderForValue.Build();

2861

return this;

2862

}

2863

public Builder MergePayload(global::grpc.testing.Payload value) {

2864

pb::ThrowHelper.ThrowIfNull(value, "value");

2865

PrepareBuilder();

2866

if (result.hasPayload &&

2867

result.payload_ != global::grpc.testing.Payload.DefaultInstance) {

2868

result.payload_ = global::grpc.testing.Payload.CreateBuilder(result.payload_).MergeFrom(value).BuildPartial();

2869

} else {

2870

result.payload_ = value;

2871

}

2872

result.hasPayload = true;

2873

return this;

2874

}

2875

public Builder ClearPayload() {

2876

PrepareBuilder();

2877

result.hasPayload = false;

2878

result.payload_ = null;

2879

return this;

2880

}

2881

}

2882

static StreamingOutputCallResponse() {

2883

object.ReferenceEquals(global::grpc.testing.Messages.Descriptor, null);

2884

}

2885

}

2886

2887

#endregion

2888

2889

}

2890

2891

#endregion Designer generated code

Older »