Home Original page

Google OR-Tools: build/ortools/constraint_solver/solver_parameters.pb.cc Source File

1

2

3

4

5

7

8#include <algorithm>

9#include <type_traits>

10#include "google/protobuf/io/coded_stream.h"

11#include "google/protobuf/generated_message_tctable_impl.h"

12#include "google/protobuf/extension_set.h"

13#include "google/protobuf/generated_message_util.h"

14#include "google/protobuf/wire_format_lite.h"

15#include "google/protobuf/descriptor.h"

16#include "google/protobuf/generated_message_reflection.h"

17#include "google/protobuf/reflection_ops.h"

18#include "google/protobuf/wire_format.h"

19

20

21

22#include "google/protobuf/port_def.inc"

23PROTOBUF_PRAGMA_INIT_SEG

26namespace _fl = ::google::protobuf::internal::field_layout;

28

29inline constexpr ConstraintSolverParameters::Impl_::Impl_(

30 ::_pbi::ConstantInitialized) noexcept

31 : _cached_size_{0},

32 profile_file_(

33 &::google::protobuf::internal::fixed_address_empty_string,

34 ::_pbi::ConstantInitialized()),

36 trail_block_size_{0},

37 array_split_size_{0},

38 store_names_{false},

39 name_cast_variables_{false},

40 name_all_variables_{false},

41 profile_propagation_{false},

42 trace_propagation_{false},

43 trace_search_{false},

44 print_model_{false},

45 print_model_stats_{false},

46 print_added_constraints_{false},

47 disable_solve_{false},

48 profile_local_search_{false},

49 print_local_search_profile_{false},

50 use_small_table_{false},

51 use_cumulative_edge_finder_{false},

52 use_cumulative_time_table_{false},

53 use_sequence_high_demand_tasks_{false},

54 max_edge_finder_size_{0},

55 use_all_possible_disjunctions_{false},

56 diffn_use_cumulative_{false},

57 use_element_rmq_{false},

58 check_solution_period_{0},

59 use_cumulative_time_table_sync_{false},

60 skip_locally_optimal_paths_{false} {}

61

62template <typename>

64#if defined(PROTOBUF_CUSTOM_VTABLE)

66#else

67 : ::google::protobuf::Message(),

68#endif

69 _impl_(::_pbi::ConstantInitialized()) {

70}

78

79PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL

81}

82static const ::_pb::EnumDescriptor* PROTOBUF_NONNULL

84static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE

86const ::uint32_t

88 protodesc_cold) = {

89 0x081,

91 30,

119 1,

120 2,

121 3,

122 4,

123 5,

124 6,

125 7,

126 0,

127 14,

128 15,

129 8,

130 9,

131 10,

132 11,

133 12,

134 13,

135 16,

136 17,

137 18,

138 25,

139 19,

140 21,

141 20,

142 22,

143 23,

144 26,

145 24,

146};

147

148static const ::_pbi::MigrationSchema

151};

155const char descriptor_table_protodef_ortools_2fconstraint_5fsolver_2fsolver_5fparameters_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE(

156 protodesc_cold) = {

157 "\n1ortools/constraint_solver/solver_param"

158 "eters.proto\022\023operations_research\"\315\007\n\032Con"

159 "straintSolverParameters\022X\n\016compress_trai"

160 "l\030\001 \001(\0162@.operations_research.Constraint"

161 "SolverParameters.TrailCompression\022\030\n\020tra"

162 "il_block_size\030\002 \001(\005\022\030\n\020array_split_size\030"

163 "\003 \001(\005\022\023\n\013store_names\030\004 \001(\010\022\033\n\023name_cast_"

164 "variables\030\005 \001(\010\022\032\n\022name_all_variables\030\006 "

165 "\001(\010\022\033\n\023profile_propagation\030\007 \001(\010\022\024\n\014prof"

166 "ile_file\030\010 \001(\t\022\034\n\024profile_local_search\030\020"

167 " \001(\010\022\"\n\032print_local_search_profile\030\021 \001(\010"

168 "\022\031\n\021trace_propagation\030\t \001(\010\022\024\n\014trace_sea"

169 "rch\030\n \001(\010\022\023\n\013print_model\030\013 \001(\010\022\031\n\021print_"

170 "model_stats\030\014 \001(\010\022\037\n\027print_added_constra"

171 "ints\030\r \001(\010\022\025\n\rdisable_solve\030\017 \001(\010\022\027\n\017use"

172 "_small_table\030e \001(\010\022\"\n\032use_cumulative_edg"

173 "e_finder\030i \001(\010\022!\n\031use_cumulative_time_ta"

174 "ble\030j \001(\010\022&\n\036use_cumulative_time_table_s"

175 "ync\030p \001(\010\022&\n\036use_sequence_high_demand_ta"

176 "sks\030k \001(\010\022%\n\035use_all_possible_disjunctio"

177 "ns\030l \001(\010\022\034\n\024max_edge_finder_size\030m \001(\005\022\034"

178 "\n\024diffn_use_cumulative\030n \001(\010\022\027\n\017use_elem"

179 "ent_rmq\030o \001(\010\022\"\n\032skip_locally_optimal_pa"

180 "ths\030q \001(\010\022\035\n\025check_solution_period\030r \001(\005"

181 "\">\n\020TrailCompression\022\022\n\016NO_COMPRESSION\020\000"

182 "\022\026\n\022COMPRESS_WITH_ZLIB\020\001J\004\010d\020eJ\004\010f\020gJ\004\010g"

183 "\020hJ\004\010h\020iBI\n#com.google.ortools.constrain"

184 "tsolverP\001\252\002\037Google.OrTools.ConstraintSol"

185 "verb\006proto3"

186};

189 false,

190 false,

191 1131,

192 descriptor_table_protodef_ortools_2fconstraint_5fsolver_2fsolver_5fparameters_2eproto,

193 "ortools/constraint_solver/solver_parameters.proto",

195 nullptr,

196 0,

197 1,

203};

211

212

213class ConstraintSolverParameters::_Internal {

216 decltype(::std::declval<ConstraintSolverParameters>()._impl_._has_bits_);

219};

220

222#if defined(PROTOBUF_CUSTOM_VTABLE)

224#else

225 : ::google::protobuf::Message(arena) {

226#endif

227 SharedCtor(arena);

228

229}

230PROTOBUF_NDEBUG_INLINE ConstraintSolverParameters::Impl_::Impl_(

231 [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,

232 [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,

233 [[maybe_unused]] const ::operations_research::ConstraintSolverParameters& from_msg)

234 : _has_bits_{from._has_bits_},

235 _cached_size_{0},

236 profile_file_(arena, from.profile_file_) {}

237

239 ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,

241#if defined(PROTOBUF_CUSTOM_VTABLE)

243#else

244 : ::google::protobuf::Message(arena) {

245#endif

247 (void)_this;

248 _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(

249 from._internal_metadata_);

250 new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);

251 ::memcpy(reinterpret_cast<char*>(&_impl_) +

252 offsetof(Impl_, compress_trail_),

253 reinterpret_cast<const char*>(&from._impl_) +

254 offsetof(Impl_, compress_trail_),

255 offsetof(Impl_, skip_locally_optimal_paths_) -

256 offsetof(Impl_, compress_trail_) +

257 sizeof(Impl_::skip_locally_optimal_paths_));

258

259

260}

261PROTOBUF_NDEBUG_INLINE ConstraintSolverParameters::Impl_::Impl_(

262 [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,

263 [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)

264 : _cached_size_{0},

265 profile_file_(arena) {}

266

267inline void ConstraintSolverParameters::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {

268 new (&_impl_) Impl_(internal_visibility(), arena);

269 ::memset(reinterpret_cast<char*>(&_impl_) +

270 offsetof(Impl_, compress_trail_),

271 0,

272 offsetof(Impl_, skip_locally_optimal_paths_) -

273 offsetof(Impl_, compress_trail_) +

274 sizeof(Impl_::skip_locally_optimal_paths_));

275}

277

278 SharedDtor(*this);

279}

280inline void ConstraintSolverParameters::SharedDtor(MessageLite& self) {

282 if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {

283 this_.CheckHasBitConsistency();

284 }

285 this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();

286 ABSL_DCHECK(this_.GetArena() == nullptr);

287 this_._impl_.profile_file_.Destroy();

288 this_._impl_.~Impl_();

289}

290

291inline void* PROTOBUF_NONNULL ConstraintSolverParameters::PlacementNew_(

292 const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,

293 ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {

295}

296constexpr auto ConstraintSolverParameters::InternalNewImpl_() {

299}

301 return ::google::protobuf::internal::ClassDataFull{

302 ::google::protobuf::internal::ClassData{

304 &_table_.header,

305 nullptr,

306 nullptr,

307 &ConstraintSolverParameters::MergeImpl,

308 ::google::protobuf::Message::GetNewImpl<ConstraintSolverParameters>(),

309#if defined(PROTOBUF_CUSTOM_VTABLE)

310 &ConstraintSolverParameters::SharedDtor,

313#endif

315 false,

316 },

317 &ConstraintSolverParameters::kDescriptorMethods,

319 nullptr,

320 };

321}

322

323PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const

326

327PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL

328ConstraintSolverParameters::GetClassData() const {

332}

333PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1

334const ::_pbi::TcParseTable<5, 27, 0, 91, 7>

335ConstraintSolverParameters::_table_ = {

336 {

338 0,

339 114, 248,

340 offsetof(decltype(_table_), field_lookup_table),

341 4294844416,

342 offsetof(decltype(_table_), field_entries),

343 27,

344 0,

345 offsetof(decltype(_table_), field_names),

347 nullptr,

348 ::_pbi::TcParser::GenericFallback,

349 #ifdef PROTOBUF_PREFETCH_PARSE_TABLE

350 ::_pbi::TcParser::GetTable<::operations_research::ConstraintSolverParameters>(),

351 #endif

352 }, {{

353 {::_pbi::TcParser::MiniParse, {}},

354

356 {8, 1, 0,

358

360 {16, 2, 0,

362

364 {24, 3, 0,

366

368 {32, 4, 0,

370

372 {40, 5, 0,

374

376 {48, 6, 0,

378

380 {56, 7, 0,

382

383 {::_pbi::TcParser::FastUS1,

384 {66, 0, 0,

386

388 {72, 8, 0,

390

392 {80, 9, 0,

394

396 {88, 10, 0,

398

400 {96, 11, 0,

402

404 {104, 12, 0,

406 {::_pbi::TcParser::MiniParse, {}},

407

409 {120, 13, 0,

411

412 {::_pbi::TcParser::FastV8S2,

413 {384, 14, 0,

415

416 {::_pbi::TcParser::FastV8S2,

417 {392, 15, 0,

419

420 {::_pbi::TcParser::FastV32S2,

421 {1936, 24, 0,

423 {::_pbi::TcParser::MiniParse, {}},

424 {::_pbi::TcParser::MiniParse, {}},

425

426 {::_pbi::TcParser::FastV8S2,

427 {1704, 16, 0,

429 {::_pbi::TcParser::MiniParse, {}},

430 {::_pbi::TcParser::MiniParse, {}},

431 {::_pbi::TcParser::MiniParse, {}},

432

433 {::_pbi::TcParser::FastV8S2,

434 {1736, 17, 0,

436

437 {::_pbi::TcParser::FastV8S2,

438 {1744, 18, 0,

440

441 {::_pbi::TcParser::FastV8S2,

442 {1752, 19, 0,

444

445 {::_pbi::TcParser::FastV8S2,

446 {1760, 21, 0,

448

449 {::_pbi::TcParser::FastV32S2,

450 {1768, 20, 0,

452

453 {::_pbi::TcParser::FastV8S2,

454 {1776, 22, 0,

456

457 {::_pbi::TcParser::FastV8S2,

458 {1784, 23, 0,

460 }}, {{

461 101, 0, 1,

462 49166, 16,

463 65535, 65535

464 }}, {{

465

467

469

471

473

475

477

479

481

483

485

487

489

491

493

495

497

499

501

503

505

507

509

511

513

515

517

519 }},

520

521 {{

522 "\56\0\0\0\0\0\0\0\14\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

523 "operations_research.ConstraintSolverParameters"

524 "profile_file"

525 }},

526};

528

529 ::google::protobuf::internal::TSanWrite(&_impl_);

530 ::uint32_t cached_has_bits = 0;

531

532 (void) cached_has_bits;

533

534 cached_has_bits = _impl_._has_bits_[0];

535 if (CheckHasBit(cached_has_bits, 0x00000001U)) {

536 _impl_.profile_file_.ClearNonDefaultToEmpty();

537 }

538 if (BatchCheckHasBit(cached_has_bits, 0x000000feU)) {

539 ::memset(&_impl_.compress_trail_, 0, static_cast<::size_t>(

540 reinterpret_cast<char*>(&_impl_.profile_propagation_) -

541 reinterpret_cast<char*>(&_impl_.compress_trail_)) + sizeof(_impl_.profile_propagation_));

542 }

543 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {

544 ::memset(&_impl_.trace_propagation_, 0, static_cast<::size_t>(

545 reinterpret_cast<char*>(&_impl_.print_local_search_profile_) -

546 reinterpret_cast<char*>(&_impl_.trace_propagation_)) + sizeof(_impl_.print_local_search_profile_));

547 }

548 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {

549 ::memset(&_impl_.use_small_table_, 0, static_cast<::size_t>(

550 reinterpret_cast<char*>(&_impl_.use_element_rmq_) -

551 reinterpret_cast<char*>(&_impl_.use_small_table_)) + sizeof(_impl_.use_element_rmq_));

552 }

553 if (BatchCheckHasBit(cached_has_bits, 0x07000000U)) {

554 ::memset(&_impl_.check_solution_period_, 0, static_cast<::size_t>(

555 reinterpret_cast<char*>(&_impl_.skip_locally_optimal_paths_) -

556 reinterpret_cast<char*>(&_impl_.check_solution_period_)) + sizeof(_impl_.skip_locally_optimal_paths_));

557 }

558 _impl_._has_bits_.Clear();

559 _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();

560}

561

562#if defined(PROTOBUF_CUSTOM_VTABLE)

564 const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,

565 ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {

567#else

569 ::uint8_t* PROTOBUF_NONNULL target,

570 ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {

572#endif

573 if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {

574 this_.CheckHasBitConsistency();

575 }

576

577 ::uint32_t cached_has_bits = 0;

578 (void)cached_has_bits;

579

580 cached_has_bits = this_._impl_._has_bits_[0];

581

582 if (CheckHasBit(cached_has_bits, 0x00000002U)) {

583 if (this_._internal_compress_trail() != 0) {

584 target = stream->EnsureSpace(target);

585 target = ::_pbi::WireFormatLite::WriteEnumToArray(

586 1, this_._internal_compress_trail(), target);

587 }

588 }

589

590

591 if (CheckHasBit(cached_has_bits, 0x00000004U)) {

592 if (this_._internal_trail_block_size() != 0) {

593 target =

594 ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<2>(

595 stream, this_._internal_trail_block_size(), target);

596 }

597 }

598

599

600 if (CheckHasBit(cached_has_bits, 0x00000008U)) {

601 if (this_._internal_array_split_size() != 0) {

602 target =

603 ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<3>(

604 stream, this_._internal_array_split_size(), target);

605 }

606 }

607

608

609 if (CheckHasBit(cached_has_bits, 0x00000010U)) {

610 if (this_._internal_store_names() != 0) {

611 target = stream->EnsureSpace(target);

612 target = ::_pbi::WireFormatLite::WriteBoolToArray(

613 4, this_._internal_store_names(), target);

614 }

615 }

616

617

618 if (CheckHasBit(cached_has_bits, 0x00000020U)) {

619 if (this_._internal_name_cast_variables() != 0) {

620 target = stream->EnsureSpace(target);

621 target = ::_pbi::WireFormatLite::WriteBoolToArray(

622 5, this_._internal_name_cast_variables(), target);

623 }

624 }

625

626

627 if (CheckHasBit(cached_has_bits, 0x00000040U)) {

628 if (this_._internal_name_all_variables() != 0) {

629 target = stream->EnsureSpace(target);

630 target = ::_pbi::WireFormatLite::WriteBoolToArray(

631 6, this_._internal_name_all_variables(), target);

632 }

633 }

634

635

636 if (CheckHasBit(cached_has_bits, 0x00000080U)) {

637 if (this_._internal_profile_propagation() != 0) {

638 target = stream->EnsureSpace(target);

639 target = ::_pbi::WireFormatLite::WriteBoolToArray(

640 7, this_._internal_profile_propagation(), target);

641 }

642 }

643

644

645 if (CheckHasBit(cached_has_bits, 0x00000001U)) {

646 if (!this_._internal_profile_file().empty()) {

647 const ::std::string& _s = this_._internal_profile_file();

648 ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(

649 _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "operations_research.ConstraintSolverParameters.profile_file");

650 target = stream->WriteStringMaybeAliased(8, _s, target);

651 }

652 }

653

654

655 if (CheckHasBit(cached_has_bits, 0x00000100U)) {

656 if (this_._internal_trace_propagation() != 0) {

657 target = stream->EnsureSpace(target);

658 target = ::_pbi::WireFormatLite::WriteBoolToArray(

659 9, this_._internal_trace_propagation(), target);

660 }

661 }

662

663

664 if (CheckHasBit(cached_has_bits, 0x00000200U)) {

665 if (this_._internal_trace_search() != 0) {

666 target = stream->EnsureSpace(target);

667 target = ::_pbi::WireFormatLite::WriteBoolToArray(

668 10, this_._internal_trace_search(), target);

669 }

670 }

671

672

673 if (CheckHasBit(cached_has_bits, 0x00000400U)) {

674 if (this_._internal_print_model() != 0) {

675 target = stream->EnsureSpace(target);

676 target = ::_pbi::WireFormatLite::WriteBoolToArray(

677 11, this_._internal_print_model(), target);

678 }

679 }

680

681

682 if (CheckHasBit(cached_has_bits, 0x00000800U)) {

683 if (this_._internal_print_model_stats() != 0) {

684 target = stream->EnsureSpace(target);

685 target = ::_pbi::WireFormatLite::WriteBoolToArray(

686 12, this_._internal_print_model_stats(), target);

687 }

688 }

689

690

691 if (CheckHasBit(cached_has_bits, 0x00001000U)) {

692 if (this_._internal_print_added_constraints() != 0) {

693 target = stream->EnsureSpace(target);

694 target = ::_pbi::WireFormatLite::WriteBoolToArray(

695 13, this_._internal_print_added_constraints(), target);

696 }

697 }

698

699

700 if (CheckHasBit(cached_has_bits, 0x00002000U)) {

701 if (this_._internal_disable_solve() != 0) {

702 target = stream->EnsureSpace(target);

703 target = ::_pbi::WireFormatLite::WriteBoolToArray(

704 15, this_._internal_disable_solve(), target);

705 }

706 }

707

708

709 if (CheckHasBit(cached_has_bits, 0x00004000U)) {

710 if (this_._internal_profile_local_search() != 0) {

711 target = stream->EnsureSpace(target);

712 target = ::_pbi::WireFormatLite::WriteBoolToArray(

713 16, this_._internal_profile_local_search(), target);

714 }

715 }

716

717

718 if (CheckHasBit(cached_has_bits, 0x00008000U)) {

719 if (this_._internal_print_local_search_profile() != 0) {

720 target = stream->EnsureSpace(target);

721 target = ::_pbi::WireFormatLite::WriteBoolToArray(

722 17, this_._internal_print_local_search_profile(), target);

723 }

724 }

725

726

727 if (CheckHasBit(cached_has_bits, 0x00010000U)) {

728 if (this_._internal_use_small_table() != 0) {

729 target = stream->EnsureSpace(target);

730 target = ::_pbi::WireFormatLite::WriteBoolToArray(

731 101, this_._internal_use_small_table(), target);

732 }

733 }

734

735

736 if (CheckHasBit(cached_has_bits, 0x00020000U)) {

737 if (this_._internal_use_cumulative_edge_finder() != 0) {

738 target = stream->EnsureSpace(target);

739 target = ::_pbi::WireFormatLite::WriteBoolToArray(

740 105, this_._internal_use_cumulative_edge_finder(), target);

741 }

742 }

743

744

745 if (CheckHasBit(cached_has_bits, 0x00040000U)) {

746 if (this_._internal_use_cumulative_time_table() != 0) {

747 target = stream->EnsureSpace(target);

748 target = ::_pbi::WireFormatLite::WriteBoolToArray(

749 106, this_._internal_use_cumulative_time_table(), target);

750 }

751 }

752

753

754 if (CheckHasBit(cached_has_bits, 0x00080000U)) {

755 if (this_._internal_use_sequence_high_demand_tasks() != 0) {

756 target = stream->EnsureSpace(target);

757 target = ::_pbi::WireFormatLite::WriteBoolToArray(

758 107, this_._internal_use_sequence_high_demand_tasks(), target);

759 }

760 }

761

762

763 if (CheckHasBit(cached_has_bits, 0x00200000U)) {

764 if (this_._internal_use_all_possible_disjunctions() != 0) {

765 target = stream->EnsureSpace(target);

766 target = ::_pbi::WireFormatLite::WriteBoolToArray(

767 108, this_._internal_use_all_possible_disjunctions(), target);

768 }

769 }

770

771

772 if (CheckHasBit(cached_has_bits, 0x00100000U)) {

773 if (this_._internal_max_edge_finder_size() != 0) {

774 target = stream->EnsureSpace(target);

775 target = ::_pbi::WireFormatLite::WriteInt32ToArray(

776 109, this_._internal_max_edge_finder_size(), target);

777 }

778 }

779

780

781 if (CheckHasBit(cached_has_bits, 0x00400000U)) {

782 if (this_._internal_diffn_use_cumulative() != 0) {

783 target = stream->EnsureSpace(target);

784 target = ::_pbi::WireFormatLite::WriteBoolToArray(

785 110, this_._internal_diffn_use_cumulative(), target);

786 }

787 }

788

789

790 if (CheckHasBit(cached_has_bits, 0x00800000U)) {

791 if (this_._internal_use_element_rmq() != 0) {

792 target = stream->EnsureSpace(target);

793 target = ::_pbi::WireFormatLite::WriteBoolToArray(

794 111, this_._internal_use_element_rmq(), target);

795 }

796 }

797

798

799 if (CheckHasBit(cached_has_bits, 0x02000000U)) {

800 if (this_._internal_use_cumulative_time_table_sync() != 0) {

801 target = stream->EnsureSpace(target);

802 target = ::_pbi::WireFormatLite::WriteBoolToArray(

803 112, this_._internal_use_cumulative_time_table_sync(), target);

804 }

805 }

806

807

808 if (CheckHasBit(cached_has_bits, 0x04000000U)) {

809 if (this_._internal_skip_locally_optimal_paths() != 0) {

810 target = stream->EnsureSpace(target);

811 target = ::_pbi::WireFormatLite::WriteBoolToArray(

812 113, this_._internal_skip_locally_optimal_paths(), target);

813 }

814 }

815

816

817 if (CheckHasBit(cached_has_bits, 0x01000000U)) {

818 if (this_._internal_check_solution_period() != 0) {

819 target = stream->EnsureSpace(target);

820 target = ::_pbi::WireFormatLite::WriteInt32ToArray(

821 114, this_._internal_check_solution_period(), target);

822 }

823 }

824

825 if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {

826 target =

827 ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(

828 this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);

829 }

830

831 return target;

832}

833

834#if defined(PROTOBUF_CUSTOM_VTABLE)

837#else

840#endif

841

842 ::size_t total_size = 0;

843

844 ::uint32_t cached_has_bits = 0;

845

846 (void)cached_has_bits;

847

848 ::_pbi::Prefetch5LinesFrom7Lines(&this_);

849 cached_has_bits = this_._impl_._has_bits_[0];

850 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {

851

852 if (CheckHasBit(cached_has_bits, 0x00000001U)) {

853 if (!this_._internal_profile_file().empty()) {

854 total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(

855 this_._internal_profile_file());

856 }

857 }

858

859 if (CheckHasBit(cached_has_bits, 0x00000002U)) {

860 if (this_._internal_compress_trail() != 0) {

861 total_size += 1 +

862 ::_pbi::WireFormatLite::EnumSize(this_._internal_compress_trail());

863 }

864 }

865

866 if (CheckHasBit(cached_has_bits, 0x00000004U)) {

867 if (this_._internal_trail_block_size() != 0) {

868 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(

869 this_._internal_trail_block_size());

870 }

871 }

872

873 if (CheckHasBit(cached_has_bits, 0x00000008U)) {

874 if (this_._internal_array_split_size() != 0) {

875 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(

876 this_._internal_array_split_size());

877 }

878 }

879

880 if (CheckHasBit(cached_has_bits, 0x00000010U)) {

881 if (this_._internal_store_names() != 0) {

882 total_size += 2;

883 }

884 }

885

886 if (CheckHasBit(cached_has_bits, 0x00000020U)) {

887 if (this_._internal_name_cast_variables() != 0) {

888 total_size += 2;

889 }

890 }

891

892 if (CheckHasBit(cached_has_bits, 0x00000040U)) {

893 if (this_._internal_name_all_variables() != 0) {

894 total_size += 2;

895 }

896 }

897

898 if (CheckHasBit(cached_has_bits, 0x00000080U)) {

899 if (this_._internal_profile_propagation() != 0) {

900 total_size += 2;

901 }

902 }

903 }

904 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {

905

906 if (CheckHasBit(cached_has_bits, 0x00000100U)) {

907 if (this_._internal_trace_propagation() != 0) {

908 total_size += 2;

909 }

910 }

911

912 if (CheckHasBit(cached_has_bits, 0x00000200U)) {

913 if (this_._internal_trace_search() != 0) {

914 total_size += 2;

915 }

916 }

917

918 if (CheckHasBit(cached_has_bits, 0x00000400U)) {

919 if (this_._internal_print_model() != 0) {

920 total_size += 2;

921 }

922 }

923

924 if (CheckHasBit(cached_has_bits, 0x00000800U)) {

925 if (this_._internal_print_model_stats() != 0) {

926 total_size += 2;

927 }

928 }

929

930 if (CheckHasBit(cached_has_bits, 0x00001000U)) {

931 if (this_._internal_print_added_constraints() != 0) {

932 total_size += 2;

933 }

934 }

935

936 if (CheckHasBit(cached_has_bits, 0x00002000U)) {

937 if (this_._internal_disable_solve() != 0) {

938 total_size += 2;

939 }

940 }

941

942 if (CheckHasBit(cached_has_bits, 0x00004000U)) {

943 if (this_._internal_profile_local_search() != 0) {

944 total_size += 3;

945 }

946 }

947

948 if (CheckHasBit(cached_has_bits, 0x00008000U)) {

949 if (this_._internal_print_local_search_profile() != 0) {

950 total_size += 3;

951 }

952 }

953 }

954 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {

955

956 if (CheckHasBit(cached_has_bits, 0x00010000U)) {

957 if (this_._internal_use_small_table() != 0) {

958 total_size += 3;

959 }

960 }

961

962 if (CheckHasBit(cached_has_bits, 0x00020000U)) {

963 if (this_._internal_use_cumulative_edge_finder() != 0) {

964 total_size += 3;

965 }

966 }

967

968 if (CheckHasBit(cached_has_bits, 0x00040000U)) {

969 if (this_._internal_use_cumulative_time_table() != 0) {

970 total_size += 3;

971 }

972 }

973

974 if (CheckHasBit(cached_has_bits, 0x00080000U)) {

975 if (this_._internal_use_sequence_high_demand_tasks() != 0) {

976 total_size += 3;

977 }

978 }

979

980 if (CheckHasBit(cached_has_bits, 0x00100000U)) {

981 if (this_._internal_max_edge_finder_size() != 0) {

982 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(

983 this_._internal_max_edge_finder_size());

984 }

985 }

986

987 if (CheckHasBit(cached_has_bits, 0x00200000U)) {

988 if (this_._internal_use_all_possible_disjunctions() != 0) {

989 total_size += 3;

990 }

991 }

992

993 if (CheckHasBit(cached_has_bits, 0x00400000U)) {

994 if (this_._internal_diffn_use_cumulative() != 0) {

995 total_size += 3;

996 }

997 }

998

999 if (CheckHasBit(cached_has_bits, 0x00800000U)) {

1000 if (this_._internal_use_element_rmq() != 0) {

1001 total_size += 3;

1002 }

1003 }

1004 }

1005 if (BatchCheckHasBit(cached_has_bits, 0x07000000U)) {

1006

1007 if (CheckHasBit(cached_has_bits, 0x01000000U)) {

1008 if (this_._internal_check_solution_period() != 0) {

1009 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(

1010 this_._internal_check_solution_period());

1011 }

1012 }

1013

1014 if (CheckHasBit(cached_has_bits, 0x02000000U)) {

1015 if (this_._internal_use_cumulative_time_table_sync() != 0) {

1016 total_size += 3;

1017 }

1018 }

1019

1020 if (CheckHasBit(cached_has_bits, 0x04000000U)) {

1021 if (this_._internal_skip_locally_optimal_paths() != 0) {

1022 total_size += 3;

1023 }

1024 }

1025 }

1026 return this_.MaybeComputeUnknownFieldsSize(total_size,

1027 &this_._impl_._cached_size_);

1028}

1029

1030void ConstraintSolverParameters::MergeImpl(::google::protobuf::MessageLite& to_msg,

1031 const ::google::protobuf::MessageLite& from_msg) {

1032 auto* const _this =

1035 if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {

1036 from.CheckHasBitConsistency();

1037 }

1038

1039 ABSL_DCHECK_NE(&from, _this);

1040 ::uint32_t cached_has_bits = 0;

1041 (void)cached_has_bits;

1042

1043 cached_has_bits = from._impl_._has_bits_[0];

1044 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {

1045 if (CheckHasBit(cached_has_bits, 0x00000001U)) {

1046 if (!from._internal_profile_file().empty()) {

1047 _this->_internal_set_profile_file(from._internal_profile_file());

1048 } else {

1049 if (_this->_impl_.profile_file_.IsDefault()) {

1050 _this->_internal_set_profile_file("");

1051 }

1052 }

1053 }

1054 if (CheckHasBit(cached_has_bits, 0x00000002U)) {

1055 if (from._internal_compress_trail() != 0) {

1056 _this->_impl_.compress_trail_ = from._impl_.compress_trail_;

1057 }

1058 }

1059 if (CheckHasBit(cached_has_bits, 0x00000004U)) {

1060 if (from._internal_trail_block_size() != 0) {

1061 _this->_impl_.trail_block_size_ = from._impl_.trail_block_size_;

1062 }

1063 }

1064 if (CheckHasBit(cached_has_bits, 0x00000008U)) {

1065 if (from._internal_array_split_size() != 0) {

1066 _this->_impl_.array_split_size_ = from._impl_.array_split_size_;

1067 }

1068 }

1069 if (CheckHasBit(cached_has_bits, 0x00000010U)) {

1070 if (from._internal_store_names() != 0) {

1071 _this->_impl_.store_names_ = from._impl_.store_names_;

1072 }

1073 }

1074 if (CheckHasBit(cached_has_bits, 0x00000020U)) {

1075 if (from._internal_name_cast_variables() != 0) {

1076 _this->_impl_.name_cast_variables_ = from._impl_.name_cast_variables_;

1077 }

1078 }

1079 if (CheckHasBit(cached_has_bits, 0x00000040U)) {

1080 if (from._internal_name_all_variables() != 0) {

1081 _this->_impl_.name_all_variables_ = from._impl_.name_all_variables_;

1082 }

1083 }

1084 if (CheckHasBit(cached_has_bits, 0x00000080U)) {

1085 if (from._internal_profile_propagation() != 0) {

1086 _this->_impl_.profile_propagation_ = from._impl_.profile_propagation_;

1087 }

1088 }

1089 }

1090 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {

1091 if (CheckHasBit(cached_has_bits, 0x00000100U)) {

1092 if (from._internal_trace_propagation() != 0) {

1093 _this->_impl_.trace_propagation_ = from._impl_.trace_propagation_;

1094 }

1095 }

1096 if (CheckHasBit(cached_has_bits, 0x00000200U)) {

1097 if (from._internal_trace_search() != 0) {

1098 _this->_impl_.trace_search_ = from._impl_.trace_search_;

1099 }

1100 }

1101 if (CheckHasBit(cached_has_bits, 0x00000400U)) {

1102 if (from._internal_print_model() != 0) {

1103 _this->_impl_.print_model_ = from._impl_.print_model_;

1104 }

1105 }

1106 if (CheckHasBit(cached_has_bits, 0x00000800U)) {

1107 if (from._internal_print_model_stats() != 0) {

1108 _this->_impl_.print_model_stats_ = from._impl_.print_model_stats_;

1109 }

1110 }

1111 if (CheckHasBit(cached_has_bits, 0x00001000U)) {

1112 if (from._internal_print_added_constraints() != 0) {

1113 _this->_impl_.print_added_constraints_ = from._impl_.print_added_constraints_;

1114 }

1115 }

1116 if (CheckHasBit(cached_has_bits, 0x00002000U)) {

1117 if (from._internal_disable_solve() != 0) {

1118 _this->_impl_.disable_solve_ = from._impl_.disable_solve_;

1119 }

1120 }

1121 if (CheckHasBit(cached_has_bits, 0x00004000U)) {

1122 if (from._internal_profile_local_search() != 0) {

1123 _this->_impl_.profile_local_search_ = from._impl_.profile_local_search_;

1124 }

1125 }

1126 if (CheckHasBit(cached_has_bits, 0x00008000U)) {

1127 if (from._internal_print_local_search_profile() != 0) {

1128 _this->_impl_.print_local_search_profile_ = from._impl_.print_local_search_profile_;

1129 }

1130 }

1131 }

1132 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {

1133 if (CheckHasBit(cached_has_bits, 0x00010000U)) {

1134 if (from._internal_use_small_table() != 0) {

1135 _this->_impl_.use_small_table_ = from._impl_.use_small_table_;

1136 }

1137 }

1138 if (CheckHasBit(cached_has_bits, 0x00020000U)) {

1139 if (from._internal_use_cumulative_edge_finder() != 0) {

1140 _this->_impl_.use_cumulative_edge_finder_ = from._impl_.use_cumulative_edge_finder_;

1141 }

1142 }

1143 if (CheckHasBit(cached_has_bits, 0x00040000U)) {

1144 if (from._internal_use_cumulative_time_table() != 0) {

1145 _this->_impl_.use_cumulative_time_table_ = from._impl_.use_cumulative_time_table_;

1146 }

1147 }

1148 if (CheckHasBit(cached_has_bits, 0x00080000U)) {

1149 if (from._internal_use_sequence_high_demand_tasks() != 0) {

1150 _this->_impl_.use_sequence_high_demand_tasks_ = from._impl_.use_sequence_high_demand_tasks_;

1151 }

1152 }

1153 if (CheckHasBit(cached_has_bits, 0x00100000U)) {

1154 if (from._internal_max_edge_finder_size() != 0) {

1155 _this->_impl_.max_edge_finder_size_ = from._impl_.max_edge_finder_size_;

1156 }

1157 }

1158 if (CheckHasBit(cached_has_bits, 0x00200000U)) {

1159 if (from._internal_use_all_possible_disjunctions() != 0) {

1160 _this->_impl_.use_all_possible_disjunctions_ = from._impl_.use_all_possible_disjunctions_;

1161 }

1162 }

1163 if (CheckHasBit(cached_has_bits, 0x00400000U)) {

1164 if (from._internal_diffn_use_cumulative() != 0) {

1165 _this->_impl_.diffn_use_cumulative_ = from._impl_.diffn_use_cumulative_;

1166 }

1167 }

1168 if (CheckHasBit(cached_has_bits, 0x00800000U)) {

1169 if (from._internal_use_element_rmq() != 0) {

1170 _this->_impl_.use_element_rmq_ = from._impl_.use_element_rmq_;

1171 }

1172 }

1173 }

1174 if (BatchCheckHasBit(cached_has_bits, 0x07000000U)) {

1175 if (CheckHasBit(cached_has_bits, 0x01000000U)) {

1176 if (from._internal_check_solution_period() != 0) {

1177 _this->_impl_.check_solution_period_ = from._impl_.check_solution_period_;

1178 }

1179 }

1180 if (CheckHasBit(cached_has_bits, 0x02000000U)) {

1181 if (from._internal_use_cumulative_time_table_sync() != 0) {

1182 _this->_impl_.use_cumulative_time_table_sync_ = from._impl_.use_cumulative_time_table_sync_;

1183 }

1184 }

1185 if (CheckHasBit(cached_has_bits, 0x04000000U)) {

1186 if (from._internal_skip_locally_optimal_paths() != 0) {

1187 _this->_impl_.skip_locally_optimal_paths_ = from._impl_.skip_locally_optimal_paths_;

1188 }

1189 }

1190 }

1191 _this->_impl_._has_bits_[0] |= cached_has_bits;

1192 _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(

1193 from._internal_metadata_);

1194}

1195

1197

1198 if (&from == this) return;

1201}

1202

1203

1204void ConstraintSolverParameters::InternalSwap(ConstraintSolverParameters* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {

1205 using ::std::swap;

1206 auto* arena = GetArena();

1207 ABSL_DCHECK_EQ(arena, other->GetArena());

1208 _internal_metadata_.InternalSwap(&other->_internal_metadata_);

1209 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);

1210 ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.profile_file_, &other->_impl_.profile_file_, arena);

1211 ::google::protobuf::internal::memswap<

1215 reinterpret_cast<char*>(&_impl_.compress_trail_),

1216 reinterpret_cast<char*>(&other->_impl_.compress_trail_));

1217}

1218

1220 return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());

1221}

1222

1223}

1225namespace protobuf {

1226}

1227}

1228

1229PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type

1232 ::std::false_type{});

1233#include "google/protobuf/port_undef.inc"

static PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 ::std::false_type _static_init2_

static const ::_pb::Message *PROTOBUF_NONNULL const file_default_instances[]

static constexpr ::int32_t kHasBitsOffset

Definition solver_parameters.pb.cc:218

decltype(::std::declval< ConstraintSolverParameters >()._impl_._has_bits_) HasBits

Definition solver_parameters.pb.cc:216

friend class ::google::protobuf::MessageLite

::size_t ByteSizeLong() const final

Definition solver_parameters.pb.cc:839

ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL

Definition solver_parameters.pb.cc:528

::uint8_t *PROTOBUF_NONNULL _InternalSerialize(::uint8_t *PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream *PROTOBUF_NONNULL stream) const final

Definition solver_parameters.pb.cc:569

ConstraintSolverParameters()

~ConstraintSolverParameters() PROTOBUF_FINAL

Definition solver_parameters.pb.cc:277

::google::protobuf::Metadata GetMetadata() const

Definition solver_parameters.pb.cc:1220

friend void swap(ConstraintSolverParameters &a, ConstraintSolverParameters &b)

static constexpr auto InternalGenerateClassData_()

Definition solver_parameters.pb.cc:301

void CopyFrom(const ConstraintSolverParameters &from)

Definition solver_parameters.pb.cc:1197

void MergeFrom(const ConstraintSolverParameters &from)

const ::google::protobuf::UnknownFieldSet & unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND

static constexpr ::_pbi::MigrationSchema *PROTOBUF_NULLABLE schemas

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ConstraintSolverParametersDefaultTypeInternal _ConstraintSolverParameters_default_instance_

Definition solver_parameters.pb.cc:80

PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const::google::protobuf::internal::ClassDataFull ConstraintSolverParameters_class_data_

Definition solver_parameters.pb.cc:325

ConstraintSolverParameters_TrailCompression

const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL ConstraintSolverParameters_TrailCompression_descriptor()

Definition solver_parameters.pb.cc:205

PROTOBUF_CONSTINIT const uint32_t ConstraintSolverParameters_TrailCompression_internal_data_[]

Definition solver_parameters.pb.cc:209

PROTOBUF_CONSTINITconst ::_pbi::DescriptorTable descriptor_table_ortools_2fconstraint_5fsolver_2fsolver_5fparameters_2eproto

Definition solver_parameters.pb.cc:188

static const ::_pb::EnumDescriptor *PROTOBUF_NONNULL file_level_enum_descriptors_ortools_2fconstraint_5fsolver_2fsolver_5fparameters_2eproto[1]

Definition solver_parameters.pb.cc:83

static constexprconst ::_pb::ServiceDescriptor *PROTOBUF_NONNULL *PROTOBUF_NULLABLE file_level_service_descriptors_ortools_2fconstraint_5fsolver_2fsolver_5fparameters_2eproto

Definition solver_parameters.pb.cc:85

const ::uint32_t TableStruct_ortools_2fconstraint_5fsolver_2fsolver_5fparameters_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold)

::absl::once_flag descriptor_table_ortools_2fconstraint_5fsolver_2fsolver_5fparameters_2eproto_once

Definition solver_parameters.pb.cc:187

~ConstraintSolverParametersDefaultTypeInternal()

Definition solver_parameters.pb.cc:73

ConstraintSolverParameters _instance

Definition solver_parameters.pb.cc:75

PROTOBUF_CONSTEXPR ConstraintSolverParametersDefaultTypeInternal()

Definition solver_parameters.pb.cc:72