Google OR-Tools: build/ortools/sat/boolean

Google OR-Tools: build/ortools/sat/boolean_problem.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;

28namespace sat {

30inline constexpr LinearObjective::Impl_::Impl_(

31 ::_pbi::ConstantInitialized) noexcept

32 : _cached_size_{0},

33 literals_{},

34 coefficients_{},

35 offset_{0},

36 scaling_factor_{1} {}

38template <typename>

40#if defined(PROTOBUF_CUSTOM_VTABLE)

42#else

43 : ::google::protobuf::Message(),

44#endif

45 _impl_(::_pbi::ConstantInitialized()) {

46}

55PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL

58inline constexpr LinearBooleanConstraint::Impl_::Impl_(

59 ::_pbi::ConstantInitialized) noexcept

60 : _cached_size_{0},

61 literals_{},

62 coefficients_{},

63 name_(

64 &::google::protobuf::internal::fixed_address_empty_string,

65 ::_pbi::ConstantInitialized()),

66 lower_bound_{::int64_t{0}},

67 upper_bound_{::int64_t{0}} {}

69template <typename>

71#if defined(PROTOBUF_CUSTOM_VTABLE)

73#else

74 : ::google::protobuf::Message(),

75#endif

76 _impl_(::_pbi::ConstantInitialized()) {

77}

86PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL

89inline constexpr BooleanAssignment::Impl_::Impl_(

90 ::_pbi::ConstantInitialized) noexcept

91 : _cached_size_{0},

92 literals_{} {}

94template <typename>

96#if defined(PROTOBUF_CUSTOM_VTABLE)

98#else

99 : ::google::protobuf::Message(),

100#endif

101 _impl_(::_pbi::ConstantInitialized()) {

102}

110

111PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL

113

114inline constexpr LinearBooleanProblem::Impl_::Impl_(

115 ::_pbi::ConstantInitialized) noexcept

116 : _cached_size_{0},

117 constraints_{},

118 var_names_{},

119 name_(

120 &::google::protobuf::internal::fixed_address_empty_string,

121 ::_pbi::ConstantInitialized()),

122 objective_{nullptr},

123 assignment_{nullptr},

124 num_variables_{0},

125 original_num_variables_{0} {}

126

127template <typename>

129#if defined(PROTOBUF_CUSTOM_VTABLE)

131#else

132 : ::google::protobuf::Message(),

133#endif

134 _impl_(::_pbi::ConstantInitialized()) {

135}

143

144PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL

146}

147}

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

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

152const ::uint32_t

154 protodesc_cold) = {

155 0x081,

157 8,

163 0,

164 1,

165 3,

166 4,

167 2,

168 0x081,

170 7,

175 0,

176 1,

177 2,

178 3,

179 0x081,

181 4,

183 0,

184 0x081,

186 10,

194 2,

195 5,

196 0,

197 3,

198 1,

199 4,

200 6,

201};

202

203static const ::_pbi::MigrationSchema

209};

217 protodesc_cold) = {

218 "\n!ortools/sat/boolean_problem.proto\022\027ope"

219 "rations_research.sat\"{\n\027LinearBooleanCon"

220 "straint\022\020\n\010literals\030\001 \003(\005\022\024\n\014coefficient"

221 "s\030\002 \003(\003\022\023\n\013lower_bound\030\003 \001(\003\022\023\n\013upper_bo"

222 "und\030\004 \001(\003\022\016\n\004name\030\005 \001(\t:\000\"g\n\017LinearObjec"

223 "tive\022\020\n\010literals\030\001 \003(\005\022\024\n\014coefficients\030\002"

224 " \003(\003\022\021\n\006offset\030\003 \001(\001:\0010\022\031\n\016scaling_facto"

225 "r\030\004 \001(\001:\0011\"%\n\021BooleanAssignment\022\020\n\010liter"

226 "als\030\001 \003(\005\"\264\002\n\024LinearBooleanProblem\022\016\n\004na"

227 "me\030\001 \001(\t:\000\022\025\n\rnum_variables\030\003 \001(\005\022E\n\013con"

228 "straints\030\004 \003(\01320.operations_research.sat"

229 ".LinearBooleanConstraint\022;\n\tobjective\030\005 "

230 "\001(\0132(.operations_research.sat.LinearObje"

231 "ctive\022\021\n\tvar_names\030\006 \003(\t\022>\n\nassignment\030\007"

232 " \001(\0132*.operations_research.sat.BooleanAs"

233 "signment\022\036\n\026original_num_variables\030\010 \001(\005"

234 "B/\n\026com.google.ortools.satP\001\252\002\022Google.Or"

235 "Tools.Sat"

236};

239 false,

240 false,

241 689,

242 descriptor_table_protodef_ortools_2fsat_2fboolean_5fproblem_2eproto,

243 "ortools/sat/boolean_problem.proto",

245 nullptr,

246 0,

247 4,

253};

255namespace sat {

256

257

261 decltype(::std::declval<LinearBooleanConstraint>()._impl_._has_bits_);

264};

265

267#if defined(PROTOBUF_CUSTOM_VTABLE)

269#else

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

271#endif

272 SharedCtor(arena);

273

274}

275PROTOBUF_NDEBUG_INLINE LinearBooleanConstraint::Impl_::Impl_(

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

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

278 [[maybe_unused]] const ::operations_research::sat::LinearBooleanConstraint& from_msg)

279 : _has_bits_{from._has_bits_},

280 _cached_size_{0},

281 literals_{visibility, arena, from.literals_},

282 coefficients_{visibility, arena, from.coefficients_},

283 name_(arena, from.name_) {}

284

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

288#if defined(PROTOBUF_CUSTOM_VTABLE)

290#else

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

292#endif

294 (void)_this;

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

296 from._internal_metadata_);

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

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

299 offsetof(Impl_, lower_bound_),

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

301 offsetof(Impl_, lower_bound_),

302 offsetof(Impl_, upper_bound_) -

303 offsetof(Impl_, lower_bound_) +

304 sizeof(Impl_::upper_bound_));

305

306

307}

308PROTOBUF_NDEBUG_INLINE LinearBooleanConstraint::Impl_::Impl_(

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

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

311 : _cached_size_{0},

312 literals_{visibility, arena},

313 coefficients_{visibility, arena},

314 name_(arena) {}

315

316inline void LinearBooleanConstraint::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {

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

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

319 offsetof(Impl_, lower_bound_),

320 0,

321 offsetof(Impl_, upper_bound_) -

322 offsetof(Impl_, lower_bound_) +

323 sizeof(Impl_::upper_bound_));

324}

326

327 SharedDtor(*this);

328}

329inline void LinearBooleanConstraint::SharedDtor(MessageLite& self) {

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

332 this_.CheckHasBitConsistency();

333 }

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

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

336 this_._impl_.name_.Destroy();

337 this_._impl_.~Impl_();

338}

339

340inline void* PROTOBUF_NONNULL LinearBooleanConstraint::PlacementNew_(

341 const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,

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

344}

345constexpr auto LinearBooleanConstraint::InternalNewImpl_() {

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

349 InternalGetArenaOffset(

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

353 InternalGetArenaOffset(

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

355 });

356 if (arena_bits.has_value()) {

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

358 sizeof(LinearBooleanConstraint), alignof(LinearBooleanConstraint), *arena_bits);

359 } else {

360 return ::google::protobuf::internal::MessageCreator(&LinearBooleanConstraint::PlacementNew_,

361 sizeof(LinearBooleanConstraint),

362 alignof(LinearBooleanConstraint));

363 }

364}

366 return ::google::protobuf::internal::ClassDataFull{

367 ::google::protobuf::internal::ClassData{

369 &_table_.header,

370 nullptr,

371 nullptr,

372 &LinearBooleanConstraint::MergeImpl,

373 ::google::protobuf::Message::GetNewImpl<LinearBooleanConstraint>(),

374#if defined(PROTOBUF_CUSTOM_VTABLE)

375 &LinearBooleanConstraint::SharedDtor,

378#endif

380 false,

381 },

382 &LinearBooleanConstraint::kDescriptorMethods,

384 nullptr,

385 };

386}

387

388PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const

391

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

393LinearBooleanConstraint::GetClassData() const {

397}

398PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1

399const ::_pbi::TcParseTable<3, 5, 0, 0, 2>

400LinearBooleanConstraint::_table_ = {

401 {

403 0,

404 5, 56,

405 offsetof(decltype(_table_), field_lookup_table),

406 4294967264,

407 offsetof(decltype(_table_), field_entries),

408 5,

409 0,

410 offsetof(decltype(_table_), field_names),

412 nullptr,

413 ::_pbi::TcParser::GenericFallback,

414 #ifdef PROTOBUF_PREFETCH_PARSE_TABLE

415 ::_pbi::TcParser::GetTable<::operations_research::sat::LinearBooleanConstraint>(),

416 #endif

417 }, {{

418 {::_pbi::TcParser::MiniParse, {}},

419

420 {::_pbi::TcParser::FastV32R1,

421 {8, 0, 0,

423

424 {::_pbi::TcParser::FastV64R1,

425 {16, 1, 0,

427

428 {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(LinearBooleanConstraint, _impl_.lower_bound_), 3>(),

429 {24, 3, 0,

431

432 {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(LinearBooleanConstraint, _impl_.upper_bound_), 4>(),

433 {32, 4, 0,

435

436 {::_pbi::TcParser::FastBS1,

437 {42, 2, 0,

439 {::_pbi::TcParser::MiniParse, {}},

440 {::_pbi::TcParser::MiniParse, {}},

441 }}, {{

442 65535, 65535

443 }}, {{

444

446

448

450

452

454 }},

455

456 {{

457 }},

458};

460

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

462 ::uint32_t cached_has_bits = 0;

463

464 (void) cached_has_bits;

465

466 cached_has_bits = _impl_._has_bits_[0];

467 if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {

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

469 _impl_.literals_.Clear();

470 }

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

472 _impl_.coefficients_.Clear();

473 }

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

475 _impl_.name_.ClearNonDefaultToEmpty();

476 }

477 }

478 if (BatchCheckHasBit(cached_has_bits, 0x00000018U)) {

479 ::memset(&_impl_.lower_bound_, 0, static_cast<::size_t>(

480 reinterpret_cast<char*>(&_impl_.upper_bound_) -

481 reinterpret_cast<char*>(&_impl_.lower_bound_)) + sizeof(_impl_.upper_bound_));

482 }

483 _impl_._has_bits_.Clear();

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

485}

486

487#if defined(PROTOBUF_CUSTOM_VTABLE)

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

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

492#else

494 ::uint8_t* PROTOBUF_NONNULL target,

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

497#endif

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

499 this_.CheckHasBitConsistency();

500 }

501

502 ::uint32_t cached_has_bits = 0;

503 (void)cached_has_bits;

504

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

506

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

508 for (int i = 0, n = this_._internal_literals_size(); i < n; ++i) {

509 target = stream->EnsureSpace(target);

510 target = ::_pbi::WireFormatLite::WriteInt32ToArray(

511 1, this_._internal_literals().Get(i), target);

512 }

513 }

514

515

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

517 for (int i = 0, n = this_._internal_coefficients_size(); i < n; ++i) {

518 target = stream->EnsureSpace(target);

519 target = ::_pbi::WireFormatLite::WriteInt64ToArray(

520 2, this_._internal_coefficients().Get(i), target);

521 }

522 }

523

524

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

526 target =

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

528 stream, this_._internal_lower_bound(), target);

529 }

530

531

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

533 target =

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

535 stream, this_._internal_upper_bound(), target);

536 }

537

538

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

540 const ::std::string& _s = this_._internal_name();

541 target = stream->WriteStringMaybeAliased(5, _s, target);

542 }

543

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

545 target =

546 ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(

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

548 }

549

550 return target;

551}

552

553#if defined(PROTOBUF_CUSTOM_VTABLE)

556#else

559#endif

560

561 ::size_t total_size = 0;

562

563 ::uint32_t cached_has_bits = 0;

564

565 (void)cached_has_bits;

566

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

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

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

570

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

572 ::size_t data_size = ::_pbi::WireFormatLite::Int32Size(

573 this_._internal_literals());

574 ::size_t tag_size = ::size_t{1} *

575 ::_pbi::FromIntSize(this_._internal_literals_size());

576 total_size += tag_size + data_size;

577 }

578

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

580 ::size_t data_size = ::_pbi::WireFormatLite::Int64Size(

581 this_._internal_coefficients());

582 ::size_t tag_size = ::size_t{1} *

583 ::_pbi::FromIntSize(this_._internal_coefficients_size());

584 total_size += tag_size + data_size;

585 }

586

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

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

589 this_._internal_name());

590 }

591

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

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

594 this_._internal_lower_bound());

595 }

596

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

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

599 this_._internal_upper_bound());

600 }

601 }

602 return this_.MaybeComputeUnknownFieldsSize(total_size,

603 &this_._impl_._cached_size_);

604}

605

606void LinearBooleanConstraint::MergeImpl(::google::protobuf::MessageLite& to_msg,

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

608 auto* const _this =

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

612 from.CheckHasBitConsistency();

613 }

614

615 ABSL_DCHECK_NE(&from, _this);

616 ::uint32_t cached_has_bits = 0;

617 (void)cached_has_bits;

618

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

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

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

622 _this->_internal_mutable_literals()->MergeFrom(from._internal_literals());

623 }

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

625 _this->_internal_mutable_coefficients()->MergeFrom(from._internal_coefficients());

626 }

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

628 _this->_internal_set_name(from._internal_name());

629 }

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

631 _this->_impl_.lower_bound_ = from._impl_.lower_bound_;

632 }

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

634 _this->_impl_.upper_bound_ = from._impl_.upper_bound_;

635 }

636 }

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

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

639 from._internal_metadata_);

640}

641

643

644 if (&from == this) return;

647}

648

649

650void LinearBooleanConstraint::InternalSwap(LinearBooleanConstraint* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {

651 using ::std::swap;

652 auto* arena = GetArena();

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

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

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

656 _impl_.literals_.InternalSwap(&other->_impl_.literals_);

657 _impl_.coefficients_.InternalSwap(&other->_impl_.coefficients_);

658 ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, &other->_impl_.name_, arena);

659 ::google::protobuf::internal::memswap<

663 reinterpret_cast<char*>(&_impl_.lower_bound_),

664 reinterpret_cast<char*>(&other->_impl_.lower_bound_));

665}

666

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

669}

670

671

673 public:

675 decltype(::std::declval<LinearObjective>()._impl_._has_bits_);

679

681#if defined(PROTOBUF_CUSTOM_VTABLE)

683#else

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

685#endif

686 SharedCtor(arena);

687

688}

689PROTOBUF_NDEBUG_INLINE LinearObjective::Impl_::Impl_(

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

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

692 [[maybe_unused]] const ::operations_research::sat::LinearObjective& from_msg)

693 : _has_bits_{from._has_bits_},

694 _cached_size_{0},

695 literals_{visibility, arena, from.literals_},

696 coefficients_{visibility, arena, from.coefficients_} {}

697

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

701#if defined(PROTOBUF_CUSTOM_VTABLE)

703#else

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

705#endif

707 (void)_this;

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

709 from._internal_metadata_);

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

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

712 offsetof(Impl_, offset_),

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

714 offsetof(Impl_, offset_),

715 offsetof(Impl_, scaling_factor_) -

716 offsetof(Impl_, offset_) +

717 sizeof(Impl_::scaling_factor_));

718

719

720}

721PROTOBUF_NDEBUG_INLINE LinearObjective::Impl_::Impl_(

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

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

724 : _cached_size_{0},

725 literals_{visibility, arena},

726 coefficients_{visibility, arena},

727 scaling_factor_{1} {}

728

729inline void LinearObjective::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {

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

732}

734

735 SharedDtor(*this);

736}

737inline void LinearObjective::SharedDtor(MessageLite& self) {

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

740 this_.CheckHasBitConsistency();

741 }

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

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

744 this_._impl_.~Impl_();

745}

746

747inline void* PROTOBUF_NONNULL LinearObjective::PlacementNew_(

748 const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,

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

751}

752constexpr auto LinearObjective::InternalNewImpl_() {

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

756 InternalGetArenaOffset(

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

760 InternalGetArenaOffset(

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

762 });

763 if (arena_bits.has_value()) {

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

765 sizeof(LinearObjective), alignof(LinearObjective), *arena_bits);

766 } else {

767 return ::google::protobuf::internal::MessageCreator(&LinearObjective::PlacementNew_,

768 sizeof(LinearObjective),

769 alignof(LinearObjective));

770 }

771}

773 return ::google::protobuf::internal::ClassDataFull{

774 ::google::protobuf::internal::ClassData{

776 &_table_.header,

777 nullptr,

778 nullptr,

779 &LinearObjective::MergeImpl,

780 ::google::protobuf::Message::GetNewImpl<LinearObjective>(),

781#if defined(PROTOBUF_CUSTOM_VTABLE)

782 &LinearObjective::SharedDtor,

785#endif

787 false,

788 },

789 &LinearObjective::kDescriptorMethods,

791 nullptr,

792 };

793}

794

795PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const

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

800LinearObjective::GetClassData() const {

804}

805PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1

806const ::_pbi::TcParseTable<2, 4, 0, 0, 2>

807LinearObjective::_table_ = {

808 {

810 0,

811 4, 24,

812 offsetof(decltype(_table_), field_lookup_table),

813 4294967280,

814 offsetof(decltype(_table_), field_entries),

815 4,

816 0,

817 offsetof(decltype(_table_), field_names),

819 nullptr,

820 ::_pbi::TcParser::GenericFallback,

821 #ifdef PROTOBUF_PREFETCH_PARSE_TABLE

822 ::_pbi::TcParser::GetTable<::operations_research::sat::LinearObjective>(),

823 #endif

824 }, {{

825

826 {::_pbi::TcParser::FastF64S1,

827 {33, 3, 0,

829

830 {::_pbi::TcParser::FastV32R1,

831 {8, 0, 0,

833

834 {::_pbi::TcParser::FastV64R1,

835 {16, 1, 0,

837

838 {::_pbi::TcParser::FastF64S1,

839 {25, 2, 0,

841 }}, {{

842 65535, 65535

843 }}, {{

844

846

848

850

852 }},

853

854 {{

855 }},

856};

858

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

860 ::uint32_t cached_has_bits = 0;

861

862 (void) cached_has_bits;

863

864 cached_has_bits = _impl_._has_bits_[0];

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

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

867 _impl_.literals_.Clear();

868 }

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

870 _impl_.coefficients_.Clear();

871 }

872 }

873 if (BatchCheckHasBit(cached_has_bits, 0x0000000cU)) {

875 _impl_.scaling_factor_ = 1;

876 }

877 _impl_._has_bits_.Clear();

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

879}

880

881#if defined(PROTOBUF_CUSTOM_VTABLE)

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

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

886#else

888 ::uint8_t* PROTOBUF_NONNULL target,

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

891#endif

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

893 this_.CheckHasBitConsistency();

894 }

895

896 ::uint32_t cached_has_bits = 0;

897 (void)cached_has_bits;

898

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

900

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

902 for (int i = 0, n = this_._internal_literals_size(); i < n; ++i) {

903 target = stream->EnsureSpace(target);

904 target = ::_pbi::WireFormatLite::WriteInt32ToArray(

905 1, this_._internal_literals().Get(i), target);

906 }

907 }

908

909

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

911 for (int i = 0, n = this_._internal_coefficients_size(); i < n; ++i) {

912 target = stream->EnsureSpace(target);

913 target = ::_pbi::WireFormatLite::WriteInt64ToArray(

914 2, this_._internal_coefficients().Get(i), target);

915 }

916 }

917

918

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

920 target = stream->EnsureSpace(target);

921 target = ::_pbi::WireFormatLite::WriteDoubleToArray(

922 3, this_._internal_offset(), target);

923 }

924

925

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

927 target = stream->EnsureSpace(target);

928 target = ::_pbi::WireFormatLite::WriteDoubleToArray(

929 4, this_._internal_scaling_factor(), target);

930 }

931

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

933 target =

934 ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(

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

936 }

937

938 return target;

939}

940

941#if defined(PROTOBUF_CUSTOM_VTABLE)

944#else

947#endif

948

949 ::size_t total_size = 0;

950

951 ::uint32_t cached_has_bits = 0;

952

953 (void)cached_has_bits;

954

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

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

957 total_size += ::absl::popcount(0x0000000cU & cached_has_bits) * 9;

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

959

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

961 ::size_t data_size = ::_pbi::WireFormatLite::Int32Size(

962 this_._internal_literals());

963 ::size_t tag_size = ::size_t{1} *

964 ::_pbi::FromIntSize(this_._internal_literals_size());

965 total_size += tag_size + data_size;

966 }

967

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

969 ::size_t data_size = ::_pbi::WireFormatLite::Int64Size(

970 this_._internal_coefficients());

971 ::size_t tag_size = ::size_t{1} *

972 ::_pbi::FromIntSize(this_._internal_coefficients_size());

973 total_size += tag_size + data_size;

974 }

975 }

976 return this_.MaybeComputeUnknownFieldsSize(total_size,

977 &this_._impl_._cached_size_);

978}

979

980void LinearObjective::MergeImpl(::google::protobuf::MessageLite& to_msg,

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

982 auto* const _this =

984 auto& from = static_cast<const LinearObjective&>(from_msg);

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

986 from.CheckHasBitConsistency();

987 }

988

989 ABSL_DCHECK_NE(&from, _this);

990 ::uint32_t cached_has_bits = 0;

991 (void)cached_has_bits;

992

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

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

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

996 _this->_internal_mutable_literals()->MergeFrom(from._internal_literals());

997 }

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

999 _this->_internal_mutable_coefficients()->MergeFrom(from._internal_coefficients());

1000 }

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

1002 _this->_impl_.offset_ = from._impl_.offset_;

1003 }

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

1005 _this->_impl_.scaling_factor_ = from._impl_.scaling_factor_;

1006 }

1007 }

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

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

1010 from._internal_metadata_);

1011}

1012

1014

1015 if (&from == this) return;

1018}

1019

1020

1021void LinearObjective::InternalSwap(LinearObjective* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {

1022 using ::std::swap;

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

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

1025 _impl_.literals_.InternalSwap(&other->_impl_.literals_);

1026 _impl_.coefficients_.InternalSwap(&other->_impl_.coefficients_);

1027 ::google::protobuf::internal::memswap<

1031 reinterpret_cast<char*>(&_impl_.offset_),

1032 reinterpret_cast<char*>(&other->_impl_.offset_));

1033}

1034

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

1041 public:

1042 using HasBits =

1043 decltype(::std::declval<BooleanAssignment>()._impl_._has_bits_);

1046};

1049#if defined(PROTOBUF_CUSTOM_VTABLE)

1051#else

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

1053#endif

1054 SharedCtor(arena);

1055

1056}

1057PROTOBUF_NDEBUG_INLINE BooleanAssignment::Impl_::Impl_(

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

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

1060 [[maybe_unused]] const ::operations_research::sat::BooleanAssignment& from_msg)

1061 : _has_bits_{from._has_bits_},

1062 _cached_size_{0},

1063 literals_{visibility, arena, from.literals_} {}

1064

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

1068#if defined(PROTOBUF_CUSTOM_VTABLE)

1070#else

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

1072#endif

1074 (void)_this;

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

1076 from._internal_metadata_);

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

1078

1079

1080}

1081PROTOBUF_NDEBUG_INLINE BooleanAssignment::Impl_::Impl_(

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

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

1084 : _cached_size_{0},

1085 literals_{visibility, arena} {}

1086

1087inline void BooleanAssignment::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {

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

1089}

1091

1092 SharedDtor(*this);

1094inline void BooleanAssignment::SharedDtor(MessageLite& self) {

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

1097 this_.CheckHasBitConsistency();

1098 }

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

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

1101 this_._impl_.~Impl_();

1102}

1103

1104inline void* PROTOBUF_NONNULL BooleanAssignment::PlacementNew_(

1105 const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,

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

1107 return ::new (mem) BooleanAssignment(arena);

1108}

1109constexpr auto BooleanAssignment::InternalNewImpl_() {

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

1111 PROTOBUF_FIELD_OFFSET(BooleanAssignment, _impl_.literals_) +

1113 InternalGetArenaOffset(

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

1115 });

1116 if (arena_bits.has_value()) {

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

1118 sizeof(BooleanAssignment), alignof(BooleanAssignment), *arena_bits);

1119 } else {

1120 return ::google::protobuf::internal::MessageCreator(&BooleanAssignment::PlacementNew_,

1121 sizeof(BooleanAssignment),

1122 alignof(BooleanAssignment));

1123 }

1124}

1126 return ::google::protobuf::internal::ClassDataFull{

1127 ::google::protobuf::internal::ClassData{

1129 &_table_.header,

1130 nullptr,

1131 nullptr,

1132 &BooleanAssignment::MergeImpl,

1133 ::google::protobuf::Message::GetNewImpl<BooleanAssignment>(),

1134#if defined(PROTOBUF_CUSTOM_VTABLE)

1135 &BooleanAssignment::SharedDtor,

1138#endif

1140 false,

1141 },

1142 &BooleanAssignment::kDescriptorMethods,

1144 nullptr,

1145 };

1146}

1147

1148PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const

1151

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

1153BooleanAssignment::GetClassData() const {

1157}

1158PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1

1159const ::_pbi::TcParseTable<0, 1, 0, 0, 2>

1160BooleanAssignment::_table_ = {

1161 {

1162 PROTOBUF_FIELD_OFFSET(BooleanAssignment, _impl_._has_bits_),

1163 0,

1164 1, 0,

1165 offsetof(decltype(_table_), field_lookup_table),

1166 4294967294,

1167 offsetof(decltype(_table_), field_entries),

1168 1,

1169 0,

1170 offsetof(decltype(_table_), field_names),

1172 nullptr,

1173 ::_pbi::TcParser::GenericFallback,

1174 #ifdef PROTOBUF_PREFETCH_PARSE_TABLE

1175 ::_pbi::TcParser::GetTable<::operations_research::sat::BooleanAssignment>(),

1176 #endif

1177 }, {{

1178

1179 {::_pbi::TcParser::FastV32R1,

1180 {8, 0, 0,

1181 PROTOBUF_FIELD_OFFSET(BooleanAssignment, _impl_.literals_)}},

1182 }}, {{

1183 65535, 65535

1184 }}, {{

1185

1186 {PROTOBUF_FIELD_OFFSET(BooleanAssignment, _impl_.literals_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kInt32)},

1187 }},

1188

1189 {{

1190 }},

1191};

1193

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

1195 ::uint32_t cached_has_bits = 0;

1196

1197 (void) cached_has_bits;

1198

1199 cached_has_bits = _impl_._has_bits_[0];

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

1201 _impl_.literals_.Clear();

1202 }

1203 _impl_._has_bits_.Clear();

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

1205}

1206

1207#if defined(PROTOBUF_CUSTOM_VTABLE)

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

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

1211 const BooleanAssignment& this_ = static_cast<const BooleanAssignment&>(base);

1212#else

1214 ::uint8_t* PROTOBUF_NONNULL target,

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

1217#endif

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

1219 this_.CheckHasBitConsistency();

1220 }

1221

1222 ::uint32_t cached_has_bits = 0;

1223 (void)cached_has_bits;

1224

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

1226

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

1228 for (int i = 0, n = this_._internal_literals_size(); i < n; ++i) {

1229 target = stream->EnsureSpace(target);

1230 target = ::_pbi::WireFormatLite::WriteInt32ToArray(

1231 1, this_._internal_literals().Get(i), target);

1232 }

1233 }

1234

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

1236 target =

1237 ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(

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

1239 }

1240

1241 return target;

1242}

1243

1244#if defined(PROTOBUF_CUSTOM_VTABLE)

1246 const BooleanAssignment& this_ = static_cast<const BooleanAssignment&>(base);

1247#else

1249 const BooleanAssignment& this_ = *this;

1250#endif

1251

1252 ::size_t total_size = 0;

1253

1254 ::uint32_t cached_has_bits = 0;

1255

1256 (void)cached_has_bits;

1257

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

1259 {

1260

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

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

1263 ::size_t data_size = ::_pbi::WireFormatLite::Int32Size(

1264 this_._internal_literals());

1265 ::size_t tag_size = ::size_t{1} *

1266 ::_pbi::FromIntSize(this_._internal_literals_size());

1267 total_size += tag_size + data_size;

1268 }

1269 }

1270 return this_.MaybeComputeUnknownFieldsSize(total_size,

1271 &this_._impl_._cached_size_);

1272}

1273

1274void BooleanAssignment::MergeImpl(::google::protobuf::MessageLite& to_msg,

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

1276 auto* const _this =

1277 static_cast<BooleanAssignment*>(&to_msg);

1278 auto& from = static_cast<const BooleanAssignment&>(from_msg);

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

1280 from.CheckHasBitConsistency();

1281 }

1282

1283 ABSL_DCHECK_NE(&from, _this);

1284 ::uint32_t cached_has_bits = 0;

1285 (void)cached_has_bits;

1286

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

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

1289 _this->_internal_mutable_literals()->MergeFrom(from._internal_literals());

1290 }

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

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

1293 from._internal_metadata_);

1294}

1295

1297

1298 if (&from == this) return;

1301}

1302

1303

1304void BooleanAssignment::InternalSwap(BooleanAssignment* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {

1305 using ::std::swap;

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

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

1308 _impl_.literals_.InternalSwap(&other->_impl_.literals_);

1309}

1310

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

1313}

1317 public:

1318 using HasBits =

1319 decltype(::std::declval<LinearBooleanProblem>()._impl_._has_bits_);

1323

1325#if defined(PROTOBUF_CUSTOM_VTABLE)

1327#else

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

1329#endif

1330 SharedCtor(arena);

1331

1332}

1333PROTOBUF_NDEBUG_INLINE LinearBooleanProblem::Impl_::Impl_(

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

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

1336 [[maybe_unused]] const ::operations_research::sat::LinearBooleanProblem& from_msg)

1337 : _has_bits_{from._has_bits_},

1338 _cached_size_{0},

1339 constraints_{visibility, arena, from.constraints_},

1340 var_names_{visibility, arena, from.var_names_},

1341 name_(arena, from.name_) {}

1342

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

1346#if defined(PROTOBUF_CUSTOM_VTABLE)

1348#else

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

1350#endif

1352 (void)_this;

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

1354 from._internal_metadata_);

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

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

1357 _impl_.objective_ = (CheckHasBit(cached_has_bits, 0x00000008U))

1358 ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.objective_)

1359 : nullptr;

1360 _impl_.assignment_ = (CheckHasBit(cached_has_bits, 0x00000010U))

1361 ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.assignment_)

1362 : nullptr;

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

1364 offsetof(Impl_, num_variables_),

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

1366 offsetof(Impl_, num_variables_),

1367 offsetof(Impl_, original_num_variables_) -

1368 offsetof(Impl_, num_variables_) +

1369 sizeof(Impl_::original_num_variables_));

1370

1371

1372}

1373PROTOBUF_NDEBUG_INLINE LinearBooleanProblem::Impl_::Impl_(

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

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

1376 : _cached_size_{0},

1377 constraints_{visibility, arena},

1378 var_names_{visibility, arena},

1379 name_(arena) {}

1380

1381inline void LinearBooleanProblem::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {

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

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

1384 offsetof(Impl_, objective_),

1385 0,

1386 offsetof(Impl_, original_num_variables_) -

1387 offsetof(Impl_, objective_) +

1388 sizeof(Impl_::original_num_variables_));

1389}

1391

1392 SharedDtor(*this);

1393}

1394inline void LinearBooleanProblem::SharedDtor(MessageLite& self) {

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

1397 this_.CheckHasBitConsistency();

1398 }

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

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

1401 this_._impl_.name_.Destroy();

1402 delete this_._impl_.objective_;

1403 delete this_._impl_.assignment_;

1404 this_._impl_.~Impl_();

1405}

1406

1407inline void* PROTOBUF_NONNULL LinearBooleanProblem::PlacementNew_(

1408 const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,

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

1411}

1412constexpr auto LinearBooleanProblem::InternalNewImpl_() {

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

1414 PROTOBUF_FIELD_OFFSET(LinearBooleanProblem, _impl_.constraints_) +

1416 InternalGetArenaOffset(

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

1418 PROTOBUF_FIELD_OFFSET(LinearBooleanProblem, _impl_.var_names_) +

1419 decltype(LinearBooleanProblem::_impl_.var_names_)::

1420 InternalGetArenaOffset(

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

1422 });

1423 if (arena_bits.has_value()) {

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

1425 sizeof(LinearBooleanProblem), alignof(LinearBooleanProblem), *arena_bits);

1426 } else {

1427 return ::google::protobuf::internal::MessageCreator(&LinearBooleanProblem::PlacementNew_,

1428 sizeof(LinearBooleanProblem),

1429 alignof(LinearBooleanProblem));

1430 }

1431}

1433 return ::google::protobuf::internal::ClassDataFull{

1434 ::google::protobuf::internal::ClassData{

1436 &_table_.header,

1437 nullptr,

1438 nullptr,

1439 &LinearBooleanProblem::MergeImpl,

1440 ::google::protobuf::Message::GetNewImpl<LinearBooleanProblem>(),

1441#if defined(PROTOBUF_CUSTOM_VTABLE)

1442 &LinearBooleanProblem::SharedDtor,

1445#endif

1447 false,

1448 },

1449 &LinearBooleanProblem::kDescriptorMethods,

1451 nullptr,

1452 };

1453}

1454

1455PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const

1458

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

1460LinearBooleanProblem::GetClassData() const {

1464}

1465PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1

1466const ::_pbi::TcParseTable<3, 7, 3, 0, 2>

1467LinearBooleanProblem::_table_ = {

1468 {

1469 PROTOBUF_FIELD_OFFSET(LinearBooleanProblem, _impl_._has_bits_),

1470 0,

1471 8, 56,

1472 offsetof(decltype(_table_), field_lookup_table),

1473 4294967042,

1474 offsetof(decltype(_table_), field_entries),

1475 7,

1476 3,

1477 offsetof(decltype(_table_), aux_entries),

1479 nullptr,

1480 ::_pbi::TcParser::GenericFallback,

1481 #ifdef PROTOBUF_PREFETCH_PARSE_TABLE

1482 ::_pbi::TcParser::GetTable<::operations_research::sat::LinearBooleanProblem>(),

1483 #endif

1484 }, {{

1485

1486 {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(LinearBooleanProblem, _impl_.original_num_variables_), 6>(),

1487 {64, 6, 0,

1488 PROTOBUF_FIELD_OFFSET(LinearBooleanProblem, _impl_.original_num_variables_)}},

1489

1490 {::_pbi::TcParser::FastBS1,

1491 {10, 2, 0,

1492 PROTOBUF_FIELD_OFFSET(LinearBooleanProblem, _impl_.name_)}},

1493 {::_pbi::TcParser::MiniParse, {}},

1494

1495 {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(LinearBooleanProblem, _impl_.num_variables_), 5>(),

1496 {24, 5, 0,

1497 PROTOBUF_FIELD_OFFSET(LinearBooleanProblem, _impl_.num_variables_)}},

1498

1499 {::_pbi::TcParser::FastMtR1,

1500 {34, 0, 0,

1501 PROTOBUF_FIELD_OFFSET(LinearBooleanProblem, _impl_.constraints_)}},

1502

1503 {::_pbi::TcParser::FastMtS1,

1504 {42, 3, 1,

1505 PROTOBUF_FIELD_OFFSET(LinearBooleanProblem, _impl_.objective_)}},

1506

1507 {::_pbi::TcParser::FastBR1,

1508 {50, 1, 0,

1509 PROTOBUF_FIELD_OFFSET(LinearBooleanProblem, _impl_.var_names_)}},

1510

1511 {::_pbi::TcParser::FastMtS1,

1512 {58, 4, 2,

1513 PROTOBUF_FIELD_OFFSET(LinearBooleanProblem, _impl_.assignment_)}},

1514 }}, {{

1515 65535, 65535

1516 }}, {{

1517

1518 {PROTOBUF_FIELD_OFFSET(LinearBooleanProblem, _impl_.name_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)},

1519

1520 {PROTOBUF_FIELD_OFFSET(LinearBooleanProblem, _impl_.num_variables_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},

1521

1522 {PROTOBUF_FIELD_OFFSET(LinearBooleanProblem, _impl_.constraints_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},

1523

1524 {PROTOBUF_FIELD_OFFSET(LinearBooleanProblem, _impl_.objective_), _Internal::kHasBitsOffset + 3, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},

1525

1526 {PROTOBUF_FIELD_OFFSET(LinearBooleanProblem, _impl_.var_names_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcRepeated | ::_fl::kBytes | ::_fl::kRepSString)},

1527

1528 {PROTOBUF_FIELD_OFFSET(LinearBooleanProblem, _impl_.assignment_), _Internal::kHasBitsOffset + 4, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},

1529

1530 {PROTOBUF_FIELD_OFFSET(LinearBooleanProblem, _impl_.original_num_variables_), _Internal::kHasBitsOffset + 6, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},

1531 }},

1532 {{

1533 {::_pbi::TcParser::GetTable<::operations_research::sat::LinearBooleanConstraint>()},

1534 {::_pbi::TcParser::GetTable<::operations_research::sat::LinearObjective>()},

1535 {::_pbi::TcParser::GetTable<::operations_research::sat::BooleanAssignment>()},

1536 }},

1537 {{

1538 }},

1539};

1541

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

1543 ::uint32_t cached_has_bits = 0;

1544

1545 (void) cached_has_bits;

1546

1547 cached_has_bits = _impl_._has_bits_[0];

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

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

1550 _impl_.constraints_.Clear();

1551 }

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

1553 _impl_.var_names_.Clear();

1554 }

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

1556 _impl_.name_.ClearNonDefaultToEmpty();

1557 }

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

1559 ABSL_DCHECK(_impl_.objective_ != nullptr);

1560 _impl_.objective_->Clear();

1561 }

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

1563 ABSL_DCHECK(_impl_.assignment_ != nullptr);

1564 _impl_.assignment_->Clear();

1565 }

1566 }

1567 if (BatchCheckHasBit(cached_has_bits, 0x00000060U)) {

1568 ::memset(&_impl_.num_variables_, 0, static_cast<::size_t>(

1569 reinterpret_cast<char*>(&_impl_.original_num_variables_) -

1570 reinterpret_cast<char*>(&_impl_.num_variables_)) + sizeof(_impl_.original_num_variables_));

1571 }

1572 _impl_._has_bits_.Clear();

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

1574}

1575

1576#if defined(PROTOBUF_CUSTOM_VTABLE)

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

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

1580 const LinearBooleanProblem& this_ = static_cast<const LinearBooleanProblem&>(base);

1581#else

1583 ::uint8_t* PROTOBUF_NONNULL target,

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

1585 const LinearBooleanProblem& this_ = *this;

1586#endif

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

1588 this_.CheckHasBitConsistency();

1589 }

1590

1591 ::uint32_t cached_has_bits = 0;

1592 (void)cached_has_bits;

1593

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

1595

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

1597 const ::std::string& _s = this_._internal_name();

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

1599 }

1600

1601

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

1603 target =

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

1605 stream, this_._internal_num_variables(), target);

1606 }

1607

1608

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

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

1611 this_._internal_constraints_size());

1612 i < n; i++) {

1613 const auto& repfield = this_._internal_constraints().Get(i);

1614 target =

1615 ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(

1616 4, repfield, repfield.GetCachedSize(),

1617 target, stream);

1618 }

1619 }

1620

1621

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

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

1624 5, *this_._impl_.objective_, this_._impl_.objective_->GetCachedSize(), target,

1625 stream);

1626 }

1627

1628

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

1630 for (int i = 0, n = this_._internal_var_names_size(); i < n; ++i) {

1631 const auto& s = this_._internal_var_names().Get(i);

1632 target = stream->WriteString(6, s, target);

1633 }

1634 }

1635

1636

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

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

1639 7, *this_._impl_.assignment_, this_._impl_.assignment_->GetCachedSize(), target,

1640 stream);

1641 }

1642

1643

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

1645 target =

1646 ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<8>(

1647 stream, this_._internal_original_num_variables(), target);

1648 }

1649

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

1651 target =

1652 ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(

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

1654 }

1655

1656 return target;

1657}

1658

1659#if defined(PROTOBUF_CUSTOM_VTABLE)

1661 const LinearBooleanProblem& this_ = static_cast<const LinearBooleanProblem&>(base);

1662#else

1664 const LinearBooleanProblem& this_ = *this;

1665#endif

1666

1667 ::size_t total_size = 0;

1668

1669 ::uint32_t cached_has_bits = 0;

1670

1671 (void)cached_has_bits;

1672

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

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

1675 if (BatchCheckHasBit(cached_has_bits, 0x0000007fU)) {

1676

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

1678 total_size += 1UL * this_._internal_constraints_size();

1679 for (const auto& msg : this_._internal_constraints()) {

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

1681 }

1682 }

1683

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

1685 total_size +=

1686 1 * ::google::protobuf::internal::FromIntSize(this_._internal_var_names().size());

1687 for (int i = 0, n = this_._internal_var_names().size(); i < n; ++i) {

1688 total_size += ::google::protobuf::internal::WireFormatLite::StringSize(

1689 this_._internal_var_names().Get(i));

1690 }

1691 }

1692

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

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

1695 this_._internal_name());

1696 }

1697

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

1699 total_size += 1 +

1700 ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.objective_);

1701 }

1702

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

1704 total_size += 1 +

1705 ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.assignment_);

1706 }

1707

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

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

1710 this_._internal_num_variables());

1711 }

1712

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

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

1715 this_._internal_original_num_variables());

1716 }

1717 }

1718 return this_.MaybeComputeUnknownFieldsSize(total_size,

1719 &this_._impl_._cached_size_);

1720}

1721

1722void LinearBooleanProblem::MergeImpl(::google::protobuf::MessageLite& to_msg,

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

1724 auto* const _this =

1725 static_cast<LinearBooleanProblem*>(&to_msg);

1726 auto& from = static_cast<const LinearBooleanProblem&>(from_msg);

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

1728 from.CheckHasBitConsistency();

1729 }

1731

1732 ABSL_DCHECK_NE(&from, _this);

1733 ::uint32_t cached_has_bits = 0;

1734 (void)cached_has_bits;

1735

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

1737 if (BatchCheckHasBit(cached_has_bits, 0x0000007fU)) {

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

1739 _this->_internal_mutable_constraints()->InternalMergeFromWithArena(

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

1741 from._internal_constraints());

1742 }

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

1744 _this->_internal_mutable_var_names()->InternalMergeFromWithArena(

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

1746 from._internal_var_names());

1747 }

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

1749 _this->_internal_set_name(from._internal_name());

1750 }

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

1752 ABSL_DCHECK(from._impl_.objective_ != nullptr);

1753 if (_this->_impl_.objective_ == nullptr) {

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

1755 } else {

1756 _this->_impl_.objective_->MergeFrom(*from._impl_.objective_);

1757 }

1758 }

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

1760 ABSL_DCHECK(from._impl_.assignment_ != nullptr);

1761 if (_this->_impl_.assignment_ == nullptr) {

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

1763 } else {

1764 _this->_impl_.assignment_->MergeFrom(*from._impl_.assignment_);

1765 }

1766 }

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

1768 _this->_impl_.num_variables_ = from._impl_.num_variables_;

1769 }

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

1771 _this->_impl_.original_num_variables_ = from._impl_.original_num_variables_;

1772 }

1773 }

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

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

1776 from._internal_metadata_);

1777}

1778

1780

1781 if (&from == this) return;

1784}

1785

1786

1787void LinearBooleanProblem::InternalSwap(LinearBooleanProblem* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {

1788 using ::std::swap;

1789 auto* arena = GetArena();

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

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

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

1793 _impl_.constraints_.InternalSwap(&other->_impl_.constraints_);

1794 _impl_.var_names_.InternalSwap(&other->_impl_.var_names_);

1795 ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, &other->_impl_.name_, arena);

1796 ::google::protobuf::internal::memswap<

1800 reinterpret_cast<char*>(&_impl_.objective_),

1801 reinterpret_cast<char*>(&other->_impl_.objective_));

1802}

1803

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

1806}

1807

1811namespace protobuf {

1812}

1813}

1814

1815PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type

1818 ::std::false_type{});

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

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

Definition boolean_problem.pb.cc:149

::absl::once_flag descriptor_table_ortools_2fsat_2fboolean_5fproblem_2eproto_once

Definition boolean_problem.pb.cc:237

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

PROTOBUF_CONSTINITconst ::_pbi::DescriptorTable descriptor_table_ortools_2fsat_2fboolean_5fproblem_2eproto

Definition boolean_problem.pb.cc:238

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

Definition boolean_problem.pb.cc:151

static PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 ::std::false_type _static_init2_

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

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

Definition boolean_problem.pb.cc:261

static constexpr ::int32_t kHasBitsOffset

Definition boolean_problem.pb.cc:1324

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

Definition boolean_problem.pb.cc:676

static constexpr ::int32_t kHasBitsOffset

Definition boolean_problem.pb.cc:1047

static constexpr auto InternalGenerateClassData_()

Definition boolean_problem.pb.cc:1128

ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL

Definition boolean_problem.pb.cc:1195

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

Definition boolean_problem.pb.cc:1314

void MergeFrom(const BooleanAssignment &from)

void CopyFrom(const BooleanAssignment &from)

Definition boolean_problem.pb.cc:1299

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

Definition boolean_problem.pb.cc:1216

~BooleanAssignment() PROTOBUF_FINAL

Definition boolean_problem.pb.cc:1093

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

::size_t ByteSizeLong() const final

Definition boolean_problem.pb.cc:1251

static constexpr ::int32_t kHasBitsOffset

Definition boolean_problem.pb.cc:263

static constexpr auto InternalGenerateClassData_()

Definition boolean_problem.pb.cc:366

friend class ::google::protobuf::MessageLite

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

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

Definition boolean_problem.pb.cc:668

ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL

Definition boolean_problem.pb.cc:460

void CopyFrom(const LinearBooleanConstraint &from)

Definition boolean_problem.pb.cc:643

LinearBooleanConstraint()

::size_t ByteSizeLong() const final

Definition boolean_problem.pb.cc:558

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

Definition boolean_problem.pb.cc:494

void MergeFrom(const LinearBooleanConstraint &from)

~LinearBooleanConstraint() PROTOBUF_FINAL

Definition boolean_problem.pb.cc:326

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

friend class ::google::protobuf::MessageLite

static constexpr auto InternalGenerateClassData_()

Definition boolean_problem.pb.cc:1436

void CopyFrom(const LinearBooleanProblem &from)

Definition boolean_problem.pb.cc:1783

void MergeFrom(const LinearBooleanProblem &from)

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

Definition boolean_problem.pb.cc:1808

ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL

Definition boolean_problem.pb.cc:1544

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

Definition boolean_problem.pb.cc:1586

~LinearBooleanProblem() PROTOBUF_FINAL

Definition boolean_problem.pb.cc:1394

::size_t ByteSizeLong() const final

Definition boolean_problem.pb.cc:1667

static constexpr ::int32_t kHasBitsOffset

Definition boolean_problem.pb.cc:678

friend class ::google::protobuf::MessageLite

::size_t ByteSizeLong() const final

Definition boolean_problem.pb.cc:947

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

void MergeFrom(const LinearObjective &from)

static constexpr auto InternalGenerateClassData_()

Definition boolean_problem.pb.cc:774

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

Definition boolean_problem.pb.cc:1037

ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL

Definition boolean_problem.pb.cc:859

~LinearObjective() PROTOBUF_FINAL

Definition boolean_problem.pb.cc:735

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

void CopyFrom(const LinearObjective &from)

Definition boolean_problem.pb.cc:1015

friend class ::google::protobuf::Arena

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

Definition boolean_problem.pb.cc:889

static constexpr ::_pbi::MigrationSchema *PROTOBUF_NULLABLE schemas

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

Definition boolean_problem.pb.cc:1152

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BooleanAssignmentDefaultTypeInternal _BooleanAssignment_default_instance_

Definition boolean_problem.pb.cc:112

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LinearBooleanProblemDefaultTypeInternal _LinearBooleanProblem_default_instance_

Definition boolean_problem.pb.cc:145

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

Definition boolean_problem.pb.cc:798

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

Definition boolean_problem.pb.cc:1460

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

Definition boolean_problem.pb.cc:390

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LinearBooleanConstraintDefaultTypeInternal _LinearBooleanConstraint_default_instance_

Definition boolean_problem.pb.cc:87

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LinearObjectiveDefaultTypeInternal _LinearObjective_default_instance_

Definition boolean_problem.pb.cc:56

~BooleanAssignmentDefaultTypeInternal()

Definition boolean_problem.pb.cc:105

PROTOBUF_CONSTEXPR BooleanAssignmentDefaultTypeInternal()

Definition boolean_problem.pb.cc:104

BooleanAssignment _instance

Definition boolean_problem.pb.cc:107

~LinearBooleanConstraintDefaultTypeInternal()

Definition boolean_problem.pb.cc:80

PROTOBUF_CONSTEXPR LinearBooleanConstraintDefaultTypeInternal()

Definition boolean_problem.pb.cc:79

LinearBooleanConstraint _instance