src/components/policy/src/policy/policy_table/table_struct/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)
  12   : CompositeType(kUninitialized),
  13     groups(groups) {
  14 }
  15 ApplicationParams::~ApplicationParams() {
  16 }
  17 ApplicationParams::ApplicationParams(const Json::Value* value__)
  18   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
  19     groups(impl::ValueMember(value__, "groups")),
  20     nicknames(impl::ValueMember(value__, "nicknames")),
  21     AppHMIType(impl::ValueMember(value__, "AppHMIType")),
  22     memory_kb(impl::ValueMember(value__, "memory_kb")),
  23     heart_beat_timeout_ms(impl::ValueMember(value__, "heart_beat_timeout_ms")),
  24     certificate(impl::ValueMember(value__, "certificate")) {
  25 }
  26 Json::Value ApplicationParams::ToJsonValue() const {
  27   Json::Value result__(Json::objectValue);
  28   impl::WriteJsonField("groups", groups, &result__);
  29   impl::WriteJsonField("nicknames", nicknames, &result__);
  30   impl::WriteJsonField("AppHMIType", AppHMIType, &result__);
  31   impl::WriteJsonField("memory_kb", memory_kb, &result__);
  32   impl::WriteJsonField("heart_beat_timeout_ms", heart_beat_timeout_ms, &result__);
  33   impl::WriteJsonField("certificate", certificate, &result__);
  34   return result__;
  35 }
  36 bool ApplicationParams::is_valid() const {
  37   if (!groups.is_valid()) {
  38     return false;
  39   }
  40   if (!nicknames.is_valid()) {
  41     return false;
  42   }
  43   if (!AppHMIType.is_valid()) {
  44     return false;
  45   }
  46   if (!memory_kb.is_valid()) {
  47     return false;
  48   }
  49   if (!heart_beat_timeout_ms.is_valid()) {
  50     return false;
  51   }
  52   if (!certificate.is_valid()) {
  53     return false;
  54   }
  55   return Validate();
  56 }
  57 bool ApplicationParams::is_initialized() const {
  58   return (initialization_state__ != kUninitialized) || (!struct_empty());
  59 }
  60 bool ApplicationParams::struct_empty() const {
  61   if (groups.is_initialized()) {
  62     return false;
  63   }
  64   if (nicknames.is_initialized()) {
  65     return false;
  66   }
  67
  68   if (AppHMIType.is_initialized()) {
  69     return false;
  70   }
  71   if (memory_kb.is_initialized()) {
  72     return false;
  73   }
  74
  75   if (heart_beat_timeout_ms.is_initialized()) {
  76     return false;
  77   }
  78   if (certificate.is_initialized()) {
  79     return false;
  80   }
  81
  82   return true;
  83 }
  84 void ApplicationParams::ReportErrors(rpc::ValidationReport* report__) const {
  85   if (struct_empty()) {
  86     rpc::CompositeType::ReportErrors(report__);
  87   }
  88   if (!groups.is_valid()) {
  89     groups.ReportErrors(&report__->ReportSubobject("groups"));
  90   }
  91   if (!nicknames.is_valid()) {
  92     nicknames.ReportErrors(&report__->ReportSubobject("nicknames"));
  93   }
  94   if (!AppHMIType.is_valid()) {
  95     AppHMIType.ReportErrors(&report__->ReportSubobject("AppHMIType"));
  96   }
  97   if (!memory_kb.is_valid()) {
  98     memory_kb.ReportErrors(&report__->ReportSubobject("memory_kb"));
  99   }
 100   if (!heart_beat_timeout_ms.is_valid()) {
 101     heart_beat_timeout_ms.ReportErrors(&report__->ReportSubobject("heart_beat_timeout_ms"));
 102   }
 103   if (!certificate.is_valid()) {
 104     certificate.ReportErrors(&report__->ReportSubobject("certificate"));
 105   }
 106 }
 107
 108 // RpcParameters methods
 109 RpcParameters::RpcParameters()
 110   : CompositeType(kUninitialized) {
 111 }
 112 RpcParameters::RpcParameters(const HmiLevels& hmi_levels)
 113   : CompositeType(kUninitialized),
 114     hmi_levels(hmi_levels) {
 115 }
 116 RpcParameters::~RpcParameters() {
 117 }
 118 RpcParameters::RpcParameters(const Json::Value* value__)
 119   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 120     hmi_levels(impl::ValueMember(value__, "hmi_levels")),
 121     parameters(impl::ValueMember(value__, "parameters")) {
 122 }
 123 Json::Value RpcParameters::ToJsonValue() const {
 124   Json::Value result__(Json::objectValue);
 125   impl::WriteJsonField("hmi_levels", hmi_levels, &result__);
 126   impl::WriteJsonField("parameters", parameters, &result__);
 127   return result__;
 128 }
 129 bool RpcParameters::is_valid() const {
 130   if (!hmi_levels.is_valid()) {
 131     return false;
 132   }
 133   if (!parameters.is_valid()) {
 134     return false;
 135   }
 136   return Validate();
 137 }
 138 bool RpcParameters::is_initialized() const {
 139   return (initialization_state__ != kUninitialized) || (!struct_empty());
 140 }
 141 bool RpcParameters::struct_empty() const {
 142   if (hmi_levels.is_initialized()) {
 143     return false;
 144   }
 145   if (parameters.is_initialized()) {
 146     return false;
 147   }
 148
 149   return true;
 150 }
 151 void RpcParameters::ReportErrors(rpc::ValidationReport* report__) const {
 152   if (struct_empty()) {
 153     rpc::CompositeType::ReportErrors(report__);
 154   }
 155   if (!hmi_levels.is_valid()) {
 156     hmi_levels.ReportErrors(&report__->ReportSubobject("hmi_levels"));
 157   }
 158   if (!parameters.is_valid()) {
 159     parameters.ReportErrors(&report__->ReportSubobject("parameters"));
 160   }
 161 }
 162
 163 // Rpcs methods
 164 Rpcs::Rpcs()
 165   : CompositeType(kUninitialized) {
 166 }
 167 Rpcs::Rpcs(const Rpc& rpcs)
 168   : CompositeType(kUninitialized),
 169     rpcs(rpcs) {
 170 }
 171 Rpcs::~Rpcs() {
 172 }
 173 Rpcs::Rpcs(const Json::Value* value__)
 174   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 175     user_consent_prompt(impl::ValueMember(value__, "user_consent_prompt")),
 176     rpcs(impl::ValueMember(value__, "rpcs")) {
 177 }
 178 Json::Value Rpcs::ToJsonValue() const {
 179   Json::Value result__(Json::objectValue);
 180   impl::WriteJsonField("user_consent_prompt", user_consent_prompt, &result__);
 181   impl::WriteJsonField("rpcs", rpcs, &result__);
 182   return result__;
 183 }
 184 bool Rpcs::is_valid() const {
 185   if (!user_consent_prompt.is_valid()) {
 186     return false;
 187   }
 188   if (!rpcs.is_valid()) {
 189     return false;
 190   }
 191   return Validate();
 192 }
 193 bool Rpcs::is_initialized() const {
 194   return (initialization_state__ != kUninitialized) || (!struct_empty());
 195 }
 196 bool Rpcs::struct_empty() const {
 197   if (user_consent_prompt.is_initialized()) {
 198     return false;
 199   }
 200   if (rpcs.is_initialized()) {
 201     return false;
 202   }
 203
 204   return true;
 205 }
 206 void Rpcs::ReportErrors(rpc::ValidationReport* report__) const {
 207   if (struct_empty()) {
 208     rpc::CompositeType::ReportErrors(report__);
 209   }
 210   if (!user_consent_prompt.is_valid()) {
 211     user_consent_prompt.ReportErrors(&report__->ReportSubobject("user_consent_prompt"));
 212   }
 213   if (!rpcs.is_valid()) {
 214     rpcs.ReportErrors(&report__->ReportSubobject("rpcs"));
 215   }
 216 }
 217
 218 // ModuleConfig methods
 219 ModuleConfig::ModuleConfig()
 220   : CompositeType(kUninitialized) {
 221 }
 222 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)
 223   : CompositeType(kUninitialized),
 224     exchange_after_x_ignition_cycles(exchange_after_x_ignition_cycles),
 225     exchange_after_x_kilometers(exchange_after_x_kilometers),
 226     exchange_after_x_days(exchange_after_x_days),
 227     timeout_after_x_seconds(timeout_after_x_seconds),
 228     seconds_between_retries(seconds_between_retries),
 229     endpoints(endpoints),
 230     notifications_per_minute_by_priority(notifications_per_minute_by_priority) {
 231 }
 232 ModuleConfig::~ModuleConfig() {
 233 }
 234 ModuleConfig::ModuleConfig(const Json::Value* value__)
 235   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 236     device_certificates(impl::ValueMember(value__, "device_certificates")),
 237     preloaded_pt(impl::ValueMember(value__, "preloaded_pt")),
 238     exchange_after_x_ignition_cycles(impl::ValueMember(value__, "exchange_after_x_ignition_cycles")),
 239     exchange_after_x_kilometers(impl::ValueMember(value__, "exchange_after_x_kilometers")),
 240     exchange_after_x_days(impl::ValueMember(value__, "exchange_after_x_days")),
 241     timeout_after_x_seconds(impl::ValueMember(value__, "timeout_after_x_seconds")),
 242     seconds_between_retries(impl::ValueMember(value__, "seconds_between_retries")),
 243     endpoints(impl::ValueMember(value__, "endpoints")),
 244     notifications_per_minute_by_priority(impl::ValueMember(value__, "notifications_per_minute_by_priority")),
 245     vehicle_make(impl::ValueMember(value__, "vehicle_make")),
 246     vehicle_model(impl::ValueMember(value__, "vehicle_model")),
 247     vehicle_year(impl::ValueMember(value__, "vehicle_year")) {
 248 }
 249 Json::Value ModuleConfig::ToJsonValue() const {
 250   Json::Value result__(Json::objectValue);
 251   impl::WriteJsonField("device_certificates", device_certificates, &result__);
 252   impl::WriteJsonField("preloaded_pt", preloaded_pt, &result__);
 253   impl::WriteJsonField("exchange_after_x_ignition_cycles", exchange_after_x_ignition_cycles, &result__);
 254   impl::WriteJsonField("exchange_after_x_kilometers", exchange_after_x_kilometers, &result__);
 255   impl::WriteJsonField("exchange_after_x_days", exchange_after_x_days, &result__);
 256   impl::WriteJsonField("timeout_after_x_seconds", timeout_after_x_seconds, &result__);
 257   impl::WriteJsonField("seconds_between_retries", seconds_between_retries, &result__);
 258   impl::WriteJsonField("endpoints", endpoints, &result__);
 259   impl::WriteJsonField("notifications_per_minute_by_priority", notifications_per_minute_by_priority, &result__);
 260   impl::WriteJsonField("vehicle_make", vehicle_make, &result__);
 261   impl::WriteJsonField("vehicle_model", vehicle_model, &result__);
 262   impl::WriteJsonField("vehicle_year", vehicle_year, &result__);
 263   return result__;
 264 }
 265 bool ModuleConfig::is_valid() const {
 266   if (!device_certificates.is_valid()) {
 267     return false;
 268   }
 269   if (!preloaded_pt.is_valid()) {
 270     return false;
 271   }
 272   if (!exchange_after_x_ignition_cycles.is_valid()) {
 273     return false;
 274   }
 275   if (!exchange_after_x_kilometers.is_valid()) {
 276     return false;
 277   }
 278   if (!exchange_after_x_days.is_valid()) {
 279     return false;
 280   }
 281   if (!timeout_after_x_seconds.is_valid()) {
 282     return false;
 283   }
 284   if (!seconds_between_retries.is_valid()) {
 285     return false;
 286   }
 287   if (!endpoints.is_valid()) {
 288     return false;
 289   }
 290   if (!notifications_per_minute_by_priority.is_valid()) {
 291     return false;
 292   }
 293   if (!vehicle_make.is_valid()) {
 294     return false;
 295   }
 296   if (!vehicle_model.is_valid()) {
 297     return false;
 298   }
 299   if (!vehicle_year.is_valid()) {
 300     return false;
 301   }
 302   return Validate();
 303 }
 304 bool ModuleConfig::is_initialized() const {
 305   return (initialization_state__ != kUninitialized) || (!struct_empty());
 306 }
 307 bool ModuleConfig::struct_empty() const {
 308   if (device_certificates.is_initialized()) {
 309     return false;
 310   }
 311   if (preloaded_pt.is_initialized()) {
 312     return false;
 313   }
 314
 315   if (exchange_after_x_ignition_cycles.is_initialized()) {
 316     return false;
 317   }
 318   if (exchange_after_x_kilometers.is_initialized()) {
 319     return false;
 320   }
 321
 322   if (exchange_after_x_days.is_initialized()) {
 323     return false;
 324   }
 325   if (timeout_after_x_seconds.is_initialized()) {
 326     return false;
 327   }
 328
 329   if (seconds_between_retries.is_initialized()) {
 330     return false;
 331   }
 332   if (endpoints.is_initialized()) {
 333     return false;
 334   }
 335
 336   if (notifications_per_minute_by_priority.is_initialized()) {
 337     return false;
 338   }
 339   if (vehicle_make.is_initialized()) {
 340     return false;
 341   }
 342
 343   if (vehicle_model.is_initialized()) {
 344     return false;
 345   }
 346   if (vehicle_year.is_initialized()) {
 347     return false;
 348   }
 349
 350   return true;
 351 }
 352 void ModuleConfig::ReportErrors(rpc::ValidationReport* report__) const {
 353   if (struct_empty()) {
 354     rpc::CompositeType::ReportErrors(report__);
 355   }
 356   if (!device_certificates.is_valid()) {
 357     device_certificates.ReportErrors(&report__->ReportSubobject("device_certificates"));
 358   }
 359   if (!preloaded_pt.is_valid()) {
 360     preloaded_pt.ReportErrors(&report__->ReportSubobject("preloaded_pt"));
 361   }
 362   if (!exchange_after_x_ignition_cycles.is_valid()) {
 363     exchange_after_x_ignition_cycles.ReportErrors(&report__->ReportSubobject("exchange_after_x_ignition_cycles"));
 364   }
 365   if (!exchange_after_x_kilometers.is_valid()) {
 366     exchange_after_x_kilometers.ReportErrors(&report__->ReportSubobject("exchange_after_x_kilometers"));
 367   }
 368   if (!exchange_after_x_days.is_valid()) {
 369     exchange_after_x_days.ReportErrors(&report__->ReportSubobject("exchange_after_x_days"));
 370   }
 371   if (!timeout_after_x_seconds.is_valid()) {
 372     timeout_after_x_seconds.ReportErrors(&report__->ReportSubobject("timeout_after_x_seconds"));
 373   }
 374   if (!seconds_between_retries.is_valid()) {
 375     seconds_between_retries.ReportErrors(&report__->ReportSubobject("seconds_between_retries"));
 376   }
 377   if (!endpoints.is_valid()) {
 378     endpoints.ReportErrors(&report__->ReportSubobject("endpoints"));
 379   }
 380   if (!notifications_per_minute_by_priority.is_valid()) {
 381     notifications_per_minute_by_priority.ReportErrors(&report__->ReportSubobject("notifications_per_minute_by_priority"));
 382   }
 383   if (!vehicle_make.is_valid()) {
 384     vehicle_make.ReportErrors(&report__->ReportSubobject("vehicle_make"));
 385   }
 386   if (!vehicle_model.is_valid()) {
 387     vehicle_model.ReportErrors(&report__->ReportSubobject("vehicle_model"));
 388   }
 389   if (!vehicle_year.is_valid()) {
 390     vehicle_year.ReportErrors(&report__->ReportSubobject("vehicle_year"));
 391   }
 392 }
 393
 394 // MessageString methods
 395 MessageString::MessageString()
 396   : CompositeType(kUninitialized) {
 397 }
 398 MessageString::~MessageString() {
 399 }
 400 MessageString::MessageString(const Json::Value* value__)
 401   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 402     line1(impl::ValueMember(value__, "line1")),
 403     line2(impl::ValueMember(value__, "line2")),
 404     tts(impl::ValueMember(value__, "tts")),
 405     label(impl::ValueMember(value__, "label")),
 406     textBody(impl::ValueMember(value__, "textBody")) {
 407 }
 408 Json::Value MessageString::ToJsonValue() const {
 409   Json::Value result__(Json::objectValue);
 410   impl::WriteJsonField("line1", line1, &result__);
 411   impl::WriteJsonField("line2", line2, &result__);
 412   impl::WriteJsonField("tts", tts, &result__);
 413   impl::WriteJsonField("label", label, &result__);
 414   impl::WriteJsonField("textBody", textBody, &result__);
 415   return result__;
 416 }
 417 bool MessageString::is_valid() const {
 418   if (struct_empty()) {
 419     return initialization_state__ == kInitialized;
 420   }
 421   if (!line1.is_valid()) {
 422     return false;
 423   }
 424   if (!line2.is_valid()) {
 425     return false;
 426   }
 427   if (!tts.is_valid()) {
 428     return false;
 429   }
 430   if (!label.is_valid()) {
 431     return false;
 432   }
 433   if (!textBody.is_valid()) {
 434     return false;
 435   }
 436   return Validate();
 437 }
 438 bool MessageString::is_initialized() const {
 439   return (initialization_state__ != kUninitialized) || (!struct_empty());
 440 }
 441 bool MessageString::struct_empty() const {
 442   if (line1.is_initialized()) {
 443     return false;
 444   }
 445   if (line2.is_initialized()) {
 446     return false;
 447   }
 448
 449   if (tts.is_initialized()) {
 450     return false;
 451   }
 452   if (label.is_initialized()) {
 453     return false;
 454   }
 455
 456   if (textBody.is_initialized()) {
 457     return false;
 458   }
 459   return true;
 460 }
 461 void MessageString::ReportErrors(rpc::ValidationReport* report__) const {
 462   if (struct_empty()) {
 463     rpc::CompositeType::ReportErrors(report__);
 464   }
 465   if (!line1.is_valid()) {
 466     line1.ReportErrors(&report__->ReportSubobject("line1"));
 467   }
 468   if (!line2.is_valid()) {
 469     line2.ReportErrors(&report__->ReportSubobject("line2"));
 470   }
 471   if (!tts.is_valid()) {
 472     tts.ReportErrors(&report__->ReportSubobject("tts"));
 473   }
 474   if (!label.is_valid()) {
 475     label.ReportErrors(&report__->ReportSubobject("label"));
 476   }
 477   if (!textBody.is_valid()) {
 478     textBody.ReportErrors(&report__->ReportSubobject("textBody"));
 479   }
 480 }
 481
 482 // MessageLanguages methods
 483 MessageLanguages::MessageLanguages()
 484   : CompositeType(kUninitialized) {
 485 }
 486 MessageLanguages::MessageLanguages(const Languages& languages)
 487   : CompositeType(kUninitialized),
 488     languages(languages) {
 489 }
 490 MessageLanguages::~MessageLanguages() {
 491 }
 492 MessageLanguages::MessageLanguages(const Json::Value* value__)
 493   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 494     languages(impl::ValueMember(value__, "languages")) {
 495 }
 496 Json::Value MessageLanguages::ToJsonValue() const {
 497   Json::Value result__(Json::objectValue);
 498   impl::WriteJsonField("languages", languages, &result__);
 499   return result__;
 500 }
 501 bool MessageLanguages::is_valid() const {
 502   if (!languages.is_valid()) {
 503     return false;
 504   }
 505   return Validate();
 506 }
 507 bool MessageLanguages::is_initialized() const {
 508   return (initialization_state__ != kUninitialized) || (!struct_empty());
 509 }
 510 bool MessageLanguages::struct_empty() const {
 511   if (languages.is_initialized()) {
 512     return false;
 513   }
 514   return true;
 515 }
 516 void MessageLanguages::ReportErrors(rpc::ValidationReport* report__) const {
 517   if (struct_empty()) {
 518     rpc::CompositeType::ReportErrors(report__);
 519   }
 520   if (!languages.is_valid()) {
 521     languages.ReportErrors(&report__->ReportSubobject("languages"));
 522   }
 523 }
 524
 525 // ConsumerFriendlyMessages methods
 526 ConsumerFriendlyMessages::ConsumerFriendlyMessages()
 527   : CompositeType(kUninitialized) {
 528 }
 529 ConsumerFriendlyMessages::ConsumerFriendlyMessages(const std::string& version)
 530   : CompositeType(kUninitialized),
 531     version(version) {
 532 }
 533 ConsumerFriendlyMessages::~ConsumerFriendlyMessages() {
 534 }
 535 ConsumerFriendlyMessages::ConsumerFriendlyMessages(const Json::Value* value__)
 536   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 537     version(impl::ValueMember(value__, "version")),
 538     messages(impl::ValueMember(value__, "messages")) {
 539 }
 540 Json::Value ConsumerFriendlyMessages::ToJsonValue() const {
 541   Json::Value result__(Json::objectValue);
 542   impl::WriteJsonField("version", version, &result__);
 543   impl::WriteJsonField("messages", messages, &result__);
 544   return result__;
 545 }
 546 bool ConsumerFriendlyMessages::is_valid() const {
 547   if (!version.is_valid()) {
 548     return false;
 549   }
 550   if (!messages.is_valid()) {
 551     return false;
 552   }
 553   return Validate();
 554 }
 555 bool ConsumerFriendlyMessages::is_initialized() const {
 556   return (initialization_state__ != kUninitialized) || (!struct_empty());
 557 }
 558 bool ConsumerFriendlyMessages::struct_empty() const {
 559   if (version.is_initialized()) {
 560     return false;
 561   }
 562   if (messages.is_initialized()) {
 563     return false;
 564   }
 565
 566   return true;
 567 }
 568 void ConsumerFriendlyMessages::ReportErrors(rpc::ValidationReport* report__) const {
 569   if (struct_empty()) {
 570     rpc::CompositeType::ReportErrors(report__);
 571   }
 572   if (!version.is_valid()) {
 573     version.ReportErrors(&report__->ReportSubobject("version"));
 574   }
 575   if (!messages.is_valid()) {
 576     messages.ReportErrors(&report__->ReportSubobject("messages"));
 577   }
 578 }
 579
 580 // ModuleMeta methods
 581 ModuleMeta::ModuleMeta()
 582   : CompositeType(kUninitialized) {
 583 }
 584 ModuleMeta::~ModuleMeta() {
 585 }
 586 ModuleMeta::ModuleMeta(const Json::Value* value__)
 587   : CompositeType(InitHelper(value__, &Json::Value::isObject)) {
 588 }
 589 Json::Value ModuleMeta::ToJsonValue() const {
 590   Json::Value result__(Json::objectValue);
 591   return result__;
 592 }
 593 bool ModuleMeta::is_valid() const {
 594   if (struct_empty()) {
 595     return initialization_state__ == kInitialized;
 596   }
 597   return Validate();
 598 }
 599 bool ModuleMeta::is_initialized() const {
 600   return (initialization_state__ != kUninitialized) || (!struct_empty());
 601 }
 602 bool ModuleMeta::struct_empty() const {
 603   return true;
 604 }
 605 void ModuleMeta::ReportErrors(rpc::ValidationReport* report__) const {
 606   if (struct_empty()) {
 607     rpc::CompositeType::ReportErrors(report__);
 608   }
 609 }
 610
 611 // AppLevel methods
 612 AppLevel::AppLevel()
 613   : CompositeType(kUninitialized) {
 614 }
 615 AppLevel::~AppLevel() {
 616 }
 617 AppLevel::AppLevel(const Json::Value* value__)
 618   : CompositeType(InitHelper(value__, &Json::Value::isObject)) {
 619 }
 620 Json::Value AppLevel::ToJsonValue() const {
 621   Json::Value result__(Json::objectValue);
 622   return result__;
 623 }
 624 bool AppLevel::is_valid() const {
 625   if (struct_empty()) {
 626     return initialization_state__ == kInitialized;
 627   }
 628   return Validate();
 629 }
 630 bool AppLevel::is_initialized() const {
 631   return (initialization_state__ != kUninitialized) || (!struct_empty());
 632 }
 633 bool AppLevel::struct_empty() const {
 634   return true;
 635 }
 636 void AppLevel::ReportErrors(rpc::ValidationReport* report__) const {
 637   if (struct_empty()) {
 638     rpc::CompositeType::ReportErrors(report__);
 639   }
 640 }
 641
 642 // UsageAndErrorCounts methods
 643 UsageAndErrorCounts::UsageAndErrorCounts()
 644   : CompositeType(kUninitialized) {
 645 }
 646 UsageAndErrorCounts::~UsageAndErrorCounts() {
 647 }
 648 UsageAndErrorCounts::UsageAndErrorCounts(const Json::Value* value__)
 649   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 650     app_level(impl::ValueMember(value__, "app_level")) {
 651 }
 652 Json::Value UsageAndErrorCounts::ToJsonValue() const {
 653   Json::Value result__(Json::objectValue);
 654   impl::WriteJsonField("app_level", app_level, &result__);
 655   return result__;
 656 }
 657 bool UsageAndErrorCounts::is_valid() const {
 658   if (struct_empty()) {
 659     return initialization_state__ == kInitialized;
 660   }
 661   if (!app_level.is_valid()) {
 662     return false;
 663   }
 664   return Validate();
 665 }
 666 bool UsageAndErrorCounts::is_initialized() const {
 667   return (initialization_state__ != kUninitialized) || (!struct_empty());
 668 }
 669 bool UsageAndErrorCounts::struct_empty() const {
 670   if (app_level.is_initialized()) {
 671     return false;
 672   }
 673   return true;
 674 }
 675 void UsageAndErrorCounts::ReportErrors(rpc::ValidationReport* report__) const {
 676   if (struct_empty()) {
 677     rpc::CompositeType::ReportErrors(report__);
 678   }
 679   if (!app_level.is_valid()) {
 680     app_level.ReportErrors(&report__->ReportSubobject("app_level"));
 681   }
 682 }
 683
 684 // DeviceParams methods
 685 DeviceParams::DeviceParams()
 686   : CompositeType(kUninitialized) {
 687 }
 688 DeviceParams::~DeviceParams() {
 689 }
 690 DeviceParams::DeviceParams(const Json::Value* value__)
 691   : CompositeType(InitHelper(value__, &Json::Value::isObject)) {
 692 }
 693 Json::Value DeviceParams::ToJsonValue() const {
 694   Json::Value result__(Json::objectValue);
 695   return result__;
 696 }
 697 bool DeviceParams::is_valid() const {
 698   if (struct_empty()) {
 699     return initialization_state__ == kInitialized;
 700   }
 701   return Validate();
 702 }
 703 bool DeviceParams::is_initialized() const {
 704   return (initialization_state__ != kUninitialized) || (!struct_empty());
 705 }
 706 bool DeviceParams::struct_empty() const {
 707   return true;
 708 }
 709 void DeviceParams::ReportErrors(rpc::ValidationReport* report__) const {
 710   if (struct_empty()) {
 711     rpc::CompositeType::ReportErrors(report__);
 712   }
 713 }
 714
 715 // PolicyTable methods
 716 PolicyTable::PolicyTable()
 717   : CompositeType(kUninitialized) {
 718 }
 719 PolicyTable::PolicyTable(const ApplicationPolicies& app_policies, const FunctionalGroupings& functional_groupings, const ConsumerFriendlyMessages& consumer_friendly_messages, const ModuleConfig& module_config)
 720   : CompositeType(kUninitialized),
 721     app_policies(app_policies),
 722     functional_groupings(functional_groupings),
 723     consumer_friendly_messages(consumer_friendly_messages),
 724     module_config(module_config) {
 725 }
 726 PolicyTable::~PolicyTable() {
 727 }
 728 PolicyTable::PolicyTable(const Json::Value* value__)
 729   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 730     app_policies(impl::ValueMember(value__, "app_policies")),
 731     functional_groupings(impl::ValueMember(value__, "functional_groupings")),
 732     consumer_friendly_messages(impl::ValueMember(value__, "consumer_friendly_messages")),
 733     module_config(impl::ValueMember(value__, "module_config")),
 734     module_meta(impl::ValueMember(value__, "module_meta")),
 735     usage_and_error_counts(impl::ValueMember(value__, "usage_and_error_counts")),
 736     device_data(impl::ValueMember(value__, "device_data")) {
 737 }
 738 Json::Value PolicyTable::ToJsonValue() const {
 739   Json::Value result__(Json::objectValue);
 740   impl::WriteJsonField("app_policies", app_policies, &result__);
 741   impl::WriteJsonField("functional_groupings", functional_groupings, &result__);
 742   impl::WriteJsonField("consumer_friendly_messages", consumer_friendly_messages, &result__);
 743   impl::WriteJsonField("module_config", module_config, &result__);
 744   impl::WriteJsonField("module_meta", module_meta, &result__);
 745   impl::WriteJsonField("usage_and_error_counts", usage_and_error_counts, &result__);
 746   impl::WriteJsonField("device_data", device_data, &result__);
 747   return result__;
 748 }
 749 bool PolicyTable::is_valid() const {
 750   if (!app_policies.is_valid()) {
 751     return false;
 752   }
 753   if (!functional_groupings.is_valid()) {
 754     return false;
 755   }
 756   if (!consumer_friendly_messages.is_valid()) {
 757     return false;
 758   }
 759   if (!module_config.is_valid()) {
 760     return false;
 761   }
 762   if (!module_meta.is_valid()) {
 763     return false;
 764   }
 765   if (!usage_and_error_counts.is_valid()) {
 766     return false;
 767   }
 768   if (!device_data.is_valid()) {
 769     return false;
 770   }
 771   return Validate();
 772 }
 773 bool PolicyTable::is_initialized() const {
 774   return (initialization_state__ != kUninitialized) || (!struct_empty());
 775 }
 776 bool PolicyTable::struct_empty() const {
 777   if (app_policies.is_initialized()) {
 778     return false;
 779   }
 780   if (functional_groupings.is_initialized()) {
 781     return false;
 782   }
 783
 784   if (consumer_friendly_messages.is_initialized()) {
 785     return false;
 786   }
 787   if (module_config.is_initialized()) {
 788     return false;
 789   }
 790
 791   if (module_meta.is_initialized()) {
 792     return false;
 793   }
 794   if (usage_and_error_counts.is_initialized()) {
 795     return false;
 796   }
 797
 798   if (device_data.is_initialized()) {
 799     return false;
 800   }
 801   return true;
 802 }
 803 void PolicyTable::ReportErrors(rpc::ValidationReport* report__) const {
 804   if (struct_empty()) {
 805     rpc::CompositeType::ReportErrors(report__);
 806   }
 807   if (!app_policies.is_valid()) {
 808     app_policies.ReportErrors(&report__->ReportSubobject("app_policies"));
 809   }
 810   if (!functional_groupings.is_valid()) {
 811     functional_groupings.ReportErrors(&report__->ReportSubobject("functional_groupings"));
 812   }
 813   if (!consumer_friendly_messages.is_valid()) {
 814     consumer_friendly_messages.ReportErrors(&report__->ReportSubobject("consumer_friendly_messages"));
 815   }
 816   if (!module_config.is_valid()) {
 817     module_config.ReportErrors(&report__->ReportSubobject("module_config"));
 818   }
 819   if (!module_meta.is_valid()) {
 820     module_meta.ReportErrors(&report__->ReportSubobject("module_meta"));
 821   }
 822   if (!usage_and_error_counts.is_valid()) {
 823     usage_and_error_counts.ReportErrors(&report__->ReportSubobject("usage_and_error_counts"));
 824   }
 825   if (!device_data.is_valid()) {
 826     device_data.ReportErrors(&report__->ReportSubobject("device_data"));
 827   }
 828 }
 829
 830 // Table methods
 831 Table::Table()
 832   : CompositeType(kUninitialized) {
 833 }
 834 Table::Table(const PolicyTable& policy_table)
 835   : CompositeType(kUninitialized),
 836     policy_table(policy_table) {
 837 }
 838 Table::~Table() {
 839 }
 840 Table::Table(const Json::Value* value__)
 841   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
 842     policy_table(impl::ValueMember(value__, "policy_table")) {
 843 }
 844 Json::Value Table::ToJsonValue() const {
 845   Json::Value result__(Json::objectValue);
 846   impl::WriteJsonField("policy_table", policy_table, &result__);
 847   return result__;
 848 }
 849 bool Table::is_valid() const {
 850   if (!policy_table.is_valid()) {
 851     return false;
 852   }
 853   return Validate();
 854 }
 855 bool Table::is_initialized() const {
 856   return (initialization_state__ != kUninitialized) || (!struct_empty());
 857 }
 858 bool Table::struct_empty() const {
 859   if (policy_table.is_initialized()) {
 860     return false;
 861   }
 862   return true;
 863 }
 864 void Table::ReportErrors(rpc::ValidationReport* report__) const {
 865   if (struct_empty()) {
 866     rpc::CompositeType::ReportErrors(report__);
 867   }
 868   if (!policy_table.is_valid()) {
 869     policy_table.ReportErrors(&report__->ReportSubobject("policy_table"));
 870   }
 871 }
 872
 873 }  // namespace policy_table_interface_base
 874 }  // namespace rpc
 875