src/third_party/cacheinvalidation/src/java/com/google/ipc/invalidation/common/ClientProtocolAccessor.java

   1 /*
   2  * Copyright 2011 Google Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 // GENERATED CODE. DO NOT EDIT. (But isn't it pretty?)
  17 package com.google.ipc.invalidation.common;
  18
  19 import com.google.common.base.Preconditions;
  20 import com.google.ipc.invalidation.common.ProtoValidator.Accessor;
  21
  22 import com.google.ipc.invalidation.common.ProtoValidator.Descriptor;
  23
  24 import com.google.protobuf.MessageLite;
  25
  26 import com.google.protos.ipc.invalidation.ClientProtocol.ApplicationClientIdP;
  27 import com.google.protos.ipc.invalidation.ClientProtocol.ClientConfigP;
  28 import com.google.protos.ipc.invalidation.ClientProtocol.ClientHeader;
  29 import com.google.protos.ipc.invalidation.ClientProtocol.ClientToServerMessage;
  30 import com.google.protos.ipc.invalidation.ClientProtocol.ClientVersion;
  31 import com.google.protos.ipc.invalidation.ClientProtocol.ConfigChangeMessage;
  32 import com.google.protos.ipc.invalidation.ClientProtocol.ErrorMessage;
  33 import com.google.protos.ipc.invalidation.ClientProtocol.InfoMessage;
  34 import com.google.protos.ipc.invalidation.ClientProtocol.InfoRequestMessage;
  35 import com.google.protos.ipc.invalidation.ClientProtocol.InitializeMessage;
  36 import com.google.protos.ipc.invalidation.ClientProtocol.InvalidationMessage;
  37 import com.google.protos.ipc.invalidation.ClientProtocol.InvalidationP;
  38 import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP;
  39 import com.google.protos.ipc.invalidation.ClientProtocol.PropertyRecord;
  40 import com.google.protos.ipc.invalidation.ClientProtocol.ProtocolHandlerConfigP;
  41 import com.google.protos.ipc.invalidation.ClientProtocol.ProtocolVersion;
  42 import com.google.protos.ipc.invalidation.ClientProtocol.RateLimitP;
  43 import com.google.protos.ipc.invalidation.ClientProtocol.RegistrationMessage;
  44 import com.google.protos.ipc.invalidation.ClientProtocol.RegistrationP;
  45 import com.google.protos.ipc.invalidation.ClientProtocol.RegistrationStatus;
  46 import com.google.protos.ipc.invalidation.ClientProtocol.RegistrationStatusMessage;
  47 import com.google.protos.ipc.invalidation.ClientProtocol.RegistrationSubtree;
  48 import com.google.protos.ipc.invalidation.ClientProtocol.RegistrationSummary;
  49 import com.google.protos.ipc.invalidation.ClientProtocol.RegistrationSyncMessage;
  50 import com.google.protos.ipc.invalidation.ClientProtocol.RegistrationSyncRequestMessage;
  51 import com.google.protos.ipc.invalidation.ClientProtocol.ServerHeader;
  52 import com.google.protos.ipc.invalidation.ClientProtocol.ServerToClientMessage;
  53 import com.google.protos.ipc.invalidation.ClientProtocol.StatusP;
  54 import com.google.protos.ipc.invalidation.ClientProtocol.TokenControlMessage;
  55 import com.google.protos.ipc.invalidation.ClientProtocol.Version;
  56
  57 import java.util.Arrays;
  58 import java.util.Collection;
  59 import java.util.HashSet;
  60 import java.util.Set;
  61
  62 /** Class providing access to fields of protocol buffers in a generic way without using Java reflection. */
  63 public class ClientProtocolAccessor {
  64   /** Class to access fields in {@link ApplicationClientIdP} protos. */
  65   public static class ApplicationClientIdPAccessor implements Accessor {
  66     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
  67       Arrays.<String>asList(
  68         "client_type",
  69         "client_name"
  70       ));
  71
  72     public static final Descriptor CLIENT_TYPE = new Descriptor("client_type");
  73     public static final Descriptor CLIENT_NAME = new Descriptor("client_name");
  74
  75     /** Returns whether {@code field} is present in {@code message}. */
  76     @Override
  77     @SuppressWarnings("unchecked")
  78     public boolean hasField(MessageLite rawMessage, Descriptor field) {
  79       Preconditions.checkNotNull(rawMessage);
  80       Preconditions.checkNotNull(field);
  81       ApplicationClientIdP message = (ApplicationClientIdP) rawMessage;
  82       if (field == CLIENT_TYPE) {
  83         return message.hasClientType();
  84       }
  85       if (field == CLIENT_NAME) {
  86         return message.hasClientName();
  87       }
  88       throw new IllegalArgumentException("Bad descriptor: " + field);
  89     }
  90
  91     /** Returns the {@code field} from {@code message}. */
  92     @Override
  93     @SuppressWarnings("unchecked")
  94     public Object getField(MessageLite rawMessage, Descriptor field) {
  95       Preconditions.checkNotNull(rawMessage);
  96       Preconditions.checkNotNull(field);
  97       ApplicationClientIdP message = (ApplicationClientIdP) rawMessage;
  98       if (field == CLIENT_TYPE) {
  99         return message.getClientType();
 100       }
 101       if (field == CLIENT_NAME) {
 102         return message.getClientName();
 103       }
 104       throw new IllegalArgumentException("Bad descriptor: " + field);
 105     }
 106
 107     @Override
 108     public Set<String> getAllFieldNames() {
 109       return ALL_FIELD_NAMES;
 110     }
 111   }
 112   public static final ApplicationClientIdPAccessor APPLICATION_CLIENT_ID_P_ACCESSOR = new ApplicationClientIdPAccessor();
 113
 114   /** Class to access fields in {@link ClientConfigP} protos. */
 115   public static class ClientConfigPAccessor implements Accessor {
 116     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
 117       Arrays.<String>asList(
 118         "version",
 119         "network_timeout_delay_ms",
 120         "write_retry_delay_ms",
 121         "heartbeat_interval_ms",
 122         "perf_counter_delay_ms",
 123         "max_exponential_backoff_factor",
 124         "smear_percent",
 125         "is_transient",
 126         "initial_persistent_heartbeat_delay_ms",
 127         "protocol_handler_config",
 128         "channel_supports_offline_delivery",
 129         "offline_heartbeat_threshold_ms",
 130         "allow_suppression"
 131       ));
 132
 133     public static final Descriptor VERSION = new Descriptor("version");
 134     public static final Descriptor NETWORK_TIMEOUT_DELAY_MS = new Descriptor("network_timeout_delay_ms");
 135     public static final Descriptor WRITE_RETRY_DELAY_MS = new Descriptor("write_retry_delay_ms");
 136     public static final Descriptor HEARTBEAT_INTERVAL_MS = new Descriptor("heartbeat_interval_ms");
 137     public static final Descriptor PERF_COUNTER_DELAY_MS = new Descriptor("perf_counter_delay_ms");
 138     public static final Descriptor MAX_EXPONENTIAL_BACKOFF_FACTOR = new Descriptor("max_exponential_backoff_factor");
 139     public static final Descriptor SMEAR_PERCENT = new Descriptor("smear_percent");
 140     public static final Descriptor IS_TRANSIENT = new Descriptor("is_transient");
 141     public static final Descriptor INITIAL_PERSISTENT_HEARTBEAT_DELAY_MS = new Descriptor("initial_persistent_heartbeat_delay_ms");
 142     public static final Descriptor PROTOCOL_HANDLER_CONFIG = new Descriptor("protocol_handler_config");
 143     public static final Descriptor CHANNEL_SUPPORTS_OFFLINE_DELIVERY = new Descriptor("channel_supports_offline_delivery");
 144     public static final Descriptor OFFLINE_HEARTBEAT_THRESHOLD_MS = new Descriptor("offline_heartbeat_threshold_ms");
 145     public static final Descriptor ALLOW_SUPPRESSION = new Descriptor("allow_suppression");
 146
 147     /** Returns whether {@code field} is present in {@code message}. */
 148     @Override
 149     @SuppressWarnings("unchecked")
 150     public boolean hasField(MessageLite rawMessage, Descriptor field) {
 151       Preconditions.checkNotNull(rawMessage);
 152       Preconditions.checkNotNull(field);
 153       ClientConfigP message = (ClientConfigP) rawMessage;
 154       if (field == VERSION) {
 155         return message.hasVersion();
 156       }
 157       if (field == NETWORK_TIMEOUT_DELAY_MS) {
 158         return message.hasNetworkTimeoutDelayMs();
 159       }
 160       if (field == WRITE_RETRY_DELAY_MS) {
 161         return message.hasWriteRetryDelayMs();
 162       }
 163       if (field == HEARTBEAT_INTERVAL_MS) {
 164         return message.hasHeartbeatIntervalMs();
 165       }
 166       if (field == PERF_COUNTER_DELAY_MS) {
 167         return message.hasPerfCounterDelayMs();
 168       }
 169       if (field == MAX_EXPONENTIAL_BACKOFF_FACTOR) {
 170         return message.hasMaxExponentialBackoffFactor();
 171       }
 172       if (field == SMEAR_PERCENT) {
 173         return message.hasSmearPercent();
 174       }
 175       if (field == IS_TRANSIENT) {
 176         return message.hasIsTransient();
 177       }
 178       if (field == INITIAL_PERSISTENT_HEARTBEAT_DELAY_MS) {
 179         return message.hasInitialPersistentHeartbeatDelayMs();
 180       }
 181       if (field == PROTOCOL_HANDLER_CONFIG) {
 182         return message.hasProtocolHandlerConfig();
 183       }
 184       if (field == CHANNEL_SUPPORTS_OFFLINE_DELIVERY) {
 185         return message.hasChannelSupportsOfflineDelivery();
 186       }
 187       if (field == OFFLINE_HEARTBEAT_THRESHOLD_MS) {
 188         return message.hasOfflineHeartbeatThresholdMs();
 189       }
 190       if (field == ALLOW_SUPPRESSION) {
 191         return message.hasAllowSuppression();
 192       }
 193       throw new IllegalArgumentException("Bad descriptor: " + field);
 194     }
 195
 196     /** Returns the {@code field} from {@code message}. */
 197     @Override
 198     @SuppressWarnings("unchecked")
 199     public Object getField(MessageLite rawMessage, Descriptor field) {
 200       Preconditions.checkNotNull(rawMessage);
 201       Preconditions.checkNotNull(field);
 202       ClientConfigP message = (ClientConfigP) rawMessage;
 203       if (field == VERSION) {
 204         return message.getVersion();
 205       }
 206       if (field == NETWORK_TIMEOUT_DELAY_MS) {
 207         return message.getNetworkTimeoutDelayMs();
 208       }
 209       if (field == WRITE_RETRY_DELAY_MS) {
 210         return message.getWriteRetryDelayMs();
 211       }
 212       if (field == HEARTBEAT_INTERVAL_MS) {
 213         return message.getHeartbeatIntervalMs();
 214       }
 215       if (field == PERF_COUNTER_DELAY_MS) {
 216         return message.getPerfCounterDelayMs();
 217       }
 218       if (field == MAX_EXPONENTIAL_BACKOFF_FACTOR) {
 219         return message.getMaxExponentialBackoffFactor();
 220       }
 221       if (field == SMEAR_PERCENT) {
 222         return message.getSmearPercent();
 223       }
 224       if (field == IS_TRANSIENT) {
 225         return message.getIsTransient();
 226       }
 227       if (field == INITIAL_PERSISTENT_HEARTBEAT_DELAY_MS) {
 228         return message.getInitialPersistentHeartbeatDelayMs();
 229       }
 230       if (field == PROTOCOL_HANDLER_CONFIG) {
 231         return message.getProtocolHandlerConfig();
 232       }
 233       if (field == CHANNEL_SUPPORTS_OFFLINE_DELIVERY) {
 234         return message.getChannelSupportsOfflineDelivery();
 235       }
 236       if (field == OFFLINE_HEARTBEAT_THRESHOLD_MS) {
 237         return message.getOfflineHeartbeatThresholdMs();
 238       }
 239       if (field == ALLOW_SUPPRESSION) {
 240         return message.getAllowSuppression();
 241       }
 242       throw new IllegalArgumentException("Bad descriptor: " + field);
 243     }
 244
 245     @Override
 246     public Set<String> getAllFieldNames() {
 247       return ALL_FIELD_NAMES;
 248     }
 249   }
 250   public static final ClientConfigPAccessor CLIENT_CONFIG_P_ACCESSOR = new ClientConfigPAccessor();
 251
 252   /** Class to access fields in {@link ClientHeader} protos. */
 253   public static class ClientHeaderAccessor implements Accessor {
 254     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
 255       Arrays.<String>asList(
 256         "protocol_version",
 257         "client_token",
 258         "registration_summary",
 259         "client_time_ms",
 260         "max_known_server_time_ms",
 261         "message_id",
 262         "client_type"
 263       ));
 264
 265     public static final Descriptor PROTOCOL_VERSION = new Descriptor("protocol_version");
 266     public static final Descriptor CLIENT_TOKEN = new Descriptor("client_token");
 267     public static final Descriptor REGISTRATION_SUMMARY = new Descriptor("registration_summary");
 268     public static final Descriptor CLIENT_TIME_MS = new Descriptor("client_time_ms");
 269     public static final Descriptor MAX_KNOWN_SERVER_TIME_MS = new Descriptor("max_known_server_time_ms");
 270     public static final Descriptor MESSAGE_ID = new Descriptor("message_id");
 271     public static final Descriptor CLIENT_TYPE = new Descriptor("client_type");
 272
 273     /** Returns whether {@code field} is present in {@code message}. */
 274     @Override
 275     @SuppressWarnings("unchecked")
 276     public boolean hasField(MessageLite rawMessage, Descriptor field) {
 277       Preconditions.checkNotNull(rawMessage);
 278       Preconditions.checkNotNull(field);
 279       ClientHeader message = (ClientHeader) rawMessage;
 280       if (field == PROTOCOL_VERSION) {
 281         return message.hasProtocolVersion();
 282       }
 283       if (field == CLIENT_TOKEN) {
 284         return message.hasClientToken();
 285       }
 286       if (field == REGISTRATION_SUMMARY) {
 287         return message.hasRegistrationSummary();
 288       }
 289       if (field == CLIENT_TIME_MS) {
 290         return message.hasClientTimeMs();
 291       }
 292       if (field == MAX_KNOWN_SERVER_TIME_MS) {
 293         return message.hasMaxKnownServerTimeMs();
 294       }
 295       if (field == MESSAGE_ID) {
 296         return message.hasMessageId();
 297       }
 298       if (field == CLIENT_TYPE) {
 299         return message.hasClientType();
 300       }
 301       throw new IllegalArgumentException("Bad descriptor: " + field);
 302     }
 303
 304     /** Returns the {@code field} from {@code message}. */
 305     @Override
 306     @SuppressWarnings("unchecked")
 307     public Object getField(MessageLite rawMessage, Descriptor field) {
 308       Preconditions.checkNotNull(rawMessage);
 309       Preconditions.checkNotNull(field);
 310       ClientHeader message = (ClientHeader) rawMessage;
 311       if (field == PROTOCOL_VERSION) {
 312         return message.getProtocolVersion();
 313       }
 314       if (field == CLIENT_TOKEN) {
 315         return message.getClientToken();
 316       }
 317       if (field == REGISTRATION_SUMMARY) {
 318         return message.getRegistrationSummary();
 319       }
 320       if (field == CLIENT_TIME_MS) {
 321         return message.getClientTimeMs();
 322       }
 323       if (field == MAX_KNOWN_SERVER_TIME_MS) {
 324         return message.getMaxKnownServerTimeMs();
 325       }
 326       if (field == MESSAGE_ID) {
 327         return message.getMessageId();
 328       }
 329       if (field == CLIENT_TYPE) {
 330         return message.getClientType();
 331       }
 332       throw new IllegalArgumentException("Bad descriptor: " + field);
 333     }
 334
 335     @Override
 336     public Set<String> getAllFieldNames() {
 337       return ALL_FIELD_NAMES;
 338     }
 339   }
 340   public static final ClientHeaderAccessor CLIENT_HEADER_ACCESSOR = new ClientHeaderAccessor();
 341
 342   /** Class to access fields in {@link ClientToServerMessage} protos. */
 343   public static class ClientToServerMessageAccessor implements Accessor {
 344     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
 345       Arrays.<String>asList(
 346         "header",
 347         "initialize_message",
 348         "registration_message",
 349         "registration_sync_message",
 350         "invalidation_ack_message",
 351         "info_message"
 352       ));
 353
 354     public static final Descriptor HEADER = new Descriptor("header");
 355     public static final Descriptor INITIALIZE_MESSAGE = new Descriptor("initialize_message");
 356     public static final Descriptor REGISTRATION_MESSAGE = new Descriptor("registration_message");
 357     public static final Descriptor REGISTRATION_SYNC_MESSAGE = new Descriptor("registration_sync_message");
 358     public static final Descriptor INVALIDATION_ACK_MESSAGE = new Descriptor("invalidation_ack_message");
 359     public static final Descriptor INFO_MESSAGE = new Descriptor("info_message");
 360
 361     /** Returns whether {@code field} is present in {@code message}. */
 362     @Override
 363     @SuppressWarnings("unchecked")
 364     public boolean hasField(MessageLite rawMessage, Descriptor field) {
 365       Preconditions.checkNotNull(rawMessage);
 366       Preconditions.checkNotNull(field);
 367       ClientToServerMessage message = (ClientToServerMessage) rawMessage;
 368       if (field == HEADER) {
 369         return message.hasHeader();
 370       }
 371       if (field == INITIALIZE_MESSAGE) {
 372         return message.hasInitializeMessage();
 373       }
 374       if (field == REGISTRATION_MESSAGE) {
 375         return message.hasRegistrationMessage();
 376       }
 377       if (field == REGISTRATION_SYNC_MESSAGE) {
 378         return message.hasRegistrationSyncMessage();
 379       }
 380       if (field == INVALIDATION_ACK_MESSAGE) {
 381         return message.hasInvalidationAckMessage();
 382       }
 383       if (field == INFO_MESSAGE) {
 384         return message.hasInfoMessage();
 385       }
 386       throw new IllegalArgumentException("Bad descriptor: " + field);
 387     }
 388
 389     /** Returns the {@code field} from {@code message}. */
 390     @Override
 391     @SuppressWarnings("unchecked")
 392     public Object getField(MessageLite rawMessage, Descriptor field) {
 393       Preconditions.checkNotNull(rawMessage);
 394       Preconditions.checkNotNull(field);
 395       ClientToServerMessage message = (ClientToServerMessage) rawMessage;
 396       if (field == HEADER) {
 397         return message.getHeader();
 398       }
 399       if (field == INITIALIZE_MESSAGE) {
 400         return message.getInitializeMessage();
 401       }
 402       if (field == REGISTRATION_MESSAGE) {
 403         return message.getRegistrationMessage();
 404       }
 405       if (field == REGISTRATION_SYNC_MESSAGE) {
 406         return message.getRegistrationSyncMessage();
 407       }
 408       if (field == INVALIDATION_ACK_MESSAGE) {
 409         return message.getInvalidationAckMessage();
 410       }
 411       if (field == INFO_MESSAGE) {
 412         return message.getInfoMessage();
 413       }
 414       throw new IllegalArgumentException("Bad descriptor: " + field);
 415     }
 416
 417     @Override
 418     public Set<String> getAllFieldNames() {
 419       return ALL_FIELD_NAMES;
 420     }
 421   }
 422   public static final ClientToServerMessageAccessor CLIENT_TO_SERVER_MESSAGE_ACCESSOR = new ClientToServerMessageAccessor();
 423
 424   /** Class to access fields in {@link ClientVersion} protos. */
 425   public static class ClientVersionAccessor implements Accessor {
 426     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
 427       Arrays.<String>asList(
 428         "version",
 429         "platform",
 430         "language",
 431         "application_info"
 432       ));
 433
 434     public static final Descriptor VERSION = new Descriptor("version");
 435     public static final Descriptor PLATFORM = new Descriptor("platform");
 436     public static final Descriptor LANGUAGE = new Descriptor("language");
 437     public static final Descriptor APPLICATION_INFO = new Descriptor("application_info");
 438
 439     /** Returns whether {@code field} is present in {@code message}. */
 440     @Override
 441     @SuppressWarnings("unchecked")
 442     public boolean hasField(MessageLite rawMessage, Descriptor field) {
 443       Preconditions.checkNotNull(rawMessage);
 444       Preconditions.checkNotNull(field);
 445       ClientVersion message = (ClientVersion) rawMessage;
 446       if (field == VERSION) {
 447         return message.hasVersion();
 448       }
 449       if (field == PLATFORM) {
 450         return message.hasPlatform();
 451       }
 452       if (field == LANGUAGE) {
 453         return message.hasLanguage();
 454       }
 455       if (field == APPLICATION_INFO) {
 456         return message.hasApplicationInfo();
 457       }
 458       throw new IllegalArgumentException("Bad descriptor: " + field);
 459     }
 460
 461     /** Returns the {@code field} from {@code message}. */
 462     @Override
 463     @SuppressWarnings("unchecked")
 464     public Object getField(MessageLite rawMessage, Descriptor field) {
 465       Preconditions.checkNotNull(rawMessage);
 466       Preconditions.checkNotNull(field);
 467       ClientVersion message = (ClientVersion) rawMessage;
 468       if (field == VERSION) {
 469         return message.getVersion();
 470       }
 471       if (field == PLATFORM) {
 472         return message.getPlatform();
 473       }
 474       if (field == LANGUAGE) {
 475         return message.getLanguage();
 476       }
 477       if (field == APPLICATION_INFO) {
 478         return message.getApplicationInfo();
 479       }
 480       throw new IllegalArgumentException("Bad descriptor: " + field);
 481     }
 482
 483     @Override
 484     public Set<String> getAllFieldNames() {
 485       return ALL_FIELD_NAMES;
 486     }
 487   }
 488   public static final ClientVersionAccessor CLIENT_VERSION_ACCESSOR = new ClientVersionAccessor();
 489
 490   /** Class to access fields in {@link ConfigChangeMessage} protos. */
 491   public static class ConfigChangeMessageAccessor implements Accessor {
 492     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
 493       Arrays.<String>asList(
 494         "next_message_delay_ms"
 495       ));
 496
 497     public static final Descriptor NEXT_MESSAGE_DELAY_MS = new Descriptor("next_message_delay_ms");
 498
 499     /** Returns whether {@code field} is present in {@code message}. */
 500     @Override
 501     @SuppressWarnings("unchecked")
 502     public boolean hasField(MessageLite rawMessage, Descriptor field) {
 503       Preconditions.checkNotNull(rawMessage);
 504       Preconditions.checkNotNull(field);
 505       ConfigChangeMessage message = (ConfigChangeMessage) rawMessage;
 506       if (field == NEXT_MESSAGE_DELAY_MS) {
 507         return message.hasNextMessageDelayMs();
 508       }
 509       throw new IllegalArgumentException("Bad descriptor: " + field);
 510     }
 511
 512     /** Returns the {@code field} from {@code message}. */
 513     @Override
 514     @SuppressWarnings("unchecked")
 515     public Object getField(MessageLite rawMessage, Descriptor field) {
 516       Preconditions.checkNotNull(rawMessage);
 517       Preconditions.checkNotNull(field);
 518       ConfigChangeMessage message = (ConfigChangeMessage) rawMessage;
 519       if (field == NEXT_MESSAGE_DELAY_MS) {
 520         return message.getNextMessageDelayMs();
 521       }
 522       throw new IllegalArgumentException("Bad descriptor: " + field);
 523     }
 524
 525     @Override
 526     public Set<String> getAllFieldNames() {
 527       return ALL_FIELD_NAMES;
 528     }
 529   }
 530   public static final ConfigChangeMessageAccessor CONFIG_CHANGE_MESSAGE_ACCESSOR = new ConfigChangeMessageAccessor();
 531
 532   /** Class to access fields in {@link ErrorMessage} protos. */
 533   public static class ErrorMessageAccessor implements Accessor {
 534     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
 535       Arrays.<String>asList(
 536         "code",
 537         "description"
 538       ));
 539
 540     public static final Descriptor CODE = new Descriptor("code");
 541     public static final Descriptor DESCRIPTION = new Descriptor("description");
 542
 543     /** Returns whether {@code field} is present in {@code message}. */
 544     @Override
 545     @SuppressWarnings("unchecked")
 546     public boolean hasField(MessageLite rawMessage, Descriptor field) {
 547       Preconditions.checkNotNull(rawMessage);
 548       Preconditions.checkNotNull(field);
 549       ErrorMessage message = (ErrorMessage) rawMessage;
 550       if (field == CODE) {
 551         return message.hasCode();
 552       }
 553       if (field == DESCRIPTION) {
 554         return message.hasDescription();
 555       }
 556       throw new IllegalArgumentException("Bad descriptor: " + field);
 557     }
 558
 559     /** Returns the {@code field} from {@code message}. */
 560     @Override
 561     @SuppressWarnings("unchecked")
 562     public Object getField(MessageLite rawMessage, Descriptor field) {
 563       Preconditions.checkNotNull(rawMessage);
 564       Preconditions.checkNotNull(field);
 565       ErrorMessage message = (ErrorMessage) rawMessage;
 566       if (field == CODE) {
 567         return message.getCode();
 568       }
 569       if (field == DESCRIPTION) {
 570         return message.getDescription();
 571       }
 572       throw new IllegalArgumentException("Bad descriptor: " + field);
 573     }
 574
 575     @Override
 576     public Set<String> getAllFieldNames() {
 577       return ALL_FIELD_NAMES;
 578     }
 579   }
 580   public static final ErrorMessageAccessor ERROR_MESSAGE_ACCESSOR = new ErrorMessageAccessor();
 581
 582   /** Class to access fields in {@link InfoMessage} protos. */
 583   public static class InfoMessageAccessor implements Accessor {
 584     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
 585       Arrays.<String>asList(
 586         "client_version",
 587         "config_parameter",
 588         "performance_counter",
 589         "server_registration_summary_requested",
 590         "client_config"
 591       ));
 592
 593     public static final Descriptor CLIENT_VERSION = new Descriptor("client_version");
 594     public static final Descriptor CONFIG_PARAMETER = new Descriptor("config_parameter");
 595     public static final Descriptor PERFORMANCE_COUNTER = new Descriptor("performance_counter");
 596     public static final Descriptor SERVER_REGISTRATION_SUMMARY_REQUESTED = new Descriptor("server_registration_summary_requested");
 597     public static final Descriptor CLIENT_CONFIG = new Descriptor("client_config");
 598
 599     /** Returns whether {@code field} is present in {@code message}. */
 600     @Override
 601     @SuppressWarnings("unchecked")
 602     public boolean hasField(MessageLite rawMessage, Descriptor field) {
 603       Preconditions.checkNotNull(rawMessage);
 604       Preconditions.checkNotNull(field);
 605       InfoMessage message = (InfoMessage) rawMessage;
 606       if (field == CLIENT_VERSION) {
 607         return message.hasClientVersion();
 608       }
 609       if (field == CONFIG_PARAMETER) {
 610         return message.getConfigParameterCount() > 0;
 611       }
 612       if (field == PERFORMANCE_COUNTER) {
 613         return message.getPerformanceCounterCount() > 0;
 614       }
 615       if (field == SERVER_REGISTRATION_SUMMARY_REQUESTED) {
 616         return message.hasServerRegistrationSummaryRequested();
 617       }
 618       if (field == CLIENT_CONFIG) {
 619         return message.hasClientConfig();
 620       }
 621       throw new IllegalArgumentException("Bad descriptor: " + field);
 622     }
 623
 624     /** Returns the {@code field} from {@code message}. */
 625     @Override
 626     @SuppressWarnings("unchecked")
 627     public Object getField(MessageLite rawMessage, Descriptor field) {
 628       Preconditions.checkNotNull(rawMessage);
 629       Preconditions.checkNotNull(field);
 630       InfoMessage message = (InfoMessage) rawMessage;
 631       if (field == CLIENT_VERSION) {
 632         return message.getClientVersion();
 633       }
 634       if (field == CONFIG_PARAMETER) {
 635         return message.getConfigParameterList();
 636       }
 637       if (field == PERFORMANCE_COUNTER) {
 638         return message.getPerformanceCounterList();
 639       }
 640       if (field == SERVER_REGISTRATION_SUMMARY_REQUESTED) {
 641         return message.getServerRegistrationSummaryRequested();
 642       }
 643       if (field == CLIENT_CONFIG) {
 644         return message.getClientConfig();
 645       }
 646       throw new IllegalArgumentException("Bad descriptor: " + field);
 647     }
 648
 649     @Override
 650     public Set<String> getAllFieldNames() {
 651       return ALL_FIELD_NAMES;
 652     }
 653   }
 654   public static final InfoMessageAccessor INFO_MESSAGE_ACCESSOR = new InfoMessageAccessor();
 655
 656   /** Class to access fields in {@link InfoRequestMessage} protos. */
 657   public static class InfoRequestMessageAccessor implements Accessor {
 658     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
 659       Arrays.<String>asList(
 660         "info_type"
 661       ));
 662
 663     public static final Descriptor INFO_TYPE = new Descriptor("info_type");
 664
 665     /** Returns whether {@code field} is present in {@code message}. */
 666     @Override
 667     @SuppressWarnings("unchecked")
 668     public boolean hasField(MessageLite rawMessage, Descriptor field) {
 669       Preconditions.checkNotNull(rawMessage);
 670       Preconditions.checkNotNull(field);
 671       InfoRequestMessage message = (InfoRequestMessage) rawMessage;
 672       if (field == INFO_TYPE) {
 673         return message.getInfoTypeCount() > 0;
 674       }
 675       throw new IllegalArgumentException("Bad descriptor: " + field);
 676     }
 677
 678     /** Returns the {@code field} from {@code message}. */
 679     @Override
 680     @SuppressWarnings("unchecked")
 681     public Object getField(MessageLite rawMessage, Descriptor field) {
 682       Preconditions.checkNotNull(rawMessage);
 683       Preconditions.checkNotNull(field);
 684       InfoRequestMessage message = (InfoRequestMessage) rawMessage;
 685       if (field == INFO_TYPE) {
 686         return message.getInfoTypeList();
 687       }
 688       throw new IllegalArgumentException("Bad descriptor: " + field);
 689     }
 690
 691     @Override
 692     public Set<String> getAllFieldNames() {
 693       return ALL_FIELD_NAMES;
 694     }
 695   }
 696   public static final InfoRequestMessageAccessor INFO_REQUEST_MESSAGE_ACCESSOR = new InfoRequestMessageAccessor();
 697
 698   /** Class to access fields in {@link InitializeMessage} protos. */
 699   public static class InitializeMessageAccessor implements Accessor {
 700     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
 701       Arrays.<String>asList(
 702         "client_type",
 703         "nonce",
 704         "application_client_id",
 705         "digest_serialization_type"
 706       ));
 707
 708     public static final Descriptor CLIENT_TYPE = new Descriptor("client_type");
 709     public static final Descriptor NONCE = new Descriptor("nonce");
 710     public static final Descriptor APPLICATION_CLIENT_ID = new Descriptor("application_client_id");
 711     public static final Descriptor DIGEST_SERIALIZATION_TYPE = new Descriptor("digest_serialization_type");
 712
 713     /** Returns whether {@code field} is present in {@code message}. */
 714     @Override
 715     @SuppressWarnings("unchecked")
 716     public boolean hasField(MessageLite rawMessage, Descriptor field) {
 717       Preconditions.checkNotNull(rawMessage);
 718       Preconditions.checkNotNull(field);
 719       InitializeMessage message = (InitializeMessage) rawMessage;
 720       if (field == CLIENT_TYPE) {
 721         return message.hasClientType();
 722       }
 723       if (field == NONCE) {
 724         return message.hasNonce();
 725       }
 726       if (field == APPLICATION_CLIENT_ID) {
 727         return message.hasApplicationClientId();
 728       }
 729       if (field == DIGEST_SERIALIZATION_TYPE) {
 730         return message.hasDigestSerializationType();
 731       }
 732       throw new IllegalArgumentException("Bad descriptor: " + field);
 733     }
 734
 735     /** Returns the {@code field} from {@code message}. */
 736     @Override
 737     @SuppressWarnings("unchecked")
 738     public Object getField(MessageLite rawMessage, Descriptor field) {
 739       Preconditions.checkNotNull(rawMessage);
 740       Preconditions.checkNotNull(field);
 741       InitializeMessage message = (InitializeMessage) rawMessage;
 742       if (field == CLIENT_TYPE) {
 743         return message.getClientType();
 744       }
 745       if (field == NONCE) {
 746         return message.getNonce();
 747       }
 748       if (field == APPLICATION_CLIENT_ID) {
 749         return message.getApplicationClientId();
 750       }
 751       if (field == DIGEST_SERIALIZATION_TYPE) {
 752         return message.getDigestSerializationType();
 753       }
 754       throw new IllegalArgumentException("Bad descriptor: " + field);
 755     }
 756
 757     @Override
 758     public Set<String> getAllFieldNames() {
 759       return ALL_FIELD_NAMES;
 760     }
 761   }
 762   public static final InitializeMessageAccessor INITIALIZE_MESSAGE_ACCESSOR = new InitializeMessageAccessor();
 763
 764   /** Class to access fields in {@link InvalidationMessage} protos. */
 765   public static class InvalidationMessageAccessor implements Accessor {
 766     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
 767       Arrays.<String>asList(
 768         "invalidation"
 769       ));
 770
 771     public static final Descriptor INVALIDATION = new Descriptor("invalidation");
 772
 773     /** Returns whether {@code field} is present in {@code message}. */
 774     @Override
 775     @SuppressWarnings("unchecked")
 776     public boolean hasField(MessageLite rawMessage, Descriptor field) {
 777       Preconditions.checkNotNull(rawMessage);
 778       Preconditions.checkNotNull(field);
 779       InvalidationMessage message = (InvalidationMessage) rawMessage;
 780       if (field == INVALIDATION) {
 781         return message.getInvalidationCount() > 0;
 782       }
 783       throw new IllegalArgumentException("Bad descriptor: " + field);
 784     }
 785
 786     /** Returns the {@code field} from {@code message}. */
 787     @Override
 788     @SuppressWarnings("unchecked")
 789     public Object getField(MessageLite rawMessage, Descriptor field) {
 790       Preconditions.checkNotNull(rawMessage);
 791       Preconditions.checkNotNull(field);
 792       InvalidationMessage message = (InvalidationMessage) rawMessage;
 793       if (field == INVALIDATION) {
 794         return message.getInvalidationList();
 795       }
 796       throw new IllegalArgumentException("Bad descriptor: " + field);
 797     }
 798
 799     @Override
 800     public Set<String> getAllFieldNames() {
 801       return ALL_FIELD_NAMES;
 802     }
 803   }
 804   public static final InvalidationMessageAccessor INVALIDATION_MESSAGE_ACCESSOR = new InvalidationMessageAccessor();
 805
 806   /** Class to access fields in {@link InvalidationP} protos. */
 807   public static class InvalidationPAccessor implements Accessor {
 808     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
 809       Arrays.<String>asList(
 810         "object_id",
 811         "is_known_version",
 812         "version",
 813         "is_trickle_restart",
 814         "payload",
 815         "bridge_arrival_time_ms_deprecated"
 816       ));
 817
 818     public static final Descriptor OBJECT_ID = new Descriptor("object_id");
 819     public static final Descriptor IS_KNOWN_VERSION = new Descriptor("is_known_version");
 820     public static final Descriptor VERSION = new Descriptor("version");
 821     public static final Descriptor IS_TRICKLE_RESTART = new Descriptor("is_trickle_restart");
 822     public static final Descriptor PAYLOAD = new Descriptor("payload");
 823     public static final Descriptor BRIDGE_ARRIVAL_TIME_MS_DEPRECATED = new Descriptor("bridge_arrival_time_ms_deprecated");
 824
 825     /** Returns whether {@code field} is present in {@code message}. */
 826     @Override
 827     @SuppressWarnings({ "deprecation", "unchecked" })
 828     public boolean hasField(MessageLite rawMessage, Descriptor field) {
 829       Preconditions.checkNotNull(rawMessage);
 830       Preconditions.checkNotNull(field);
 831       InvalidationP message = (InvalidationP) rawMessage;
 832       if (field == OBJECT_ID) {
 833         return message.hasObjectId();
 834       }
 835       if (field == IS_KNOWN_VERSION) {
 836         return message.hasIsKnownVersion();
 837       }
 838       if (field == VERSION) {
 839         return message.hasVersion();
 840       }
 841       if (field == IS_TRICKLE_RESTART) {
 842         return message.hasIsTrickleRestart();
 843       }
 844       if (field == PAYLOAD) {
 845         return message.hasPayload();
 846       }
 847       if (field == BRIDGE_ARRIVAL_TIME_MS_DEPRECATED) {
 848         return message.hasBridgeArrivalTimeMsDeprecated();
 849       }
 850       throw new IllegalArgumentException("Bad descriptor: " + field);
 851     }
 852
 853     /** Returns the {@code field} from {@code message}. */
 854     @Override
 855     @SuppressWarnings({ "deprecation", "unchecked" })
 856     public Object getField(MessageLite rawMessage, Descriptor field) {
 857       Preconditions.checkNotNull(rawMessage);
 858       Preconditions.checkNotNull(field);
 859       InvalidationP message = (InvalidationP) rawMessage;
 860       if (field == OBJECT_ID) {
 861         return message.getObjectId();
 862       }
 863       if (field == IS_KNOWN_VERSION) {
 864         return message.getIsKnownVersion();
 865       }
 866       if (field == VERSION) {
 867         return message.getVersion();
 868       }
 869       if (field == IS_TRICKLE_RESTART) {
 870         return message.getIsTrickleRestart();
 871       }
 872       if (field == PAYLOAD) {
 873         return message.getPayload();
 874       }
 875       if (field == BRIDGE_ARRIVAL_TIME_MS_DEPRECATED) {
 876         return message.getBridgeArrivalTimeMsDeprecated();
 877       }
 878       throw new IllegalArgumentException("Bad descriptor: " + field);
 879     }
 880
 881     @Override
 882     public Set<String> getAllFieldNames() {
 883       return ALL_FIELD_NAMES;
 884     }
 885   }
 886   public static final InvalidationPAccessor INVALIDATION_P_ACCESSOR = new InvalidationPAccessor();
 887
 888   /** Class to access fields in {@link ObjectIdP} protos. */
 889   public static class ObjectIdPAccessor implements Accessor {
 890     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
 891       Arrays.<String>asList(
 892         "source",
 893         "name"
 894       ));
 895
 896     public static final Descriptor SOURCE = new Descriptor("source");
 897     public static final Descriptor NAME = new Descriptor("name");
 898
 899     /** Returns whether {@code field} is present in {@code message}. */
 900     @Override
 901     @SuppressWarnings("unchecked")
 902     public boolean hasField(MessageLite rawMessage, Descriptor field) {
 903       Preconditions.checkNotNull(rawMessage);
 904       Preconditions.checkNotNull(field);
 905       ObjectIdP message = (ObjectIdP) rawMessage;
 906       if (field == SOURCE) {
 907         return message.hasSource();
 908       }
 909       if (field == NAME) {
 910         return message.hasName();
 911       }
 912       throw new IllegalArgumentException("Bad descriptor: " + field);
 913     }
 914
 915     /** Returns the {@code field} from {@code message}. */
 916     @Override
 917     @SuppressWarnings("unchecked")
 918     public Object getField(MessageLite rawMessage, Descriptor field) {
 919       Preconditions.checkNotNull(rawMessage);
 920       Preconditions.checkNotNull(field);
 921       ObjectIdP message = (ObjectIdP) rawMessage;
 922       if (field == SOURCE) {
 923         return message.getSource();
 924       }
 925       if (field == NAME) {
 926         return message.getName();
 927       }
 928       throw new IllegalArgumentException("Bad descriptor: " + field);
 929     }
 930
 931     @Override
 932     public Set<String> getAllFieldNames() {
 933       return ALL_FIELD_NAMES;
 934     }
 935   }
 936   public static final ObjectIdPAccessor OBJECT_ID_P_ACCESSOR = new ObjectIdPAccessor();
 937
 938   /** Class to access fields in {@link PropertyRecord} protos. */
 939   public static class PropertyRecordAccessor implements Accessor {
 940     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
 941       Arrays.<String>asList(
 942         "name",
 943         "value"
 944       ));
 945
 946     public static final Descriptor NAME = new Descriptor("name");
 947     public static final Descriptor VALUE = new Descriptor("value");
 948
 949     /** Returns whether {@code field} is present in {@code message}. */
 950     @Override
 951     @SuppressWarnings("unchecked")
 952     public boolean hasField(MessageLite rawMessage, Descriptor field) {
 953       Preconditions.checkNotNull(rawMessage);
 954       Preconditions.checkNotNull(field);
 955       PropertyRecord message = (PropertyRecord) rawMessage;
 956       if (field == NAME) {
 957         return message.hasName();
 958       }
 959       if (field == VALUE) {
 960         return message.hasValue();
 961       }
 962       throw new IllegalArgumentException("Bad descriptor: " + field);
 963     }
 964
 965     /** Returns the {@code field} from {@code message}. */
 966     @Override
 967     @SuppressWarnings("unchecked")
 968     public Object getField(MessageLite rawMessage, Descriptor field) {
 969       Preconditions.checkNotNull(rawMessage);
 970       Preconditions.checkNotNull(field);
 971       PropertyRecord message = (PropertyRecord) rawMessage;
 972       if (field == NAME) {
 973         return message.getName();
 974       }
 975       if (field == VALUE) {
 976         return message.getValue();
 977       }
 978       throw new IllegalArgumentException("Bad descriptor: " + field);
 979     }
 980
 981     @Override
 982     public Set<String> getAllFieldNames() {
 983       return ALL_FIELD_NAMES;
 984     }
 985   }
 986   public static final PropertyRecordAccessor PROPERTY_RECORD_ACCESSOR = new PropertyRecordAccessor();
 987
 988   /** Class to access fields in {@link ProtocolHandlerConfigP} protos. */
 989   public static class ProtocolHandlerConfigPAccessor implements Accessor {
 990     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
 991       Arrays.<String>asList(
 992         "batching_delay_ms",
 993         "rate_limit"
 994       ));
 995
 996     public static final Descriptor BATCHING_DELAY_MS = new Descriptor("batching_delay_ms");
 997     public static final Descriptor RATE_LIMIT = new Descriptor("rate_limit");
 998
 999     /** Returns whether {@code field} is present in {@code message}. */
1000     @Override
1001     @SuppressWarnings("unchecked")
1002     public boolean hasField(MessageLite rawMessage, Descriptor field) {
1003       Preconditions.checkNotNull(rawMessage);
1004       Preconditions.checkNotNull(field);
1005       ProtocolHandlerConfigP message = (ProtocolHandlerConfigP) rawMessage;
1006       if (field == BATCHING_DELAY_MS) {
1007         return message.hasBatchingDelayMs();
1008       }
1009       if (field == RATE_LIMIT) {
1010         return message.getRateLimitCount() > 0;
1011       }
1012       throw new IllegalArgumentException("Bad descriptor: " + field);
1013     }
1014
1015     /** Returns the {@code field} from {@code message}. */
1016     @Override
1017     @SuppressWarnings("unchecked")
1018     public Object getField(MessageLite rawMessage, Descriptor field) {
1019       Preconditions.checkNotNull(rawMessage);
1020       Preconditions.checkNotNull(field);
1021       ProtocolHandlerConfigP message = (ProtocolHandlerConfigP) rawMessage;
1022       if (field == BATCHING_DELAY_MS) {
1023         return message.getBatchingDelayMs();
1024       }
1025       if (field == RATE_LIMIT) {
1026         return message.getRateLimitList();
1027       }
1028       throw new IllegalArgumentException("Bad descriptor: " + field);
1029     }
1030
1031     @Override
1032     public Set<String> getAllFieldNames() {
1033       return ALL_FIELD_NAMES;
1034     }
1035   }
1036   public static final ProtocolHandlerConfigPAccessor PROTOCOL_HANDLER_CONFIG_P_ACCESSOR = new ProtocolHandlerConfigPAccessor();
1037
1038   /** Class to access fields in {@link ProtocolVersion} protos. */
1039   public static class ProtocolVersionAccessor implements Accessor {
1040     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
1041       Arrays.<String>asList(
1042         "version"
1043       ));
1044
1045     public static final Descriptor VERSION = new Descriptor("version");
1046
1047     /** Returns whether {@code field} is present in {@code message}. */
1048     @Override
1049     @SuppressWarnings("unchecked")
1050     public boolean hasField(MessageLite rawMessage, Descriptor field) {
1051       Preconditions.checkNotNull(rawMessage);
1052       Preconditions.checkNotNull(field);
1053       ProtocolVersion message = (ProtocolVersion) rawMessage;
1054       if (field == VERSION) {
1055         return message.hasVersion();
1056       }
1057       throw new IllegalArgumentException("Bad descriptor: " + field);
1058     }
1059
1060     /** Returns the {@code field} from {@code message}. */
1061     @Override
1062     @SuppressWarnings("unchecked")
1063     public Object getField(MessageLite rawMessage, Descriptor field) {
1064       Preconditions.checkNotNull(rawMessage);
1065       Preconditions.checkNotNull(field);
1066       ProtocolVersion message = (ProtocolVersion) rawMessage;
1067       if (field == VERSION) {
1068         return message.getVersion();
1069       }
1070       throw new IllegalArgumentException("Bad descriptor: " + field);
1071     }
1072
1073     @Override
1074     public Set<String> getAllFieldNames() {
1075       return ALL_FIELD_NAMES;
1076     }
1077   }
1078   public static final ProtocolVersionAccessor PROTOCOL_VERSION_ACCESSOR = new ProtocolVersionAccessor();
1079
1080   /** Class to access fields in {@link RateLimitP} protos. */
1081   public static class RateLimitPAccessor implements Accessor {
1082     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
1083       Arrays.<String>asList(
1084         "window_ms",
1085         "count"
1086       ));
1087
1088     public static final Descriptor WINDOW_MS = new Descriptor("window_ms");
1089     public static final Descriptor COUNT = new Descriptor("count");
1090
1091     /** Returns whether {@code field} is present in {@code message}. */
1092     @Override
1093     @SuppressWarnings("unchecked")
1094     public boolean hasField(MessageLite rawMessage, Descriptor field) {
1095       Preconditions.checkNotNull(rawMessage);
1096       Preconditions.checkNotNull(field);
1097       RateLimitP message = (RateLimitP) rawMessage;
1098       if (field == WINDOW_MS) {
1099         return message.hasWindowMs();
1100       }
1101       if (field == COUNT) {
1102         return message.hasCount();
1103       }
1104       throw new IllegalArgumentException("Bad descriptor: " + field);
1105     }
1106
1107     /** Returns the {@code field} from {@code message}. */
1108     @Override
1109     @SuppressWarnings("unchecked")
1110     public Object getField(MessageLite rawMessage, Descriptor field) {
1111       Preconditions.checkNotNull(rawMessage);
1112       Preconditions.checkNotNull(field);
1113       RateLimitP message = (RateLimitP) rawMessage;
1114       if (field == WINDOW_MS) {
1115         return message.getWindowMs();
1116       }
1117       if (field == COUNT) {
1118         return message.getCount();
1119       }
1120       throw new IllegalArgumentException("Bad descriptor: " + field);
1121     }
1122
1123     @Override
1124     public Set<String> getAllFieldNames() {
1125       return ALL_FIELD_NAMES;
1126     }
1127   }
1128   public static final RateLimitPAccessor RATE_LIMIT_P_ACCESSOR = new RateLimitPAccessor();
1129
1130   /** Class to access fields in {@link RegistrationMessage} protos. */
1131   public static class RegistrationMessageAccessor implements Accessor {
1132     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
1133       Arrays.<String>asList(
1134         "registration"
1135       ));
1136
1137     public static final Descriptor REGISTRATION = new Descriptor("registration");
1138
1139     /** Returns whether {@code field} is present in {@code message}. */
1140     @Override
1141     @SuppressWarnings("unchecked")
1142     public boolean hasField(MessageLite rawMessage, Descriptor field) {
1143       Preconditions.checkNotNull(rawMessage);
1144       Preconditions.checkNotNull(field);
1145       RegistrationMessage message = (RegistrationMessage) rawMessage;
1146       if (field == REGISTRATION) {
1147         return message.getRegistrationCount() > 0;
1148       }
1149       throw new IllegalArgumentException("Bad descriptor: " + field);
1150     }
1151
1152     /** Returns the {@code field} from {@code message}. */
1153     @Override
1154     @SuppressWarnings("unchecked")
1155     public Object getField(MessageLite rawMessage, Descriptor field) {
1156       Preconditions.checkNotNull(rawMessage);
1157       Preconditions.checkNotNull(field);
1158       RegistrationMessage message = (RegistrationMessage) rawMessage;
1159       if (field == REGISTRATION) {
1160         return message.getRegistrationList();
1161       }
1162       throw new IllegalArgumentException("Bad descriptor: " + field);
1163     }
1164
1165     @Override
1166     public Set<String> getAllFieldNames() {
1167       return ALL_FIELD_NAMES;
1168     }
1169   }
1170   public static final RegistrationMessageAccessor REGISTRATION_MESSAGE_ACCESSOR = new RegistrationMessageAccessor();
1171
1172   /** Class to access fields in {@link RegistrationP} protos. */
1173   public static class RegistrationPAccessor implements Accessor {
1174     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
1175       Arrays.<String>asList(
1176         "object_id",
1177         "op_type"
1178       ));
1179
1180     public static final Descriptor OBJECT_ID = new Descriptor("object_id");
1181     public static final Descriptor OP_TYPE = new Descriptor("op_type");
1182
1183     /** Returns whether {@code field} is present in {@code message}. */
1184     @Override
1185     @SuppressWarnings("unchecked")
1186     public boolean hasField(MessageLite rawMessage, Descriptor field) {
1187       Preconditions.checkNotNull(rawMessage);
1188       Preconditions.checkNotNull(field);
1189       RegistrationP message = (RegistrationP) rawMessage;
1190       if (field == OBJECT_ID) {
1191         return message.hasObjectId();
1192       }
1193       if (field == OP_TYPE) {
1194         return message.hasOpType();
1195       }
1196       throw new IllegalArgumentException("Bad descriptor: " + field);
1197     }
1198
1199     /** Returns the {@code field} from {@code message}. */
1200     @Override
1201     @SuppressWarnings("unchecked")
1202     public Object getField(MessageLite rawMessage, Descriptor field) {
1203       Preconditions.checkNotNull(rawMessage);
1204       Preconditions.checkNotNull(field);
1205       RegistrationP message = (RegistrationP) rawMessage;
1206       if (field == OBJECT_ID) {
1207         return message.getObjectId();
1208       }
1209       if (field == OP_TYPE) {
1210         return message.getOpType();
1211       }
1212       throw new IllegalArgumentException("Bad descriptor: " + field);
1213     }
1214
1215     @Override
1216     public Set<String> getAllFieldNames() {
1217       return ALL_FIELD_NAMES;
1218     }
1219   }
1220   public static final RegistrationPAccessor REGISTRATION_P_ACCESSOR = new RegistrationPAccessor();
1221
1222   /** Class to access fields in {@link RegistrationStatus} protos. */
1223   public static class RegistrationStatusAccessor implements Accessor {
1224     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
1225       Arrays.<String>asList(
1226         "registration",
1227         "status"
1228       ));
1229
1230     public static final Descriptor REGISTRATION = new Descriptor("registration");
1231     public static final Descriptor STATUS = new Descriptor("status");
1232
1233     /** Returns whether {@code field} is present in {@code message}. */
1234     @Override
1235     @SuppressWarnings("unchecked")
1236     public boolean hasField(MessageLite rawMessage, Descriptor field) {
1237       Preconditions.checkNotNull(rawMessage);
1238       Preconditions.checkNotNull(field);
1239       RegistrationStatus message = (RegistrationStatus) rawMessage;
1240       if (field == REGISTRATION) {
1241         return message.hasRegistration();
1242       }
1243       if (field == STATUS) {
1244         return message.hasStatus();
1245       }
1246       throw new IllegalArgumentException("Bad descriptor: " + field);
1247     }
1248
1249     /** Returns the {@code field} from {@code message}. */
1250     @Override
1251     @SuppressWarnings("unchecked")
1252     public Object getField(MessageLite rawMessage, Descriptor field) {
1253       Preconditions.checkNotNull(rawMessage);
1254       Preconditions.checkNotNull(field);
1255       RegistrationStatus message = (RegistrationStatus) rawMessage;
1256       if (field == REGISTRATION) {
1257         return message.getRegistration();
1258       }
1259       if (field == STATUS) {
1260         return message.getStatus();
1261       }
1262       throw new IllegalArgumentException("Bad descriptor: " + field);
1263     }
1264
1265     @Override
1266     public Set<String> getAllFieldNames() {
1267       return ALL_FIELD_NAMES;
1268     }
1269   }
1270   public static final RegistrationStatusAccessor REGISTRATION_STATUS_ACCESSOR = new RegistrationStatusAccessor();
1271
1272   /** Class to access fields in {@link RegistrationStatusMessage} protos. */
1273   public static class RegistrationStatusMessageAccessor implements Accessor {
1274     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
1275       Arrays.<String>asList(
1276         "registration_status"
1277       ));
1278
1279     public static final Descriptor REGISTRATION_STATUS = new Descriptor("registration_status");
1280
1281     /** Returns whether {@code field} is present in {@code message}. */
1282     @Override
1283     @SuppressWarnings("unchecked")
1284     public boolean hasField(MessageLite rawMessage, Descriptor field) {
1285       Preconditions.checkNotNull(rawMessage);
1286       Preconditions.checkNotNull(field);
1287       RegistrationStatusMessage message = (RegistrationStatusMessage) rawMessage;
1288       if (field == REGISTRATION_STATUS) {
1289         return message.getRegistrationStatusCount() > 0;
1290       }
1291       throw new IllegalArgumentException("Bad descriptor: " + field);
1292     }
1293
1294     /** Returns the {@code field} from {@code message}. */
1295     @Override
1296     @SuppressWarnings("unchecked")
1297     public Object getField(MessageLite rawMessage, Descriptor field) {
1298       Preconditions.checkNotNull(rawMessage);
1299       Preconditions.checkNotNull(field);
1300       RegistrationStatusMessage message = (RegistrationStatusMessage) rawMessage;
1301       if (field == REGISTRATION_STATUS) {
1302         return message.getRegistrationStatusList();
1303       }
1304       throw new IllegalArgumentException("Bad descriptor: " + field);
1305     }
1306
1307     @Override
1308     public Set<String> getAllFieldNames() {
1309       return ALL_FIELD_NAMES;
1310     }
1311   }
1312   public static final RegistrationStatusMessageAccessor REGISTRATION_STATUS_MESSAGE_ACCESSOR = new RegistrationStatusMessageAccessor();
1313
1314   /** Class to access fields in {@link RegistrationSubtree} protos. */
1315   public static class RegistrationSubtreeAccessor implements Accessor {
1316     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
1317       Arrays.<String>asList(
1318         "registered_object"
1319       ));
1320
1321     public static final Descriptor REGISTERED_OBJECT = new Descriptor("registered_object");
1322
1323     /** Returns whether {@code field} is present in {@code message}. */
1324     @Override
1325     @SuppressWarnings("unchecked")
1326     public boolean hasField(MessageLite rawMessage, Descriptor field) {
1327       Preconditions.checkNotNull(rawMessage);
1328       Preconditions.checkNotNull(field);
1329       RegistrationSubtree message = (RegistrationSubtree) rawMessage;
1330       if (field == REGISTERED_OBJECT) {
1331         return message.getRegisteredObjectCount() > 0;
1332       }
1333       throw new IllegalArgumentException("Bad descriptor: " + field);
1334     }
1335
1336     /** Returns the {@code field} from {@code message}. */
1337     @Override
1338     @SuppressWarnings("unchecked")
1339     public Object getField(MessageLite rawMessage, Descriptor field) {
1340       Preconditions.checkNotNull(rawMessage);
1341       Preconditions.checkNotNull(field);
1342       RegistrationSubtree message = (RegistrationSubtree) rawMessage;
1343       if (field == REGISTERED_OBJECT) {
1344         return message.getRegisteredObjectList();
1345       }
1346       throw new IllegalArgumentException("Bad descriptor: " + field);
1347     }
1348
1349     @Override
1350     public Set<String> getAllFieldNames() {
1351       return ALL_FIELD_NAMES;
1352     }
1353   }
1354   public static final RegistrationSubtreeAccessor REGISTRATION_SUBTREE_ACCESSOR = new RegistrationSubtreeAccessor();
1355
1356   /** Class to access fields in {@link RegistrationSummary} protos. */
1357   public static class RegistrationSummaryAccessor implements Accessor {
1358     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
1359       Arrays.<String>asList(
1360         "num_registrations",
1361         "registration_digest"
1362       ));
1363
1364     public static final Descriptor NUM_REGISTRATIONS = new Descriptor("num_registrations");
1365     public static final Descriptor REGISTRATION_DIGEST = new Descriptor("registration_digest");
1366
1367     /** Returns whether {@code field} is present in {@code message}. */
1368     @Override
1369     @SuppressWarnings("unchecked")
1370     public boolean hasField(MessageLite rawMessage, Descriptor field) {
1371       Preconditions.checkNotNull(rawMessage);
1372       Preconditions.checkNotNull(field);
1373       RegistrationSummary message = (RegistrationSummary) rawMessage;
1374       if (field == NUM_REGISTRATIONS) {
1375         return message.hasNumRegistrations();
1376       }
1377       if (field == REGISTRATION_DIGEST) {
1378         return message.hasRegistrationDigest();
1379       }
1380       throw new IllegalArgumentException("Bad descriptor: " + field);
1381     }
1382
1383     /** Returns the {@code field} from {@code message}. */
1384     @Override
1385     @SuppressWarnings("unchecked")
1386     public Object getField(MessageLite rawMessage, Descriptor field) {
1387       Preconditions.checkNotNull(rawMessage);
1388       Preconditions.checkNotNull(field);
1389       RegistrationSummary message = (RegistrationSummary) rawMessage;
1390       if (field == NUM_REGISTRATIONS) {
1391         return message.getNumRegistrations();
1392       }
1393       if (field == REGISTRATION_DIGEST) {
1394         return message.getRegistrationDigest();
1395       }
1396       throw new IllegalArgumentException("Bad descriptor: " + field);
1397     }
1398
1399     @Override
1400     public Set<String> getAllFieldNames() {
1401       return ALL_FIELD_NAMES;
1402     }
1403   }
1404   public static final RegistrationSummaryAccessor REGISTRATION_SUMMARY_ACCESSOR = new RegistrationSummaryAccessor();
1405
1406   /** Class to access fields in {@link RegistrationSyncMessage} protos. */
1407   public static class RegistrationSyncMessageAccessor implements Accessor {
1408     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
1409       Arrays.<String>asList(
1410         "subtree"
1411       ));
1412
1413     public static final Descriptor SUBTREE = new Descriptor("subtree");
1414
1415     /** Returns whether {@code field} is present in {@code message}. */
1416     @Override
1417     @SuppressWarnings("unchecked")
1418     public boolean hasField(MessageLite rawMessage, Descriptor field) {
1419       Preconditions.checkNotNull(rawMessage);
1420       Preconditions.checkNotNull(field);
1421       RegistrationSyncMessage message = (RegistrationSyncMessage) rawMessage;
1422       if (field == SUBTREE) {
1423         return message.getSubtreeCount() > 0;
1424       }
1425       throw new IllegalArgumentException("Bad descriptor: " + field);
1426     }
1427
1428     /** Returns the {@code field} from {@code message}. */
1429     @Override
1430     @SuppressWarnings("unchecked")
1431     public Object getField(MessageLite rawMessage, Descriptor field) {
1432       Preconditions.checkNotNull(rawMessage);
1433       Preconditions.checkNotNull(field);
1434       RegistrationSyncMessage message = (RegistrationSyncMessage) rawMessage;
1435       if (field == SUBTREE) {
1436         return message.getSubtreeList();
1437       }
1438       throw new IllegalArgumentException("Bad descriptor: " + field);
1439     }
1440
1441     @Override
1442     public Set<String> getAllFieldNames() {
1443       return ALL_FIELD_NAMES;
1444     }
1445   }
1446   public static final RegistrationSyncMessageAccessor REGISTRATION_SYNC_MESSAGE_ACCESSOR = new RegistrationSyncMessageAccessor();
1447
1448   /** Class to access fields in {@link RegistrationSyncRequestMessage} protos. */
1449   public static class RegistrationSyncRequestMessageAccessor implements Accessor {
1450     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
1451       Arrays.<String>asList(
1452       ));
1453
1454
1455     /** Returns whether {@code field} is present in {@code message}. */
1456     @Override
1457     @SuppressWarnings("unchecked")
1458     public boolean hasField(MessageLite rawMessage, Descriptor field) {
1459       Preconditions.checkNotNull(rawMessage);
1460       Preconditions.checkNotNull(field);
1461       RegistrationSyncRequestMessage message = (RegistrationSyncRequestMessage) rawMessage;
1462       throw new IllegalArgumentException("Bad descriptor: " + field);
1463     }
1464
1465     /** Returns the {@code field} from {@code message}. */
1466     @Override
1467     @SuppressWarnings("unchecked")
1468     public Object getField(MessageLite rawMessage, Descriptor field) {
1469       Preconditions.checkNotNull(rawMessage);
1470       Preconditions.checkNotNull(field);
1471       RegistrationSyncRequestMessage message = (RegistrationSyncRequestMessage) rawMessage;
1472       throw new IllegalArgumentException("Bad descriptor: " + field);
1473     }
1474
1475     @Override
1476     public Set<String> getAllFieldNames() {
1477       return ALL_FIELD_NAMES;
1478     }
1479   }
1480   public static final RegistrationSyncRequestMessageAccessor REGISTRATION_SYNC_REQUEST_MESSAGE_ACCESSOR = new RegistrationSyncRequestMessageAccessor();
1481
1482   /** Class to access fields in {@link ServerHeader} protos. */
1483   public static class ServerHeaderAccessor implements Accessor {
1484     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
1485       Arrays.<String>asList(
1486         "protocol_version",
1487         "client_token",
1488         "registration_summary",
1489         "server_time_ms",
1490         "message_id"
1491       ));
1492
1493     public static final Descriptor PROTOCOL_VERSION = new Descriptor("protocol_version");
1494     public static final Descriptor CLIENT_TOKEN = new Descriptor("client_token");
1495     public static final Descriptor REGISTRATION_SUMMARY = new Descriptor("registration_summary");
1496     public static final Descriptor SERVER_TIME_MS = new Descriptor("server_time_ms");
1497     public static final Descriptor MESSAGE_ID = new Descriptor("message_id");
1498
1499     /** Returns whether {@code field} is present in {@code message}. */
1500     @Override
1501     @SuppressWarnings("unchecked")
1502     public boolean hasField(MessageLite rawMessage, Descriptor field) {
1503       Preconditions.checkNotNull(rawMessage);
1504       Preconditions.checkNotNull(field);
1505       ServerHeader message = (ServerHeader) rawMessage;
1506       if (field == PROTOCOL_VERSION) {
1507         return message.hasProtocolVersion();
1508       }
1509       if (field == CLIENT_TOKEN) {
1510         return message.hasClientToken();
1511       }
1512       if (field == REGISTRATION_SUMMARY) {
1513         return message.hasRegistrationSummary();
1514       }
1515       if (field == SERVER_TIME_MS) {
1516         return message.hasServerTimeMs();
1517       }
1518       if (field == MESSAGE_ID) {
1519         return message.hasMessageId();
1520       }
1521       throw new IllegalArgumentException("Bad descriptor: " + field);
1522     }
1523
1524     /** Returns the {@code field} from {@code message}. */
1525     @Override
1526     @SuppressWarnings("unchecked")
1527     public Object getField(MessageLite rawMessage, Descriptor field) {
1528       Preconditions.checkNotNull(rawMessage);
1529       Preconditions.checkNotNull(field);
1530       ServerHeader message = (ServerHeader) rawMessage;
1531       if (field == PROTOCOL_VERSION) {
1532         return message.getProtocolVersion();
1533       }
1534       if (field == CLIENT_TOKEN) {
1535         return message.getClientToken();
1536       }
1537       if (field == REGISTRATION_SUMMARY) {
1538         return message.getRegistrationSummary();
1539       }
1540       if (field == SERVER_TIME_MS) {
1541         return message.getServerTimeMs();
1542       }
1543       if (field == MESSAGE_ID) {
1544         return message.getMessageId();
1545       }
1546       throw new IllegalArgumentException("Bad descriptor: " + field);
1547     }
1548
1549     @Override
1550     public Set<String> getAllFieldNames() {
1551       return ALL_FIELD_NAMES;
1552     }
1553   }
1554   public static final ServerHeaderAccessor SERVER_HEADER_ACCESSOR = new ServerHeaderAccessor();
1555
1556   /** Class to access fields in {@link ServerToClientMessage} protos. */
1557   public static class ServerToClientMessageAccessor implements Accessor {
1558     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
1559       Arrays.<String>asList(
1560         "header",
1561         "token_control_message",
1562         "invalidation_message",
1563         "registration_status_message",
1564         "registration_sync_request_message",
1565         "config_change_message",
1566         "info_request_message",
1567         "error_message"
1568       ));
1569
1570     public static final Descriptor HEADER = new Descriptor("header");
1571     public static final Descriptor TOKEN_CONTROL_MESSAGE = new Descriptor("token_control_message");
1572     public static final Descriptor INVALIDATION_MESSAGE = new Descriptor("invalidation_message");
1573     public static final Descriptor REGISTRATION_STATUS_MESSAGE = new Descriptor("registration_status_message");
1574     public static final Descriptor REGISTRATION_SYNC_REQUEST_MESSAGE = new Descriptor("registration_sync_request_message");
1575     public static final Descriptor CONFIG_CHANGE_MESSAGE = new Descriptor("config_change_message");
1576     public static final Descriptor INFO_REQUEST_MESSAGE = new Descriptor("info_request_message");
1577     public static final Descriptor ERROR_MESSAGE = new Descriptor("error_message");
1578
1579     /** Returns whether {@code field} is present in {@code message}. */
1580     @Override
1581     @SuppressWarnings("unchecked")
1582     public boolean hasField(MessageLite rawMessage, Descriptor field) {
1583       Preconditions.checkNotNull(rawMessage);
1584       Preconditions.checkNotNull(field);
1585       ServerToClientMessage message = (ServerToClientMessage) rawMessage;
1586       if (field == HEADER) {
1587         return message.hasHeader();
1588       }
1589       if (field == TOKEN_CONTROL_MESSAGE) {
1590         return message.hasTokenControlMessage();
1591       }
1592       if (field == INVALIDATION_MESSAGE) {
1593         return message.hasInvalidationMessage();
1594       }
1595       if (field == REGISTRATION_STATUS_MESSAGE) {
1596         return message.hasRegistrationStatusMessage();
1597       }
1598       if (field == REGISTRATION_SYNC_REQUEST_MESSAGE) {
1599         return message.hasRegistrationSyncRequestMessage();
1600       }
1601       if (field == CONFIG_CHANGE_MESSAGE) {
1602         return message.hasConfigChangeMessage();
1603       }
1604       if (field == INFO_REQUEST_MESSAGE) {
1605         return message.hasInfoRequestMessage();
1606       }
1607       if (field == ERROR_MESSAGE) {
1608         return message.hasErrorMessage();
1609       }
1610       throw new IllegalArgumentException("Bad descriptor: " + field);
1611     }
1612
1613     /** Returns the {@code field} from {@code message}. */
1614     @Override
1615     @SuppressWarnings("unchecked")
1616     public Object getField(MessageLite rawMessage, Descriptor field) {
1617       Preconditions.checkNotNull(rawMessage);
1618       Preconditions.checkNotNull(field);
1619       ServerToClientMessage message = (ServerToClientMessage) rawMessage;
1620       if (field == HEADER) {
1621         return message.getHeader();
1622       }
1623       if (field == TOKEN_CONTROL_MESSAGE) {
1624         return message.getTokenControlMessage();
1625       }
1626       if (field == INVALIDATION_MESSAGE) {
1627         return message.getInvalidationMessage();
1628       }
1629       if (field == REGISTRATION_STATUS_MESSAGE) {
1630         return message.getRegistrationStatusMessage();
1631       }
1632       if (field == REGISTRATION_SYNC_REQUEST_MESSAGE) {
1633         return message.getRegistrationSyncRequestMessage();
1634       }
1635       if (field == CONFIG_CHANGE_MESSAGE) {
1636         return message.getConfigChangeMessage();
1637       }
1638       if (field == INFO_REQUEST_MESSAGE) {
1639         return message.getInfoRequestMessage();
1640       }
1641       if (field == ERROR_MESSAGE) {
1642         return message.getErrorMessage();
1643       }
1644       throw new IllegalArgumentException("Bad descriptor: " + field);
1645     }
1646
1647     @Override
1648     public Set<String> getAllFieldNames() {
1649       return ALL_FIELD_NAMES;
1650     }
1651   }
1652   public static final ServerToClientMessageAccessor SERVER_TO_CLIENT_MESSAGE_ACCESSOR = new ServerToClientMessageAccessor();
1653
1654   /** Class to access fields in {@link StatusP} protos. */
1655   public static class StatusPAccessor implements Accessor {
1656     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
1657       Arrays.<String>asList(
1658         "code",
1659         "description"
1660       ));
1661
1662     public static final Descriptor CODE = new Descriptor("code");
1663     public static final Descriptor DESCRIPTION = new Descriptor("description");
1664
1665     /** Returns whether {@code field} is present in {@code message}. */
1666     @Override
1667     @SuppressWarnings("unchecked")
1668     public boolean hasField(MessageLite rawMessage, Descriptor field) {
1669       Preconditions.checkNotNull(rawMessage);
1670       Preconditions.checkNotNull(field);
1671       StatusP message = (StatusP) rawMessage;
1672       if (field == CODE) {
1673         return message.hasCode();
1674       }
1675       if (field == DESCRIPTION) {
1676         return message.hasDescription();
1677       }
1678       throw new IllegalArgumentException("Bad descriptor: " + field);
1679     }
1680
1681     /** Returns the {@code field} from {@code message}. */
1682     @Override
1683     @SuppressWarnings("unchecked")
1684     public Object getField(MessageLite rawMessage, Descriptor field) {
1685       Preconditions.checkNotNull(rawMessage);
1686       Preconditions.checkNotNull(field);
1687       StatusP message = (StatusP) rawMessage;
1688       if (field == CODE) {
1689         return message.getCode();
1690       }
1691       if (field == DESCRIPTION) {
1692         return message.getDescription();
1693       }
1694       throw new IllegalArgumentException("Bad descriptor: " + field);
1695     }
1696
1697     @Override
1698     public Set<String> getAllFieldNames() {
1699       return ALL_FIELD_NAMES;
1700     }
1701   }
1702   public static final StatusPAccessor STATUS_P_ACCESSOR = new StatusPAccessor();
1703
1704   /** Class to access fields in {@link TokenControlMessage} protos. */
1705   public static class TokenControlMessageAccessor implements Accessor {
1706     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
1707       Arrays.<String>asList(
1708         "new_token"
1709       ));
1710
1711     public static final Descriptor NEW_TOKEN = new Descriptor("new_token");
1712
1713     /** Returns whether {@code field} is present in {@code message}. */
1714     @Override
1715     @SuppressWarnings("unchecked")
1716     public boolean hasField(MessageLite rawMessage, Descriptor field) {
1717       Preconditions.checkNotNull(rawMessage);
1718       Preconditions.checkNotNull(field);
1719       TokenControlMessage message = (TokenControlMessage) rawMessage;
1720       if (field == NEW_TOKEN) {
1721         return message.hasNewToken();
1722       }
1723       throw new IllegalArgumentException("Bad descriptor: " + field);
1724     }
1725
1726     /** Returns the {@code field} from {@code message}. */
1727     @Override
1728     @SuppressWarnings("unchecked")
1729     public Object getField(MessageLite rawMessage, Descriptor field) {
1730       Preconditions.checkNotNull(rawMessage);
1731       Preconditions.checkNotNull(field);
1732       TokenControlMessage message = (TokenControlMessage) rawMessage;
1733       if (field == NEW_TOKEN) {
1734         return message.getNewToken();
1735       }
1736       throw new IllegalArgumentException("Bad descriptor: " + field);
1737     }
1738
1739     @Override
1740     public Set<String> getAllFieldNames() {
1741       return ALL_FIELD_NAMES;
1742     }
1743   }
1744   public static final TokenControlMessageAccessor TOKEN_CONTROL_MESSAGE_ACCESSOR = new TokenControlMessageAccessor();
1745
1746   /** Class to access fields in {@link Version} protos. */
1747   public static class VersionAccessor implements Accessor {
1748     private static final Set<String> ALL_FIELD_NAMES = new HashSet<String>(
1749       Arrays.<String>asList(
1750         "major_version",
1751         "minor_version"
1752       ));
1753
1754     public static final Descriptor MAJOR_VERSION = new Descriptor("major_version");
1755     public static final Descriptor MINOR_VERSION = new Descriptor("minor_version");
1756
1757     /** Returns whether {@code field} is present in {@code message}. */
1758     @Override
1759     @SuppressWarnings("unchecked")
1760     public boolean hasField(MessageLite rawMessage, Descriptor field) {
1761       Preconditions.checkNotNull(rawMessage);
1762       Preconditions.checkNotNull(field);
1763       Version message = (Version) rawMessage;
1764       if (field == MAJOR_VERSION) {
1765         return message.hasMajorVersion();
1766       }
1767       if (field == MINOR_VERSION) {
1768         return message.hasMinorVersion();
1769       }
1770       throw new IllegalArgumentException("Bad descriptor: " + field);
1771     }
1772
1773     /** Returns the {@code field} from {@code message}. */
1774     @Override
1775     @SuppressWarnings("unchecked")
1776     public Object getField(MessageLite rawMessage, Descriptor field) {
1777       Preconditions.checkNotNull(rawMessage);
1778       Preconditions.checkNotNull(field);
1779       Version message = (Version) rawMessage;
1780       if (field == MAJOR_VERSION) {
1781         return message.getMajorVersion();
1782       }
1783       if (field == MINOR_VERSION) {
1784         return message.getMinorVersion();
1785       }
1786       throw new IllegalArgumentException("Bad descriptor: " + field);
1787     }
1788
1789     @Override
1790     public Set<String> getAllFieldNames() {
1791       return ALL_FIELD_NAMES;
1792     }
1793   }
1794   public static final VersionAccessor VERSION_ACCESSOR = new VersionAccessor();
1795
1796 }