src/components/policy/src/policy/policy_table/table_struct_ext/types.cc

   1 // This file is generated, do not edit
   2 #include "./types.h"
   3 #include "rpc_base/rpc_base_json_inl.h"
   4
   5 namespace rpc {
   6 namespace policy_table_interface_base {
   7 // ApplicationParams methods
   8 ApplicationParams::ApplicationParams()
   9   : CompositeType(kUninitialized) {
  10 }
  11 ApplicationParams::ApplicationParams(const Strings& groups, Priority priority, HmiLevel default_hmi, bool keep_context, bool steal_focus)
  12   : CompositeType(kUninitialized),
  13     groups(groups),
  14     priority(priority),
  15     default_hmi(default_hmi),
  16     keep_context(keep_context),
  17     steal_focus(steal_focus) {
  18 }
  19 ApplicationParams::~ApplicationParams() {
  20 }
  21 ApplicationParams::ApplicationParams(const Json::Value* value__)
  22   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
  23     groups(impl::ValueMember(value__, "groups")),
  24     nicknames(impl::ValueMember(value__, "nicknames")),
  25     preconsented_groups(impl::ValueMember(value__, "preconsented_groups")),
  26     AppHMIType(impl::ValueMember(value__, "AppHMIType")),
  27     priority(impl::ValueMember(value__, "priority")),
  28     default_hmi(impl::ValueMember(value__, "default_hmi")),
  29     keep_context(impl::ValueMember(value__, "keep_context")),
  30     steal_focus(impl::ValueMember(value__, "steal_focus")),
  31     memory_kb(impl::ValueMember(value__, "memory_kb")),
  32     heart_beat_timeout_ms(impl::ValueMember(value__, "heart_beat_timeout_ms")),
  33     certificate(impl::ValueMember(value__, "certificate")) {
  34 }
  35 Json::Value ApplicationParams::ToJsonValue() const {
  36   Json::Value result__(Json::objectValue);
  37   impl::WriteJsonField("groups", groups, &result__);
  38   impl::WriteJsonField("nicknames", nicknames, &result__);
  39   impl::WriteJsonField("preconsented_groups", preconsented_groups, &result__);
  40   impl::WriteJsonField("AppHMIType", AppHMIType, &result__);
  41   impl::WriteJsonField("priority", priority, &result__);
  42   impl::WriteJsonField("default_hmi", default_hmi, &result__);
  43   impl::WriteJsonField("keep_context", keep_context, &result__);
  44   impl::WriteJsonField("steal_focus", steal_focus, &result__);
  45   impl::WriteJsonField("memory_kb", memory_kb, &result__);
  46   impl::WriteJsonField("heart_beat_timeout_ms", heart_beat_timeout_ms, &result__);
  47   impl::WriteJsonField("certificate", certificate, &result__);
  48   return result__;
  49 }
  50 bool ApplicationParams::is_valid() const {
  51   if (!groups.is_valid()) {
  52     return false;
  53   }
  54   if (!nicknames.is_valid()) {
  55     return false;
  56   }
  57   if (!preconsented_groups.is_valid()) {
  58     return false;
  59   }
  60   if (!AppHMIType.is_valid()) {
  61     return false;
  62   }
  63   if (!priority.is_valid()) {
  64     return false;
  65   }
  66   if (!default_hmi.is_valid()) {
  67     return false;
  68   }
  69   if (!keep_context.is_valid()) {
  70     return false;
  71   }
  72   if (!steal_focus.is_valid()) {
  73     return false;
  74   }
  75   if (!memory_kb.is_valid()) {
  76     return false;
  77   }
  78   if (!heart_beat_timeout_ms.is_valid()) {
  79     return false;
  80   }
  81   if (!certificate.is_valid()) {
  82     return false;
  83   }
  84   return Validate();
  85 }
  86 bool ApplicationParams::is_initialized() const {
  87   return (initialization_state__ != kUninitialized) || (!struct_empty());
  88 }
  89 bool ApplicationParams::struct_empty() const {
  90   if (groups.is_initialized()) {
  91     return false;
  92   }
  93   if (nicknames.is_initialized()) {
  94     return false;
  95   }
  96
  97   if (preconsented_groups.is_initialized()) {
  98     return false;
  99   }
 100   if (AppHMIType.is_initialized()) {
 101     return false;
 102   }
 103
 104   if (priority.is_initialized()) {
 105     return false;
 106   }
 107   if (default_hmi.is_initialized()) {
 108     return false;
 109   }
 110
 111   if (keep_context.is_initialized()) {
 112     return false;
 113   }
 114   if (steal_focus.is_initialized()) {
 115     return false;
 116   }
 117
 118   if (memory_kb.is_initialized()) {
 119     return false;
 120   }
 121   if (heart_beat_timeout_ms.is_initialized()) {
 122     return false;
 123   }
 124
 125   if (certificate.is_initialized()) {
 126     return false;
 127   }
 128   return true;
 129 }
 130 void ApplicationParams::ReportErrors(rpc::ValidationReport* report__) const {
 131   if (struct_empty()) {
 132     rpc::CompositeType::ReportErrors(report__);
 133   }
 134   if (!groups.is_valid()) {
 135     groups.ReportErrors(&report__->ReportSubobject("groups"));
 136   }
 137   if (!nicknames.is_valid()) {
 138     nicknames.ReportErrors(&report__->ReportSubobject("nicknames"));
 139   }
 140   if (!preconsented_groups.is_valid()) {
 141     preconsented_groups.ReportErrors(&report__->ReportSubobject("preconsented_groups"));
 142   }
 143   if (!AppHMIType.is_valid()) {
 144     AppHMIType.ReportErrors(&report__->ReportSubobject("AppHMIType"));
 145   }
 146   if (!priority.is_valid()) {
 147     priority.ReportErrors(&report__->ReportSubobject("priority"));
 148   }
 149   if (!default_hmi.is_valid()) {
 150     default_hmi.ReportErrors(&report__->ReportSubobject("default_hmi"));
 151   }
 152   if (!keep_context.is_valid()) {
 153     keep_context.ReportErrors(&report__->ReportSubobject("keep_context"));
 154   }
 155   if (!steal_focus.is_valid()) {
 156     steal_focus.ReportErrors(&report__->ReportSubobject("steal_focus"));
 157   }
 158   if (!memory_kb.is_valid()) {
 159     memory_kb.ReportErrors(&report__->ReportSubobject("memory_kb"));
 160   }
 161   if (!heart_beat_timeout_ms.is_valid()) {
 162     heart_beat_timeout_ms.ReportErrors(&report__->ReportSubobject("heart_beat_timeout_ms"));
 163   }
 164   if (!certificate.is_valid()) {
 165     certificate.ReportErrors(&report__->ReportSubobject("certificate"));
 166   }
 167 }
 168
 169 // RpcParameters methods
 170 RpcParameters::RpcParameters()
 171   : CompositeType(kUninitialized) {
 172 }
 173 RpcParameters::RpcParameters(const HmiLevels& hmi_levels)
 174   : CompositeType(kUninitialized),
 175     hmi_levels(hmi_levels) {
 176 }
 177 RpcParameters::~RpcParameters() {
 178 }
 179 RpcParameters::RpcParameters(const Json::Value* value__)
 180   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 181     hmi_levels(impl::ValueMember(value__, "hmi_levels")),
 182     parameters(impl::ValueMember(value__, "parameters")) {
 183 }
 184 Json::Value RpcParameters::ToJsonValue() const {
 185   Json::Value result__(Json::objectValue);
 186   impl::WriteJsonField("hmi_levels", hmi_levels, &result__);
 187   impl::WriteJsonField("parameters", parameters, &result__);
 188   return result__;
 189 }
 190 bool RpcParameters::is_valid() const {
 191   if (!hmi_levels.is_valid()) {
 192     return false;
 193   }
 194   if (!parameters.is_valid()) {
 195     return false;
 196   }
 197   return Validate();
 198 }
 199 bool RpcParameters::is_initialized() const {
 200   return (initialization_state__ != kUninitialized) || (!struct_empty());
 201 }
 202 bool RpcParameters::struct_empty() const {
 203   if (hmi_levels.is_initialized()) {
 204     return false;
 205   }
 206   if (parameters.is_initialized()) {
 207     return false;
 208   }
 209
 210   return true;
 211 }
 212 void RpcParameters::ReportErrors(rpc::ValidationReport* report__) const {
 213   if (struct_empty()) {
 214     rpc::CompositeType::ReportErrors(report__);
 215   }
 216   if (!hmi_levels.is_valid()) {
 217     hmi_levels.ReportErrors(&report__->ReportSubobject("hmi_levels"));
 218   }
 219   if (!parameters.is_valid()) {
 220     parameters.ReportErrors(&report__->ReportSubobject("parameters"));
 221   }
 222 }
 223
 224 // Rpcs methods
 225 Rpcs::Rpcs()
 226   : CompositeType(kUninitialized) {
 227 }
 228 Rpcs::Rpcs(const Rpc& rpcs)
 229   : CompositeType(kUninitialized),
 230     rpcs(rpcs) {
 231 }
 232 Rpcs::~Rpcs() {
 233 }
 234 Rpcs::Rpcs(const Json::Value* value__)
 235   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 236     user_consent_prompt(impl::ValueMember(value__, "user_consent_prompt")),
 237     rpcs(impl::ValueMember(value__, "rpcs")) {
 238 }
 239 Json::Value Rpcs::ToJsonValue() const {
 240   Json::Value result__(Json::objectValue);
 241   impl::WriteJsonField("user_consent_prompt", user_consent_prompt, &result__);
 242   impl::WriteJsonField("rpcs", rpcs, &result__);
 243   return result__;
 244 }
 245 bool Rpcs::is_valid() const {
 246   if (!user_consent_prompt.is_valid()) {
 247     return false;
 248   }
 249   if (!rpcs.is_valid()) {
 250     return false;
 251   }
 252   return Validate();
 253 }
 254 bool Rpcs::is_initialized() const {
 255   return (initialization_state__ != kUninitialized) || (!struct_empty());
 256 }
 257 bool Rpcs::struct_empty() const {
 258   if (user_consent_prompt.is_initialized()) {
 259     return false;
 260   }
 261   if (rpcs.is_initialized()) {
 262     return false;
 263   }
 264
 265   return true;
 266 }
 267 void Rpcs::ReportErrors(rpc::ValidationReport* report__) const {
 268   if (struct_empty()) {
 269     rpc::CompositeType::ReportErrors(report__);
 270   }
 271   if (!user_consent_prompt.is_valid()) {
 272     user_consent_prompt.ReportErrors(&report__->ReportSubobject("user_consent_prompt"));
 273   }
 274   if (!rpcs.is_valid()) {
 275     rpcs.ReportErrors(&report__->ReportSubobject("rpcs"));
 276   }
 277 }
 278
 279 // ModuleConfig methods
 280 ModuleConfig::ModuleConfig()
 281   : CompositeType(kUninitialized) {
 282 }
 283 ModuleConfig::ModuleConfig(uint8_t exchange_after_x_ignition_cycles, int64_t exchange_after_x_kilometers, uint8_t exchange_after_x_days, uint16_t timeout_after_x_seconds, const SecondsBetweenRetries& seconds_between_retries, const ServiceEndpoints& endpoints, const NumberOfNotificationsPerMinute& notifications_per_minute_by_priority)
 284   : CompositeType(kUninitialized),
 285     exchange_after_x_ignition_cycles(exchange_after_x_ignition_cycles),
 286     exchange_after_x_kilometers(exchange_after_x_kilometers),
 287     exchange_after_x_days(exchange_after_x_days),
 288     timeout_after_x_seconds(timeout_after_x_seconds),
 289     seconds_between_retries(seconds_between_retries),
 290     endpoints(endpoints),
 291     notifications_per_minute_by_priority(notifications_per_minute_by_priority) {
 292 }
 293 ModuleConfig::~ModuleConfig() {
 294 }
 295 ModuleConfig::ModuleConfig(const Json::Value* value__)
 296   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 297     device_certificates(impl::ValueMember(value__, "device_certificates")),
 298     preloaded_pt(impl::ValueMember(value__, "preloaded_pt")),
 299     exchange_after_x_ignition_cycles(impl::ValueMember(value__, "exchange_after_x_ignition_cycles")),
 300     exchange_after_x_kilometers(impl::ValueMember(value__, "exchange_after_x_kilometers")),
 301     exchange_after_x_days(impl::ValueMember(value__, "exchange_after_x_days")),
 302     timeout_after_x_seconds(impl::ValueMember(value__, "timeout_after_x_seconds")),
 303     seconds_between_retries(impl::ValueMember(value__, "seconds_between_retries")),
 304     endpoints(impl::ValueMember(value__, "endpoints")),
 305     notifications_per_minute_by_priority(impl::ValueMember(value__, "notifications_per_minute_by_priority")),
 306     vehicle_make(impl::ValueMember(value__, "vehicle_make")),
 307     vehicle_model(impl::ValueMember(value__, "vehicle_model")),
 308     vehicle_year(impl::ValueMember(value__, "vehicle_year")) {
 309 }
 310 Json::Value ModuleConfig::ToJsonValue() const {
 311   Json::Value result__(Json::objectValue);
 312   impl::WriteJsonField("device_certificates", device_certificates, &result__);
 313   impl::WriteJsonField("preloaded_pt", preloaded_pt, &result__);
 314   impl::WriteJsonField("exchange_after_x_ignition_cycles", exchange_after_x_ignition_cycles, &result__);
 315   impl::WriteJsonField("exchange_after_x_kilometers", exchange_after_x_kilometers, &result__);
 316   impl::WriteJsonField("exchange_after_x_days", exchange_after_x_days, &result__);
 317   impl::WriteJsonField("timeout_after_x_seconds", timeout_after_x_seconds, &result__);
 318   impl::WriteJsonField("seconds_between_retries", seconds_between_retries, &result__);
 319   impl::WriteJsonField("endpoints", endpoints, &result__);
 320   impl::WriteJsonField("notifications_per_minute_by_priority", notifications_per_minute_by_priority, &result__);
 321   impl::WriteJsonField("vehicle_make", vehicle_make, &result__);
 322   impl::WriteJsonField("vehicle_model", vehicle_model, &result__);
 323   impl::WriteJsonField("vehicle_year", vehicle_year, &result__);
 324   return result__;
 325 }
 326 bool ModuleConfig::is_valid() const {
 327   if (!device_certificates.is_valid()) {
 328     return false;
 329   }
 330   if (!preloaded_pt.is_valid()) {
 331     return false;
 332   }
 333   if (!exchange_after_x_ignition_cycles.is_valid()) {
 334     return false;
 335   }
 336   if (!exchange_after_x_kilometers.is_valid()) {
 337     return false;
 338   }
 339   if (!exchange_after_x_days.is_valid()) {
 340     return false;
 341   }
 342   if (!timeout_after_x_seconds.is_valid()) {
 343     return false;
 344   }
 345   if (!seconds_between_retries.is_valid()) {
 346     return false;
 347   }
 348   if (!endpoints.is_valid()) {
 349     return false;
 350   }
 351   if (!notifications_per_minute_by_priority.is_valid()) {
 352     return false;
 353   }
 354   if (!vehicle_make.is_valid()) {
 355     return false;
 356   }
 357   if (!vehicle_model.is_valid()) {
 358     return false;
 359   }
 360   if (!vehicle_year.is_valid()) {
 361     return false;
 362   }
 363   return Validate();
 364 }
 365 bool ModuleConfig::is_initialized() const {
 366   return (initialization_state__ != kUninitialized) || (!struct_empty());
 367 }
 368 bool ModuleConfig::struct_empty() const {
 369   if (device_certificates.is_initialized()) {
 370     return false;
 371   }
 372   if (preloaded_pt.is_initialized()) {
 373     return false;
 374   }
 375
 376   if (exchange_after_x_ignition_cycles.is_initialized()) {
 377     return false;
 378   }
 379   if (exchange_after_x_kilometers.is_initialized()) {
 380     return false;
 381   }
 382
 383   if (exchange_after_x_days.is_initialized()) {
 384     return false;
 385   }
 386   if (timeout_after_x_seconds.is_initialized()) {
 387     return false;
 388   }
 389
 390   if (seconds_between_retries.is_initialized()) {
 391     return false;
 392   }
 393   if (endpoints.is_initialized()) {
 394     return false;
 395   }
 396
 397   if (notifications_per_minute_by_priority.is_initialized()) {
 398     return false;
 399   }
 400   if (vehicle_make.is_initialized()) {
 401     return false;
 402   }
 403
 404   if (vehicle_model.is_initialized()) {
 405     return false;
 406   }
 407   if (vehicle_year.is_initialized()) {
 408     return false;
 409   }
 410
 411   return true;
 412 }
 413 void ModuleConfig::ReportErrors(rpc::ValidationReport* report__) const {
 414   if (struct_empty()) {
 415     rpc::CompositeType::ReportErrors(report__);
 416   }
 417   if (!device_certificates.is_valid()) {
 418     device_certificates.ReportErrors(&report__->ReportSubobject("device_certificates"));
 419   }
 420   if (!preloaded_pt.is_valid()) {
 421     preloaded_pt.ReportErrors(&report__->ReportSubobject("preloaded_pt"));
 422   }
 423   if (!exchange_after_x_ignition_cycles.is_valid()) {
 424     exchange_after_x_ignition_cycles.ReportErrors(&report__->ReportSubobject("exchange_after_x_ignition_cycles"));
 425   }
 426   if (!exchange_after_x_kilometers.is_valid()) {
 427     exchange_after_x_kilometers.ReportErrors(&report__->ReportSubobject("exchange_after_x_kilometers"));
 428   }
 429   if (!exchange_after_x_days.is_valid()) {
 430     exchange_after_x_days.ReportErrors(&report__->ReportSubobject("exchange_after_x_days"));
 431   }
 432   if (!timeout_after_x_seconds.is_valid()) {
 433     timeout_after_x_seconds.ReportErrors(&report__->ReportSubobject("timeout_after_x_seconds"));
 434   }
 435   if (!seconds_between_retries.is_valid()) {
 436     seconds_between_retries.ReportErrors(&report__->ReportSubobject("seconds_between_retries"));
 437   }
 438   if (!endpoints.is_valid()) {
 439     endpoints.ReportErrors(&report__->ReportSubobject("endpoints"));
 440   }
 441   if (!notifications_per_minute_by_priority.is_valid()) {
 442     notifications_per_minute_by_priority.ReportErrors(&report__->ReportSubobject("notifications_per_minute_by_priority"));
 443   }
 444   if (!vehicle_make.is_valid()) {
 445     vehicle_make.ReportErrors(&report__->ReportSubobject("vehicle_make"));
 446   }
 447   if (!vehicle_model.is_valid()) {
 448     vehicle_model.ReportErrors(&report__->ReportSubobject("vehicle_model"));
 449   }
 450   if (!vehicle_year.is_valid()) {
 451     vehicle_year.ReportErrors(&report__->ReportSubobject("vehicle_year"));
 452   }
 453 }
 454
 455 // MessageString methods
 456 MessageString::MessageString()
 457   : CompositeType(kUninitialized) {
 458 }
 459 MessageString::~MessageString() {
 460 }
 461 MessageString::MessageString(const Json::Value* value__)
 462   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 463     line1(impl::ValueMember(value__, "line1")),
 464     line2(impl::ValueMember(value__, "line2")),
 465     tts(impl::ValueMember(value__, "tts")),
 466     label(impl::ValueMember(value__, "label")),
 467     textBody(impl::ValueMember(value__, "textBody")) {
 468 }
 469 Json::Value MessageString::ToJsonValue() const {
 470   Json::Value result__(Json::objectValue);
 471   impl::WriteJsonField("line1", line1, &result__);
 472   impl::WriteJsonField("line2", line2, &result__);
 473   impl::WriteJsonField("tts", tts, &result__);
 474   impl::WriteJsonField("label", label, &result__);
 475   impl::WriteJsonField("textBody", textBody, &result__);
 476   return result__;
 477 }
 478 bool MessageString::is_valid() const {
 479   if (struct_empty()) {
 480     return initialization_state__ == kInitialized;
 481   }
 482   if (!line1.is_valid()) {
 483     return false;
 484   }
 485   if (!line2.is_valid()) {
 486     return false;
 487   }
 488   if (!tts.is_valid()) {
 489     return false;
 490   }
 491   if (!label.is_valid()) {
 492     return false;
 493   }
 494   if (!textBody.is_valid()) {
 495     return false;
 496   }
 497   return Validate();
 498 }
 499 bool MessageString::is_initialized() const {
 500   return (initialization_state__ != kUninitialized) || (!struct_empty());
 501 }
 502 bool MessageString::struct_empty() const {
 503   if (line1.is_initialized()) {
 504     return false;
 505   }
 506   if (line2.is_initialized()) {
 507     return false;
 508   }
 509
 510   if (tts.is_initialized()) {
 511     return false;
 512   }
 513   if (label.is_initialized()) {
 514     return false;
 515   }
 516
 517   if (textBody.is_initialized()) {
 518     return false;
 519   }
 520   return true;
 521 }
 522 void MessageString::ReportErrors(rpc::ValidationReport* report__) const {
 523   if (struct_empty()) {
 524     rpc::CompositeType::ReportErrors(report__);
 525   }
 526   if (!line1.is_valid()) {
 527     line1.ReportErrors(&report__->ReportSubobject("line1"));
 528   }
 529   if (!line2.is_valid()) {
 530     line2.ReportErrors(&report__->ReportSubobject("line2"));
 531   }
 532   if (!tts.is_valid()) {
 533     tts.ReportErrors(&report__->ReportSubobject("tts"));
 534   }
 535   if (!label.is_valid()) {
 536     label.ReportErrors(&report__->ReportSubobject("label"));
 537   }
 538   if (!textBody.is_valid()) {
 539     textBody.ReportErrors(&report__->ReportSubobject("textBody"));
 540   }
 541 }
 542
 543 // MessageLanguages methods
 544 MessageLanguages::MessageLanguages()
 545   : CompositeType(kUninitialized) {
 546 }
 547 MessageLanguages::MessageLanguages(const Languages& languages)
 548   : CompositeType(kUninitialized),
 549     languages(languages) {
 550 }
 551 MessageLanguages::~MessageLanguages() {
 552 }
 553 MessageLanguages::MessageLanguages(const Json::Value* value__)
 554   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 555     languages(impl::ValueMember(value__, "languages")) {
 556 }
 557 Json::Value MessageLanguages::ToJsonValue() const {
 558   Json::Value result__(Json::objectValue);
 559   impl::WriteJsonField("languages", languages, &result__);
 560   return result__;
 561 }
 562 bool MessageLanguages::is_valid() const {
 563   if (!languages.is_valid()) {
 564     return false;
 565   }
 566   return Validate();
 567 }
 568 bool MessageLanguages::is_initialized() const {
 569   return (initialization_state__ != kUninitialized) || (!struct_empty());
 570 }
 571 bool MessageLanguages::struct_empty() const {
 572   if (languages.is_initialized()) {
 573     return false;
 574   }
 575   return true;
 576 }
 577 void MessageLanguages::ReportErrors(rpc::ValidationReport* report__) const {
 578   if (struct_empty()) {
 579     rpc::CompositeType::ReportErrors(report__);
 580   }
 581   if (!languages.is_valid()) {
 582     languages.ReportErrors(&report__->ReportSubobject("languages"));
 583   }
 584 }
 585
 586 // ConsumerFriendlyMessages methods
 587 ConsumerFriendlyMessages::ConsumerFriendlyMessages()
 588   : CompositeType(kUninitialized) {
 589 }
 590 ConsumerFriendlyMessages::ConsumerFriendlyMessages(const std::string& version)
 591   : CompositeType(kUninitialized),
 592     version(version) {
 593 }
 594 ConsumerFriendlyMessages::~ConsumerFriendlyMessages() {
 595 }
 596 ConsumerFriendlyMessages::ConsumerFriendlyMessages(const Json::Value* value__)
 597   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 598     version(impl::ValueMember(value__, "version")),
 599     messages(impl::ValueMember(value__, "messages")) {
 600 }
 601 Json::Value ConsumerFriendlyMessages::ToJsonValue() const {
 602   Json::Value result__(Json::objectValue);
 603   impl::WriteJsonField("version", version, &result__);
 604   impl::WriteJsonField("messages", messages, &result__);
 605   return result__;
 606 }
 607 bool ConsumerFriendlyMessages::is_valid() const {
 608   if (!version.is_valid()) {
 609     return false;
 610   }
 611   if (!messages.is_valid()) {
 612     return false;
 613   }
 614   return Validate();
 615 }
 616 bool ConsumerFriendlyMessages::is_initialized() const {
 617   return (initialization_state__ != kUninitialized) || (!struct_empty());
 618 }
 619 bool ConsumerFriendlyMessages::struct_empty() const {
 620   if (version.is_initialized()) {
 621     return false;
 622   }
 623   if (messages.is_initialized()) {
 624     return false;
 625   }
 626
 627   return true;
 628 }
 629 void ConsumerFriendlyMessages::ReportErrors(rpc::ValidationReport* report__) const {
 630   if (struct_empty()) {
 631     rpc::CompositeType::ReportErrors(report__);
 632   }
 633   if (!version.is_valid()) {
 634     version.ReportErrors(&report__->ReportSubobject("version"));
 635   }
 636   if (!messages.is_valid()) {
 637     messages.ReportErrors(&report__->ReportSubobject("messages"));
 638   }
 639 }
 640
 641 // ModuleMeta methods
 642 ModuleMeta::ModuleMeta()
 643   : CompositeType(kUninitialized) {
 644 }
 645 ModuleMeta::~ModuleMeta() {
 646 }
 647 ModuleMeta::ModuleMeta(const Json::Value* value__)
 648   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 649     ccpu_version(impl::ValueMember(value__, "ccpu_version")),
 650     language(impl::ValueMember(value__, "language")),
 651     wers_country_code(impl::ValueMember(value__, "wers_country_code")),
 652     pt_exchanged_at_odometer_x(impl::ValueMember(value__, "pt_exchanged_at_odometer_x")),
 653     pt_exchanged_x_days_after_epoch(impl::ValueMember(value__, "pt_exchanged_x_days_after_epoch")),
 654     ignition_cycles_since_last_exchange(impl::ValueMember(value__, "ignition_cycles_since_last_exchange")),
 655     vin(impl::ValueMember(value__, "vin")) {
 656 }
 657 Json::Value ModuleMeta::ToJsonValue() const {
 658   Json::Value result__(Json::objectValue);
 659   impl::WriteJsonField("ccpu_version", ccpu_version, &result__);
 660   impl::WriteJsonField("language", language, &result__);
 661   impl::WriteJsonField("wers_country_code", wers_country_code, &result__);
 662   impl::WriteJsonField("pt_exchanged_at_odometer_x", pt_exchanged_at_odometer_x, &result__);
 663   impl::WriteJsonField("pt_exchanged_x_days_after_epoch", pt_exchanged_x_days_after_epoch, &result__);
 664   impl::WriteJsonField("ignition_cycles_since_last_exchange", ignition_cycles_since_last_exchange, &result__);
 665   impl::WriteJsonField("vin", vin, &result__);
 666   return result__;
 667 }
 668 bool ModuleMeta::is_valid() const {
 669   if (struct_empty()) {
 670     return initialization_state__ == kInitialized;
 671   }
 672   if (!ccpu_version.is_valid()) {
 673     return false;
 674   }
 675   if (!language.is_valid()) {
 676     return false;
 677   }
 678   if (!wers_country_code.is_valid()) {
 679     return false;
 680   }
 681   if (!pt_exchanged_at_odometer_x.is_valid()) {
 682     return false;
 683   }
 684   if (!pt_exchanged_x_days_after_epoch.is_valid()) {
 685     return false;
 686   }
 687   if (!ignition_cycles_since_last_exchange.is_valid()) {
 688     return false;
 689   }
 690   if (!vin.is_valid()) {
 691     return false;
 692   }
 693   return Validate();
 694 }
 695 bool ModuleMeta::is_initialized() const {
 696   return (initialization_state__ != kUninitialized) || (!struct_empty());
 697 }
 698 bool ModuleMeta::struct_empty() const {
 699   if (ccpu_version.is_initialized()) {
 700     return false;
 701   }
 702   if (language.is_initialized()) {
 703     return false;
 704   }
 705
 706   if (wers_country_code.is_initialized()) {
 707     return false;
 708   }
 709   if (pt_exchanged_at_odometer_x.is_initialized()) {
 710     return false;
 711   }
 712
 713   if (pt_exchanged_x_days_after_epoch.is_initialized()) {
 714     return false;
 715   }
 716   if (ignition_cycles_since_last_exchange.is_initialized()) {
 717     return false;
 718   }
 719
 720   if (vin.is_initialized()) {
 721     return false;
 722   }
 723   return true;
 724 }
 725 void ModuleMeta::ReportErrors(rpc::ValidationReport* report__) const {
 726   if (struct_empty()) {
 727     rpc::CompositeType::ReportErrors(report__);
 728   }
 729   if (!ccpu_version.is_valid()) {
 730     ccpu_version.ReportErrors(&report__->ReportSubobject("ccpu_version"));
 731   }
 732   if (!language.is_valid()) {
 733     language.ReportErrors(&report__->ReportSubobject("language"));
 734   }
 735   if (!wers_country_code.is_valid()) {
 736     wers_country_code.ReportErrors(&report__->ReportSubobject("wers_country_code"));
 737   }
 738   if (!pt_exchanged_at_odometer_x.is_valid()) {
 739     pt_exchanged_at_odometer_x.ReportErrors(&report__->ReportSubobject("pt_exchanged_at_odometer_x"));
 740   }
 741   if (!pt_exchanged_x_days_after_epoch.is_valid()) {
 742     pt_exchanged_x_days_after_epoch.ReportErrors(&report__->ReportSubobject("pt_exchanged_x_days_after_epoch"));
 743   }
 744   if (!ignition_cycles_since_last_exchange.is_valid()) {
 745     ignition_cycles_since_last_exchange.ReportErrors(&report__->ReportSubobject("ignition_cycles_since_last_exchange"));
 746   }
 747   if (!vin.is_valid()) {
 748     vin.ReportErrors(&report__->ReportSubobject("vin"));
 749   }
 750 }
 751
 752 // AppLevel methods
 753 AppLevel::AppLevel()
 754   : CompositeType(kUninitialized) {
 755 }
 756 AppLevel::AppLevel(uint16_t minutes_in_hmi_full, const std::string& app_registration_language_gui, const std::string& app_registration_language_vui, uint16_t count_of_rfcom_limit_reached, uint16_t minutes_in_hmi_limited, uint16_t minutes_in_hmi_background, uint16_t minutes_in_hmi_none, uint16_t count_of_user_selections, uint16_t count_of_rejections_sync_out_of_memory, uint16_t count_of_rejections_nickname_mismatch, uint16_t count_of_rejections_duplicate_name, uint16_t count_of_rejected_rpc_calls, uint16_t count_of_rpcs_sent_in_hmi_none, uint16_t count_of_removals_for_bad_behavior, uint16_t count_of_run_attempts_while_revoked)
 757   : CompositeType(kUninitialized),
 758     minutes_in_hmi_full(minutes_in_hmi_full),
 759     app_registration_language_gui(app_registration_language_gui),
 760     app_registration_language_vui(app_registration_language_vui),
 761     count_of_rfcom_limit_reached(count_of_rfcom_limit_reached),
 762     minutes_in_hmi_limited(minutes_in_hmi_limited),
 763     minutes_in_hmi_background(minutes_in_hmi_background),
 764     minutes_in_hmi_none(minutes_in_hmi_none),
 765     count_of_user_selections(count_of_user_selections),
 766     count_of_rejections_sync_out_of_memory(count_of_rejections_sync_out_of_memory),
 767     count_of_rejections_nickname_mismatch(count_of_rejections_nickname_mismatch),
 768     count_of_rejections_duplicate_name(count_of_rejections_duplicate_name),
 769     count_of_rejected_rpc_calls(count_of_rejected_rpc_calls),
 770     count_of_rpcs_sent_in_hmi_none(count_of_rpcs_sent_in_hmi_none),
 771     count_of_removals_for_bad_behavior(count_of_removals_for_bad_behavior),
 772     count_of_run_attempts_while_revoked(count_of_run_attempts_while_revoked) {
 773 }
 774 AppLevel::~AppLevel() {
 775 }
 776 AppLevel::AppLevel(const Json::Value* value__)
 777   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 778     minutes_in_hmi_full(impl::ValueMember(value__, "minutes_in_hmi_full")),
 779     app_registration_language_gui(impl::ValueMember(value__, "app_registration_language_gui")),
 780     app_registration_language_vui(impl::ValueMember(value__, "app_registration_language_vui")),
 781     count_of_rfcom_limit_reached(impl::ValueMember(value__, "count_of_rfcom_limit_reached")),
 782     minutes_in_hmi_limited(impl::ValueMember(value__, "minutes_in_hmi_limited")),
 783     minutes_in_hmi_background(impl::ValueMember(value__, "minutes_in_hmi_background")),
 784     minutes_in_hmi_none(impl::ValueMember(value__, "minutes_in_hmi_none")),
 785     count_of_user_selections(impl::ValueMember(value__, "count_of_user_selections")),
 786     count_of_rejections_sync_out_of_memory(impl::ValueMember(value__, "count_of_rejections_sync_out_of_memory")),
 787     count_of_rejections_nickname_mismatch(impl::ValueMember(value__, "count_of_rejections_nickname_mismatch")),
 788     count_of_rejections_duplicate_name(impl::ValueMember(value__, "count_of_rejections_duplicate_name")),
 789     count_of_rejected_rpc_calls(impl::ValueMember(value__, "count_of_rejected_rpc_calls")),
 790     count_of_rpcs_sent_in_hmi_none(impl::ValueMember(value__, "count_of_rpcs_sent_in_hmi_none")),
 791     count_of_removals_for_bad_behavior(impl::ValueMember(value__, "count_of_removals_for_bad_behavior")),
 792     count_of_run_attempts_while_revoked(impl::ValueMember(value__, "count_of_run_attempts_while_revoked")) {
 793 }
 794 Json::Value AppLevel::ToJsonValue() const {
 795   Json::Value result__(Json::objectValue);
 796   impl::WriteJsonField("minutes_in_hmi_full", minutes_in_hmi_full, &result__);
 797   impl::WriteJsonField("app_registration_language_gui", app_registration_language_gui, &result__);
 798   impl::WriteJsonField("app_registration_language_vui", app_registration_language_vui, &result__);
 799   impl::WriteJsonField("count_of_rfcom_limit_reached", count_of_rfcom_limit_reached, &result__);
 800   impl::WriteJsonField("minutes_in_hmi_limited", minutes_in_hmi_limited, &result__);
 801   impl::WriteJsonField("minutes_in_hmi_background", minutes_in_hmi_background, &result__);
 802   impl::WriteJsonField("minutes_in_hmi_none", minutes_in_hmi_none, &result__);
 803   impl::WriteJsonField("count_of_user_selections", count_of_user_selections, &result__);
 804   impl::WriteJsonField("count_of_rejections_sync_out_of_memory", count_of_rejections_sync_out_of_memory, &result__);
 805   impl::WriteJsonField("count_of_rejections_nickname_mismatch", count_of_rejections_nickname_mismatch, &result__);
 806   impl::WriteJsonField("count_of_rejections_duplicate_name", count_of_rejections_duplicate_name, &result__);
 807   impl::WriteJsonField("count_of_rejected_rpc_calls", count_of_rejected_rpc_calls, &result__);
 808   impl::WriteJsonField("count_of_rpcs_sent_in_hmi_none", count_of_rpcs_sent_in_hmi_none, &result__);
 809   impl::WriteJsonField("count_of_removals_for_bad_behavior", count_of_removals_for_bad_behavior, &result__);
 810   impl::WriteJsonField("count_of_run_attempts_while_revoked", count_of_run_attempts_while_revoked, &result__);
 811   return result__;
 812 }
 813 bool AppLevel::is_valid() const {
 814   if (!minutes_in_hmi_full.is_valid()) {
 815     return false;
 816   }
 817   if (!app_registration_language_gui.is_valid()) {
 818     return false;
 819   }
 820   if (!app_registration_language_vui.is_valid()) {
 821     return false;
 822   }
 823   if (!count_of_rfcom_limit_reached.is_valid()) {
 824     return false;
 825   }
 826   if (!minutes_in_hmi_limited.is_valid()) {
 827     return false;
 828   }
 829   if (!minutes_in_hmi_background.is_valid()) {
 830     return false;
 831   }
 832   if (!minutes_in_hmi_none.is_valid()) {
 833     return false;
 834   }
 835   if (!count_of_user_selections.is_valid()) {
 836     return false;
 837   }
 838   if (!count_of_rejections_sync_out_of_memory.is_valid()) {
 839     return false;
 840   }
 841   if (!count_of_rejections_nickname_mismatch.is_valid()) {
 842     return false;
 843   }
 844   if (!count_of_rejections_duplicate_name.is_valid()) {
 845     return false;
 846   }
 847   if (!count_of_rejected_rpc_calls.is_valid()) {
 848     return false;
 849   }
 850   if (!count_of_rpcs_sent_in_hmi_none.is_valid()) {
 851     return false;
 852   }
 853   if (!count_of_removals_for_bad_behavior.is_valid()) {
 854     return false;
 855   }
 856   if (!count_of_run_attempts_while_revoked.is_valid()) {
 857     return false;
 858   }
 859   return Validate();
 860 }
 861 bool AppLevel::is_initialized() const {
 862   return (initialization_state__ != kUninitialized) || (!struct_empty());
 863 }
 864 bool AppLevel::struct_empty() const {
 865   if (minutes_in_hmi_full.is_initialized()) {
 866     return false;
 867   }
 868   if (app_registration_language_gui.is_initialized()) {
 869     return false;
 870   }
 871
 872   if (app_registration_language_vui.is_initialized()) {
 873     return false;
 874   }
 875   if (count_of_rfcom_limit_reached.is_initialized()) {
 876     return false;
 877   }
 878
 879   if (minutes_in_hmi_limited.is_initialized()) {
 880     return false;
 881   }
 882   if (minutes_in_hmi_background.is_initialized()) {
 883     return false;
 884   }
 885
 886   if (minutes_in_hmi_none.is_initialized()) {
 887     return false;
 888   }
 889   if (count_of_user_selections.is_initialized()) {
 890     return false;
 891   }
 892
 893   if (count_of_rejections_sync_out_of_memory.is_initialized()) {
 894     return false;
 895   }
 896   if (count_of_rejections_nickname_mismatch.is_initialized()) {
 897     return false;
 898   }
 899
 900   if (count_of_rejections_duplicate_name.is_initialized()) {
 901     return false;
 902   }
 903   if (count_of_rejected_rpc_calls.is_initialized()) {
 904     return false;
 905   }
 906
 907   if (count_of_rpcs_sent_in_hmi_none.is_initialized()) {
 908     return false;
 909   }
 910   if (count_of_removals_for_bad_behavior.is_initialized()) {
 911     return false;
 912   }
 913
 914   if (count_of_run_attempts_while_revoked.is_initialized()) {
 915     return false;
 916   }
 917   return true;
 918 }
 919 void AppLevel::ReportErrors(rpc::ValidationReport* report__) const {
 920   if (struct_empty()) {
 921     rpc::CompositeType::ReportErrors(report__);
 922   }
 923   if (!minutes_in_hmi_full.is_valid()) {
 924     minutes_in_hmi_full.ReportErrors(&report__->ReportSubobject("minutes_in_hmi_full"));
 925   }
 926   if (!app_registration_language_gui.is_valid()) {
 927     app_registration_language_gui.ReportErrors(&report__->ReportSubobject("app_registration_language_gui"));
 928   }
 929   if (!app_registration_language_vui.is_valid()) {
 930     app_registration_language_vui.ReportErrors(&report__->ReportSubobject("app_registration_language_vui"));
 931   }
 932   if (!count_of_rfcom_limit_reached.is_valid()) {
 933     count_of_rfcom_limit_reached.ReportErrors(&report__->ReportSubobject("count_of_rfcom_limit_reached"));
 934   }
 935   if (!minutes_in_hmi_limited.is_valid()) {
 936     minutes_in_hmi_limited.ReportErrors(&report__->ReportSubobject("minutes_in_hmi_limited"));
 937   }
 938   if (!minutes_in_hmi_background.is_valid()) {
 939     minutes_in_hmi_background.ReportErrors(&report__->ReportSubobject("minutes_in_hmi_background"));
 940   }
 941   if (!minutes_in_hmi_none.is_valid()) {
 942     minutes_in_hmi_none.ReportErrors(&report__->ReportSubobject("minutes_in_hmi_none"));
 943   }
 944   if (!count_of_user_selections.is_valid()) {
 945     count_of_user_selections.ReportErrors(&report__->ReportSubobject("count_of_user_selections"));
 946   }
 947   if (!count_of_rejections_sync_out_of_memory.is_valid()) {
 948     count_of_rejections_sync_out_of_memory.ReportErrors(&report__->ReportSubobject("count_of_rejections_sync_out_of_memory"));
 949   }
 950   if (!count_of_rejections_nickname_mismatch.is_valid()) {
 951     count_of_rejections_nickname_mismatch.ReportErrors(&report__->ReportSubobject("count_of_rejections_nickname_mismatch"));
 952   }
 953   if (!count_of_rejections_duplicate_name.is_valid()) {
 954     count_of_rejections_duplicate_name.ReportErrors(&report__->ReportSubobject("count_of_rejections_duplicate_name"));
 955   }
 956   if (!count_of_rejected_rpc_calls.is_valid()) {
 957     count_of_rejected_rpc_calls.ReportErrors(&report__->ReportSubobject("count_of_rejected_rpc_calls"));
 958   }
 959   if (!count_of_rpcs_sent_in_hmi_none.is_valid()) {
 960     count_of_rpcs_sent_in_hmi_none.ReportErrors(&report__->ReportSubobject("count_of_rpcs_sent_in_hmi_none"));
 961   }
 962   if (!count_of_removals_for_bad_behavior.is_valid()) {
 963     count_of_removals_for_bad_behavior.ReportErrors(&report__->ReportSubobject("count_of_removals_for_bad_behavior"));
 964   }
 965   if (!count_of_run_attempts_while_revoked.is_valid()) {
 966     count_of_run_attempts_while_revoked.ReportErrors(&report__->ReportSubobject("count_of_run_attempts_while_revoked"));
 967   }
 968 }
 969
 970 // UsageAndErrorCounts methods
 971 UsageAndErrorCounts::UsageAndErrorCounts()
 972   : CompositeType(kUninitialized) {
 973 }
 974 UsageAndErrorCounts::~UsageAndErrorCounts() {
 975 }
 976 UsageAndErrorCounts::UsageAndErrorCounts(const Json::Value* value__)
 977   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 978     count_of_iap_buffer_full(impl::ValueMember(value__, "count_of_iap_buffer_full")),
 979     count_sync_out_of_memory(impl::ValueMember(value__, "count_sync_out_of_memory")),
 980     count_of_sync_reboots(impl::ValueMember(value__, "count_of_sync_reboots")),
 981     app_level(impl::ValueMember(value__, "app_level")) {
 982 }
 983 Json::Value UsageAndErrorCounts::ToJsonValue() const {
 984   Json::Value result__(Json::objectValue);
 985   impl::WriteJsonField("count_of_iap_buffer_full", count_of_iap_buffer_full, &result__);
 986   impl::WriteJsonField("count_sync_out_of_memory", count_sync_out_of_memory, &result__);
 987   impl::WriteJsonField("count_of_sync_reboots", count_of_sync_reboots, &result__);
 988   impl::WriteJsonField("app_level", app_level, &result__);
 989   return result__;
 990 }
 991 bool UsageAndErrorCounts::is_valid() const {
 992   if (struct_empty()) {
 993     return initialization_state__ == kInitialized;
 994   }
 995   if (!count_of_iap_buffer_full.is_valid()) {
 996     return false;
 997   }
 998   if (!count_sync_out_of_memory.is_valid()) {
 999     return false;
1000   }
1001   if (!count_of_sync_reboots.is_valid()) {
1002     return false;
1003   }
1004   if (!app_level.is_valid()) {
1005     return false;
1006   }
1007   return Validate();
1008 }
1009 bool UsageAndErrorCounts::is_initialized() const {
1010   return (initialization_state__ != kUninitialized) || (!struct_empty());
1011 }
1012 bool UsageAndErrorCounts::struct_empty() const {
1013   if (count_of_iap_buffer_full.is_initialized()) {
1014     return false;
1015   }
1016   if (count_sync_out_of_memory.is_initialized()) {
1017     return false;
1018   }
1019
1020   if (count_of_sync_reboots.is_initialized()) {
1021     return false;
1022   }
1023   if (app_level.is_initialized()) {
1024     return false;
1025   }
1026
1027   return true;
1028 }
1029 void UsageAndErrorCounts::ReportErrors(rpc::ValidationReport* report__) const {
1030   if (struct_empty()) {
1031     rpc::CompositeType::ReportErrors(report__);
1032   }
1033   if (!count_of_iap_buffer_full.is_valid()) {
1034     count_of_iap_buffer_full.ReportErrors(&report__->ReportSubobject("count_of_iap_buffer_full"));
1035   }
1036   if (!count_sync_out_of_memory.is_valid()) {
1037     count_sync_out_of_memory.ReportErrors(&report__->ReportSubobject("count_sync_out_of_memory"));
1038   }
1039   if (!count_of_sync_reboots.is_valid()) {
1040     count_of_sync_reboots.ReportErrors(&report__->ReportSubobject("count_of_sync_reboots"));
1041   }
1042   if (!app_level.is_valid()) {
1043     app_level.ReportErrors(&report__->ReportSubobject("app_level"));
1044   }
1045 }
1046
1047 // ConsentRecords methods
1048 ConsentRecords::ConsentRecords()
1049   : CompositeType(kUninitialized) {
1050 }
1051 ConsentRecords::~ConsentRecords() {
1052 }
1053 ConsentRecords::ConsentRecords(const Json::Value* value__)
1054   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
1055     consent_groups(impl::ValueMember(value__, "consent_groups")),
1056     input(impl::ValueMember(value__, "input")),
1057     time_stamp(impl::ValueMember(value__, "time_stamp")) {
1058 }
1059 Json::Value ConsentRecords::ToJsonValue() const {
1060   Json::Value result__(Json::objectValue);
1061   impl::WriteJsonField("consent_groups", consent_groups, &result__);
1062   impl::WriteJsonField("input", input, &result__);
1063   impl::WriteJsonField("time_stamp", time_stamp, &result__);
1064   return result__;
1065 }
1066 bool ConsentRecords::is_valid() const {
1067   if (struct_empty()) {
1068     return initialization_state__ == kInitialized;
1069   }
1070   if (!consent_groups.is_valid()) {
1071     return false;
1072   }
1073   if (!input.is_valid()) {
1074     return false;
1075   }
1076   if (!time_stamp.is_valid()) {
1077     return false;
1078   }
1079   return Validate();
1080 }
1081 bool ConsentRecords::is_initialized() const {
1082   return (initialization_state__ != kUninitialized) || (!struct_empty());
1083 }
1084 bool ConsentRecords::struct_empty() const {
1085   if (consent_groups.is_initialized()) {
1086     return false;
1087   }
1088   if (input.is_initialized()) {
1089     return false;
1090   }
1091
1092   if (time_stamp.is_initialized()) {
1093     return false;
1094   }
1095   return true;
1096 }
1097 void ConsentRecords::ReportErrors(rpc::ValidationReport* report__) const {
1098   if (struct_empty()) {
1099     rpc::CompositeType::ReportErrors(report__);
1100   }
1101   if (!consent_groups.is_valid()) {
1102     consent_groups.ReportErrors(&report__->ReportSubobject("consent_groups"));
1103   }
1104   if (!input.is_valid()) {
1105     input.ReportErrors(&report__->ReportSubobject("input"));
1106   }
1107   if (!time_stamp.is_valid()) {
1108     time_stamp.ReportErrors(&report__->ReportSubobject("time_stamp"));
1109   }
1110 }
1111
1112 // DeviceParams methods
1113 DeviceParams::DeviceParams()
1114   : CompositeType(kUninitialized) {
1115 }
1116 DeviceParams::~DeviceParams() {
1117 }
1118 DeviceParams::DeviceParams(const Json::Value* value__)
1119   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
1120     hardware(impl::ValueMember(value__, "hardware")),
1121     firmware_rev(impl::ValueMember(value__, "firmware_rev")),
1122     os(impl::ValueMember(value__, "os")),
1123     os_version(impl::ValueMember(value__, "os_version")),
1124     carrier(impl::ValueMember(value__, "carrier")),
1125     user_consent_records(impl::ValueMember(value__, "user_consent_records")),
1126     max_number_rfcom_ports(impl::ValueMember(value__, "max_number_rfcom_ports")) {
1127 }
1128 Json::Value DeviceParams::ToJsonValue() const {
1129   Json::Value result__(Json::objectValue);
1130   impl::WriteJsonField("hardware", hardware, &result__);
1131   impl::WriteJsonField("firmware_rev", firmware_rev, &result__);
1132   impl::WriteJsonField("os", os, &result__);
1133   impl::WriteJsonField("os_version", os_version, &result__);
1134   impl::WriteJsonField("carrier", carrier, &result__);
1135   impl::WriteJsonField("user_consent_records", user_consent_records, &result__);
1136   impl::WriteJsonField("max_number_rfcom_ports", max_number_rfcom_ports, &result__);
1137   return result__;
1138 }
1139 bool DeviceParams::is_valid() const {
1140   if (struct_empty()) {
1141     return initialization_state__ == kInitialized;
1142   }
1143   if (!hardware.is_valid()) {
1144     return false;
1145   }
1146   if (!firmware_rev.is_valid()) {
1147     return false;
1148   }
1149   if (!os.is_valid()) {
1150     return false;
1151   }
1152   if (!os_version.is_valid()) {
1153     return false;
1154   }
1155   if (!carrier.is_valid()) {
1156     return false;
1157   }
1158   if (!user_consent_records.is_valid()) {
1159     return false;
1160   }
1161   if (!max_number_rfcom_ports.is_valid()) {
1162     return false;
1163   }
1164   return Validate();
1165 }
1166 bool DeviceParams::is_initialized() const {
1167   return (initialization_state__ != kUninitialized) || (!struct_empty());
1168 }
1169 bool DeviceParams::struct_empty() const {
1170   if (hardware.is_initialized()) {
1171     return false;
1172   }
1173   if (firmware_rev.is_initialized()) {
1174     return false;
1175   }
1176
1177   if (os.is_initialized()) {
1178     return false;
1179   }
1180   if (os_version.is_initialized()) {
1181     return false;
1182   }
1183
1184   if (carrier.is_initialized()) {
1185     return false;
1186   }
1187   if (user_consent_records.is_initialized()) {
1188     return false;
1189   }
1190
1191   if (max_number_rfcom_ports.is_initialized()) {
1192     return false;
1193   }
1194   return true;
1195 }
1196 void DeviceParams::ReportErrors(rpc::ValidationReport* report__) const {
1197   if (struct_empty()) {
1198     rpc::CompositeType::ReportErrors(report__);
1199   }
1200   if (!hardware.is_valid()) {
1201     hardware.ReportErrors(&report__->ReportSubobject("hardware"));
1202   }
1203   if (!firmware_rev.is_valid()) {
1204     firmware_rev.ReportErrors(&report__->ReportSubobject("firmware_rev"));
1205   }
1206   if (!os.is_valid()) {
1207     os.ReportErrors(&report__->ReportSubobject("os"));
1208   }
1209   if (!os_version.is_valid()) {
1210     os_version.ReportErrors(&report__->ReportSubobject("os_version"));
1211   }
1212   if (!carrier.is_valid()) {
1213     carrier.ReportErrors(&report__->ReportSubobject("carrier"));
1214   }
1215   if (!user_consent_records.is_valid()) {
1216     user_consent_records.ReportErrors(&report__->ReportSubobject("user_consent_records"));
1217   }
1218   if (!max_number_rfcom_ports.is_valid()) {
1219     max_number_rfcom_ports.ReportErrors(&report__->ReportSubobject("max_number_rfcom_ports"));
1220   }
1221 }
1222
1223 // PolicyTable methods
1224 PolicyTable::PolicyTable()
1225   : CompositeType(kUninitialized) {
1226 }
1227 PolicyTable::PolicyTable(const ApplicationPolicies& app_policies, const FunctionalGroupings& functional_groupings, const ConsumerFriendlyMessages& consumer_friendly_messages, const ModuleConfig& module_config)
1228   : CompositeType(kUninitialized),
1229     app_policies(app_policies),
1230     functional_groupings(functional_groupings),
1231     consumer_friendly_messages(consumer_friendly_messages),
1232     module_config(module_config) {
1233 }
1234 PolicyTable::~PolicyTable() {
1235 }
1236 PolicyTable::PolicyTable(const Json::Value* value__)
1237   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
1238     app_policies(impl::ValueMember(value__, "app_policies")),
1239     functional_groupings(impl::ValueMember(value__, "functional_groupings")),
1240     consumer_friendly_messages(impl::ValueMember(value__, "consumer_friendly_messages")),
1241     module_config(impl::ValueMember(value__, "module_config")),
1242     module_meta(impl::ValueMember(value__, "module_meta")),
1243     usage_and_error_counts(impl::ValueMember(value__, "usage_and_error_counts")),
1244     device_data(impl::ValueMember(value__, "device_data")) {
1245 }
1246 Json::Value PolicyTable::ToJsonValue() const {
1247   Json::Value result__(Json::objectValue);
1248   impl::WriteJsonField("app_policies", app_policies, &result__);
1249   impl::WriteJsonField("functional_groupings", functional_groupings, &result__);
1250   impl::WriteJsonField("consumer_friendly_messages", consumer_friendly_messages, &result__);
1251   impl::WriteJsonField("module_config", module_config, &result__);
1252   impl::WriteJsonField("module_meta", module_meta, &result__);
1253   impl::WriteJsonField("usage_and_error_counts", usage_and_error_counts, &result__);
1254   impl::WriteJsonField("device_data", device_data, &result__);
1255   return result__;
1256 }
1257 bool PolicyTable::is_valid() const {
1258   if (!app_policies.is_valid()) {
1259     return false;
1260   }
1261   if (!functional_groupings.is_valid()) {
1262     return false;
1263   }
1264   if (!consumer_friendly_messages.is_valid()) {
1265     return false;
1266   }
1267   if (!module_config.is_valid()) {
1268     return false;
1269   }
1270   if (!module_meta.is_valid()) {
1271     return false;
1272   }
1273   if (!usage_and_error_counts.is_valid()) {
1274     return false;
1275   }
1276   if (!device_data.is_valid()) {
1277     return false;
1278   }
1279   return Validate();
1280 }
1281 bool PolicyTable::is_initialized() const {
1282   return (initialization_state__ != kUninitialized) || (!struct_empty());
1283 }
1284 bool PolicyTable::struct_empty() const {
1285   if (app_policies.is_initialized()) {
1286     return false;
1287   }
1288   if (functional_groupings.is_initialized()) {
1289     return false;
1290   }
1291
1292   if (consumer_friendly_messages.is_initialized()) {
1293     return false;
1294   }
1295   if (module_config.is_initialized()) {
1296     return false;
1297   }
1298
1299   if (module_meta.is_initialized()) {
1300     return false;
1301   }
1302   if (usage_and_error_counts.is_initialized()) {
1303     return false;
1304   }
1305
1306   if (device_data.is_initialized()) {
1307     return false;
1308   }
1309   return true;
1310 }
1311 void PolicyTable::ReportErrors(rpc::ValidationReport* report__) const {
1312   if (struct_empty()) {
1313     rpc::CompositeType::ReportErrors(report__);
1314   }
1315   if (!app_policies.is_valid()) {
1316     app_policies.ReportErrors(&report__->ReportSubobject("app_policies"));
1317   }
1318   if (!functional_groupings.is_valid()) {
1319     functional_groupings.ReportErrors(&report__->ReportSubobject("functional_groupings"));
1320   }
1321   if (!consumer_friendly_messages.is_valid()) {
1322     consumer_friendly_messages.ReportErrors(&report__->ReportSubobject("consumer_friendly_messages"));
1323   }
1324   if (!module_config.is_valid()) {
1325     module_config.ReportErrors(&report__->ReportSubobject("module_config"));
1326   }
1327   if (!module_meta.is_valid()) {
1328     module_meta.ReportErrors(&report__->ReportSubobject("module_meta"));
1329   }
1330   if (!usage_and_error_counts.is_valid()) {
1331     usage_and_error_counts.ReportErrors(&report__->ReportSubobject("usage_and_error_counts"));
1332   }
1333   if (!device_data.is_valid()) {
1334     device_data.ReportErrors(&report__->ReportSubobject("device_data"));
1335   }
1336 }
1337
1338 // Table methods
1339 Table::Table()
1340   : CompositeType(kUninitialized) {
1341 }
1342 Table::Table(const PolicyTable& policy_table)
1343   : CompositeType(kUninitialized),
1344     policy_table(policy_table) {
1345 }
1346 Table::~Table() {
1347 }
1348 Table::Table(const Json::Value* value__)
1349   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
1350     policy_table(impl::ValueMember(value__, "policy_table")) {
1351 }
1352 Json::Value Table::ToJsonValue() const {
1353   Json::Value result__(Json::objectValue);
1354   impl::WriteJsonField("policy_table", policy_table, &result__);
1355   return result__;
1356 }
1357 bool Table::is_valid() const {
1358   if (!policy_table.is_valid()) {
1359     return false;
1360   }
1361   return Validate();
1362 }
1363 bool Table::is_initialized() const {
1364   return (initialization_state__ != kUninitialized) || (!struct_empty());
1365 }
1366 bool Table::struct_empty() const {
1367   if (policy_table.is_initialized()) {
1368     return false;
1369   }
1370   return true;
1371 }
1372 void Table::ReportErrors(rpc::ValidationReport* report__) const {
1373   if (struct_empty()) {
1374     rpc::CompositeType::ReportErrors(report__);
1375   }
1376   if (!policy_table.is_valid()) {
1377     policy_table.ReportErrors(&report__->ReportSubobject("policy_table"));
1378   }
1379 }
1380
1381 }  // namespace policy_table_interface_base
1382 }  // namespace rpc
1383