Skip to content

Commit fb9e2c3

Browse files
protobuf-team-botprotobuf-team-bot
committed
Auto-generate files after cl/728885909
1 parent 3b79e22 commit fb9e2c3

File tree

4 files changed

+184
-72
lines changed

4 files changed

+184
-72
lines changed

‎php/ext/google/protobuf/php-upb.c

Lines changed: 85 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -12141,6 +12141,50 @@ bool upb_strtable_iter_isequal(const upb_strtable_iter* i1,
1214112141
return i1->t == i2->t && i1->index == i2->index;
1214212142
}
1214312143

12144+
bool upb_strtable_next2(const upb_strtable* t, upb_StringView* key,
12145+
upb_value* val, intptr_t* iter) {
12146+
size_t tab_idx = next(&t->t, *iter);
12147+
if (tab_idx < upb_table_size(&t->t)) {
12148+
upb_tabent* ent = &t->t.entries[tab_idx];
12149+
uint32_t len;
12150+
key->data = upb_tabstr(ent->key, &len);
12151+
key->size = len;
12152+
*val = _upb_value_val(ent->val.val);
12153+
*iter = tab_idx;
12154+
return true;
12155+
}
12156+
12157+
return false;
12158+
}
12159+
12160+
void upb_strtable_removeiter(upb_strtable* t, intptr_t* iter) {
12161+
intptr_t i = *iter;
12162+
upb_tabent* ent = &t->t.entries[i];
12163+
upb_tabent* prev = NULL;
12164+
12165+
// Linear search, not great.
12166+
upb_tabent* end = &t->t.entries[upb_table_size(&t->t)];
12167+
for (upb_tabent* e = t->t.entries; e != end; e++) {
12168+
if (e->next == ent) {
12169+
prev = e;
12170+
break;
12171+
}
12172+
}
12173+
12174+
if (prev) {
12175+
prev->next = ent->next;
12176+
}
12177+
12178+
t->t.count--;
12179+
ent->key = 0;
12180+
ent->next = NULL;
12181+
}
12182+
12183+
void upb_strtable_setentryvalue(upb_strtable* t, intptr_t iter, upb_value v) {
12184+
upb_tabent* ent = &t->t.entries[iter];
12185+
ent->val.val = v.val;
12186+
}
12187+
1214412188
/* upb_inttable ***************************************************************/
1214512189

1214612190
/* For inttables we use a hybrid structure where small keys are kept in an
@@ -12350,6 +12394,18 @@ void upb_inttable_compact(upb_inttable* t, upb_Arena* a) {
1235012394
*t = new_t;
1235112395
}
1235212396

12397+
void upb_inttable_clear(upb_inttable* t) {
12398+
// Clear the array part.
12399+
size_t array_bytes = t->array_size * sizeof(upb_tabval);
12400+
t->array_count = 0;
12401+
memset(mutable_array(t), 0, array_bytes);
12402+
12403+
// Clear the table part.
12404+
size_t bytes = upb_table_size(&t->t) * sizeof(upb_tabent);
12405+
t->t.count = 0;
12406+
memset((char*)t->t.entries, 0, bytes);
12407+
}
12408+
1235312409
// Iteration.
1235412410

1235512411
bool upb_inttable_next(const upb_inttable* t, uintptr_t* key, upb_value* val,
@@ -12369,11 +12425,15 @@ bool upb_inttable_next(const upb_inttable* t, uintptr_t* key, upb_value* val,
1236912425
}
1237012426

1237112427
size_t tab_idx = next(&t->t, i - t->array_size);
12428+
// We should set the iterator any way. When we are done, the iterator value is
12429+
// invalidated.
12430+
// `upb_inttable_done` will check on the iterator value to determine if the
12431+
// iteration is done.
12432+
*iter = tab_idx + t->array_size;
1237212433
if (tab_idx < upb_table_size(&t->t)) {
1237312434
upb_tabent* ent = &t->t.entries[tab_idx];
1237412435
*key = ent->key;
1237512436
*val = _upb_value_val(ent->val.val);
12376-
*iter = tab_idx + t->array_size;
1237712437
return true;
1237812438
}
1237912439

@@ -12408,48 +12468,37 @@ void upb_inttable_removeiter(upb_inttable* t, intptr_t* iter) {
1240812468
}
1240912469
}
1241012470

12411-
bool upb_strtable_next2(const upb_strtable* t, upb_StringView* key,
12412-
upb_value* val, intptr_t* iter) {
12413-
size_t tab_idx = next(&t->t, *iter);
12414-
if (tab_idx < upb_table_size(&t->t)) {
12415-
upb_tabent* ent = &t->t.entries[tab_idx];
12416-
uint32_t len;
12417-
key->data = upb_tabstr(ent->key, &len);
12418-
key->size = len;
12419-
*val = _upb_value_val(ent->val.val);
12420-
*iter = tab_idx;
12421-
return true;
12471+
void upb_inttable_setentryvalue(upb_inttable* t, intptr_t iter, upb_value v) {
12472+
if ((size_t)iter < t->array_size) {
12473+
mutable_array(t)[iter].val = v.val;
12474+
} else {
12475+
upb_tabent* ent = &t->t.entries[iter - t->array_size];
12476+
ent->val.val = v.val;
1242212477
}
12423-
12424-
return false;
1242512478
}
1242612479

12427-
void upb_strtable_removeiter(upb_strtable* t, intptr_t* iter) {
12428-
intptr_t i = *iter;
12429-
upb_tabent* ent = &t->t.entries[i];
12430-
upb_tabent* prev = NULL;
12431-
12432-
// Linear search, not great.
12433-
upb_tabent* end = &t->t.entries[upb_table_size(&t->t)];
12434-
for (upb_tabent* e = t->t.entries; e != end; e++) {
12435-
if (e->next == ent) {
12436-
prev = e;
12437-
break;
12438-
}
12439-
}
12440-
12441-
if (prev) {
12442-
prev->next = ent->next;
12480+
bool upb_inttable_done(const upb_inttable* t, intptr_t iter) {
12481+
if ((uintptr_t)iter >= t->array_size + upb_table_size(&t->t)) {
12482+
return true;
12483+
} else if ((size_t)iter < t->array_size) {
12484+
return !upb_arrhas(t->array[iter]);
12485+
} else {
12486+
return upb_tabent_isempty(&t->t.entries[iter - t->array_size]);
1244312487
}
12488+
}
1244412489

12445-
t->t.count--;
12446-
ent->key = 0;
12447-
ent->next = NULL;
12490+
uintptr_t upb_inttable_iter_key(const upb_inttable* t, intptr_t iter) {
12491+
UPB_ASSERT(!upb_inttable_done(t, iter));
12492+
return (size_t)iter < t->array_size ? iter
12493+
: t->t.entries[iter - t->array_size].key;
1244812494
}
1244912495

12450-
void upb_strtable_setentryvalue(upb_strtable* t, intptr_t iter, upb_value v) {
12451-
upb_tabent* ent = &t->t.entries[iter];
12452-
ent->val.val = v.val;
12496+
upb_value upb_inttable_iter_value(const upb_inttable* t, intptr_t iter) {
12497+
UPB_ASSERT(!upb_inttable_done(t, iter));
12498+
uint64_t val = (size_t)iter < t->array_size
12499+
? t->array[iter].val
12500+
: t->t.entries[iter - t->array_size].val.val;
12501+
return _upb_value_val(val);
1245312502
}
1245412503

1245512504

‎php/ext/google/protobuf/php-upb.h

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2743,6 +2743,9 @@ bool upb_inttable_replace(upb_inttable* t, uintptr_t key, upb_value val);
27432743
// inserting more entries is legal, but will likely require a table resize.
27442744
void upb_inttable_compact(upb_inttable* t, upb_Arena* a);
27452745

2746+
// Clears the table.
2747+
void upb_inttable_clear(upb_inttable* t);
2748+
27462749
// Iteration over inttable:
27472750
//
27482751
// intptr_t iter = UPB_INTTABLE_BEGIN;
@@ -2757,6 +2760,10 @@ void upb_inttable_compact(upb_inttable* t, upb_Arena* a);
27572760
bool upb_inttable_next(const upb_inttable* t, uintptr_t* key, upb_value* val,
27582761
intptr_t* iter);
27592762
void upb_inttable_removeiter(upb_inttable* t, intptr_t* iter);
2763+
void upb_inttable_setentryvalue(upb_inttable* t, intptr_t iter, upb_value v);
2764+
bool upb_inttable_done(const upb_inttable* t, intptr_t i);
2765+
uintptr_t upb_inttable_iter_key(const upb_inttable* t, intptr_t iter);
2766+
upb_value upb_inttable_iter_value(const upb_inttable* t, intptr_t iter);
27602767

27612768
#ifdef __cplusplus
27622769
} /* extern "C" */

‎ruby/ext/google/protobuf_c/ruby-upb.c

Lines changed: 85 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -11617,6 +11617,50 @@ bool upb_strtable_iter_isequal(const upb_strtable_iter* i1,
1161711617
return i1->t == i2->t && i1->index == i2->index;
1161811618
}
1161911619

11620+
bool upb_strtable_next2(const upb_strtable* t, upb_StringView* key,
11621+
upb_value* val, intptr_t* iter) {
11622+
size_t tab_idx = next(&t->t, *iter);
11623+
if (tab_idx < upb_table_size(&t->t)) {
11624+
upb_tabent* ent = &t->t.entries[tab_idx];
11625+
uint32_t len;
11626+
key->data = upb_tabstr(ent->key, &len);
11627+
key->size = len;
11628+
*val = _upb_value_val(ent->val.val);
11629+
*iter = tab_idx;
11630+
return true;
11631+
}
11632+
11633+
return false;
11634+
}
11635+
11636+
void upb_strtable_removeiter(upb_strtable* t, intptr_t* iter) {
11637+
intptr_t i = *iter;
11638+
upb_tabent* ent = &t->t.entries[i];
11639+
upb_tabent* prev = NULL;
11640+
11641+
// Linear search, not great.
11642+
upb_tabent* end = &t->t.entries[upb_table_size(&t->t)];
11643+
for (upb_tabent* e = t->t.entries; e != end; e++) {
11644+
if (e->next == ent) {
11645+
prev = e;
11646+
break;
11647+
}
11648+
}
11649+
11650+
if (prev) {
11651+
prev->next = ent->next;
11652+
}
11653+
11654+
t->t.count--;
11655+
ent->key = 0;
11656+
ent->next = NULL;
11657+
}
11658+
11659+
void upb_strtable_setentryvalue(upb_strtable* t, intptr_t iter, upb_value v) {
11660+
upb_tabent* ent = &t->t.entries[iter];
11661+
ent->val.val = v.val;
11662+
}
11663+
1162011664
/* upb_inttable ***************************************************************/
1162111665

1162211666
/* For inttables we use a hybrid structure where small keys are kept in an
@@ -11826,6 +11870,18 @@ void upb_inttable_compact(upb_inttable* t, upb_Arena* a) {
1182611870
*t = new_t;
1182711871
}
1182811872

11873+
void upb_inttable_clear(upb_inttable* t) {
11874+
// Clear the array part.
11875+
size_t array_bytes = t->array_size * sizeof(upb_tabval);
11876+
t->array_count = 0;
11877+
memset(mutable_array(t), 0, array_bytes);
11878+
11879+
// Clear the table part.
11880+
size_t bytes = upb_table_size(&t->t) * sizeof(upb_tabent);
11881+
t->t.count = 0;
11882+
memset((char*)t->t.entries, 0, bytes);
11883+
}
11884+
1182911885
// Iteration.
1183011886

1183111887
bool upb_inttable_next(const upb_inttable* t, uintptr_t* key, upb_value* val,
@@ -11845,11 +11901,15 @@ bool upb_inttable_next(const upb_inttable* t, uintptr_t* key, upb_value* val,
1184511901
}
1184611902

1184711903
size_t tab_idx = next(&t->t, i - t->array_size);
11904+
// We should set the iterator any way. When we are done, the iterator value is
11905+
// invalidated.
11906+
// `upb_inttable_done` will check on the iterator value to determine if the
11907+
// iteration is done.
11908+
*iter = tab_idx + t->array_size;
1184811909
if (tab_idx < upb_table_size(&t->t)) {
1184911910
upb_tabent* ent = &t->t.entries[tab_idx];
1185011911
*key = ent->key;
1185111912
*val = _upb_value_val(ent->val.val);
11852-
*iter = tab_idx + t->array_size;
1185311913
return true;
1185411914
}
1185511915

@@ -11884,48 +11944,37 @@ void upb_inttable_removeiter(upb_inttable* t, intptr_t* iter) {
1188411944
}
1188511945
}
1188611946

11887-
bool upb_strtable_next2(const upb_strtable* t, upb_StringView* key,
11888-
upb_value* val, intptr_t* iter) {
11889-
size_t tab_idx = next(&t->t, *iter);
11890-
if (tab_idx < upb_table_size(&t->t)) {
11891-
upb_tabent* ent = &t->t.entries[tab_idx];
11892-
uint32_t len;
11893-
key->data = upb_tabstr(ent->key, &len);
11894-
key->size = len;
11895-
*val = _upb_value_val(ent->val.val);
11896-
*iter = tab_idx;
11897-
return true;
11947+
void upb_inttable_setentryvalue(upb_inttable* t, intptr_t iter, upb_value v) {
11948+
if ((size_t)iter < t->array_size) {
11949+
mutable_array(t)[iter].val = v.val;
11950+
} else {
11951+
upb_tabent* ent = &t->t.entries[iter - t->array_size];
11952+
ent->val.val = v.val;
1189811953
}
11899-
11900-
return false;
1190111954
}
1190211955

11903-
void upb_strtable_removeiter(upb_strtable* t, intptr_t* iter) {
11904-
intptr_t i = *iter;
11905-
upb_tabent* ent = &t->t.entries[i];
11906-
upb_tabent* prev = NULL;
11907-
11908-
// Linear search, not great.
11909-
upb_tabent* end = &t->t.entries[upb_table_size(&t->t)];
11910-
for (upb_tabent* e = t->t.entries; e != end; e++) {
11911-
if (e->next == ent) {
11912-
prev = e;
11913-
break;
11914-
}
11915-
}
11916-
11917-
if (prev) {
11918-
prev->next = ent->next;
11956+
bool upb_inttable_done(const upb_inttable* t, intptr_t iter) {
11957+
if ((uintptr_t)iter >= t->array_size + upb_table_size(&t->t)) {
11958+
return true;
11959+
} else if ((size_t)iter < t->array_size) {
11960+
return !upb_arrhas(t->array[iter]);
11961+
} else {
11962+
return upb_tabent_isempty(&t->t.entries[iter - t->array_size]);
1191911963
}
11964+
}
1192011965

11921-
t->t.count--;
11922-
ent->key = 0;
11923-
ent->next = NULL;
11966+
uintptr_t upb_inttable_iter_key(const upb_inttable* t, intptr_t iter) {
11967+
UPB_ASSERT(!upb_inttable_done(t, iter));
11968+
return (size_t)iter < t->array_size ? iter
11969+
: t->t.entries[iter - t->array_size].key;
1192411970
}
1192511971

11926-
void upb_strtable_setentryvalue(upb_strtable* t, intptr_t iter, upb_value v) {
11927-
upb_tabent* ent = &t->t.entries[iter];
11928-
ent->val.val = v.val;
11972+
upb_value upb_inttable_iter_value(const upb_inttable* t, intptr_t iter) {
11973+
UPB_ASSERT(!upb_inttable_done(t, iter));
11974+
uint64_t val = (size_t)iter < t->array_size
11975+
? t->array[iter].val
11976+
: t->t.entries[iter - t->array_size].val.val;
11977+
return _upb_value_val(val);
1192911978
}
1193011979

1193111980

‎ruby/ext/google/protobuf_c/ruby-upb.h

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2745,6 +2745,9 @@ bool upb_inttable_replace(upb_inttable* t, uintptr_t key, upb_value val);
27452745
// inserting more entries is legal, but will likely require a table resize.
27462746
void upb_inttable_compact(upb_inttable* t, upb_Arena* a);
27472747

2748+
// Clears the table.
2749+
void upb_inttable_clear(upb_inttable* t);
2750+
27482751
// Iteration over inttable:
27492752
//
27502753
// intptr_t iter = UPB_INTTABLE_BEGIN;
@@ -2759,6 +2762,10 @@ void upb_inttable_compact(upb_inttable* t, upb_Arena* a);
27592762
bool upb_inttable_next(const upb_inttable* t, uintptr_t* key, upb_value* val,
27602763
intptr_t* iter);
27612764
void upb_inttable_removeiter(upb_inttable* t, intptr_t* iter);
2765+
void upb_inttable_setentryvalue(upb_inttable* t, intptr_t iter, upb_value v);
2766+
bool upb_inttable_done(const upb_inttable* t, intptr_t i);
2767+
uintptr_t upb_inttable_iter_key(const upb_inttable* t, intptr_t iter);
2768+
upb_value upb_inttable_iter_value(const upb_inttable* t, intptr_t iter);
27622769

27632770
#ifdef __cplusplus
27642771
} /* extern "C" */

0 commit comments

Comments
 (0)