Merge branch 'master' of github.com:google/grpc into private_build

1 files changed, 1435 insertions, 0 deletions

diff --git a/src/objective-c/examples/Sample/RouteGuideClient/Route_guide.pb.m b/src/objective-c/examples/Sample/RouteGuideClient/Route_guide.pb.m
new file mode 100644
index 0000000000..63cdd00206
--- /dev/null
+++ b/src/objective-c/examples/Sample/RouteGuideClient/Route_guide.pb.m
@@ -0,0 +1,1435 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+
+#import "Route_guide.pb.h"
+// @@protoc_insertion_point(imports)
+
+@implementation RGDRouteGuideRoot
+static PBExtensionRegistry* extensionRegistry = nil;
++ (PBExtensionRegistry*) extensionRegistry {
+  return extensionRegistry;
+}
+
++ (void) initialize {
+  if (self == [RGDRouteGuideRoot class]) {
+    PBMutableExtensionRegistry* registry = [PBMutableExtensionRegistry registry];
+    [self registerAllExtensions:registry];
+    [ObjectivecDescriptorRoot registerAllExtensions:registry];
+    extensionRegistry = registry;
+  }
+}
++ (void) registerAllExtensions:(PBMutableExtensionRegistry*) registry {
+}
+@end
+
+@interface RGDPoint ()
+@property SInt32 latitude;
+@property SInt32 longitude;
+@end
+
+@implementation RGDPoint
+
+- (BOOL) hasLatitude {
+  return !!hasLatitude_;
+}
+- (void) setHasLatitude:(BOOL) _value_ {
+  hasLatitude_ = !!_value_;
+}
+@synthesize latitude;
+- (BOOL) hasLongitude {
+  return !!hasLongitude_;
+}
+- (void) setHasLongitude:(BOOL) _value_ {
+  hasLongitude_ = !!_value_;
+}
+@synthesize longitude;
+- (instancetype) init {
+  if ((self = [super init])) {
+    self.latitude = 0;
+    self.longitude = 0;
+  }
+  return self;
+}
+static RGDPoint* defaultRGDPointInstance = nil;
++ (void) initialize {
+  if (self == [RGDPoint class]) {
+    defaultRGDPointInstance = [[RGDPoint alloc] init];
+  }
+}
++ (instancetype) defaultInstance {
+  return defaultRGDPointInstance;
+}
+- (instancetype) defaultInstance {
+  return defaultRGDPointInstance;
+}
+- (BOOL) isInitialized {
+  return YES;
+}
+- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
+  if (self.hasLatitude) {
+    [output writeInt32:1 value:self.latitude];
+  }
+  if (self.hasLongitude) {
+    [output writeInt32:2 value:self.longitude];
+  }
+  [self.unknownFields writeToCodedOutputStream:output];
+}
+- (SInt32) serializedSize {
+  __block SInt32 size_ = memoizedSerializedSize;
+  if (size_ != -1) {
+    return size_;
+  }
+
+  size_ = 0;
+  if (self.hasLatitude) {
+    size_ += computeInt32Size(1, self.latitude);
+  }
+  if (self.hasLongitude) {
+    size_ += computeInt32Size(2, self.longitude);
+  }
+  size_ += self.unknownFields.serializedSize;
+  memoizedSerializedSize = size_;
+  return size_;
+}
++ (RGDPoint*) parseFromData:(NSData*) data {
+  return (RGDPoint*)[[[RGDPoint builder] mergeFromData:data] build];
+}
++ (RGDPoint*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  return (RGDPoint*)[[[RGDPoint builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
+}
++ (RGDPoint*) parseFromInputStream:(NSInputStream*) input {
+  return (RGDPoint*)[[[RGDPoint builder] mergeFromInputStream:input] build];
+}
++ (RGDPoint*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  return (RGDPoint*)[[[RGDPoint builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
+}
++ (RGDPoint*) parseFromCodedInputStream:(PBCodedInputStream*) input {
+  return (RGDPoint*)[[[RGDPoint builder] mergeFromCodedInputStream:input] build];
+}
++ (RGDPoint*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  return (RGDPoint*)[[[RGDPoint builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
+}
++ (RGDPointBuilder*) builder {
+  return [[RGDPointBuilder alloc] init];
+}
++ (RGDPointBuilder*) builderWithPrototype:(RGDPoint*) prototype {
+  return [[RGDPoint builder] mergeFrom:prototype];
+}
+- (RGDPointBuilder*) builder {
+  return [RGDPoint builder];
+}
+- (RGDPointBuilder*) toBuilder {
+  return [RGDPoint builderWithPrototype:self];
+}
+- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
+  if (self.hasLatitude) {
+    [output appendFormat:@"%@%@: %@\n", indent, @"latitude", [NSNumber numberWithInteger:self.latitude]];
+  }
+  if (self.hasLongitude) {
+    [output appendFormat:@"%@%@: %@\n", indent, @"longitude", [NSNumber numberWithInteger:self.longitude]];
+  }
+  [self.unknownFields writeDescriptionTo:output withIndent:indent];
+}
+- (BOOL) isEqual:(id)other {
+  if (other == self) {
+    return YES;
+  }
+  if (![other isKindOfClass:[RGDPoint class]]) {
+    return NO;
+  }
+  RGDPoint *otherMessage = other;
+  return
+      self.hasLatitude == otherMessage.hasLatitude &&
+      (!self.hasLatitude || self.latitude == otherMessage.latitude) &&
+      self.hasLongitude == otherMessage.hasLongitude &&
+      (!self.hasLongitude || self.longitude == otherMessage.longitude) &&
+      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
+}
+- (NSUInteger) hash {
+  __block NSUInteger hashCode = 7;
+  if (self.hasLatitude) {
+    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.latitude] hash];
+  }
+  if (self.hasLongitude) {
+    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.longitude] hash];
+  }
+  hashCode = hashCode * 31 + [self.unknownFields hash];
+  return hashCode;
+}
+@end
+
+@interface RGDPointBuilder()
+@property (strong) RGDPoint* resultPoint;
+@end
+
+@implementation RGDPointBuilder
+@synthesize resultPoint;
+- (instancetype) init {
+  if ((self = [super init])) {
+    self.resultPoint = [[RGDPoint alloc] init];
+  }
+  return self;
+}
+- (PBGeneratedMessage*) internalGetResult {
+  return resultPoint;
+}
+- (RGDPointBuilder*) clear {
+  self.resultPoint = [[RGDPoint alloc] init];
+  return self;
+}
+- (RGDPointBuilder*) clone {
+  return [RGDPoint builderWithPrototype:resultPoint];
+}
+- (RGDPoint*) defaultInstance {
+  return [RGDPoint defaultInstance];
+}
+- (RGDPoint*) build {
+  [self checkInitialized];
+  return [self buildPartial];
+}
+- (RGDPoint*) buildPartial {
+  RGDPoint* returnMe = resultPoint;
+  self.resultPoint = nil;
+  return returnMe;
+}
+- (RGDPointBuilder*) mergeFrom:(RGDPoint*) other {
+  if (other == [RGDPoint defaultInstance]) {
+    return self;
+  }
+  if (other.hasLatitude) {
+    [self setLatitude:other.latitude];
+  }
+  if (other.hasLongitude) {
+    [self setLongitude:other.longitude];
+  }
+  [self mergeUnknownFields:other.unknownFields];
+  return self;
+}
+- (RGDPointBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
+  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
+}
+- (RGDPointBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
+  while (YES) {
+    SInt32 tag = [input readTag];
+    switch (tag) {
+      case 0:
+        [self setUnknownFields:[unknownFields build]];
+        return self;
+      default: {
+        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
+          [self setUnknownFields:[unknownFields build]];
+          return self;
+        }
+        break;
+      }
+      case 8: {
+        [self setLatitude:[input readInt32]];
+        break;
+      }
+      case 16: {
+        [self setLongitude:[input readInt32]];
+        break;
+      }
+    }
+  }
+}
+- (BOOL) hasLatitude {
+  return resultPoint.hasLatitude;
+}
+- (SInt32) latitude {
+  return resultPoint.latitude;
+}
+- (RGDPointBuilder*) setLatitude:(SInt32) value {
+  resultPoint.hasLatitude = YES;
+  resultPoint.latitude = value;
+  return self;
+}
+- (RGDPointBuilder*) clearLatitude {
+  resultPoint.hasLatitude = NO;
+  resultPoint.latitude = 0;
+  return self;
+}
+- (BOOL) hasLongitude {
+  return resultPoint.hasLongitude;
+}
+- (SInt32) longitude {
+  return resultPoint.longitude;
+}
+- (RGDPointBuilder*) setLongitude:(SInt32) value {
+  resultPoint.hasLongitude = YES;
+  resultPoint.longitude = value;
+  return self;
+}
+- (RGDPointBuilder*) clearLongitude {
+  resultPoint.hasLongitude = NO;
+  resultPoint.longitude = 0;
+  return self;
+}
+@end
+
+@interface RGDRectangle ()
+@property (strong) RGDPoint* lo;
+@property (strong) RGDPoint* hi;
+@end
+
+@implementation RGDRectangle
+
+- (BOOL) hasLo {
+  return !!hasLo_;
+}
+- (void) setHasLo:(BOOL) _value_ {
+  hasLo_ = !!_value_;
+}
+@synthesize lo;
+- (BOOL) hasHi {
+  return !!hasHi_;
+}
+- (void) setHasHi:(BOOL) _value_ {
+  hasHi_ = !!_value_;
+}
+@synthesize hi;
+- (instancetype) init {
+  if ((self = [super init])) {
+    self.lo = [RGDPoint defaultInstance];
+    self.hi = [RGDPoint defaultInstance];
+  }
+  return self;
+}
+static RGDRectangle* defaultRGDRectangleInstance = nil;
++ (void) initialize {
+  if (self == [RGDRectangle class]) {
+    defaultRGDRectangleInstance = [[RGDRectangle alloc] init];
+  }
+}
++ (instancetype) defaultInstance {
+  return defaultRGDRectangleInstance;
+}
+- (instancetype) defaultInstance {
+  return defaultRGDRectangleInstance;
+}
+- (BOOL) isInitialized {
+  return YES;
+}
+- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
+  if (self.hasLo) {
+    [output writeMessage:1 value:self.lo];
+  }
+  if (self.hasHi) {
+    [output writeMessage:2 value:self.hi];
+  }
+  [self.unknownFields writeToCodedOutputStream:output];
+}
+- (SInt32) serializedSize {
+  __block SInt32 size_ = memoizedSerializedSize;
+  if (size_ != -1) {
+    return size_;
+  }
+
+  size_ = 0;
+  if (self.hasLo) {
+    size_ += computeMessageSize(1, self.lo);
+  }
+  if (self.hasHi) {
+    size_ += computeMessageSize(2, self.hi);
+  }
+  size_ += self.unknownFields.serializedSize;
+  memoizedSerializedSize = size_;
+  return size_;
+}
++ (RGDRectangle*) parseFromData:(NSData*) data {
+  return (RGDRectangle*)[[[RGDRectangle builder] mergeFromData:data] build];
+}
++ (RGDRectangle*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  return (RGDRectangle*)[[[RGDRectangle builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
+}
++ (RGDRectangle*) parseFromInputStream:(NSInputStream*) input {
+  return (RGDRectangle*)[[[RGDRectangle builder] mergeFromInputStream:input] build];
+}
++ (RGDRectangle*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  return (RGDRectangle*)[[[RGDRectangle builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
+}
++ (RGDRectangle*) parseFromCodedInputStream:(PBCodedInputStream*) input {
+  return (RGDRectangle*)[[[RGDRectangle builder] mergeFromCodedInputStream:input] build];
+}
++ (RGDRectangle*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  return (RGDRectangle*)[[[RGDRectangle builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
+}
++ (RGDRectangleBuilder*) builder {
+  return [[RGDRectangleBuilder alloc] init];
+}
++ (RGDRectangleBuilder*) builderWithPrototype:(RGDRectangle*) prototype {
+  return [[RGDRectangle builder] mergeFrom:prototype];
+}
+- (RGDRectangleBuilder*) builder {
+  return [RGDRectangle builder];
+}
+- (RGDRectangleBuilder*) toBuilder {
+  return [RGDRectangle builderWithPrototype:self];
+}
+- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
+  if (self.hasLo) {
+    [output appendFormat:@"%@%@ {\n", indent, @"lo"];
+    [self.lo writeDescriptionTo:output
+                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
+    [output appendFormat:@"%@}\n", indent];
+  }
+  if (self.hasHi) {
+    [output appendFormat:@"%@%@ {\n", indent, @"hi"];
+    [self.hi writeDescriptionTo:output
+                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
+    [output appendFormat:@"%@}\n", indent];
+  }
+  [self.unknownFields writeDescriptionTo:output withIndent:indent];
+}
+- (BOOL) isEqual:(id)other {
+  if (other == self) {
+    return YES;
+  }
+  if (![other isKindOfClass:[RGDRectangle class]]) {
+    return NO;
+  }
+  RGDRectangle *otherMessage = other;
+  return
+      self.hasLo == otherMessage.hasLo &&
+      (!self.hasLo || [self.lo isEqual:otherMessage.lo]) &&
+      self.hasHi == otherMessage.hasHi &&
+      (!self.hasHi || [self.hi isEqual:otherMessage.hi]) &&
+      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
+}
+- (NSUInteger) hash {
+  __block NSUInteger hashCode = 7;
+  if (self.hasLo) {
+    hashCode = hashCode * 31 + [self.lo hash];
+  }
+  if (self.hasHi) {
+    hashCode = hashCode * 31 + [self.hi hash];
+  }
+  hashCode = hashCode * 31 + [self.unknownFields hash];
+  return hashCode;
+}
+@end
+
+@interface RGDRectangleBuilder()
+@property (strong) RGDRectangle* resultRectangle;
+@end
+
+@implementation RGDRectangleBuilder
+@synthesize resultRectangle;
+- (instancetype) init {
+  if ((self = [super init])) {
+    self.resultRectangle = [[RGDRectangle alloc] init];
+  }
+  return self;
+}
+- (PBGeneratedMessage*) internalGetResult {
+  return resultRectangle;
+}
+- (RGDRectangleBuilder*) clear {
+  self.resultRectangle = [[RGDRectangle alloc] init];
+  return self;
+}
+- (RGDRectangleBuilder*) clone {
+  return [RGDRectangle builderWithPrototype:resultRectangle];
+}
+- (RGDRectangle*) defaultInstance {
+  return [RGDRectangle defaultInstance];
+}
+- (RGDRectangle*) build {
+  [self checkInitialized];
+  return [self buildPartial];
+}
+- (RGDRectangle*) buildPartial {
+  RGDRectangle* returnMe = resultRectangle;
+  self.resultRectangle = nil;
+  return returnMe;
+}
+- (RGDRectangleBuilder*) mergeFrom:(RGDRectangle*) other {
+  if (other == [RGDRectangle defaultInstance]) {
+    return self;
+  }
+  if (other.hasLo) {
+    [self mergeLo:other.lo];
+  }
+  if (other.hasHi) {
+    [self mergeHi:other.hi];
+  }
+  [self mergeUnknownFields:other.unknownFields];
+  return self;
+}
+- (RGDRectangleBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
+  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
+}
+- (RGDRectangleBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
+  while (YES) {
+    SInt32 tag = [input readTag];
+    switch (tag) {
+      case 0:
+        [self setUnknownFields:[unknownFields build]];
+        return self;
+      default: {
+        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
+          [self setUnknownFields:[unknownFields build]];
+          return self;
+        }
+        break;
+      }
+      case 10: {
+        RGDPointBuilder* subBuilder = [RGDPoint builder];
+        if (self.hasLo) {
+          [subBuilder mergeFrom:self.lo];
+        }
+        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
+        [self setLo:[subBuilder buildPartial]];
+        break;
+      }
+      case 18: {
+        RGDPointBuilder* subBuilder = [RGDPoint builder];
+        if (self.hasHi) {
+          [subBuilder mergeFrom:self.hi];
+        }
+        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
+        [self setHi:[subBuilder buildPartial]];
+        break;
+      }
+    }
+  }
+}
+- (BOOL) hasLo {
+  return resultRectangle.hasLo;
+}
+- (RGDPoint*) lo {
+  return resultRectangle.lo;
+}
+- (RGDRectangleBuilder*) setLo:(RGDPoint*) value {
+  resultRectangle.hasLo = YES;
+  resultRectangle.lo = value;
+  return self;
+}
+- (RGDRectangleBuilder*) setLoBuilder:(RGDPointBuilder*) builderForValue {
+  return [self setLo:[builderForValue build]];
+}
+- (RGDRectangleBuilder*) mergeLo:(RGDPoint*) value {
+  if (resultRectangle.hasLo &&
+      resultRectangle.lo != [RGDPoint defaultInstance]) {
+    resultRectangle.lo =
+      [[[RGDPoint builderWithPrototype:resultRectangle.lo] mergeFrom:value] buildPartial];
+  } else {
+    resultRectangle.lo = value;
+  }
+  resultRectangle.hasLo = YES;
+  return self;
+}
+- (RGDRectangleBuilder*) clearLo {
+  resultRectangle.hasLo = NO;
+  resultRectangle.lo = [RGDPoint defaultInstance];
+  return self;
+}
+- (BOOL) hasHi {
+  return resultRectangle.hasHi;
+}
+- (RGDPoint*) hi {
+  return resultRectangle.hi;
+}
+- (RGDRectangleBuilder*) setHi:(RGDPoint*) value {
+  resultRectangle.hasHi = YES;
+  resultRectangle.hi = value;
+  return self;
+}
+- (RGDRectangleBuilder*) setHiBuilder:(RGDPointBuilder*) builderForValue {
+  return [self setHi:[builderForValue build]];
+}
+- (RGDRectangleBuilder*) mergeHi:(RGDPoint*) value {
+  if (resultRectangle.hasHi &&
+      resultRectangle.hi != [RGDPoint defaultInstance]) {
+    resultRectangle.hi =
+      [[[RGDPoint builderWithPrototype:resultRectangle.hi] mergeFrom:value] buildPartial];
+  } else {
+    resultRectangle.hi = value;
+  }
+  resultRectangle.hasHi = YES;
+  return self;
+}
+- (RGDRectangleBuilder*) clearHi {
+  resultRectangle.hasHi = NO;
+  resultRectangle.hi = [RGDPoint defaultInstance];
+  return self;
+}
+@end
+
+@interface RGDFeature ()
+@property (strong) NSString* name;
+@property (strong) RGDPoint* location;
+@end
+
+@implementation RGDFeature
+
+- (BOOL) hasName {
+  return !!hasName_;
+}
+- (void) setHasName:(BOOL) _value_ {
+  hasName_ = !!_value_;
+}
+@synthesize name;
+- (BOOL) hasLocation {
+  return !!hasLocation_;
+}
+- (void) setHasLocation:(BOOL) _value_ {
+  hasLocation_ = !!_value_;
+}
+@synthesize location;
+- (instancetype) init {
+  if ((self = [super init])) {
+    self.name = @"";
+    self.location = [RGDPoint defaultInstance];
+  }
+  return self;
+}
+static RGDFeature* defaultRGDFeatureInstance = nil;
++ (void) initialize {
+  if (self == [RGDFeature class]) {
+    defaultRGDFeatureInstance = [[RGDFeature alloc] init];
+  }
+}
++ (instancetype) defaultInstance {
+  return defaultRGDFeatureInstance;
+}
+- (instancetype) defaultInstance {
+  return defaultRGDFeatureInstance;
+}
+- (BOOL) isInitialized {
+  return YES;
+}
+- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
+  if (self.hasName) {
+    [output writeString:1 value:self.name];
+  }
+  if (self.hasLocation) {
+    [output writeMessage:2 value:self.location];
+  }
+  [self.unknownFields writeToCodedOutputStream:output];
+}
+- (SInt32) serializedSize {
+  __block SInt32 size_ = memoizedSerializedSize;
+  if (size_ != -1) {
+    return size_;
+  }
+
+  size_ = 0;
+  if (self.hasName) {
+    size_ += computeStringSize(1, self.name);
+  }
+  if (self.hasLocation) {
+    size_ += computeMessageSize(2, self.location);
+  }
+  size_ += self.unknownFields.serializedSize;
+  memoizedSerializedSize = size_;
+  return size_;
+}
++ (RGDFeature*) parseFromData:(NSData*) data {
+  return (RGDFeature*)[[[RGDFeature builder] mergeFromData:data] build];
+}
++ (RGDFeature*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  return (RGDFeature*)[[[RGDFeature builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
+}
++ (RGDFeature*) parseFromInputStream:(NSInputStream*) input {
+  return (RGDFeature*)[[[RGDFeature builder] mergeFromInputStream:input] build];
+}
++ (RGDFeature*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  return (RGDFeature*)[[[RGDFeature builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
+}
++ (RGDFeature*) parseFromCodedInputStream:(PBCodedInputStream*) input {
+  return (RGDFeature*)[[[RGDFeature builder] mergeFromCodedInputStream:input] build];
+}
++ (RGDFeature*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  return (RGDFeature*)[[[RGDFeature builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
+}
++ (RGDFeatureBuilder*) builder {
+  return [[RGDFeatureBuilder alloc] init];
+}
++ (RGDFeatureBuilder*) builderWithPrototype:(RGDFeature*) prototype {
+  return [[RGDFeature builder] mergeFrom:prototype];
+}
+- (RGDFeatureBuilder*) builder {
+  return [RGDFeature builder];
+}
+- (RGDFeatureBuilder*) toBuilder {
+  return [RGDFeature builderWithPrototype:self];
+}
+- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
+  if (self.hasName) {
+    [output appendFormat:@"%@%@: %@\n", indent, @"name", self.name];
+  }
+  if (self.hasLocation) {
+    [output appendFormat:@"%@%@ {\n", indent, @"location"];
+    [self.location writeDescriptionTo:output
+                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
+    [output appendFormat:@"%@}\n", indent];
+  }
+  [self.unknownFields writeDescriptionTo:output withIndent:indent];
+}
+- (BOOL) isEqual:(id)other {
+  if (other == self) {
+    return YES;
+  }
+  if (![other isKindOfClass:[RGDFeature class]]) {
+    return NO;
+  }
+  RGDFeature *otherMessage = other;
+  return
+      self.hasName == otherMessage.hasName &&
+      (!self.hasName || [self.name isEqual:otherMessage.name]) &&
+      self.hasLocation == otherMessage.hasLocation &&
+      (!self.hasLocation || [self.location isEqual:otherMessage.location]) &&
+      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
+}
+- (NSUInteger) hash {
+  __block NSUInteger hashCode = 7;
+  if (self.hasName) {
+    hashCode = hashCode * 31 + [self.name hash];
+  }
+  if (self.hasLocation) {
+    hashCode = hashCode * 31 + [self.location hash];
+  }
+  hashCode = hashCode * 31 + [self.unknownFields hash];
+  return hashCode;
+}
+@end
+
+@interface RGDFeatureBuilder()
+@property (strong) RGDFeature* resultFeature;
+@end
+
+@implementation RGDFeatureBuilder
+@synthesize resultFeature;
+- (instancetype) init {
+  if ((self = [super init])) {
+    self.resultFeature = [[RGDFeature alloc] init];
+  }
+  return self;
+}
+- (PBGeneratedMessage*) internalGetResult {
+  return resultFeature;
+}
+- (RGDFeatureBuilder*) clear {
+  self.resultFeature = [[RGDFeature alloc] init];
+  return self;
+}
+- (RGDFeatureBuilder*) clone {
+  return [RGDFeature builderWithPrototype:resultFeature];
+}
+- (RGDFeature*) defaultInstance {
+  return [RGDFeature defaultInstance];
+}
+- (RGDFeature*) build {
+  [self checkInitialized];
+  return [self buildPartial];
+}
+- (RGDFeature*) buildPartial {
+  RGDFeature* returnMe = resultFeature;
+  self.resultFeature = nil;
+  return returnMe;
+}
+- (RGDFeatureBuilder*) mergeFrom:(RGDFeature*) other {
+  if (other == [RGDFeature defaultInstance]) {
+    return self;
+  }
+  if (other.hasName) {
+    [self setName:other.name];
+  }
+  if (other.hasLocation) {
+    [self mergeLocation:other.location];
+  }
+  [self mergeUnknownFields:other.unknownFields];
+  return self;
+}
+- (RGDFeatureBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
+  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
+}
+- (RGDFeatureBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
+  while (YES) {
+    SInt32 tag = [input readTag];
+    switch (tag) {
+      case 0:
+        [self setUnknownFields:[unknownFields build]];
+        return self;
+      default: {
+        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
+          [self setUnknownFields:[unknownFields build]];
+          return self;
+        }
+        break;
+      }
+      case 10: {
+        [self setName:[input readString]];
+        break;
+      }
+      case 18: {
+        RGDPointBuilder* subBuilder = [RGDPoint builder];
+        if (self.hasLocation) {
+          [subBuilder mergeFrom:self.location];
+        }
+        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
+        [self setLocation:[subBuilder buildPartial]];
+        break;
+      }
+    }
+  }
+}
+- (BOOL) hasName {
+  return resultFeature.hasName;
+}
+- (NSString*) name {
+  return resultFeature.name;
+}
+- (RGDFeatureBuilder*) setName:(NSString*) value {
+  resultFeature.hasName = YES;
+  resultFeature.name = value;
+  return self;
+}
+- (RGDFeatureBuilder*) clearName {
+  resultFeature.hasName = NO;
+  resultFeature.name = @"";
+  return self;
+}
+- (BOOL) hasLocation {
+  return resultFeature.hasLocation;
+}
+- (RGDPoint*) location {
+  return resultFeature.location;
+}
+- (RGDFeatureBuilder*) setLocation:(RGDPoint*) value {
+  resultFeature.hasLocation = YES;
+  resultFeature.location = value;
+  return self;
+}
+- (RGDFeatureBuilder*) setLocationBuilder:(RGDPointBuilder*) builderForValue {
+  return [self setLocation:[builderForValue build]];
+}
+- (RGDFeatureBuilder*) mergeLocation:(RGDPoint*) value {
+  if (resultFeature.hasLocation &&
+      resultFeature.location != [RGDPoint defaultInstance]) {
+    resultFeature.location =
+      [[[RGDPoint builderWithPrototype:resultFeature.location] mergeFrom:value] buildPartial];
+  } else {
+    resultFeature.location = value;
+  }
+  resultFeature.hasLocation = YES;
+  return self;
+}
+- (RGDFeatureBuilder*) clearLocation {
+  resultFeature.hasLocation = NO;
+  resultFeature.location = [RGDPoint defaultInstance];
+  return self;
+}
+@end
+
+@interface RGDRouteNote ()
+@property (strong) RGDPoint* location;
+@property (strong) NSString* message;
+@end
+
+@implementation RGDRouteNote
+
+- (BOOL) hasLocation {
+  return !!hasLocation_;
+}
+- (void) setHasLocation:(BOOL) _value_ {
+  hasLocation_ = !!_value_;
+}
+@synthesize location;
+- (BOOL) hasMessage {
+  return !!hasMessage_;
+}
+- (void) setHasMessage:(BOOL) _value_ {
+  hasMessage_ = !!_value_;
+}
+@synthesize message;
+- (instancetype) init {
+  if ((self = [super init])) {
+    self.location = [RGDPoint defaultInstance];
+    self.message = @"";
+  }
+  return self;
+}
+static RGDRouteNote* defaultRGDRouteNoteInstance = nil;
++ (void) initialize {
+  if (self == [RGDRouteNote class]) {
+    defaultRGDRouteNoteInstance = [[RGDRouteNote alloc] init];
+  }
+}
++ (instancetype) defaultInstance {
+  return defaultRGDRouteNoteInstance;
+}
+- (instancetype) defaultInstance {
+  return defaultRGDRouteNoteInstance;
+}
+- (BOOL) isInitialized {
+  return YES;
+}
+- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
+  if (self.hasLocation) {
+    [output writeMessage:1 value:self.location];
+  }
+  if (self.hasMessage) {
+    [output writeString:2 value:self.message];
+  }
+  [self.unknownFields writeToCodedOutputStream:output];
+}
+- (SInt32) serializedSize {
+  __block SInt32 size_ = memoizedSerializedSize;
+  if (size_ != -1) {
+    return size_;
+  }
+
+  size_ = 0;
+  if (self.hasLocation) {
+    size_ += computeMessageSize(1, self.location);
+  }
+  if (self.hasMessage) {
+    size_ += computeStringSize(2, self.message);
+  }
+  size_ += self.unknownFields.serializedSize;
+  memoizedSerializedSize = size_;
+  return size_;
+}
++ (RGDRouteNote*) parseFromData:(NSData*) data {
+  return (RGDRouteNote*)[[[RGDRouteNote builder] mergeFromData:data] build];
+}
++ (RGDRouteNote*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  return (RGDRouteNote*)[[[RGDRouteNote builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
+}
++ (RGDRouteNote*) parseFromInputStream:(NSInputStream*) input {
+  return (RGDRouteNote*)[[[RGDRouteNote builder] mergeFromInputStream:input] build];
+}
++ (RGDRouteNote*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  return (RGDRouteNote*)[[[RGDRouteNote builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
+}
++ (RGDRouteNote*) parseFromCodedInputStream:(PBCodedInputStream*) input {
+  return (RGDRouteNote*)[[[RGDRouteNote builder] mergeFromCodedInputStream:input] build];
+}
++ (RGDRouteNote*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  return (RGDRouteNote*)[[[RGDRouteNote builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
+}
++ (RGDRouteNoteBuilder*) builder {
+  return [[RGDRouteNoteBuilder alloc] init];
+}
++ (RGDRouteNoteBuilder*) builderWithPrototype:(RGDRouteNote*) prototype {
+  return [[RGDRouteNote builder] mergeFrom:prototype];
+}
+- (RGDRouteNoteBuilder*) builder {
+  return [RGDRouteNote builder];
+}
+- (RGDRouteNoteBuilder*) toBuilder {
+  return [RGDRouteNote builderWithPrototype:self];
+}
+- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
+  if (self.hasLocation) {
+    [output appendFormat:@"%@%@ {\n", indent, @"location"];
+    [self.location writeDescriptionTo:output
+                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
+    [output appendFormat:@"%@}\n", indent];
+  }
+  if (self.hasMessage) {
+    [output appendFormat:@"%@%@: %@\n", indent, @"message", self.message];
+  }
+  [self.unknownFields writeDescriptionTo:output withIndent:indent];
+}
+- (BOOL) isEqual:(id)other {
+  if (other == self) {
+    return YES;
+  }
+  if (![other isKindOfClass:[RGDRouteNote class]]) {
+    return NO;
+  }
+  RGDRouteNote *otherMessage = other;
+  return
+      self.hasLocation == otherMessage.hasLocation &&
+      (!self.hasLocation || [self.location isEqual:otherMessage.location]) &&
+      self.hasMessage == otherMessage.hasMessage &&
+      (!self.hasMessage || [self.message isEqual:otherMessage.message]) &&
+      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
+}
+- (NSUInteger) hash {
+  __block NSUInteger hashCode = 7;
+  if (self.hasLocation) {
+    hashCode = hashCode * 31 + [self.location hash];
+  }
+  if (self.hasMessage) {
+    hashCode = hashCode * 31 + [self.message hash];
+  }
+  hashCode = hashCode * 31 + [self.unknownFields hash];
+  return hashCode;
+}
+@end
+
+@interface RGDRouteNoteBuilder()
+@property (strong) RGDRouteNote* resultRouteNote;
+@end
+
+@implementation RGDRouteNoteBuilder
+@synthesize resultRouteNote;
+- (instancetype) init {
+  if ((self = [super init])) {
+    self.resultRouteNote = [[RGDRouteNote alloc] init];
+  }
+  return self;
+}
+- (PBGeneratedMessage*) internalGetResult {
+  return resultRouteNote;
+}
+- (RGDRouteNoteBuilder*) clear {
+  self.resultRouteNote = [[RGDRouteNote alloc] init];
+  return self;
+}
+- (RGDRouteNoteBuilder*) clone {
+  return [RGDRouteNote builderWithPrototype:resultRouteNote];
+}
+- (RGDRouteNote*) defaultInstance {
+  return [RGDRouteNote defaultInstance];
+}
+- (RGDRouteNote*) build {
+  [self checkInitialized];
+  return [self buildPartial];
+}
+- (RGDRouteNote*) buildPartial {
+  RGDRouteNote* returnMe = resultRouteNote;
+  self.resultRouteNote = nil;
+  return returnMe;
+}
+- (RGDRouteNoteBuilder*) mergeFrom:(RGDRouteNote*) other {
+  if (other == [RGDRouteNote defaultInstance]) {
+    return self;
+  }
+  if (other.hasLocation) {
+    [self mergeLocation:other.location];
+  }
+  if (other.hasMessage) {
+    [self setMessage:other.message];
+  }
+  [self mergeUnknownFields:other.unknownFields];
+  return self;
+}
+- (RGDRouteNoteBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
+  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
+}
+- (RGDRouteNoteBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
+  while (YES) {
+    SInt32 tag = [input readTag];
+    switch (tag) {
+      case 0:
+        [self setUnknownFields:[unknownFields build]];
+        return self;
+      default: {
+        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
+          [self setUnknownFields:[unknownFields build]];
+          return self;
+        }
+        break;
+      }
+      case 10: {
+        RGDPointBuilder* subBuilder = [RGDPoint builder];
+        if (self.hasLocation) {
+          [subBuilder mergeFrom:self.location];
+        }
+        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
+        [self setLocation:[subBuilder buildPartial]];
+        break;
+      }
+      case 18: {
+        [self setMessage:[input readString]];
+        break;
+      }
+    }
+  }
+}
+- (BOOL) hasLocation {
+  return resultRouteNote.hasLocation;
+}
+- (RGDPoint*) location {
+  return resultRouteNote.location;
+}
+- (RGDRouteNoteBuilder*) setLocation:(RGDPoint*) value {
+  resultRouteNote.hasLocation = YES;
+  resultRouteNote.location = value;
+  return self;
+}
+- (RGDRouteNoteBuilder*) setLocationBuilder:(RGDPointBuilder*) builderForValue {
+  return [self setLocation:[builderForValue build]];
+}
+- (RGDRouteNoteBuilder*) mergeLocation:(RGDPoint*) value {
+  if (resultRouteNote.hasLocation &&
+      resultRouteNote.location != [RGDPoint defaultInstance]) {
+    resultRouteNote.location =
+      [[[RGDPoint builderWithPrototype:resultRouteNote.location] mergeFrom:value] buildPartial];
+  } else {
+    resultRouteNote.location = value;
+  }
+  resultRouteNote.hasLocation = YES;
+  return self;
+}
+- (RGDRouteNoteBuilder*) clearLocation {
+  resultRouteNote.hasLocation = NO;
+  resultRouteNote.location = [RGDPoint defaultInstance];
+  return self;
+}
+- (BOOL) hasMessage {
+  return resultRouteNote.hasMessage;
+}
+- (NSString*) message {
+  return resultRouteNote.message;
+}
+- (RGDRouteNoteBuilder*) setMessage:(NSString*) value {
+  resultRouteNote.hasMessage = YES;
+  resultRouteNote.message = value;
+  return self;
+}
+- (RGDRouteNoteBuilder*) clearMessage {
+  resultRouteNote.hasMessage = NO;
+  resultRouteNote.message = @"";
+  return self;
+}
+@end
+
+@interface RGDRouteSummary ()
+@property SInt32 pointCount;
+@property SInt32 featureCount;
+@property SInt32 distance;
+@property SInt32 elapsedTime;
+@end
+
+@implementation RGDRouteSummary
+
+- (BOOL) hasPointCount {
+  return !!hasPointCount_;
+}
+- (void) setHasPointCount:(BOOL) _value_ {
+  hasPointCount_ = !!_value_;
+}
+@synthesize pointCount;
+- (BOOL) hasFeatureCount {
+  return !!hasFeatureCount_;
+}
+- (void) setHasFeatureCount:(BOOL) _value_ {
+  hasFeatureCount_ = !!_value_;
+}
+@synthesize featureCount;
+- (BOOL) hasDistance {
+  return !!hasDistance_;
+}
+- (void) setHasDistance:(BOOL) _value_ {
+  hasDistance_ = !!_value_;
+}
+@synthesize distance;
+- (BOOL) hasElapsedTime {
+  return !!hasElapsedTime_;
+}
+- (void) setHasElapsedTime:(BOOL) _value_ {
+  hasElapsedTime_ = !!_value_;
+}
+@synthesize elapsedTime;
+- (instancetype) init {
+  if ((self = [super init])) {
+    self.pointCount = 0;
+    self.featureCount = 0;
+    self.distance = 0;
+    self.elapsedTime = 0;
+  }
+  return self;
+}
+static RGDRouteSummary* defaultRGDRouteSummaryInstance = nil;
++ (void) initialize {
+  if (self == [RGDRouteSummary class]) {
+    defaultRGDRouteSummaryInstance = [[RGDRouteSummary alloc] init];
+  }
+}
++ (instancetype) defaultInstance {
+  return defaultRGDRouteSummaryInstance;
+}
+- (instancetype) defaultInstance {
+  return defaultRGDRouteSummaryInstance;
+}
+- (BOOL) isInitialized {
+  return YES;
+}
+- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
+  if (self.hasPointCount) {
+    [output writeInt32:1 value:self.pointCount];
+  }
+  if (self.hasFeatureCount) {
+    [output writeInt32:2 value:self.featureCount];
+  }
+  if (self.hasDistance) {
+    [output writeInt32:3 value:self.distance];
+  }
+  if (self.hasElapsedTime) {
+    [output writeInt32:4 value:self.elapsedTime];
+  }
+  [self.unknownFields writeToCodedOutputStream:output];
+}
+- (SInt32) serializedSize {
+  __block SInt32 size_ = memoizedSerializedSize;
+  if (size_ != -1) {
+    return size_;
+  }
+
+  size_ = 0;
+  if (self.hasPointCount) {
+    size_ += computeInt32Size(1, self.pointCount);
+  }
+  if (self.hasFeatureCount) {
+    size_ += computeInt32Size(2, self.featureCount);
+  }
+  if (self.hasDistance) {
+    size_ += computeInt32Size(3, self.distance);
+  }
+  if (self.hasElapsedTime) {
+    size_ += computeInt32Size(4, self.elapsedTime);
+  }
+  size_ += self.unknownFields.serializedSize;
+  memoizedSerializedSize = size_;
+  return size_;
+}
++ (RGDRouteSummary*) parseFromData:(NSData*) data {
+  return (RGDRouteSummary*)[[[RGDRouteSummary builder] mergeFromData:data] build];
+}
++ (RGDRouteSummary*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  return (RGDRouteSummary*)[[[RGDRouteSummary builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
+}
++ (RGDRouteSummary*) parseFromInputStream:(NSInputStream*) input {
+  return (RGDRouteSummary*)[[[RGDRouteSummary builder] mergeFromInputStream:input] build];
+}
++ (RGDRouteSummary*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  return (RGDRouteSummary*)[[[RGDRouteSummary builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
+}
++ (RGDRouteSummary*) parseFromCodedInputStream:(PBCodedInputStream*) input {
+  return (RGDRouteSummary*)[[[RGDRouteSummary builder] mergeFromCodedInputStream:input] build];
+}
++ (RGDRouteSummary*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  return (RGDRouteSummary*)[[[RGDRouteSummary builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
+}
++ (RGDRouteSummaryBuilder*) builder {
+  return [[RGDRouteSummaryBuilder alloc] init];
+}
++ (RGDRouteSummaryBuilder*) builderWithPrototype:(RGDRouteSummary*) prototype {
+  return [[RGDRouteSummary builder] mergeFrom:prototype];
+}
+- (RGDRouteSummaryBuilder*) builder {
+  return [RGDRouteSummary builder];
+}
+- (RGDRouteSummaryBuilder*) toBuilder {
+  return [RGDRouteSummary builderWithPrototype:self];
+}
+- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
+  if (self.hasPointCount) {
+    [output appendFormat:@"%@%@: %@\n", indent, @"pointCount", [NSNumber numberWithInteger:self.pointCount]];
+  }
+  if (self.hasFeatureCount) {
+    [output appendFormat:@"%@%@: %@\n", indent, @"featureCount", [NSNumber numberWithInteger:self.featureCount]];
+  }
+  if (self.hasDistance) {
+    [output appendFormat:@"%@%@: %@\n", indent, @"distance", [NSNumber numberWithInteger:self.distance]];
+  }
+  if (self.hasElapsedTime) {
+    [output appendFormat:@"%@%@: %@\n", indent, @"elapsedTime", [NSNumber numberWithInteger:self.elapsedTime]];
+  }
+  [self.unknownFields writeDescriptionTo:output withIndent:indent];
+}
+- (BOOL) isEqual:(id)other {
+  if (other == self) {
+    return YES;
+  }
+  if (![other isKindOfClass:[RGDRouteSummary class]]) {
+    return NO;
+  }
+  RGDRouteSummary *otherMessage = other;
+  return
+      self.hasPointCount == otherMessage.hasPointCount &&
+      (!self.hasPointCount || self.pointCount == otherMessage.pointCount) &&
+      self.hasFeatureCount == otherMessage.hasFeatureCount &&
+      (!self.hasFeatureCount || self.featureCount == otherMessage.featureCount) &&
+      self.hasDistance == otherMessage.hasDistance &&
+      (!self.hasDistance || self.distance == otherMessage.distance) &&
+      self.hasElapsedTime == otherMessage.hasElapsedTime &&
+      (!self.hasElapsedTime || self.elapsedTime == otherMessage.elapsedTime) &&
+      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
+}
+- (NSUInteger) hash {
+  __block NSUInteger hashCode = 7;
+  if (self.hasPointCount) {
+    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.pointCount] hash];
+  }
+  if (self.hasFeatureCount) {
+    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.featureCount] hash];
+  }
+  if (self.hasDistance) {
+    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.distance] hash];
+  }
+  if (self.hasElapsedTime) {
+    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.elapsedTime] hash];
+  }
+  hashCode = hashCode * 31 + [self.unknownFields hash];
+  return hashCode;
+}
+@end
+
+@interface RGDRouteSummaryBuilder()
+@property (strong) RGDRouteSummary* resultRouteSummary;
+@end
+
+@implementation RGDRouteSummaryBuilder
+@synthesize resultRouteSummary;
+- (instancetype) init {
+  if ((self = [super init])) {
+    self.resultRouteSummary = [[RGDRouteSummary alloc] init];
+  }
+  return self;
+}
+- (PBGeneratedMessage*) internalGetResult {
+  return resultRouteSummary;
+}
+- (RGDRouteSummaryBuilder*) clear {
+  self.resultRouteSummary = [[RGDRouteSummary alloc] init];
+  return self;
+}
+- (RGDRouteSummaryBuilder*) clone {
+  return [RGDRouteSummary builderWithPrototype:resultRouteSummary];
+}
+- (RGDRouteSummary*) defaultInstance {
+  return [RGDRouteSummary defaultInstance];
+}
+- (RGDRouteSummary*) build {
+  [self checkInitialized];
+  return [self buildPartial];
+}
+- (RGDRouteSummary*) buildPartial {
+  RGDRouteSummary* returnMe = resultRouteSummary;
+  self.resultRouteSummary = nil;
+  return returnMe;
+}
+- (RGDRouteSummaryBuilder*) mergeFrom:(RGDRouteSummary*) other {
+  if (other == [RGDRouteSummary defaultInstance]) {
+    return self;
+  }
+  if (other.hasPointCount) {
+    [self setPointCount:other.pointCount];
+  }
+  if (other.hasFeatureCount) {
+    [self setFeatureCount:other.featureCount];
+  }
+  if (other.hasDistance) {
+    [self setDistance:other.distance];
+  }
+  if (other.hasElapsedTime) {
+    [self setElapsedTime:other.elapsedTime];
+  }
+  [self mergeUnknownFields:other.unknownFields];
+  return self;
+}
+- (RGDRouteSummaryBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
+  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
+}
+- (RGDRouteSummaryBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
+  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
+  while (YES) {
+    SInt32 tag = [input readTag];
+    switch (tag) {
+      case 0:
+        [self setUnknownFields:[unknownFields build]];
+        return self;
+      default: {
+        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
+          [self setUnknownFields:[unknownFields build]];
+          return self;
+        }
+        break;
+      }
+      case 8: {
+        [self setPointCount:[input readInt32]];
+        break;
+      }
+      case 16: {
+        [self setFeatureCount:[input readInt32]];
+        break;
+      }
+      case 24: {
+        [self setDistance:[input readInt32]];
+        break;
+      }
+      case 32: {
+        [self setElapsedTime:[input readInt32]];
+        break;
+      }
+    }
+  }
+}
+- (BOOL) hasPointCount {
+  return resultRouteSummary.hasPointCount;
+}
+- (SInt32) pointCount {
+  return resultRouteSummary.pointCount;
+}
+- (RGDRouteSummaryBuilder*) setPointCount:(SInt32) value {
+  resultRouteSummary.hasPointCount = YES;
+  resultRouteSummary.pointCount = value;
+  return self;
+}
+- (RGDRouteSummaryBuilder*) clearPointCount {
+  resultRouteSummary.hasPointCount = NO;
+  resultRouteSummary.pointCount = 0;
+  return self;
+}
+- (BOOL) hasFeatureCount {
+  return resultRouteSummary.hasFeatureCount;
+}
+- (SInt32) featureCount {
+  return resultRouteSummary.featureCount;
+}
+- (RGDRouteSummaryBuilder*) setFeatureCount:(SInt32) value {
+  resultRouteSummary.hasFeatureCount = YES;
+  resultRouteSummary.featureCount = value;
+  return self;
+}
+- (RGDRouteSummaryBuilder*) clearFeatureCount {
+  resultRouteSummary.hasFeatureCount = NO;
+  resultRouteSummary.featureCount = 0;
+  return self;
+}
+- (BOOL) hasDistance {
+  return resultRouteSummary.hasDistance;
+}
+- (SInt32) distance {
+  return resultRouteSummary.distance;
+}
+- (RGDRouteSummaryBuilder*) setDistance:(SInt32) value {
+  resultRouteSummary.hasDistance = YES;
+  resultRouteSummary.distance = value;
+  return self;
+}
+- (RGDRouteSummaryBuilder*) clearDistance {
+  resultRouteSummary.hasDistance = NO;
+  resultRouteSummary.distance = 0;
+  return self;
+}
+- (BOOL) hasElapsedTime {
+  return resultRouteSummary.hasElapsedTime;
+}
+- (SInt32) elapsedTime {
+  return resultRouteSummary.elapsedTime;
+}
+- (RGDRouteSummaryBuilder*) setElapsedTime:(SInt32) value {
+  resultRouteSummary.hasElapsedTime = YES;
+  resultRouteSummary.elapsedTime = value;
+  return self;
+}
+- (RGDRouteSummaryBuilder*) clearElapsedTime {
+  resultRouteSummary.hasElapsedTime = NO;
+  resultRouteSummary.elapsedTime = 0;
+  return self;
+}
+@end
+
+
+// @@protoc_insertion_point(global_scope)