Google OR-Tools: build/ortools/constraint_solver/demon

Google OR-Tools: build/ortools/constraint_solver/demon_profiler.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 DemonRuns::Impl_::Impl_(

30 ::_pbi::ConstantInitialized) noexcept

31 : _cached_size_{0},

32 start_time_{},

33 _start_time_cached_byte_size_{0},

34 end_time_{},

35 _end_time_cached_byte_size_{0},

36 demon_id_(

37 &::google::protobuf::internal::fixed_address_empty_string,

38 ::_pbi::ConstantInitialized()),

39 failures_{::int64_t{0}} {}

41template <typename>

43#if defined(PROTOBUF_CUSTOM_VTABLE)

45#else

46 : ::google::protobuf::Message(),

47#endif

48 _impl_(::_pbi::ConstantInitialized()) {

49}

58PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL

61inline constexpr ConstraintRuns::Impl_::Impl_(

62 ::_pbi::ConstantInitialized) noexcept

63 : _cached_size_{0},

64 initial_propagation_start_time_{},

65 _initial_propagation_start_time_cached_byte_size_{0},

66 initial_propagation_end_time_{},

67 _initial_propagation_end_time_cached_byte_size_{0},

68 demons_{},

69 constraint_id_(

70 &::google::protobuf::internal::fixed_address_empty_string,

71 ::_pbi::ConstantInitialized()),

72 failures_{::int64_t{0}} {}

74template <typename>

76#if defined(PROTOBUF_CUSTOM_VTABLE)

78#else

79 : ::google::protobuf::Message(),

80#endif

81 _impl_(::_pbi::ConstantInitialized()) {

82}

91PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL

93}

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

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

98const ::uint32_t

100 protodesc_cold) = {

101 0x081,

103 7,

108 2,

109 0,

110 1,

111 3,

112 0x081,

114 8,

120 3,

121 0,

122 1,

123 4,

124 2,

125};

126

127static const ::_pbi::MigrationSchema

131};

136const char descriptor_table_protodef_ortools_2fconstraint_5fsolver_2fdemon_5fprofiler_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE(

137 protodesc_cold) = {

138 "\n.ortools/constraint_solver/demon_profil"

139 "er.proto\022\023operations_research\"U\n\tDemonRu"

140 "ns\022\020\n\010demon_id\030\001 \001(\t\022\022\n\nstart_time\030\002 \003(\003"

141 "\022\020\n\010end_time\030\003 \003(\003\022\020\n\010failures\030\004 \001(\003\"\267\001\n"

142 "\016ConstraintRuns\022\025\n\rconstraint_id\030\001 \001(\t\022&"

143 "\n\036initial_propagation_start_time\030\002 \003(\003\022$"

144 "\n\034initial_propagation_end_time\030\003 \003(\003\022\020\n\010"

145 "failures\030\004 \001(\003\022.\n\006demons\030\005 \003(\0132\036.operati"

146 "ons_research.DemonRunsb\006proto3"

147};

150 false,

151 false,

152 350,

153 descriptor_table_protodef_ortools_2fconstraint_5fsolver_2fdemon_5fprofiler_2eproto,

154 "ortools/constraint_solver/demon_profiler.proto",

156 nullptr,

157 0,

158 2,

164};

166

167

171 decltype(::std::declval<DemonRuns>()._impl_._has_bits_);

174};

175

177#if defined(PROTOBUF_CUSTOM_VTABLE)

179#else

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

181#endif

182 SharedCtor(arena);

183

184}

185PROTOBUF_NDEBUG_INLINE DemonRuns::Impl_::Impl_(

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

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

188 [[maybe_unused]] const ::operations_research::DemonRuns& from_msg)

189 : _has_bits_{from._has_bits_},

190 _cached_size_{0},

191 start_time_{visibility, arena, from.start_time_},

192 _start_time_cached_byte_size_{0},

193 end_time_{visibility, arena, from.end_time_},

194 _end_time_cached_byte_size_{0},

195 demon_id_(arena, from.demon_id_) {}

196

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

200#if defined(PROTOBUF_CUSTOM_VTABLE)

202#else

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

204#endif

206 (void)_this;

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

208 from._internal_metadata_);

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

210 _impl_.failures_ = from._impl_.failures_;

211

212

213}

214PROTOBUF_NDEBUG_INLINE DemonRuns::Impl_::Impl_(

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

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

217 : _cached_size_{0},

218 start_time_{visibility, arena},

219 _start_time_cached_byte_size_{0},

220 end_time_{visibility, arena},

221 _end_time_cached_byte_size_{0},

222 demon_id_(arena) {}

223

224inline void DemonRuns::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {

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

226 _impl_.failures_ = {};

227}

229

230 SharedDtor(*this);

231}

232inline void DemonRuns::SharedDtor(MessageLite& self) {

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

235 this_.CheckHasBitConsistency();

236 }

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

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

239 this_._impl_.demon_id_.Destroy();

240 this_._impl_.~Impl_();

241}

242

243inline void* PROTOBUF_NONNULL DemonRuns::PlacementNew_(

244 const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,

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

246 return ::new (mem) DemonRuns(arena);

247}

248constexpr auto DemonRuns::InternalNewImpl_() {

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

252 InternalGetArenaOffset(

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

256 InternalGetArenaOffset(

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

258 });

259 if (arena_bits.has_value()) {

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

261 sizeof(DemonRuns), alignof(DemonRuns), *arena_bits);

262 } else {

263 return ::google::protobuf::internal::MessageCreator(&DemonRuns::PlacementNew_,

264 sizeof(DemonRuns),

265 alignof(DemonRuns));

266 }

267}

269 return ::google::protobuf::internal::ClassDataFull{

270 ::google::protobuf::internal::ClassData{

272 &_table_.header,

273 nullptr,

274 nullptr,

275 &DemonRuns::MergeImpl,

276 ::google::protobuf::Message::GetNewImpl<DemonRuns>(),

277#if defined(PROTOBUF_CUSTOM_VTABLE)

278 &DemonRuns::SharedDtor,

281#endif

283 false,

284 },

285 &DemonRuns::kDescriptorMethods,

287 nullptr,

288 };

289}

290

291PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const

294

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

296DemonRuns::GetClassData() const {

298 ::google::protobuf::internal::PrefetchToLocalCache(DemonRuns_class_data_.tc_table);

300}

301PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1

302const ::_pbi::TcParseTable<2, 4, 0, 46, 2>

303DemonRuns::_table_ = {

304 {

306 0,

307 4, 24,

308 offsetof(decltype(_table_), field_lookup_table),

309 4294967280,

310 offsetof(decltype(_table_), field_entries),

311 4,

312 0,

313 offsetof(decltype(_table_), field_names),

315 nullptr,

316 ::_pbi::TcParser::GenericFallback,

317 #ifdef PROTOBUF_PREFETCH_PARSE_TABLE

318 ::_pbi::TcParser::GetTable<::operations_research::DemonRuns>(),

319 #endif

320 }, {{

321

322 {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(DemonRuns, _impl_.failures_), 3>(),

323 {32, 3, 0,

325

326 {::_pbi::TcParser::FastUS1,

327 {10, 2, 0,

329

330 {::_pbi::TcParser::FastV64P1,

331 {18, 0, 0,

333

334 {::_pbi::TcParser::FastV64P1,

335 {26, 1, 0,

337 }}, {{

338 65535, 65535

339 }}, {{

340

342

344

346

348 }},

349

350 {{

351 "\35\10\0\0\0\0\0\0"

352 "operations_research.DemonRuns"

353 "demon_id"

354 }},

355};

357

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

359 ::uint32_t cached_has_bits = 0;

360

361 (void) cached_has_bits;

362

363 cached_has_bits = _impl_._has_bits_[0];

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

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

366 _impl_.start_time_.Clear();

367 }

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

369 _impl_.end_time_.Clear();

370 }

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

372 _impl_.demon_id_.ClearNonDefaultToEmpty();

373 }

374 }

375 _impl_.failures_ = ::int64_t{0};

376 _impl_._has_bits_.Clear();

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

378}

379

380#if defined(PROTOBUF_CUSTOM_VTABLE)

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

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

385#else

387 ::uint8_t* PROTOBUF_NONNULL target,

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

390#endif

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

392 this_.CheckHasBitConsistency();

393 }

394

395 ::uint32_t cached_has_bits = 0;

396 (void)cached_has_bits;

397

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

399

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

401 if (!this_._internal_demon_id().empty()) {

402 const ::std::string& _s = this_._internal_demon_id();

403 ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(

404 _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "operations_research.DemonRuns.demon_id");

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

406 }

407 }

408

409

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

411 {

412 int byte_size = this_._impl_._start_time_cached_byte_size_.Get();

413 if (byte_size > 0) {

414 target = stream->WriteInt64Packed(

415 2, this_._internal_start_time(), byte_size, target);

416 }

417 }

418 }

419

420

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

422 {

423 int byte_size = this_._impl_._end_time_cached_byte_size_.Get();

424 if (byte_size > 0) {

425 target = stream->WriteInt64Packed(

426 3, this_._internal_end_time(), byte_size, target);

427 }

428 }

429 }

430

431

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

433 if (this_._internal_failures() != 0) {

434 target =

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

436 stream, this_._internal_failures(), target);

437 }

438 }

439

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

441 target =

442 ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(

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

444 }

445

446 return target;

447}

448

449#if defined(PROTOBUF_CUSTOM_VTABLE)

452#else

455#endif

456

457 ::size_t total_size = 0;

458

459 ::uint32_t cached_has_bits = 0;

460

461 (void)cached_has_bits;

462

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

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

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

466

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

468 total_size +=

469 ::_pbi::WireFormatLite::Int64SizeWithPackedTagSize(

470 this_._internal_start_time(), 1,

471 this_._impl_._start_time_cached_byte_size_);

472 }

473

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

475 total_size +=

476 ::_pbi::WireFormatLite::Int64SizeWithPackedTagSize(

477 this_._internal_end_time(), 1,

478 this_._impl_._end_time_cached_byte_size_);

479 }

480

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

482 if (!this_._internal_demon_id().empty()) {

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

484 this_._internal_demon_id());

485 }

486 }

487

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

489 if (this_._internal_failures() != 0) {

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

491 this_._internal_failures());

492 }

493 }

494 }

495 return this_.MaybeComputeUnknownFieldsSize(total_size,

496 &this_._impl_._cached_size_);

497}

498

499void DemonRuns::MergeImpl(::google::protobuf::MessageLite& to_msg,

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

501 auto* const _this =

502 static_cast<DemonRuns*>(&to_msg);

503 auto& from = static_cast<const DemonRuns&>(from_msg);

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

505 from.CheckHasBitConsistency();

506 }

507

508 ABSL_DCHECK_NE(&from, _this);

509 ::uint32_t cached_has_bits = 0;

510 (void)cached_has_bits;

511

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

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

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

515 _this->_internal_mutable_start_time()->MergeFrom(from._internal_start_time());

516 }

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

518 _this->_internal_mutable_end_time()->MergeFrom(from._internal_end_time());

519 }

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

521 if (!from._internal_demon_id().empty()) {

522 _this->_internal_set_demon_id(from._internal_demon_id());

523 } else {

524 if (_this->_impl_.demon_id_.IsDefault()) {

525 _this->_internal_set_demon_id("");

526 }

527 }

528 }

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

530 if (from._internal_failures() != 0) {

531 _this->_impl_.failures_ = from._impl_.failures_;

532 }

533 }

534 }

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

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

537 from._internal_metadata_);

538}

539

541

542 if (&from == this) return;

545}

546

547

548void DemonRuns::InternalSwap(DemonRuns* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {

549 using ::std::swap;

550 auto* arena = GetArena();

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

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

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

554 _impl_.start_time_.InternalSwap(&other->_impl_.start_time_);

555 _impl_.end_time_.InternalSwap(&other->_impl_.end_time_);

556 ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.demon_id_, &other->_impl_.demon_id_, arena);

557 swap(_impl_.failures_, other->_impl_.failures_);

558}

559

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

562}

563

564

566 public:

568 decltype(::std::declval<ConstraintRuns>()._impl_._has_bits_);

572

574#if defined(PROTOBUF_CUSTOM_VTABLE)

576#else

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

578#endif

579 SharedCtor(arena);

580

581}

582PROTOBUF_NDEBUG_INLINE ConstraintRuns::Impl_::Impl_(

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

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

585 [[maybe_unused]] const ::operations_research::ConstraintRuns& from_msg)

586 : _has_bits_{from._has_bits_},

587 _cached_size_{0},

588 initial_propagation_start_time_{visibility, arena, from.initial_propagation_start_time_},

589 _initial_propagation_start_time_cached_byte_size_{0},

590 initial_propagation_end_time_{visibility, arena, from.initial_propagation_end_time_},

591 _initial_propagation_end_time_cached_byte_size_{0},

592 demons_{visibility, arena, from.demons_},

593 constraint_id_(arena, from.constraint_id_) {}

594

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

598#if defined(PROTOBUF_CUSTOM_VTABLE)

600#else

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

602#endif

604 (void)_this;

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

606 from._internal_metadata_);

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

608 _impl_.failures_ = from._impl_.failures_;

609

610

611}

612PROTOBUF_NDEBUG_INLINE ConstraintRuns::Impl_::Impl_(

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

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

615 : _cached_size_{0},

616 initial_propagation_start_time_{visibility, arena},

617 _initial_propagation_start_time_cached_byte_size_{0},

618 initial_propagation_end_time_{visibility, arena},

619 _initial_propagation_end_time_cached_byte_size_{0},

620 demons_{visibility, arena},

621 constraint_id_(arena) {}

622

623inline void ConstraintRuns::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {

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

625 _impl_.failures_ = {};

626}

628

629 SharedDtor(*this);

630}

631inline void ConstraintRuns::SharedDtor(MessageLite& self) {

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

634 this_.CheckHasBitConsistency();

635 }

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

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

638 this_._impl_.constraint_id_.Destroy();

639 this_._impl_.~Impl_();

640}

641

642inline void* PROTOBUF_NONNULL ConstraintRuns::PlacementNew_(

643 const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,

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

646}

647constexpr auto ConstraintRuns::InternalNewImpl_() {

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

649 PROTOBUF_FIELD_OFFSET(ConstraintRuns, _impl_.initial_propagation_start_time_) +

651 InternalGetArenaOffset(

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

653 PROTOBUF_FIELD_OFFSET(ConstraintRuns, _impl_.initial_propagation_end_time_) +

655 InternalGetArenaOffset(

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

659 InternalGetArenaOffset(

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

661 });

662 if (arena_bits.has_value()) {

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

664 sizeof(ConstraintRuns), alignof(ConstraintRuns), *arena_bits);

665 } else {

666 return ::google::protobuf::internal::MessageCreator(&ConstraintRuns::PlacementNew_,

667 sizeof(ConstraintRuns),

668 alignof(ConstraintRuns));

669 }

670}

672 return ::google::protobuf::internal::ClassDataFull{

673 ::google::protobuf::internal::ClassData{

675 &_table_.header,

676 nullptr,

677 nullptr,

678 &ConstraintRuns::MergeImpl,

679 ::google::protobuf::Message::GetNewImpl<ConstraintRuns>(),

680#if defined(PROTOBUF_CUSTOM_VTABLE)

681 &ConstraintRuns::SharedDtor,

684#endif

686 false,

687 },

688 &ConstraintRuns::kDescriptorMethods,

690 nullptr,

691 };

692}

693

694PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const

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

699ConstraintRuns::GetClassData() const {

703}

704PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1

705const ::_pbi::TcParseTable<3, 5, 1, 56, 2>

706ConstraintRuns::_table_ = {

707 {

709 0,

710 5, 56,

711 offsetof(decltype(_table_), field_lookup_table),

712 4294967264,

713 offsetof(decltype(_table_), field_entries),

714 5,

715 1,

716 offsetof(decltype(_table_), aux_entries),

718 nullptr,

719 ::_pbi::TcParser::GenericFallback,

720 #ifdef PROTOBUF_PREFETCH_PARSE_TABLE

721 ::_pbi::TcParser::GetTable<::operations_research::ConstraintRuns>(),

722 #endif

723 }, {{

724 {::_pbi::TcParser::MiniParse, {}},

725

726 {::_pbi::TcParser::FastUS1,

727 {10, 3, 0,

729

730 {::_pbi::TcParser::FastV64P1,

731 {18, 0, 0,

732 PROTOBUF_FIELD_OFFSET(ConstraintRuns, _impl_.initial_propagation_start_time_)}},

733

734 {::_pbi::TcParser::FastV64P1,

735 {26, 1, 0,

736 PROTOBUF_FIELD_OFFSET(ConstraintRuns, _impl_.initial_propagation_end_time_)}},

737

738 {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(ConstraintRuns, _impl_.failures_), 4>(),

739 {32, 4, 0,

741

742 {::_pbi::TcParser::FastMtR1,

743 {42, 2, 0,

745 {::_pbi::TcParser::MiniParse, {}},

746 {::_pbi::TcParser::MiniParse, {}},

747 }}, {{

748 65535, 65535

749 }}, {{

750

752

754

756

758

760 }},

761 {{

762 {::_pbi::TcParser::GetTable<::operations_research::DemonRuns>()},

763 }},

764 {{

765 "\42\15\0\0\0\0\0\0"

766 "operations_research.ConstraintRuns"

767 "constraint_id"

768 }},

769};

771

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

773 ::uint32_t cached_has_bits = 0;

774

775 (void) cached_has_bits;

776

777 cached_has_bits = _impl_._has_bits_[0];

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

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

780 _impl_.initial_propagation_start_time_.Clear();

781 }

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

783 _impl_.initial_propagation_end_time_.Clear();

784 }

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

786 _impl_.demons_.Clear();

787 }

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

789 _impl_.constraint_id_.ClearNonDefaultToEmpty();

790 }

791 }

792 _impl_.failures_ = ::int64_t{0};

793 _impl_._has_bits_.Clear();

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

795}

796

797#if defined(PROTOBUF_CUSTOM_VTABLE)

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

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

802#else

804 ::uint8_t* PROTOBUF_NONNULL target,

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

807#endif

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

809 this_.CheckHasBitConsistency();

810 }

811

812 ::uint32_t cached_has_bits = 0;

813 (void)cached_has_bits;

814

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

816

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

818 if (!this_._internal_constraint_id().empty()) {

819 const ::std::string& _s = this_._internal_constraint_id();

820 ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(

821 _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "operations_research.ConstraintRuns.constraint_id");

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

823 }

824 }

825

826

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

828 {

829 int byte_size = this_._impl_._initial_propagation_start_time_cached_byte_size_.Get();

830 if (byte_size > 0) {

831 target = stream->WriteInt64Packed(

832 2, this_._internal_initial_propagation_start_time(), byte_size, target);

833 }

834 }

835 }

836

837

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

839 {

840 int byte_size = this_._impl_._initial_propagation_end_time_cached_byte_size_.Get();

841 if (byte_size > 0) {

842 target = stream->WriteInt64Packed(

843 3, this_._internal_initial_propagation_end_time(), byte_size, target);

844 }

845 }

846 }

847

848

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

850 if (this_._internal_failures() != 0) {

851 target =

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

853 stream, this_._internal_failures(), target);

854 }

855 }

856

857

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

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

860 this_._internal_demons_size());

861 i < n; i++) {

862 const auto& repfield = this_._internal_demons().Get(i);

863 target =

864 ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(

865 5, repfield, repfield.GetCachedSize(),

866 target, stream);

867 }

868 }

869

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

871 target =

872 ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(

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

874 }

875

876 return target;

877}

878

879#if defined(PROTOBUF_CUSTOM_VTABLE)

882#else

885#endif

886

887 ::size_t total_size = 0;

888

889 ::uint32_t cached_has_bits = 0;

890

891 (void)cached_has_bits;

892

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

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

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

896

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

898 total_size +=

899 ::_pbi::WireFormatLite::Int64SizeWithPackedTagSize(

900 this_._internal_initial_propagation_start_time(), 1,

901 this_._impl_._initial_propagation_start_time_cached_byte_size_);

902 }

903

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

905 total_size +=

906 ::_pbi::WireFormatLite::Int64SizeWithPackedTagSize(

907 this_._internal_initial_propagation_end_time(), 1,

908 this_._impl_._initial_propagation_end_time_cached_byte_size_);

909 }

910

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

912 total_size += 1UL * this_._internal_demons_size();

913 for (const auto& msg : this_._internal_demons()) {

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

915 }

916 }

917

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

919 if (!this_._internal_constraint_id().empty()) {

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

921 this_._internal_constraint_id());

922 }

923 }

924

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

926 if (this_._internal_failures() != 0) {

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

928 this_._internal_failures());

929 }

930 }

931 }

932 return this_.MaybeComputeUnknownFieldsSize(total_size,

933 &this_._impl_._cached_size_);

934}

935

936void ConstraintRuns::MergeImpl(::google::protobuf::MessageLite& to_msg,

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

938 auto* const _this =

940 auto& from = static_cast<const ConstraintRuns&>(from_msg);

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

942 from.CheckHasBitConsistency();

943 }

945

946 ABSL_DCHECK_NE(&from, _this);

947 ::uint32_t cached_has_bits = 0;

948 (void)cached_has_bits;

949

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

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

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

953 _this->_internal_mutable_initial_propagation_start_time()->MergeFrom(from._internal_initial_propagation_start_time());

954 }

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

956 _this->_internal_mutable_initial_propagation_end_time()->MergeFrom(from._internal_initial_propagation_end_time());

957 }

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

959 _this->_internal_mutable_demons()->InternalMergeFromWithArena(

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

961 from._internal_demons());

962 }

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

964 if (!from._internal_constraint_id().empty()) {

965 _this->_internal_set_constraint_id(from._internal_constraint_id());

966 } else {

967 if (_this->_impl_.constraint_id_.IsDefault()) {

968 _this->_internal_set_constraint_id("");

969 }

970 }

971 }

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

973 if (from._internal_failures() != 0) {

974 _this->_impl_.failures_ = from._impl_.failures_;

975 }

976 }

977 }

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

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

980 from._internal_metadata_);

981}

982

984

985 if (&from == this) return;

988}

989

990

991void ConstraintRuns::InternalSwap(ConstraintRuns* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {

992 using ::std::swap;

993 auto* arena = GetArena();

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

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

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

997 _impl_.initial_propagation_start_time_.InternalSwap(&other->_impl_.initial_propagation_start_time_);

998 _impl_.initial_propagation_end_time_.InternalSwap(&other->_impl_.initial_propagation_end_time_);

999 _impl_.demons_.InternalSwap(&other->_impl_.demons_);

1000 ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.constraint_id_, &other->_impl_.constraint_id_, arena);

1001 swap(_impl_.failures_, other->_impl_.failures_);

1002}

1003

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

1010namespace protobuf {

1011}

1012}

1013

1014PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type

1017 ::std::false_type{});

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

static PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 ::std::false_type _static_init2_

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

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

Definition demon_profiler.pb.cc:569

static constexpr ::int32_t kHasBitsOffset

Definition demon_profiler.pb.cc:571

static constexpr auto InternalGenerateClassData_()

Definition demon_profiler.pb.cc:673

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 demon_profiler.pb.cc:805

ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL

Definition demon_profiler.pb.cc:772

~ConstraintRuns() PROTOBUF_FINAL

Definition demon_profiler.pb.cc:629

void CopyFrom(const ConstraintRuns &from)

Definition demon_profiler.pb.cc:985

void MergeFrom(const ConstraintRuns &from)

::size_t ByteSizeLong() const final

Definition demon_profiler.pb.cc:885

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

Definition demon_profiler.pb.cc:1006

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

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

friend class ::google::protobuf::Arena

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

Definition demon_profiler.pb.cc:171

static constexpr ::int32_t kHasBitsOffset

Definition demon_profiler.pb.cc:173

void CopyFrom(const DemonRuns &from)

Definition demon_profiler.pb.cc:541

friend class ::google::protobuf::MessageLite

void MergeFrom(const DemonRuns &from)

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

~DemonRuns() PROTOBUF_FINAL

Definition demon_profiler.pb.cc:229

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

static constexpr auto InternalGenerateClassData_()

Definition demon_profiler.pb.cc:269

ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL

Definition demon_profiler.pb.cc:357

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

Definition demon_profiler.pb.cc:387

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

Definition demon_profiler.pb.cc:561

::size_t ByteSizeLong() const final

Definition demon_profiler.pb.cc:454

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

Definition demon_profiler.pb.cc:97

::absl::once_flag descriptor_table_ortools_2fconstraint_5fsolver_2fdemon_5fprofiler_2eproto_once

Definition demon_profiler.pb.cc:148

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

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

Definition demon_profiler.pb.cc:95

PROTOBUF_CONSTINITconst ::_pbi::DescriptorTable descriptor_table_ortools_2fconstraint_5fsolver_2fdemon_5fprofiler_2eproto

Definition demon_profiler.pb.cc:149

static constexpr ::_pbi::MigrationSchema *PROTOBUF_NULLABLE schemas

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DemonRunsDefaultTypeInternal _DemonRuns_default_instance_

Definition demon_profiler.pb.cc:59

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

Definition demon_profiler.pb.cc:293

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

Definition demon_profiler.pb.cc:697

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ConstraintRunsDefaultTypeInternal _ConstraintRuns_default_instance_

Definition demon_profiler.pb.cc:92

PROTOBUF_CONSTEXPR ConstraintRunsDefaultTypeInternal()

Definition demon_profiler.pb.cc:84

ConstraintRuns _instance

Definition demon_profiler.pb.cc:87

~ConstraintRunsDefaultTypeInternal()

Definition demon_profiler.pb.cc:85

PROTOBUF_CONSTEXPR DemonRunsDefaultTypeInternal()

Definition demon_profiler.pb.cc:51

~DemonRunsDefaultTypeInternal()

Definition demon_profiler.pb.cc:52

DemonRuns _instance

Definition demon_profiler.pb.cc:54