// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: messages.proto

#import "GPBProtocolBuffers_RuntimeSupport.h"

#import "Messages.pbobjc.h"

#pragma mark - RMTMessagesRoot

@implementation RMTMessagesRoot

@end

static GPBFileDescriptor *RMTMessagesRoot_FileDescriptor(void) {
  // This is called by +initialize so there is no need to worry
  // about thread safety of the singleton.
  static GPBFileDescriptor *descriptor = NULL;
  if (!descriptor) {
    descriptor = [[GPBFileDescriptor alloc] initWithPackage:@"grpc.testing"
                                                     syntax:GPBFileSyntaxProto3];
  }
  return descriptor;
}

#pragma mark - Enum RMTPayloadType

GPBEnumDescriptor *RMTPayloadType_EnumDescriptor(void) {
  static GPBEnumDescriptor *descriptor = NULL;
  if (!descriptor) {
    static GPBMessageEnumValueDescription values[] = {
      { .name = "Compressable", .number = RMTPayloadType_Compressable },
      { .name = "Uncompressable", .number = RMTPayloadType_Uncompressable },
      { .name = "Random", .number = RMTPayloadType_Random },
    };
    descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(RMTPayloadType)
                                                   values:values
                                               valueCount:sizeof(values) / sizeof(GPBMessageEnumValueDescription)
                                             enumVerifier:RMTPayloadType_IsValidValue];
  }
  return descriptor;
}

BOOL RMTPayloadType_IsValidValue(int32_t value__) {
  switch (value__) {
    case RMTPayloadType_Compressable:
    case RMTPayloadType_Uncompressable:
    case RMTPayloadType_Random:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - RMTPayload

@implementation RMTPayload

@dynamic type;
@dynamic body;

typedef struct RMTPayload_Storage {
  uint32_t _has_storage_[1];
  RMTPayloadType type;
  NSData *body;
} RMTPayload_Storage;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "type",
        .number = RMTPayload_FieldNumber_Type,
        .hasIndex = 0,
        .flags = GPBFieldOptional | GPBFieldHasEnumDescriptor,
        .type = GPBTypeEnum,
        .offset = offsetof(RMTPayload_Storage, type),
        .defaultValue.valueEnum = RMTPayloadType_Compressable,
        .typeSpecific.enumDescFunc = RMTPayloadType_EnumDescriptor,
        .fieldOptions = NULL,
      },
      {
        .name = "body",
        .number = RMTPayload_FieldNumber_Body,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .type = GPBTypeData,
        .offset = offsetof(RMTPayload_Storage, body),
        .defaultValue.valueData = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    descriptor = [GPBDescriptor allocDescriptorForClass:[RMTPayload class]
                                              rootClass:[RMTMessagesRoot class]
                                                   file:RMTMessagesRoot_FileDescriptor()
                                                 fields:fields
                                             fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                                 oneofs:NULL
                                             oneofCount:0
                                                  enums:NULL
                                              enumCount:0
                                                 ranges:NULL
                                             rangeCount:0
                                            storageSize:sizeof(RMTPayload_Storage)
                                             wireFormat:NO];
  }
  return descriptor;
}

@end

int32_t RMTPayload_Type_RawValue(RMTPayload *message) {
  GPBDescriptor *descriptor = [RMTPayload descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:RMTPayload_FieldNumber_Type];
  return GPBGetInt32IvarWithField(message, field);
}

void SetRMTPayload_Type_RawValue(RMTPayload *message, int32_t value) {
  GPBDescriptor *descriptor = [RMTPayload descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:RMTPayload_FieldNumber_Type];
  GPBSetInt32IvarWithFieldInternal(message, field, value, descriptor.file.syntax);
}

#pragma mark - RMTSimpleRequest

@implementation RMTSimpleRequest

@dynamic responseType;
@dynamic responseSize;
@dynamic hasPayload, payload;
@dynamic fillUsername;
@dynamic fillOauthScope;

typedef struct RMTSimpleRequest_Storage {
  uint32_t _has_storage_[1];
  BOOL fillUsername;
  BOOL fillOauthScope;
  RMTPayloadType responseType;
  int32_t responseSize;
  RMTPayload *payload;
} RMTSimpleRequest_Storage;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "responseType",
        .number = RMTSimpleRequest_FieldNumber_ResponseType,
        .hasIndex = 0,
        .flags = GPBFieldOptional | GPBFieldHasEnumDescriptor,
        .type = GPBTypeEnum,
        .offset = offsetof(RMTSimpleRequest_Storage, responseType),
        .defaultValue.valueEnum = RMTPayloadType_Compressable,
        .typeSpecific.enumDescFunc = RMTPayloadType_EnumDescriptor,
        .fieldOptions = NULL,
      },
      {
        .name = "responseSize",
        .number = RMTSimpleRequest_FieldNumber_ResponseSize,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .type = GPBTypeInt32,
        .offset = offsetof(RMTSimpleRequest_Storage, responseSize),
        .defaultValue.valueInt32 = 0,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "payload",
        .number = RMTSimpleRequest_FieldNumber_Payload,
        .hasIndex = 2,
        .flags = GPBFieldOptional,
        .type = GPBTypeMessage,
        .offset = offsetof(RMTSimpleRequest_Storage, payload),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(RMTPayload),
        .fieldOptions = NULL,
      },
      {
        .name = "fillUsername",
        .number = RMTSimpleRequest_FieldNumber_FillUsername,
        .hasIndex = 3,
        .flags = GPBFieldOptional,
        .type = GPBTypeBool,
        .offset = offsetof(RMTSimpleRequest_Storage, fillUsername),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "fillOauthScope",
        .number = RMTSimpleRequest_FieldNumber_FillOauthScope,
        .hasIndex = 4,
        .flags = GPBFieldOptional,
        .type = GPBTypeBool,
        .offset = offsetof(RMTSimpleRequest_Storage, fillOauthScope),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    descriptor = [GPBDescriptor allocDescriptorForClass:[RMTSimpleRequest class]
                                              rootClass:[RMTMessagesRoot class]
                                                   file:RMTMessagesRoot_FileDescriptor()
                                                 fields:fields
                                             fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                                 oneofs:NULL
                                             oneofCount:0
                                                  enums:NULL
                                              enumCount:0
                                                 ranges:NULL
                                             rangeCount:0
                                            storageSize:sizeof(RMTSimpleRequest_Storage)
                                             wireFormat:NO];
  }
  return descriptor;
}

@end

int32_t RMTSimpleRequest_ResponseType_RawValue(RMTSimpleRequest *message) {
  GPBDescriptor *descriptor = [RMTSimpleRequest descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:RMTSimpleRequest_FieldNumber_ResponseType];
  return GPBGetInt32IvarWithField(message, field);
}

void SetRMTSimpleRequest_ResponseType_RawValue(RMTSimpleRequest *message, int32_t value) {
  GPBDescriptor *descriptor = [RMTSimpleRequest descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:RMTSimpleRequest_FieldNumber_ResponseType];
  GPBSetInt32IvarWithFieldInternal(message, field, value, descriptor.file.syntax);
}

#pragma mark - RMTSimpleResponse

@implementation RMTSimpleResponse

@dynamic hasPayload, payload;
@dynamic username;
@dynamic oauthScope;

typedef struct RMTSimpleResponse_Storage {
  uint32_t _has_storage_[1];
  RMTPayload *payload;
  NSString *username;
  NSString *oauthScope;
} RMTSimpleResponse_Storage;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "payload",
        .number = RMTSimpleResponse_FieldNumber_Payload,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .type = GPBTypeMessage,
        .offset = offsetof(RMTSimpleResponse_Storage, payload),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(RMTPayload),
        .fieldOptions = NULL,
      },
      {
        .name = "username",
        .number = RMTSimpleResponse_FieldNumber_Username,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(RMTSimpleResponse_Storage, username),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "oauthScope",
        .number = RMTSimpleResponse_FieldNumber_OauthScope,
        .hasIndex = 2,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(RMTSimpleResponse_Storage, oauthScope),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    descriptor = [GPBDescriptor allocDescriptorForClass:[RMTSimpleResponse class]
                                              rootClass:[RMTMessagesRoot class]
                                                   file:RMTMessagesRoot_FileDescriptor()
                                                 fields:fields
                                             fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                                 oneofs:NULL
                                             oneofCount:0
                                                  enums:NULL
                                              enumCount:0
                                                 ranges:NULL
                                             rangeCount:0
                                            storageSize:sizeof(RMTSimpleResponse_Storage)
                                             wireFormat:NO];
  }
  return descriptor;
}

@end

#pragma mark - RMTStreamingInputCallRequest

@implementation RMTStreamingInputCallRequest

@dynamic hasPayload, payload;

typedef struct RMTStreamingInputCallRequest_Storage {
  uint32_t _has_storage_[1];
  RMTPayload *payload;
} RMTStreamingInputCallRequest_Storage;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "payload",
        .number = RMTStreamingInputCallRequest_FieldNumber_Payload,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .type = GPBTypeMessage,
        .offset = offsetof(RMTStreamingInputCallRequest_Storage, payload),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(RMTPayload),
        .fieldOptions = NULL,
      },
    };
    descriptor = [GPBDescriptor allocDescriptorForClass:[RMTStreamingInputCallRequest class]
                                              rootClass:[RMTMessagesRoot class]
                                                   file:RMTMessagesRoot_FileDescriptor()
                                                 fields:fields
                                             fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                                 oneofs:NULL
                                             oneofCount:0
                                                  enums:NULL
                                              enumCount:0
                                                 ranges:NULL
                                             rangeCount:0
                                            storageSize:sizeof(RMTStreamingInputCallRequest_Storage)
                                             wireFormat:NO];
  }
  return descriptor;
}

@end

#pragma mark - RMTStreamingInputCallResponse

@implementation RMTStreamingInputCallResponse

@dynamic aggregatedPayloadSize;

typedef struct RMTStreamingInputCallResponse_Storage {
  uint32_t _has_storage_[1];
  int32_t aggregatedPayloadSize;
} RMTStreamingInputCallResponse_Storage;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "aggregatedPayloadSize",
        .number = RMTStreamingInputCallResponse_FieldNumber_AggregatedPayloadSize,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .type = GPBTypeInt32,
        .offset = offsetof(RMTStreamingInputCallResponse_Storage, aggregatedPayloadSize),
        .defaultValue.valueInt32 = 0,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    descriptor = [GPBDescriptor allocDescriptorForClass:[RMTStreamingInputCallResponse class]
                                              rootClass:[RMTMessagesRoot class]
                                                   file:RMTMessagesRoot_FileDescriptor()
                                                 fields:fields
                                             fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                                 oneofs:NULL
                                             oneofCount:0
                                                  enums:NULL
                                              enumCount:0
                                                 ranges:NULL
                                             rangeCount:0
                                            storageSize:sizeof(RMTStreamingInputCallResponse_Storage)
                                             wireFormat:NO];
  }
  return descriptor;
}

@end

#pragma mark - RMTResponseParameters

@implementation RMTResponseParameters

@dynamic size;
@dynamic intervalUs;

typedef struct RMTResponseParameters_Storage {
  uint32_t _has_storage_[1];
  int32_t size;
  int32_t intervalUs;
} RMTResponseParameters_Storage;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "size",
        .number = RMTResponseParameters_FieldNumber_Size,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .type = GPBTypeInt32,
        .offset = offsetof(RMTResponseParameters_Storage, size),
        .defaultValue.valueInt32 = 0,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "intervalUs",
        .number = RMTResponseParameters_FieldNumber_IntervalUs,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .type = GPBTypeInt32,
        .offset = offsetof(RMTResponseParameters_Storage, intervalUs),
        .defaultValue.valueInt32 = 0,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    descriptor = [GPBDescriptor allocDescriptorForClass:[RMTResponseParameters class]
                                              rootClass:[RMTMessagesRoot class]
                                                   file:RMTMessagesRoot_FileDescriptor()
                                                 fields:fields
                                             fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                                 oneofs:NULL
                                             oneofCount:0
                                                  enums:NULL
                                              enumCount:0
                                                 ranges:NULL
                                             rangeCount:0
                                            storageSize:sizeof(RMTResponseParameters_Storage)
                                             wireFormat:NO];
  }
  return descriptor;
}

@end

#pragma mark - RMTStreamingOutputCallRequest

@implementation RMTStreamingOutputCallRequest

@dynamic responseType;
@dynamic responseParametersArray;
@dynamic hasPayload, payload;

typedef struct RMTStreamingOutputCallRequest_Storage {
  uint32_t _has_storage_[1];
  RMTPayloadType responseType;
  NSMutableArray *responseParametersArray;
  RMTPayload *payload;
} RMTStreamingOutputCallRequest_Storage;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "responseType",
        .number = RMTStreamingOutputCallRequest_FieldNumber_ResponseType,
        .hasIndex = 0,
        .flags = GPBFieldOptional | GPBFieldHasEnumDescriptor,
        .type = GPBTypeEnum,
        .offset = offsetof(RMTStreamingOutputCallRequest_Storage, responseType),
        .defaultValue.valueEnum = RMTPayloadType_Compressable,
        .typeSpecific.enumDescFunc = RMTPayloadType_EnumDescriptor,
        .fieldOptions = NULL,
      },
      {
        .name = "responseParametersArray",
        .number = RMTStreamingOutputCallRequest_FieldNumber_ResponseParametersArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(RMTStreamingOutputCallRequest_Storage, responseParametersArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(RMTResponseParameters),
        .fieldOptions = NULL,
      },
      {
        .name = "payload",
        .number = RMTStreamingOutputCallRequest_FieldNumber_Payload,
        .hasIndex = 2,
        .flags = GPBFieldOptional,
        .type = GPBTypeMessage,
        .offset = offsetof(RMTStreamingOutputCallRequest_Storage, payload),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(RMTPayload),
        .fieldOptions = NULL,
      },
    };
    descriptor = [GPBDescriptor allocDescriptorForClass:[RMTStreamingOutputCallRequest class]
                                              rootClass:[RMTMessagesRoot class]
                                                   file:RMTMessagesRoot_FileDescriptor()
                                                 fields:fields
                                             fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                                 oneofs:NULL
                                             oneofCount:0
                                                  enums:NULL
                                              enumCount:0
                                                 ranges:NULL
                                             rangeCount:0
                                            storageSize:sizeof(RMTStreamingOutputCallRequest_Storage)
                                             wireFormat:NO];
  }
  return descriptor;
}

@end

int32_t RMTStreamingOutputCallRequest_ResponseType_RawValue(RMTStreamingOutputCallRequest *message) {
  GPBDescriptor *descriptor = [RMTStreamingOutputCallRequest descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:RMTStreamingOutputCallRequest_FieldNumber_ResponseType];
  return GPBGetInt32IvarWithField(message, field);
}

void SetRMTStreamingOutputCallRequest_ResponseType_RawValue(RMTStreamingOutputCallRequest *message, int32_t value) {
  GPBDescriptor *descriptor = [RMTStreamingOutputCallRequest descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:RMTStreamingOutputCallRequest_FieldNumber_ResponseType];
  GPBSetInt32IvarWithFieldInternal(message, field, value, descriptor.file.syntax);
}

#pragma mark - RMTStreamingOutputCallResponse

@implementation RMTStreamingOutputCallResponse

@dynamic hasPayload, payload;

typedef struct RMTStreamingOutputCallResponse_Storage {
  uint32_t _has_storage_[1];
  RMTPayload *payload;
} RMTStreamingOutputCallResponse_Storage;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "payload",
        .number = RMTStreamingOutputCallResponse_FieldNumber_Payload,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .type = GPBTypeMessage,
        .offset = offsetof(RMTStreamingOutputCallResponse_Storage, payload),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(RMTPayload),
        .fieldOptions = NULL,
      },
    };
    descriptor = [GPBDescriptor allocDescriptorForClass:[RMTStreamingOutputCallResponse class]
                                              rootClass:[RMTMessagesRoot class]
                                                   file:RMTMessagesRoot_FileDescriptor()
                                                 fields:fields
                                             fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                                 oneofs:NULL
                                             oneofCount:0
                                                  enums:NULL
                                              enumCount:0
                                                 ranges:NULL
                                             rangeCount:0
                                            storageSize:sizeof(RMTStreamingOutputCallResponse_Storage)
                                             wireFormat:NO];
  }
  return descriptor;
}

@end

