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

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"

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

23PROTOBUF_PRAGMA_INIT_SEG

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

29inline constexpr WorkerInfo::Impl_::Impl_(

30 ::_pbi::ConstantInitialized) noexcept

31 : _cached_size_{0},

32 bns_(

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

34 ::_pbi::ConstantInitialized()),

35 worker_id_{0} {}

37template <typename>

39#if defined(PROTOBUF_CUSTOM_VTABLE)

41#else

42 : ::google::protobuf::Message(),

43#endif

44 _impl_(::_pbi::ConstantInitialized()) {

45}

54PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL

57inline constexpr SequenceVarAssignment::Impl_::Impl_(

58 ::_pbi::ConstantInitialized) noexcept

59 : _cached_size_{0},

60 forward_sequence_{},

61 _forward_sequence_cached_byte_size_{0},

62 backward_sequence_{},

63 _backward_sequence_cached_byte_size_{0},

64 unperformed_{},

65 _unperformed_cached_byte_size_{0},

66 var_id_(

67 &::google::protobuf::internal::fixed_address_empty_string,

68 ::_pbi::ConstantInitialized()),

69 active_{false} {}

71template <typename>

73#if defined(PROTOBUF_CUSTOM_VTABLE)

75#else

76 : ::google::protobuf::Message(),

77#endif

78 _impl_(::_pbi::ConstantInitialized()) {

79}

88PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL

91inline constexpr IntervalVarAssignment::Impl_::Impl_(

92 ::_pbi::ConstantInitialized) noexcept

93 : _cached_size_{0},

94 var_id_(

95 &::google::protobuf::internal::fixed_address_empty_string,

96 ::_pbi::ConstantInitialized()),

97 start_min_{::int64_t{0}},

98 start_max_{::int64_t{0}},

99 duration_min_{::int64_t{0}},

100 duration_max_{::int64_t{0}},

101 end_min_{::int64_t{0}},

102 end_max_{::int64_t{0}},

103 performed_min_{::int64_t{0}},

104 performed_max_{::int64_t{0}},

105 active_{false} {}

106

107template <typename>

109#if defined(PROTOBUF_CUSTOM_VTABLE)

111#else

112 : ::google::protobuf::Message(),

113#endif

114 _impl_(::_pbi::ConstantInitialized()) {

115}

123

124PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL

126

127inline constexpr IntVarAssignment::Impl_::Impl_(

128 ::_pbi::ConstantInitialized) noexcept

129 : _cached_size_{0},

130 var_id_(

131 &::google::protobuf::internal::fixed_address_empty_string,

132 ::_pbi::ConstantInitialized()),

133 min_{::int64_t{0}},

134 max_{::int64_t{0}},

135 active_{false} {}

136

137template <typename>

139#if defined(PROTOBUF_CUSTOM_VTABLE)

141#else

142 : ::google::protobuf::Message(),

143#endif

144 _impl_(::_pbi::ConstantInitialized()) {

145}

153

154PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL

156

157inline constexpr AssignmentProto::Impl_::Impl_(

158 ::_pbi::ConstantInitialized) noexcept

159 : _cached_size_{0},

160 int_var_assignment_{},

161 interval_var_assignment_{},

162 objective_{},

163 sequence_var_assignment_{},

164 worker_info_{nullptr},

165 is_valid_{false} {}

166

167template <typename>

169#if defined(PROTOBUF_CUSTOM_VTABLE)

171#else

172 : ::google::protobuf::Message(),

173#endif

174 _impl_(::_pbi::ConstantInitialized()) {

175}

183

184PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL

186}

187static constexpr const ::_pb::EnumDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE

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

191const ::uint32_t

193 protodesc_cold) = {

194 0x081,

196 7,

201 0,

202 1,

203 2,

204 3,

205 0x081,

207 13,

218 0,

219 1,

220 2,

221 3,

222 4,

223 5,

224 6,

225 7,

226 8,

227 9,

228 0x081,

230 8,

236 3,

237 0,

238 1,

239 2,

240 4,

241 0x081,

243 5,

246 1,

247 0,

248 0x081,

250 9,

257 0,

258 1,

259 3,

260 2,

261 4,

262 5,

263};

264

265static const ::_pbi::MigrationSchema

272};

280const char descriptor_table_protodef_ortools_2fconstraint_5fsolver_2fassignment_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE(

281 protodesc_cold) = {

282 "\n*ortools/constraint_solver/assignment.p"

283 "roto\022\023operations_research\"L\n\020IntVarAssig"

284 "nment\022\016\n\006var_id\030\001 \001(\t\022\013\n\003min\030\002 \001(\003\022\013\n\003ma"

285 "x\030\003 \001(\003\022\016\n\006active\030\004 \001(\010\"\331\001\n\025IntervalVarA"

286 "ssignment\022\016\n\006var_id\030\001 \001(\t\022\021\n\tstart_min\030\002"

287 " \001(\003\022\021\n\tstart_max\030\003 \001(\003\022\024\n\014duration_min\030"

288 "\004 \001(\003\022\024\n\014duration_max\030\005 \001(\003\022\017\n\007end_min\030\006"

289 " \001(\003\022\017\n\007end_max\030\007 \001(\003\022\025\n\rperformed_min\030\010"

290 " \001(\003\022\025\n\rperformed_max\030\t \001(\003\022\016\n\006active\030\n "

291 "\001(\010\"\201\001\n\025SequenceVarAssignment\022\016\n\006var_id\030"

292 "\001 \001(\t\022\030\n\020forward_sequence\030\002 \003(\005\022\031\n\021backw"

293 "ard_sequence\030\003 \003(\005\022\023\n\013unperformed\030\004 \003(\005\022"

294 "\016\n\006active\030\005 \001(\010\",\n\nWorkerInfo\022\021\n\tworker_"

295 "id\030\001 \001(\005\022\013\n\003bns\030\002 \001(\t\"\360\002\n\017AssignmentProt"

296 "o\022A\n\022int_var_assignment\030\001 \003(\0132%.operatio"

297 "ns_research.IntVarAssignment\022K\n\027interval"

298 "_var_assignment\030\002 \003(\0132*.operations_resea"

299 "rch.IntervalVarAssignment\022K\n\027sequence_va"

300 "r_assignment\030\006 \003(\0132*.operations_research"

301 ".SequenceVarAssignment\0228\n\tobjective\030\003 \003("

302 "\0132%.operations_research.IntVarAssignment"

303 "\0224\n\013worker_info\030\004 \001(\0132\037.operations_resea"

304 "rch.WorkerInfo\022\020\n\010is_valid\030\005 \001(\010b\006proto3"

305};

308 false,

309 false,

310 920,

311 descriptor_table_protodef_ortools_2fconstraint_5fsolver_2fassignment_2eproto,

312 "ortools/constraint_solver/assignment.proto",

314 nullptr,

315 0,

316 5,

322};

324

325

329 decltype(::std::declval<IntVarAssignment>()._impl_._has_bits_);

332};

333

335#if defined(PROTOBUF_CUSTOM_VTABLE)

337#else

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

339#endif

340 SharedCtor(arena);

341

342}

343PROTOBUF_NDEBUG_INLINE IntVarAssignment::Impl_::Impl_(

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

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

346 [[maybe_unused]] const ::operations_research::IntVarAssignment& from_msg)

347 : _has_bits_{from._has_bits_},

348 _cached_size_{0},

349 var_id_(arena, from.var_id_) {}

350

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

354#if defined(PROTOBUF_CUSTOM_VTABLE)

356#else

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

358#endif

360 (void)_this;

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

362 from._internal_metadata_);

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

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

365 offsetof(Impl_, min_),

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

367 offsetof(Impl_, min_),

368 offsetof(Impl_, active_) -

369 offsetof(Impl_, min_) +

370 sizeof(Impl_::active_));

371

372

373}

374PROTOBUF_NDEBUG_INLINE IntVarAssignment::Impl_::Impl_(

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

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

377 : _cached_size_{0},

378 var_id_(arena) {}

379

380inline void IntVarAssignment::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {

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

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

383 offsetof(Impl_, min_),

384 0,

385 offsetof(Impl_, active_) -

386 offsetof(Impl_, min_) +

387 sizeof(Impl_::active_));

388}

390

391 SharedDtor(*this);

392}

393inline void IntVarAssignment::SharedDtor(MessageLite& self) {

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

396 this_.CheckHasBitConsistency();

397 }

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

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

400 this_._impl_.var_id_.Destroy();

401 this_._impl_.~Impl_();

402}

403

404inline void* PROTOBUF_NONNULL IntVarAssignment::PlacementNew_(

405 const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,

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

408}

409constexpr auto IntVarAssignment::InternalNewImpl_() {

410 return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(IntVarAssignment),

412}

414 return ::google::protobuf::internal::ClassDataFull{

415 ::google::protobuf::internal::ClassData{

417 &_table_.header,

418 nullptr,

419 nullptr,

420 &IntVarAssignment::MergeImpl,

421 ::google::protobuf::Message::GetNewImpl<IntVarAssignment>(),

422#if defined(PROTOBUF_CUSTOM_VTABLE)

423 &IntVarAssignment::SharedDtor,

426#endif

428 false,

429 },

430 &IntVarAssignment::kDescriptorMethods,

432 nullptr,

433 };

434}

435

436PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const

439

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

441IntVarAssignment::GetClassData() const {

445}

446PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1

447const ::_pbi::TcParseTable<2, 4, 0, 51, 2>

448IntVarAssignment::_table_ = {

449 {

451 0,

452 4, 24,

453 offsetof(decltype(_table_), field_lookup_table),

454 4294967280,

455 offsetof(decltype(_table_), field_entries),

456 4,

457 0,

458 offsetof(decltype(_table_), field_names),

460 nullptr,

461 ::_pbi::TcParser::GenericFallback,

462 #ifdef PROTOBUF_PREFETCH_PARSE_TABLE

463 ::_pbi::TcParser::GetTable<::operations_research::IntVarAssignment>(),

464 #endif

465 }, {{

466

467 {::_pbi::TcParser::SingularVarintNoZag1<bool, offsetof(IntVarAssignment, _impl_.active_), 3>(),

468 {32, 3, 0,

470

471 {::_pbi::TcParser::FastUS1,

472 {10, 0, 0,

474

475 {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(IntVarAssignment, _impl_.min_), 1>(),

476 {16, 1, 0,

478

479 {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(IntVarAssignment, _impl_.max_), 2>(),

480 {24, 2, 0,

482 }}, {{

483 65535, 65535

484 }}, {{

485

487

489

491

493 }},

494

495 {{

496 "\44\6\0\0\0\0\0\0"

497 "operations_research.IntVarAssignment"

498 "var_id"

499 }},

500};

502

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

504 ::uint32_t cached_has_bits = 0;

505

506 (void) cached_has_bits;

507

508 cached_has_bits = _impl_._has_bits_[0];

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

510 _impl_.var_id_.ClearNonDefaultToEmpty();

511 }

512 if (BatchCheckHasBit(cached_has_bits, 0x0000000eU)) {

513 ::memset(&_impl_.min_, 0, static_cast<::size_t>(

514 reinterpret_cast<char*>(&_impl_.active_) -

515 reinterpret_cast<char*>(&_impl_.min_)) + sizeof(_impl_.active_));

516 }

517 _impl_._has_bits_.Clear();

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

519}

520

521#if defined(PROTOBUF_CUSTOM_VTABLE)

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

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

526#else

528 ::uint8_t* PROTOBUF_NONNULL target,

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

531#endif

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

533 this_.CheckHasBitConsistency();

534 }

535

536 ::uint32_t cached_has_bits = 0;

537 (void)cached_has_bits;

538

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

540

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

542 if (!this_._internal_var_id().empty()) {

543 const ::std::string& _s = this_._internal_var_id();

544 ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(

545 _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "operations_research.IntVarAssignment.var_id");

546 target = stream->WriteStringMaybeAliased(1, _s, target);

547 }

548 }

549

550

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

552 if (this_._internal_min() != 0) {

553 target =

554 ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<2>(

555 stream, this_._internal_min(), target);

556 }

557 }

558

559

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

561 if (this_._internal_max() != 0) {

562 target =

563 ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<3>(

564 stream, this_._internal_max(), target);

565 }

566 }

567

568

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

570 if (this_._internal_active() != 0) {

571 target = stream->EnsureSpace(target);

572 target = ::_pbi::WireFormatLite::WriteBoolToArray(

573 4, this_._internal_active(), target);

574 }

575 }

576

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

578 target =

579 ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(

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

581 }

582

583 return target;

584}

585

586#if defined(PROTOBUF_CUSTOM_VTABLE)

589#else

592#endif

593

594 ::size_t total_size = 0;

595

596 ::uint32_t cached_has_bits = 0;

597

598 (void)cached_has_bits;

599

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

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

602 if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {

603

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

605 if (!this_._internal_var_id().empty()) {

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

607 this_._internal_var_id());

608 }

609 }

610

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

612 if (this_._internal_min() != 0) {

613 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(

614 this_._internal_min());

615 }

616 }

617

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

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

620 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(

621 this_._internal_max());

622 }

623 }

624

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

626 if (this_._internal_active() != 0) {

627 total_size += 2;

628 }

629 }

630 }

631 return this_.MaybeComputeUnknownFieldsSize(total_size,

632 &this_._impl_._cached_size_);

633}

634

635void IntVarAssignment::MergeImpl(::google::protobuf::MessageLite& to_msg,

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

637 auto* const _this =

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

641 from.CheckHasBitConsistency();

642 }

643

644 ABSL_DCHECK_NE(&from, _this);

645 ::uint32_t cached_has_bits = 0;

646 (void)cached_has_bits;

647

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

649 if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {

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

651 if (!from._internal_var_id().empty()) {

652 _this->_internal_set_var_id(from._internal_var_id());

653 } else {

654 if (_this->_impl_.var_id_.IsDefault()) {

655 _this->_internal_set_var_id("");

656 }

657 }

658 }

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

660 if (from._internal_min() != 0) {

661 _this->_impl_.min_ = from._impl_.min_;

662 }

663 }

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

665 if (from._internal_max() != 0) {

666 _this->_impl_.max_ = from._impl_.max_;

667 }

668 }

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

670 if (from._internal_active() != 0) {

671 _this->_impl_.active_ = from._impl_.active_;

672 }

673 }

674 }

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

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

677 from._internal_metadata_);

678}

679

681

682 if (&from == this) return;

685}

686

687

688void IntVarAssignment::InternalSwap(IntVarAssignment* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {

689 using ::std::swap;

690 auto* arena = GetArena();

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

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

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

694 ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.var_id_, &other->_impl_.var_id_, arena);

695 ::google::protobuf::internal::memswap<

699 reinterpret_cast<char*>(&_impl_.min_),

700 reinterpret_cast<char*>(&other->_impl_.min_));

701}

702

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

705}

706

707

709 public:

711 decltype(::std::declval<IntervalVarAssignment>()._impl_._has_bits_);

715

717#if defined(PROTOBUF_CUSTOM_VTABLE)

719#else

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

721#endif

722 SharedCtor(arena);

723

724}

725PROTOBUF_NDEBUG_INLINE IntervalVarAssignment::Impl_::Impl_(

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

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

728 [[maybe_unused]] const ::operations_research::IntervalVarAssignment& from_msg)

729 : _has_bits_{from._has_bits_},

730 _cached_size_{0},

731 var_id_(arena, from.var_id_) {}

732

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

736#if defined(PROTOBUF_CUSTOM_VTABLE)

738#else

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

740#endif

742 (void)_this;

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

744 from._internal_metadata_);

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

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

747 offsetof(Impl_, start_min_),

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

749 offsetof(Impl_, start_min_),

750 offsetof(Impl_, active_) -

751 offsetof(Impl_, start_min_) +

752 sizeof(Impl_::active_));

753

754

755}

756PROTOBUF_NDEBUG_INLINE IntervalVarAssignment::Impl_::Impl_(

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

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

759 : _cached_size_{0},

760 var_id_(arena) {}

761

762inline void IntervalVarAssignment::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {

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

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

765 offsetof(Impl_, start_min_),

766 0,

767 offsetof(Impl_, active_) -

768 offsetof(Impl_, start_min_) +

769 sizeof(Impl_::active_));

770}

772

773 SharedDtor(*this);

774}

775inline void IntervalVarAssignment::SharedDtor(MessageLite& self) {

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

778 this_.CheckHasBitConsistency();

779 }

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

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

782 this_._impl_.var_id_.Destroy();

783 this_._impl_.~Impl_();

784}

785

786inline void* PROTOBUF_NONNULL IntervalVarAssignment::PlacementNew_(

787 const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,

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

790}

791constexpr auto IntervalVarAssignment::InternalNewImpl_() {

792 return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(IntervalVarAssignment),

794}

796 return ::google::protobuf::internal::ClassDataFull{

797 ::google::protobuf::internal::ClassData{

799 &_table_.header,

800 nullptr,

801 nullptr,

802 &IntervalVarAssignment::MergeImpl,

803 ::google::protobuf::Message::GetNewImpl<IntervalVarAssignment>(),

804#if defined(PROTOBUF_CUSTOM_VTABLE)

805 &IntervalVarAssignment::SharedDtor,

808#endif

810 false,

811 },

812 &IntervalVarAssignment::kDescriptorMethods,

814 nullptr,

815 };

816}

817

818PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const

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

823IntervalVarAssignment::GetClassData() const {

827}

828PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1

829const ::_pbi::TcParseTable<4, 10, 0, 64, 2>

830IntervalVarAssignment::_table_ = {

831 {

833 0,

834 10, 120,

835 offsetof(decltype(_table_), field_lookup_table),

836 4294966272,

837 offsetof(decltype(_table_), field_entries),

838 10,

839 0,

840 offsetof(decltype(_table_), field_names),

842 nullptr,

843 ::_pbi::TcParser::GenericFallback,

844 #ifdef PROTOBUF_PREFETCH_PARSE_TABLE

845 ::_pbi::TcParser::GetTable<::operations_research::IntervalVarAssignment>(),

846 #endif

847 }, {{

848 {::_pbi::TcParser::MiniParse, {}},

849

850 {::_pbi::TcParser::FastUS1,

851 {10, 0, 0,

853

854 {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(IntervalVarAssignment, _impl_.start_min_), 1>(),

855 {16, 1, 0,

857

858 {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(IntervalVarAssignment, _impl_.start_max_), 2>(),

859 {24, 2, 0,

861

862 {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(IntervalVarAssignment, _impl_.duration_min_), 3>(),

863 {32, 3, 0,

865

866 {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(IntervalVarAssignment, _impl_.duration_max_), 4>(),

867 {40, 4, 0,

869

870 {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(IntervalVarAssignment, _impl_.end_min_), 5>(),

871 {48, 5, 0,

873

874 {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(IntervalVarAssignment, _impl_.end_max_), 6>(),

875 {56, 6, 0,

877

878 {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(IntervalVarAssignment, _impl_.performed_min_), 7>(),

879 {64, 7, 0,

881

882 {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(IntervalVarAssignment, _impl_.performed_max_), 8>(),

883 {72, 8, 0,

885

887 {80, 9, 0,

889 {::_pbi::TcParser::MiniParse, {}},

890 {::_pbi::TcParser::MiniParse, {}},

891 {::_pbi::TcParser::MiniParse, {}},

892 {::_pbi::TcParser::MiniParse, {}},

893 {::_pbi::TcParser::MiniParse, {}},

894 }}, {{

895 65535, 65535

896 }}, {{

897

899

901

903

905

907

909

911

913

915

917 }},

918

919 {{

920 "\51\6\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

921 "operations_research.IntervalVarAssignment"

922 "var_id"

923 }},

924};

926

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

928 ::uint32_t cached_has_bits = 0;

929

930 (void) cached_has_bits;

931

932 cached_has_bits = _impl_._has_bits_[0];

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

934 _impl_.var_id_.ClearNonDefaultToEmpty();

935 }

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

937 ::memset(&_impl_.start_min_, 0, static_cast<::size_t>(

938 reinterpret_cast<char*>(&_impl_.performed_min_) -

939 reinterpret_cast<char*>(&_impl_.start_min_)) + sizeof(_impl_.performed_min_));

940 }

941 if (BatchCheckHasBit(cached_has_bits, 0x00000300U)) {

942 ::memset(&_impl_.performed_max_, 0, static_cast<::size_t>(

943 reinterpret_cast<char*>(&_impl_.active_) -

944 reinterpret_cast<char*>(&_impl_.performed_max_)) + sizeof(_impl_.active_));

945 }

946 _impl_._has_bits_.Clear();

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

948}

949

950#if defined(PROTOBUF_CUSTOM_VTABLE)

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

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

955#else

957 ::uint8_t* PROTOBUF_NONNULL target,

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

960#endif

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

962 this_.CheckHasBitConsistency();

963 }

964

965 ::uint32_t cached_has_bits = 0;

966 (void)cached_has_bits;

967

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

969

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

971 if (!this_._internal_var_id().empty()) {

972 const ::std::string& _s = this_._internal_var_id();

973 ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(

974 _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "operations_research.IntervalVarAssignment.var_id");

975 target = stream->WriteStringMaybeAliased(1, _s, target);

976 }

977 }

978

979

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

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

982 target =

983 ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<2>(

984 stream, this_._internal_start_min(), target);

985 }

986 }

987

988

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

990 if (this_._internal_start_max() != 0) {

991 target =

992 ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<3>(

993 stream, this_._internal_start_max(), target);

994 }

995 }

996

997

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

999 if (this_._internal_duration_min() != 0) {

1000 target =

1001 ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<4>(

1002 stream, this_._internal_duration_min(), target);

1003 }

1004 }

1005

1006

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

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

1009 target =

1010 ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<5>(

1011 stream, this_._internal_duration_max(), target);

1012 }

1013 }

1014

1015

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

1017 if (this_._internal_end_min() != 0) {

1018 target =

1019 ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<6>(

1020 stream, this_._internal_end_min(), target);

1021 }

1022 }

1023

1024

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

1026 if (this_._internal_end_max() != 0) {

1027 target =

1028 ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<7>(

1029 stream, this_._internal_end_max(), target);

1030 }

1031 }

1032

1033

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

1035 if (this_._internal_performed_min() != 0) {

1036 target =

1037 ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<8>(

1038 stream, this_._internal_performed_min(), target);

1039 }

1040 }

1041

1042

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

1044 if (this_._internal_performed_max() != 0) {

1045 target =

1046 ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<9>(

1047 stream, this_._internal_performed_max(), target);

1048 }

1049 }

1050

1051

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

1053 if (this_._internal_active() != 0) {

1054 target = stream->EnsureSpace(target);

1055 target = ::_pbi::WireFormatLite::WriteBoolToArray(

1056 10, this_._internal_active(), target);

1057 }

1058 }

1059

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

1061 target =

1062 ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(

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

1064 }

1065

1066 return target;

1067}

1068

1069#if defined(PROTOBUF_CUSTOM_VTABLE)

1072#else

1075#endif

1076

1077 ::size_t total_size = 0;

1078

1079 ::uint32_t cached_has_bits = 0;

1080

1081 (void)cached_has_bits;

1082

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

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

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

1086

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

1088 if (!this_._internal_var_id().empty()) {

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

1090 this_._internal_var_id());

1091 }

1092 }

1093

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

1095 if (this_._internal_start_min() != 0) {

1096 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(

1097 this_._internal_start_min());

1098 }

1099 }

1100

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

1102 if (this_._internal_start_max() != 0) {

1103 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(

1104 this_._internal_start_max());

1105 }

1106 }

1107

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

1109 if (this_._internal_duration_min() != 0) {

1110 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(

1111 this_._internal_duration_min());

1112 }

1113 }

1114

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

1116 if (this_._internal_duration_max() != 0) {

1117 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(

1118 this_._internal_duration_max());

1119 }

1120 }

1121

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

1123 if (this_._internal_end_min() != 0) {

1124 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(

1125 this_._internal_end_min());

1126 }

1127 }

1128

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

1130 if (this_._internal_end_max() != 0) {

1131 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(

1132 this_._internal_end_max());

1133 }

1134 }

1135

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

1137 if (this_._internal_performed_min() != 0) {

1138 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(

1139 this_._internal_performed_min());

1140 }

1141 }

1142 }

1143 if (BatchCheckHasBit(cached_has_bits, 0x00000300U)) {

1144

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

1146 if (this_._internal_performed_max() != 0) {

1147 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(

1148 this_._internal_performed_max());

1149 }

1150 }

1151

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

1153 if (this_._internal_active() != 0) {

1154 total_size += 2;

1155 }

1156 }

1157 }

1158 return this_.MaybeComputeUnknownFieldsSize(total_size,

1159 &this_._impl_._cached_size_);

1160}

1161

1162void IntervalVarAssignment::MergeImpl(::google::protobuf::MessageLite& to_msg,

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

1164 auto* const _this =

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

1168 from.CheckHasBitConsistency();

1169 }

1170

1171 ABSL_DCHECK_NE(&from, _this);

1172 ::uint32_t cached_has_bits = 0;

1173 (void)cached_has_bits;

1174

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

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

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

1178 if (!from._internal_var_id().empty()) {

1179 _this->_internal_set_var_id(from._internal_var_id());

1180 } else {

1181 if (_this->_impl_.var_id_.IsDefault()) {

1182 _this->_internal_set_var_id("");

1183 }

1184 }

1185 }

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

1187 if (from._internal_start_min() != 0) {

1188 _this->_impl_.start_min_ = from._impl_.start_min_;

1189 }

1190 }

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

1192 if (from._internal_start_max() != 0) {

1193 _this->_impl_.start_max_ = from._impl_.start_max_;

1194 }

1195 }

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

1197 if (from._internal_duration_min() != 0) {

1198 _this->_impl_.duration_min_ = from._impl_.duration_min_;

1199 }

1200 }

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

1202 if (from._internal_duration_max() != 0) {

1203 _this->_impl_.duration_max_ = from._impl_.duration_max_;

1204 }

1205 }

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

1207 if (from._internal_end_min() != 0) {

1208 _this->_impl_.end_min_ = from._impl_.end_min_;

1209 }

1210 }

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

1212 if (from._internal_end_max() != 0) {

1213 _this->_impl_.end_max_ = from._impl_.end_max_;

1214 }

1215 }

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

1217 if (from._internal_performed_min() != 0) {

1218 _this->_impl_.performed_min_ = from._impl_.performed_min_;

1219 }

1220 }

1221 }

1222 if (BatchCheckHasBit(cached_has_bits, 0x00000300U)) {

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

1224 if (from._internal_performed_max() != 0) {

1225 _this->_impl_.performed_max_ = from._impl_.performed_max_;

1226 }

1227 }

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

1229 if (from._internal_active() != 0) {

1230 _this->_impl_.active_ = from._impl_.active_;

1231 }

1232 }

1233 }

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

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

1236 from._internal_metadata_);

1237}

1238

1240

1241 if (&from == this) return;

1244}

1245

1246

1247void IntervalVarAssignment::InternalSwap(IntervalVarAssignment* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {

1248 using ::std::swap;

1249 auto* arena = GetArena();

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

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

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

1253 ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.var_id_, &other->_impl_.var_id_, arena);

1254 ::google::protobuf::internal::memswap<

1258 reinterpret_cast<char*>(&_impl_.start_min_),

1259 reinterpret_cast<char*>(&other->_impl_.start_min_));

1260}

1261

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

1268 public:

1269 using HasBits =

1270 decltype(::std::declval<SequenceVarAssignment>()._impl_._has_bits_);

1273};

1276#if defined(PROTOBUF_CUSTOM_VTABLE)

1278#else

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

1280#endif

1281 SharedCtor(arena);

1282

1283}

1284PROTOBUF_NDEBUG_INLINE SequenceVarAssignment::Impl_::Impl_(

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

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

1287 [[maybe_unused]] const ::operations_research::SequenceVarAssignment& from_msg)

1288 : _has_bits_{from._has_bits_},

1289 _cached_size_{0},

1290 forward_sequence_{visibility, arena, from.forward_sequence_},

1291 _forward_sequence_cached_byte_size_{0},

1292 backward_sequence_{visibility, arena, from.backward_sequence_},

1293 _backward_sequence_cached_byte_size_{0},

1294 unperformed_{visibility, arena, from.unperformed_},

1295 _unperformed_cached_byte_size_{0},

1296 var_id_(arena, from.var_id_) {}

1297

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

1301#if defined(PROTOBUF_CUSTOM_VTABLE)

1303#else

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

1305#endif

1307 (void)_this;

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

1309 from._internal_metadata_);

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

1311 _impl_.active_ = from._impl_.active_;

1312

1313

1314}

1315PROTOBUF_NDEBUG_INLINE SequenceVarAssignment::Impl_::Impl_(

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

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

1318 : _cached_size_{0},

1319 forward_sequence_{visibility, arena},

1320 _forward_sequence_cached_byte_size_{0},

1321 backward_sequence_{visibility, arena},

1322 _backward_sequence_cached_byte_size_{0},

1323 unperformed_{visibility, arena},

1324 _unperformed_cached_byte_size_{0},

1325 var_id_(arena) {}

1326

1327inline void SequenceVarAssignment::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {

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

1329 _impl_.active_ = {};

1330}

1332

1333 SharedDtor(*this);

1335inline void SequenceVarAssignment::SharedDtor(MessageLite& self) {

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

1338 this_.CheckHasBitConsistency();

1339 }

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

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

1342 this_._impl_.var_id_.Destroy();

1343 this_._impl_.~Impl_();

1344}

1345

1346inline void* PROTOBUF_NONNULL SequenceVarAssignment::PlacementNew_(

1347 const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,

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

1349 return ::new (mem) SequenceVarAssignment(arena);

1350}

1351constexpr auto SequenceVarAssignment::InternalNewImpl_() {

1352 constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({

1353 PROTOBUF_FIELD_OFFSET(SequenceVarAssignment, _impl_.forward_sequence_) +

1355 InternalGetArenaOffset(

1356 ::google::protobuf::Message::internal_visibility()),

1357 PROTOBUF_FIELD_OFFSET(SequenceVarAssignment, _impl_.backward_sequence_) +

1358 decltype(SequenceVarAssignment::_impl_.backward_sequence_)::

1359 InternalGetArenaOffset(

1360 ::google::protobuf::Message::internal_visibility()),

1361 PROTOBUF_FIELD_OFFSET(SequenceVarAssignment, _impl_.unperformed_) +

1362 decltype(SequenceVarAssignment::_impl_.unperformed_)::

1363 InternalGetArenaOffset(

1364 ::google::protobuf::Message::internal_visibility()),

1365 });

1366 if (arena_bits.has_value()) {

1367 return ::google::protobuf::internal::MessageCreator::CopyInit(

1368 sizeof(SequenceVarAssignment), alignof(SequenceVarAssignment), *arena_bits);

1369 } else {

1370 return ::google::protobuf::internal::MessageCreator(&SequenceVarAssignment::PlacementNew_,

1371 sizeof(SequenceVarAssignment),

1372 alignof(SequenceVarAssignment));

1373 }

1374}

1376 return ::google::protobuf::internal::ClassDataFull{

1377 ::google::protobuf::internal::ClassData{

1379 &_table_.header,

1380 nullptr,

1381 nullptr,

1382 &SequenceVarAssignment::MergeImpl,

1383 ::google::protobuf::Message::GetNewImpl<SequenceVarAssignment>(),

1384#if defined(PROTOBUF_CUSTOM_VTABLE)

1385 &SequenceVarAssignment::SharedDtor,

1388#endif

1390 false,

1391 },

1392 &SequenceVarAssignment::kDescriptorMethods,

1394 nullptr,

1395 };

1396}

1397

1398PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const

1401

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

1403SequenceVarAssignment::GetClassData() const {

1407}

1408PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1

1409const ::_pbi::TcParseTable<3, 5, 0, 56, 2>

1410SequenceVarAssignment::_table_ = {

1411 {

1412 PROTOBUF_FIELD_OFFSET(SequenceVarAssignment, _impl_._has_bits_),

1413 0,

1414 5, 56,

1415 offsetof(decltype(_table_), field_lookup_table),

1416 4294967264,

1417 offsetof(decltype(_table_), field_entries),

1418 5,

1419 0,

1420 offsetof(decltype(_table_), field_names),

1422 nullptr,

1423 ::_pbi::TcParser::GenericFallback,

1424 #ifdef PROTOBUF_PREFETCH_PARSE_TABLE

1425 ::_pbi::TcParser::GetTable<::operations_research::SequenceVarAssignment>(),

1426 #endif

1427 }, {{

1428 {::_pbi::TcParser::MiniParse, {}},

1429

1430 {::_pbi::TcParser::FastUS1,

1431 {10, 3, 0,

1432 PROTOBUF_FIELD_OFFSET(SequenceVarAssignment, _impl_.var_id_)}},

1433

1434 {::_pbi::TcParser::FastV32P1,

1435 {18, 0, 0,

1436 PROTOBUF_FIELD_OFFSET(SequenceVarAssignment, _impl_.forward_sequence_)}},

1437

1438 {::_pbi::TcParser::FastV32P1,

1439 {26, 1, 0,

1440 PROTOBUF_FIELD_OFFSET(SequenceVarAssignment, _impl_.backward_sequence_)}},

1441

1442 {::_pbi::TcParser::FastV32P1,

1443 {34, 2, 0,

1444 PROTOBUF_FIELD_OFFSET(SequenceVarAssignment, _impl_.unperformed_)}},

1445

1446 {::_pbi::TcParser::SingularVarintNoZag1<bool, offsetof(SequenceVarAssignment, _impl_.active_), 4>(),

1447 {40, 4, 0,

1448 PROTOBUF_FIELD_OFFSET(SequenceVarAssignment, _impl_.active_)}},

1449 {::_pbi::TcParser::MiniParse, {}},

1450 {::_pbi::TcParser::MiniParse, {}},

1451 }}, {{

1452 65535, 65535

1453 }}, {{

1454

1455 {PROTOBUF_FIELD_OFFSET(SequenceVarAssignment, _impl_.var_id_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)},

1456

1457 {PROTOBUF_FIELD_OFFSET(SequenceVarAssignment, _impl_.forward_sequence_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kPackedInt32)},

1458

1459 {PROTOBUF_FIELD_OFFSET(SequenceVarAssignment, _impl_.backward_sequence_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcRepeated | ::_fl::kPackedInt32)},

1460

1461 {PROTOBUF_FIELD_OFFSET(SequenceVarAssignment, _impl_.unperformed_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcRepeated | ::_fl::kPackedInt32)},

1462

1463 {PROTOBUF_FIELD_OFFSET(SequenceVarAssignment, _impl_.active_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)},

1464 }},

1465

1466 {{

1467 "\51\6\0\0\0\0\0\0"

1468 "operations_research.SequenceVarAssignment"

1469 "var_id"

1470 }},

1471};

1473

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

1475 ::uint32_t cached_has_bits = 0;

1476

1477 (void) cached_has_bits;

1478

1479 cached_has_bits = _impl_._has_bits_[0];

1480 if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {

1481 if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {

1482 _impl_.forward_sequence_.Clear();

1483 }

1484 if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {

1485 _impl_.backward_sequence_.Clear();

1486 }

1487 if (CheckHasBitForRepeated(cached_has_bits, 0x00000004U)) {

1488 _impl_.unperformed_.Clear();

1489 }

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

1491 _impl_.var_id_.ClearNonDefaultToEmpty();

1492 }

1493 }

1494 _impl_.active_ = false;

1495 _impl_._has_bits_.Clear();

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

1497}

1498

1499#if defined(PROTOBUF_CUSTOM_VTABLE)

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

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

1503 const SequenceVarAssignment& this_ = static_cast<const SequenceVarAssignment&>(base);

1504#else

1506 ::uint8_t* PROTOBUF_NONNULL target,

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

1509#endif

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

1511 this_.CheckHasBitConsistency();

1512 }

1513

1514 ::uint32_t cached_has_bits = 0;

1515 (void)cached_has_bits;

1516

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

1518

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

1520 if (!this_._internal_var_id().empty()) {

1521 const ::std::string& _s = this_._internal_var_id();

1522 ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(

1523 _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "operations_research.SequenceVarAssignment.var_id");

1524 target = stream->WriteStringMaybeAliased(1, _s, target);

1525 }

1526 }

1527

1528

1529 if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {

1530 {

1531 int byte_size = this_._impl_._forward_sequence_cached_byte_size_.Get();

1532 if (byte_size > 0) {

1533 target = stream->WriteInt32Packed(

1534 2, this_._internal_forward_sequence(), byte_size, target);

1535 }

1536 }

1537 }

1538

1539

1540 if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {

1541 {

1542 int byte_size = this_._impl_._backward_sequence_cached_byte_size_.Get();

1543 if (byte_size > 0) {

1544 target = stream->WriteInt32Packed(

1545 3, this_._internal_backward_sequence(), byte_size, target);

1546 }

1547 }

1548 }

1549

1550

1551 if (CheckHasBitForRepeated(cached_has_bits, 0x00000004U)) {

1552 {

1553 int byte_size = this_._impl_._unperformed_cached_byte_size_.Get();

1554 if (byte_size > 0) {

1555 target = stream->WriteInt32Packed(

1556 4, this_._internal_unperformed(), byte_size, target);

1557 }

1558 }

1559 }

1560

1561

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

1563 if (this_._internal_active() != 0) {

1564 target = stream->EnsureSpace(target);

1565 target = ::_pbi::WireFormatLite::WriteBoolToArray(

1566 5, this_._internal_active(), target);

1567 }

1568 }

1569

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

1571 target =

1572 ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(

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

1574 }

1575

1576 return target;

1577}

1578

1579#if defined(PROTOBUF_CUSTOM_VTABLE)

1581 const SequenceVarAssignment& this_ = static_cast<const SequenceVarAssignment&>(base);

1582#else

1584 const SequenceVarAssignment& this_ = *this;

1585#endif

1586

1587 ::size_t total_size = 0;

1588

1589 ::uint32_t cached_has_bits = 0;

1590

1591 (void)cached_has_bits;

1592

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

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

1595 if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) {

1596

1597 if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {

1598 total_size +=

1599 ::_pbi::WireFormatLite::Int32SizeWithPackedTagSize(

1600 this_._internal_forward_sequence(), 1,

1601 this_._impl_._forward_sequence_cached_byte_size_);

1602 }

1603

1604 if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {

1605 total_size +=

1606 ::_pbi::WireFormatLite::Int32SizeWithPackedTagSize(

1607 this_._internal_backward_sequence(), 1,

1608 this_._impl_._backward_sequence_cached_byte_size_);

1609 }

1610

1611 if (CheckHasBitForRepeated(cached_has_bits, 0x00000004U)) {

1612 total_size +=

1613 ::_pbi::WireFormatLite::Int32SizeWithPackedTagSize(

1614 this_._internal_unperformed(), 1,

1615 this_._impl_._unperformed_cached_byte_size_);

1616 }

1617

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

1619 if (!this_._internal_var_id().empty()) {

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

1621 this_._internal_var_id());

1622 }

1623 }

1624

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

1626 if (this_._internal_active() != 0) {

1627 total_size += 2;

1628 }

1629 }

1630 }

1631 return this_.MaybeComputeUnknownFieldsSize(total_size,

1632 &this_._impl_._cached_size_);

1633}

1634

1635void SequenceVarAssignment::MergeImpl(::google::protobuf::MessageLite& to_msg,

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

1637 auto* const _this =

1638 static_cast<SequenceVarAssignment*>(&to_msg);

1639 auto& from = static_cast<const SequenceVarAssignment&>(from_msg);

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

1641 from.CheckHasBitConsistency();

1642 }

1643

1644 ABSL_DCHECK_NE(&from, _this);

1645 ::uint32_t cached_has_bits = 0;

1646 (void)cached_has_bits;

1647

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

1649 if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) {

1650 if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {

1651 _this->_internal_mutable_forward_sequence()->MergeFrom(from._internal_forward_sequence());

1652 }

1653 if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {

1654 _this->_internal_mutable_backward_sequence()->MergeFrom(from._internal_backward_sequence());

1655 }

1656 if (CheckHasBitForRepeated(cached_has_bits, 0x00000004U)) {

1657 _this->_internal_mutable_unperformed()->MergeFrom(from._internal_unperformed());

1658 }

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

1660 if (!from._internal_var_id().empty()) {

1661 _this->_internal_set_var_id(from._internal_var_id());

1662 } else {

1663 if (_this->_impl_.var_id_.IsDefault()) {

1664 _this->_internal_set_var_id("");

1665 }

1666 }

1667 }

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

1669 if (from._internal_active() != 0) {

1670 _this->_impl_.active_ = from._impl_.active_;

1671 }

1672 }

1673 }

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

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

1676 from._internal_metadata_);

1677}

1678

1680

1681 if (&from == this) return;

1684}

1685

1686

1687void SequenceVarAssignment::InternalSwap(SequenceVarAssignment* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {

1688 using ::std::swap;

1689 auto* arena = GetArena();

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

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

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

1693 _impl_.forward_sequence_.InternalSwap(&other->_impl_.forward_sequence_);

1694 _impl_.backward_sequence_.InternalSwap(&other->_impl_.backward_sequence_);

1695 _impl_.unperformed_.InternalSwap(&other->_impl_.unperformed_);

1696 ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.var_id_, &other->_impl_.var_id_, arena);

1697 swap(_impl_.active_, other->_impl_.active_);

1698}

1699

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

1702}

1706 public:

1707 using HasBits =

1708 decltype(::std::declval<WorkerInfo>()._impl_._has_bits_);

1712

1714#if defined(PROTOBUF_CUSTOM_VTABLE)

1716#else

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

1718#endif

1719 SharedCtor(arena);

1720

1721}

1722PROTOBUF_NDEBUG_INLINE WorkerInfo::Impl_::Impl_(

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

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

1725 [[maybe_unused]] const ::operations_research::WorkerInfo& from_msg)

1726 : _has_bits_{from._has_bits_},

1727 _cached_size_{0},

1728 bns_(arena, from.bns_) {}

1729

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

1733#if defined(PROTOBUF_CUSTOM_VTABLE)

1735#else

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

1737#endif

1739 (void)_this;

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

1741 from._internal_metadata_);

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

1743 _impl_.worker_id_ = from._impl_.worker_id_;

1744

1745

1746}

1747PROTOBUF_NDEBUG_INLINE WorkerInfo::Impl_::Impl_(

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

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

1750 : _cached_size_{0},

1751 bns_(arena) {}

1752

1753inline void WorkerInfo::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {

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

1755 _impl_.worker_id_ = {};

1756}

1758

1759 SharedDtor(*this);

1760}

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

1764 this_.CheckHasBitConsistency();

1765 }

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

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

1768 this_._impl_.bns_.Destroy();

1769 this_._impl_.~Impl_();

1770}

1771

1772inline void* PROTOBUF_NONNULL WorkerInfo::PlacementNew_(

1773 const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,

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

1775 return ::new (mem) WorkerInfo(arena);

1776}

1777constexpr auto WorkerInfo::InternalNewImpl_() {

1778 return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(WorkerInfo),

1779 alignof(WorkerInfo));

1780}

1782 return ::google::protobuf::internal::ClassDataFull{

1783 ::google::protobuf::internal::ClassData{

1785 &_table_.header,

1786 nullptr,

1787 nullptr,

1788 &WorkerInfo::MergeImpl,

1789 ::google::protobuf::Message::GetNewImpl<WorkerInfo>(),

1790#if defined(PROTOBUF_CUSTOM_VTABLE)

1791 &WorkerInfo::SharedDtor,

1794#endif

1796 false,

1797 },

1798 &WorkerInfo::kDescriptorMethods,

1800 nullptr,

1801 };

1802}

1803

1804PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const

1807

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

1809WorkerInfo::GetClassData() const {

1811 ::google::protobuf::internal::PrefetchToLocalCache(WorkerInfo_class_data_.tc_table);

1813}

1814PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1

1815const ::_pbi::TcParseTable<1, 2, 0, 42, 2>

1816WorkerInfo::_table_ = {

1817 {

1818 PROTOBUF_FIELD_OFFSET(WorkerInfo, _impl_._has_bits_),

1819 0,

1820 2, 8,

1821 offsetof(decltype(_table_), field_lookup_table),

1822 4294967292,

1823 offsetof(decltype(_table_), field_entries),

1824 2,

1825 0,

1826 offsetof(decltype(_table_), field_names),

1828 nullptr,

1829 ::_pbi::TcParser::GenericFallback,

1830 #ifdef PROTOBUF_PREFETCH_PARSE_TABLE

1831 ::_pbi::TcParser::GetTable<::operations_research::WorkerInfo>(),

1832 #endif

1833 }, {{

1834

1835 {::_pbi::TcParser::FastUS1,

1836 {18, 0, 0,

1837 PROTOBUF_FIELD_OFFSET(WorkerInfo, _impl_.bns_)}},

1838

1839 {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(WorkerInfo, _impl_.worker_id_), 1>(),

1840 {8, 1, 0,

1841 PROTOBUF_FIELD_OFFSET(WorkerInfo, _impl_.worker_id_)}},

1842 }}, {{

1843 65535, 65535

1844 }}, {{

1845

1846 {PROTOBUF_FIELD_OFFSET(WorkerInfo, _impl_.worker_id_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},

1847

1848 {PROTOBUF_FIELD_OFFSET(WorkerInfo, _impl_.bns_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)},

1849 }},

1850

1851 {{

1852 "\36\0\3\0\0\0\0\0"

1853 "operations_research.WorkerInfo"

1854 "bns"

1855 }},

1856};

1858

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

1860 ::uint32_t cached_has_bits = 0;

1861

1862 (void) cached_has_bits;

1863

1864 cached_has_bits = _impl_._has_bits_[0];

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

1866 _impl_.bns_.ClearNonDefaultToEmpty();

1867 }

1868 _impl_.worker_id_ = 0;

1869 _impl_._has_bits_.Clear();

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

1871}

1872

1873#if defined(PROTOBUF_CUSTOM_VTABLE)

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

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

1877 const WorkerInfo& this_ = static_cast<const WorkerInfo&>(base);

1878#else

1880 ::uint8_t* PROTOBUF_NONNULL target,

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

1882 const WorkerInfo& this_ = *this;

1883#endif

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

1885 this_.CheckHasBitConsistency();

1886 }

1887

1888 ::uint32_t cached_has_bits = 0;

1889 (void)cached_has_bits;

1890

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

1892

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

1894 if (this_._internal_worker_id() != 0) {

1895 target =

1896 ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<1>(

1897 stream, this_._internal_worker_id(), target);

1898 }

1899 }

1900

1901

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

1903 if (!this_._internal_bns().empty()) {

1904 const ::std::string& _s = this_._internal_bns();

1905 ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(

1906 _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "operations_research.WorkerInfo.bns");

1907 target = stream->WriteStringMaybeAliased(2, _s, target);

1908 }

1909 }

1910

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

1912 target =

1913 ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(

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

1915 }

1916

1917 return target;

1918}

1919

1920#if defined(PROTOBUF_CUSTOM_VTABLE)

1922 const WorkerInfo& this_ = static_cast<const WorkerInfo&>(base);

1923#else

1925 const WorkerInfo& this_ = *this;

1926#endif

1927

1928 ::size_t total_size = 0;

1929

1930 ::uint32_t cached_has_bits = 0;

1931

1932 (void)cached_has_bits;

1933

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

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

1936 if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {

1937

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

1939 if (!this_._internal_bns().empty()) {

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

1941 this_._internal_bns());

1942 }

1943 }

1944

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

1946 if (this_._internal_worker_id() != 0) {

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

1948 this_._internal_worker_id());

1949 }

1950 }

1951 }

1952 return this_.MaybeComputeUnknownFieldsSize(total_size,

1953 &this_._impl_._cached_size_);

1954}

1955

1956void WorkerInfo::MergeImpl(::google::protobuf::MessageLite& to_msg,

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

1958 auto* const _this =

1959 static_cast<WorkerInfo*>(&to_msg);

1960 auto& from = static_cast<const WorkerInfo&>(from_msg);

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

1962 from.CheckHasBitConsistency();

1963 }

1964

1965 ABSL_DCHECK_NE(&from, _this);

1966 ::uint32_t cached_has_bits = 0;

1967 (void)cached_has_bits;

1968

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

1970 if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {

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

1972 if (!from._internal_bns().empty()) {

1973 _this->_internal_set_bns(from._internal_bns());

1974 } else {

1975 if (_this->_impl_.bns_.IsDefault()) {

1976 _this->_internal_set_bns("");

1977 }

1978 }

1979 }

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

1981 if (from._internal_worker_id() != 0) {

1982 _this->_impl_.worker_id_ = from._impl_.worker_id_;

1983 }

1984 }

1985 }

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

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

1988 from._internal_metadata_);

1989}

1990

1992

1993 if (&from == this) return;

1996}

1997

1998

1999void WorkerInfo::InternalSwap(WorkerInfo* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {

2000 using ::std::swap;

2001 auto* arena = GetArena();

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

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

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

2005 ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.bns_, &other->_impl_.bns_, arena);

2006 swap(_impl_.worker_id_, other->_impl_.worker_id_);

2007}

2008

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

2011}

2012

2016 using HasBits =

2017 decltype(::std::declval<AssignmentProto>()._impl_._has_bits_);

2018 static constexpr ::int32_t kHasBitsOffset =

2020};

2023#if defined(PROTOBUF_CUSTOM_VTABLE)

2025#else

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

2027#endif

2028 SharedCtor(arena);

2029

2030}

2031PROTOBUF_NDEBUG_INLINE AssignmentProto::Impl_::Impl_(

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

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

2034 [[maybe_unused]] const ::operations_research::AssignmentProto& from_msg)

2035 : _has_bits_{from._has_bits_},

2036 _cached_size_{0},

2037 int_var_assignment_{visibility, arena, from.int_var_assignment_},

2038 interval_var_assignment_{visibility, arena, from.interval_var_assignment_},

2039 objective_{visibility, arena, from.objective_},

2040 sequence_var_assignment_{visibility, arena, from.sequence_var_assignment_} {}

2041

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

2045#if defined(PROTOBUF_CUSTOM_VTABLE)

2047#else

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

2049#endif

2051 (void)_this;

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

2053 from._internal_metadata_);

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

2055 ::uint32_t cached_has_bits = _impl_._has_bits_[0];

2056 _impl_.worker_info_ = (CheckHasBit(cached_has_bits, 0x00000010U))

2057 ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.worker_info_)

2058 : nullptr;

2059 _impl_.is_valid_ = from._impl_.is_valid_;

2060

2061

2062}

2063PROTOBUF_NDEBUG_INLINE AssignmentProto::Impl_::Impl_(

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

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

2066 : _cached_size_{0},

2067 int_var_assignment_{visibility, arena},

2068 interval_var_assignment_{visibility, arena},

2069 objective_{visibility, arena},

2070 sequence_var_assignment_{visibility, arena} {}

2071

2072inline void AssignmentProto::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {

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

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

2075 offsetof(Impl_, worker_info_),

2076 0,

2077 offsetof(Impl_, is_valid_) -

2078 offsetof(Impl_, worker_info_) +

2079 sizeof(Impl_::is_valid_));

2080}

2082

2083 SharedDtor(*this);

2084}

2085inline void AssignmentProto::SharedDtor(MessageLite& self) {

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

2088 this_.CheckHasBitConsistency();

2089 }

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

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

2092 delete this_._impl_.worker_info_;

2093 this_._impl_.~Impl_();

2094}

2095

2096inline void* PROTOBUF_NONNULL AssignmentProto::PlacementNew_(

2097 const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,

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

2099 return ::new (mem) AssignmentProto(arena);

2100}

2101constexpr auto AssignmentProto::InternalNewImpl_() {

2102 constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({

2103 PROTOBUF_FIELD_OFFSET(AssignmentProto, _impl_.int_var_assignment_) +

2105 InternalGetArenaOffset(

2106 ::google::protobuf::Message::internal_visibility()),

2107 PROTOBUF_FIELD_OFFSET(AssignmentProto, _impl_.interval_var_assignment_) +

2108 decltype(AssignmentProto::_impl_.interval_var_assignment_)::

2109 InternalGetArenaOffset(

2110 ::google::protobuf::Message::internal_visibility()),

2111 PROTOBUF_FIELD_OFFSET(AssignmentProto, _impl_.sequence_var_assignment_) +

2112 decltype(AssignmentProto::_impl_.sequence_var_assignment_)::

2113 InternalGetArenaOffset(

2114 ::google::protobuf::Message::internal_visibility()),

2115 PROTOBUF_FIELD_OFFSET(AssignmentProto, _impl_.objective_) +

2116 decltype(AssignmentProto::_impl_.objective_)::

2117 InternalGetArenaOffset(

2118 ::google::protobuf::Message::internal_visibility()),

2119 });

2120 if (arena_bits.has_value()) {

2121 return ::google::protobuf::internal::MessageCreator::ZeroInit(

2122 sizeof(AssignmentProto), alignof(AssignmentProto), *arena_bits);

2123 } else {

2124 return ::google::protobuf::internal::MessageCreator(&AssignmentProto::PlacementNew_,

2125 sizeof(AssignmentProto),

2126 alignof(AssignmentProto));

2127 }

2128}

2130 return ::google::protobuf::internal::ClassDataFull{

2131 ::google::protobuf::internal::ClassData{

2133 &_table_.header,

2134 nullptr,

2135 nullptr,

2136 &AssignmentProto::MergeImpl,

2137 ::google::protobuf::Message::GetNewImpl<AssignmentProto>(),

2138#if defined(PROTOBUF_CUSTOM_VTABLE)

2139 &AssignmentProto::SharedDtor,

2142#endif

2144 false,

2145 },

2146 &AssignmentProto::kDescriptorMethods,

2148 nullptr,

2149 };

2150}

2151

2152PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const

2155

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

2157AssignmentProto::GetClassData() const {

2161}

2162PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1

2163const ::_pbi::TcParseTable<3, 6, 5, 0, 2>

2164AssignmentProto::_table_ = {

2165 {

2166 PROTOBUF_FIELD_OFFSET(AssignmentProto, _impl_._has_bits_),

2167 0,

2168 6, 56,

2169 offsetof(decltype(_table_), field_lookup_table),

2170 4294967232,

2171 offsetof(decltype(_table_), field_entries),

2172 6,

2173 5,

2174 offsetof(decltype(_table_), aux_entries),

2176 nullptr,

2177 ::_pbi::TcParser::GenericFallback,

2178 #ifdef PROTOBUF_PREFETCH_PARSE_TABLE

2179 ::_pbi::TcParser::GetTable<::operations_research::AssignmentProto>(),

2180 #endif

2181 }, {{

2182 {::_pbi::TcParser::MiniParse, {}},

2183

2184 {::_pbi::TcParser::FastMtR1,

2185 {10, 0, 0,

2186 PROTOBUF_FIELD_OFFSET(AssignmentProto, _impl_.int_var_assignment_)}},

2187

2188 {::_pbi::TcParser::FastMtR1,

2189 {18, 1, 1,

2190 PROTOBUF_FIELD_OFFSET(AssignmentProto, _impl_.interval_var_assignment_)}},

2191

2192 {::_pbi::TcParser::FastMtR1,

2193 {26, 2, 2,

2194 PROTOBUF_FIELD_OFFSET(AssignmentProto, _impl_.objective_)}},

2195

2196 {::_pbi::TcParser::FastMtS1,

2197 {34, 4, 3,

2198 PROTOBUF_FIELD_OFFSET(AssignmentProto, _impl_.worker_info_)}},

2199

2200 {::_pbi::TcParser::SingularVarintNoZag1<bool, offsetof(AssignmentProto, _impl_.is_valid_), 5>(),

2201 {40, 5, 0,

2202 PROTOBUF_FIELD_OFFSET(AssignmentProto, _impl_.is_valid_)}},

2203

2204 {::_pbi::TcParser::FastMtR1,

2205 {50, 3, 4,

2206 PROTOBUF_FIELD_OFFSET(AssignmentProto, _impl_.sequence_var_assignment_)}},

2207 {::_pbi::TcParser::MiniParse, {}},

2208 }}, {{

2209 65535, 65535

2210 }}, {{

2211

2212 {PROTOBUF_FIELD_OFFSET(AssignmentProto, _impl_.int_var_assignment_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},

2213

2214 {PROTOBUF_FIELD_OFFSET(AssignmentProto, _impl_.interval_var_assignment_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},

2215

2216 {PROTOBUF_FIELD_OFFSET(AssignmentProto, _impl_.objective_), _Internal::kHasBitsOffset + 2, 2, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},

2217

2218 {PROTOBUF_FIELD_OFFSET(AssignmentProto, _impl_.worker_info_), _Internal::kHasBitsOffset + 4, 3, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},

2219

2220 {PROTOBUF_FIELD_OFFSET(AssignmentProto, _impl_.is_valid_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)},

2221

2222 {PROTOBUF_FIELD_OFFSET(AssignmentProto, _impl_.sequence_var_assignment_), _Internal::kHasBitsOffset + 3, 4, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},

2223 }},

2224 {{

2225 {::_pbi::TcParser::GetTable<::operations_research::IntVarAssignment>()},

2226 {::_pbi::TcParser::GetTable<::operations_research::IntervalVarAssignment>()},

2227 {::_pbi::TcParser::GetTable<::operations_research::IntVarAssignment>()},

2228 {::_pbi::TcParser::GetTable<::operations_research::WorkerInfo>()},

2229 {::_pbi::TcParser::GetTable<::operations_research::SequenceVarAssignment>()},

2230 }},

2231 {{

2232 }},

2233};

2235

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

2237 ::uint32_t cached_has_bits = 0;

2238

2239 (void) cached_has_bits;

2240

2241 cached_has_bits = _impl_._has_bits_[0];

2242 if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) {

2243 if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {

2244 _impl_.int_var_assignment_.Clear();

2245 }

2246 if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {

2247 _impl_.interval_var_assignment_.Clear();

2248 }

2249 if (CheckHasBitForRepeated(cached_has_bits, 0x00000004U)) {

2250 _impl_.objective_.Clear();

2251 }

2252 if (CheckHasBitForRepeated(cached_has_bits, 0x00000008U)) {

2253 _impl_.sequence_var_assignment_.Clear();

2254 }

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

2256 ABSL_DCHECK(_impl_.worker_info_ != nullptr);

2257 _impl_.worker_info_->Clear();

2258 }

2259 }

2260 _impl_.is_valid_ = false;

2261 _impl_._has_bits_.Clear();

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

2263}

2264

2265#if defined(PROTOBUF_CUSTOM_VTABLE)

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

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

2269 const AssignmentProto& this_ = static_cast<const AssignmentProto&>(base);

2270#else

2272 ::uint8_t* PROTOBUF_NONNULL target,

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

2274 const AssignmentProto& this_ = *this;

2275#endif

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

2277 this_.CheckHasBitConsistency();

2278 }

2279

2280 ::uint32_t cached_has_bits = 0;

2281 (void)cached_has_bits;

2282

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

2284

2285 if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {

2286 for (unsigned i = 0, n = static_cast<unsigned>(

2287 this_._internal_int_var_assignment_size());

2288 i < n; i++) {

2289 const auto& repfield = this_._internal_int_var_assignment().Get(i);

2290 target =

2291 ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(

2292 1, repfield, repfield.GetCachedSize(),

2293 target, stream);

2294 }

2295 }

2296

2297

2298 if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {

2299 for (unsigned i = 0, n = static_cast<unsigned>(

2300 this_._internal_interval_var_assignment_size());

2301 i < n; i++) {

2302 const auto& repfield = this_._internal_interval_var_assignment().Get(i);

2303 target =

2304 ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(

2305 2, repfield, repfield.GetCachedSize(),

2306 target, stream);

2307 }

2308 }

2309

2310

2311 if (CheckHasBitForRepeated(cached_has_bits, 0x00000004U)) {

2312 for (unsigned i = 0, n = static_cast<unsigned>(

2313 this_._internal_objective_size());

2314 i < n; i++) {

2315 const auto& repfield = this_._internal_objective().Get(i);

2316 target =

2317 ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(

2318 3, repfield, repfield.GetCachedSize(),

2319 target, stream);

2320 }

2321 }

2322

2323

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

2325 target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(

2326 4, *this_._impl_.worker_info_, this_._impl_.worker_info_->GetCachedSize(), target,

2327 stream);

2328 }

2329

2330

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

2332 if (this_._internal_is_valid() != 0) {

2333 target = stream->EnsureSpace(target);

2334 target = ::_pbi::WireFormatLite::WriteBoolToArray(

2335 5, this_._internal_is_valid(), target);

2336 }

2337 }

2338

2339

2340 if (CheckHasBitForRepeated(cached_has_bits, 0x00000008U)) {

2341 for (unsigned i = 0, n = static_cast<unsigned>(

2342 this_._internal_sequence_var_assignment_size());

2343 i < n; i++) {

2344 const auto& repfield = this_._internal_sequence_var_assignment().Get(i);

2345 target =

2346 ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(

2347 6, repfield, repfield.GetCachedSize(),

2348 target, stream);

2349 }

2350 }

2351

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

2353 target =

2354 ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(

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

2356 }

2357

2358 return target;

2359}

2360

2361#if defined(PROTOBUF_CUSTOM_VTABLE)

2363 const AssignmentProto& this_ = static_cast<const AssignmentProto&>(base);

2364#else

2366 const AssignmentProto& this_ = *this;

2367#endif

2368

2369 ::size_t total_size = 0;

2371 ::uint32_t cached_has_bits = 0;

2372

2373 (void)cached_has_bits;

2374

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

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

2377 if (BatchCheckHasBit(cached_has_bits, 0x0000003fU)) {

2378

2379 if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {

2380 total_size += 1UL * this_._internal_int_var_assignment_size();

2381 for (const auto& msg : this_._internal_int_var_assignment()) {

2382 total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);

2383 }

2384 }

2385

2386 if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {

2387 total_size += 1UL * this_._internal_interval_var_assignment_size();

2388 for (const auto& msg : this_._internal_interval_var_assignment()) {

2389 total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);

2390 }

2391 }

2392

2393 if (CheckHasBitForRepeated(cached_has_bits, 0x00000004U)) {

2394 total_size += 1UL * this_._internal_objective_size();

2395 for (const auto& msg : this_._internal_objective()) {

2396 total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);

2397 }

2398 }

2399

2400 if (CheckHasBitForRepeated(cached_has_bits, 0x00000008U)) {

2401 total_size += 1UL * this_._internal_sequence_var_assignment_size();

2402 for (const auto& msg : this_._internal_sequence_var_assignment()) {

2403 total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);

2404 }

2405 }

2406

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

2408 total_size += 1 +

2409 ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.worker_info_);

2410 }

2411

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

2413 if (this_._internal_is_valid() != 0) {

2414 total_size += 2;

2415 }

2416 }

2417 }

2418 return this_.MaybeComputeUnknownFieldsSize(total_size,

2419 &this_._impl_._cached_size_);

2420}

2421

2422void AssignmentProto::MergeImpl(::google::protobuf::MessageLite& to_msg,

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

2424 auto* const _this =

2425 static_cast<AssignmentProto*>(&to_msg);

2426 auto& from = static_cast<const AssignmentProto&>(from_msg);

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

2428 from.CheckHasBitConsistency();

2429 }

2431

2432 ABSL_DCHECK_NE(&from, _this);

2433 ::uint32_t cached_has_bits = 0;

2434 (void)cached_has_bits;

2435

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

2437 if (BatchCheckHasBit(cached_has_bits, 0x0000003fU)) {

2438 if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {

2439 _this->_internal_mutable_int_var_assignment()->InternalMergeFromWithArena(

2440 ::google::protobuf::MessageLite::internal_visibility(), arena,

2441 from._internal_int_var_assignment());

2442 }

2443 if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {

2444 _this->_internal_mutable_interval_var_assignment()->InternalMergeFromWithArena(

2445 ::google::protobuf::MessageLite::internal_visibility(), arena,

2446 from._internal_interval_var_assignment());

2447 }

2448 if (CheckHasBitForRepeated(cached_has_bits, 0x00000004U)) {

2449 _this->_internal_mutable_objective()->InternalMergeFromWithArena(

2450 ::google::protobuf::MessageLite::internal_visibility(), arena,

2451 from._internal_objective());

2452 }

2453 if (CheckHasBitForRepeated(cached_has_bits, 0x00000008U)) {

2454 _this->_internal_mutable_sequence_var_assignment()->InternalMergeFromWithArena(

2455 ::google::protobuf::MessageLite::internal_visibility(), arena,

2456 from._internal_sequence_var_assignment());

2457 }

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

2459 ABSL_DCHECK(from._impl_.worker_info_ != nullptr);

2460 if (_this->_impl_.worker_info_ == nullptr) {

2461 _this->_impl_.worker_info_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.worker_info_);

2462 } else {

2463 _this->_impl_.worker_info_->MergeFrom(*from._impl_.worker_info_);

2464 }

2465 }

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

2467 if (from._internal_is_valid() != 0) {

2468 _this->_impl_.is_valid_ = from._impl_.is_valid_;

2469 }

2470 }

2471 }

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

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

2474 from._internal_metadata_);

2475}

2476

2478

2479 if (&from == this) return;

2483

2484

2485void AssignmentProto::InternalSwap(AssignmentProto* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {

2486 using ::std::swap;

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

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

2489 _impl_.int_var_assignment_.InternalSwap(&other->_impl_.int_var_assignment_);

2490 _impl_.interval_var_assignment_.InternalSwap(&other->_impl_.interval_var_assignment_);

2491 _impl_.objective_.InternalSwap(&other->_impl_.objective_);

2492 _impl_.sequence_var_assignment_.InternalSwap(&other->_impl_.sequence_var_assignment_);

2493 ::google::protobuf::internal::memswap<

2497 reinterpret_cast<char*>(&_impl_.worker_info_),

2498 reinterpret_cast<char*>(&other->_impl_.worker_info_));

2499}

2500

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

2503}

2504

2505}

2507namespace protobuf {

2508}

2509}

2510

2511PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type

2514 ::std::false_type{});

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

static constexprconst ::_pb::EnumDescriptor *PROTOBUF_NONNULL *PROTOBUF_NULLABLE file_level_enum_descriptors_ortools_2fconstraint_5fsolver_2fassignment_2eproto

Definition assignment.pb.cc:188

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

Definition assignment.pb.cc:190

::absl::once_flag descriptor_table_ortools_2fconstraint_5fsolver_2fassignment_2eproto_once

Definition assignment.pb.cc:306

PROTOBUF_CONSTINITconst ::_pbi::DescriptorTable descriptor_table_ortools_2fconstraint_5fsolver_2fassignment_2eproto

Definition assignment.pb.cc:307

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

static PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 ::std::false_type _static_init2_

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

Definition assignment.pb.cc:2019

::size_t ByteSizeLong() const final

Definition assignment.pb.cc:2370

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

Definition assignment.pb.cc:2276

friend class ::google::protobuf::MessageLite

static constexpr auto InternalGenerateClassData_()

Definition assignment.pb.cc:2134

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

Definition assignment.pb.cc:2506

ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL

Definition assignment.pb.cc:2239

void CopyFrom(const AssignmentProto &from)

Definition assignment.pb.cc:2482

void MergeFrom(const AssignmentProto &from)

~AssignmentProto() PROTOBUF_FINAL

Definition assignment.pb.cc:2086

Definition assignment.pb.cc:327

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

Definition assignment.pb.cc:329

static constexpr ::int32_t kHasBitsOffset

Definition assignment.pb.cc:331

friend class ::google::protobuf::MessageLite

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

Definition assignment.pb.cc:528

::size_t ByteSizeLong() const final

Definition assignment.pb.cc:591

static constexpr auto InternalGenerateClassData_()

Definition assignment.pb.cc:414

ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL

Definition assignment.pb.cc:502

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

~IntVarAssignment() PROTOBUF_FINAL

Definition assignment.pb.cc:390

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

void MergeFrom(const IntVarAssignment &from)

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

Definition assignment.pb.cc:704

void CopyFrom(const IntVarAssignment &from)

Definition assignment.pb.cc:681

Definition assignment.pb.cc:710

static constexpr ::int32_t kHasBitsOffset

Definition assignment.pb.cc:714

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

Definition assignment.pb.cc:712

friend class ::google::protobuf::MessageLite

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

Definition assignment.pb.cc:1264

void MergeFrom(const IntervalVarAssignment &from)

void CopyFrom(const IntervalVarAssignment &from)

Definition assignment.pb.cc:1241

static constexpr auto InternalGenerateClassData_()

Definition assignment.pb.cc:797

ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL

Definition assignment.pb.cc:927

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

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

Definition assignment.pb.cc:958

~IntervalVarAssignment() PROTOBUF_FINAL

Definition assignment.pb.cc:773

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

::size_t ByteSizeLong() const final

Definition assignment.pb.cc:1075

friend class ::google::protobuf::Arena

Definition assignment.pb.cc:1270

static constexpr ::int32_t kHasBitsOffset

Definition assignment.pb.cc:1274

static constexpr auto InternalGenerateClassData_()

Definition assignment.pb.cc:1378

void MergeFrom(const SequenceVarAssignment &from)

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

Definition assignment.pb.cc:1703

void CopyFrom(const SequenceVarAssignment &from)

Definition assignment.pb.cc:1682

::size_t ByteSizeLong() const final

Definition assignment.pb.cc:1586

~SequenceVarAssignment() PROTOBUF_FINAL

Definition assignment.pb.cc:1334

ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL

Definition assignment.pb.cc:1475

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

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

Definition assignment.pb.cc:1508

Definition assignment.pb.cc:1709

static constexpr ::int32_t kHasBitsOffset

Definition assignment.pb.cc:1713

friend class ::google::protobuf::MessageLite

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

Definition assignment.pb.cc:1883

static constexpr auto InternalGenerateClassData_()

Definition assignment.pb.cc:1785

::size_t ByteSizeLong() const final

Definition assignment.pb.cc:1928

ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL

Definition assignment.pb.cc:1861

~WorkerInfo() PROTOBUF_FINAL

Definition assignment.pb.cc:1761

void CopyFrom(const WorkerInfo &from)

Definition assignment.pb.cc:1995

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

Definition assignment.pb.cc:2013

void MergeFrom(const WorkerInfo &from)

static constexpr ::_pbi::MigrationSchema *PROTOBUF_NULLABLE schemas

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SequenceVarAssignmentDefaultTypeInternal _SequenceVarAssignment_default_instance_

Definition assignment.pb.cc:89

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

Definition assignment.pb.cc:1809

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IntVarAssignmentDefaultTypeInternal _IntVarAssignment_default_instance_

Definition assignment.pb.cc:155

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

Definition assignment.pb.cc:821

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

Definition assignment.pb.cc:1402

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IntervalVarAssignmentDefaultTypeInternal _IntervalVarAssignment_default_instance_

Definition assignment.pb.cc:125

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

Definition assignment.pb.cc:2158

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorkerInfoDefaultTypeInternal _WorkerInfo_default_instance_

Definition assignment.pb.cc:55

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AssignmentProtoDefaultTypeInternal _AssignmentProto_default_instance_

Definition assignment.pb.cc:185

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

Definition assignment.pb.cc:438

Definition assignment.pb.cc:176

AssignmentProto _instance

Definition assignment.pb.cc:180

~AssignmentProtoDefaultTypeInternal()

Definition assignment.pb.cc:178

PROTOBUF_CONSTEXPR AssignmentProtoDefaultTypeInternal()

Definition assignment.pb.cc:177

Definition assignment.pb.cc:146

~IntVarAssignmentDefaultTypeInternal()