246 lines
8.3 KiB
C
246 lines
8.3 KiB
C
// Protocol Buffers - Google's data interchange format
|
|
// Copyright 2023 Google LLC. All rights reserved.
|
|
//
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file or at
|
|
// https://developers.google.com/open-source/licenses/bsd
|
|
|
|
#include "upb/message/compare.h"
|
|
|
|
#include <stddef.h>
|
|
|
|
#include "upb/base/descriptor_constants.h"
|
|
#include "upb/message/accessors.h"
|
|
#include "upb/message/array.h"
|
|
#include "upb/message/internal/accessors.h"
|
|
#include "upb/message/internal/compare_unknown.h"
|
|
#include "upb/message/internal/extension.h"
|
|
#include "upb/message/map.h"
|
|
#include "upb/message/message.h"
|
|
#include "upb/mini_table/extension.h"
|
|
#include "upb/mini_table/field.h"
|
|
#include "upb/mini_table/internal/field.h"
|
|
#include "upb/mini_table/message.h"
|
|
|
|
// Must be last.
|
|
#include "upb/port/def.inc"
|
|
|
|
#define kUpb_BaseField_Begin ((size_t)-1)
|
|
#define kUpb_Extension_Begin ((size_t)-1)
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
static bool _upb_Message_NextBaseField(const upb_Message* msg,
|
|
const upb_MiniTable* m,
|
|
const upb_MiniTableField** out_f,
|
|
upb_MessageValue* out_v, size_t* iter) {
|
|
const size_t count = upb_MiniTable_FieldCount(m);
|
|
size_t i = *iter;
|
|
|
|
while (++i < count) {
|
|
const upb_MiniTableField* f = upb_MiniTable_GetFieldByIndex(m, i);
|
|
const void* src = UPB_PRIVATE(_upb_Message_DataPtr)(msg, f);
|
|
|
|
upb_MessageValue val;
|
|
UPB_PRIVATE(_upb_MiniTableField_DataCopy)(f, &val, src);
|
|
|
|
// Skip field if unset or empty.
|
|
if (upb_MiniTableField_HasPresence(f)) {
|
|
if (!upb_Message_HasBaseField(msg, f)) continue;
|
|
} else {
|
|
if (UPB_PRIVATE(_upb_MiniTableField_DataIsZero)(f, src)) continue;
|
|
|
|
if (upb_MiniTableField_IsArray(f)) {
|
|
if (upb_Array_Size(val.array_val) == 0) continue;
|
|
} else if (upb_MiniTableField_IsMap(f)) {
|
|
if (upb_Map_Size(val.map_val) == 0) continue;
|
|
}
|
|
}
|
|
|
|
*out_f = f;
|
|
*out_v = val;
|
|
*iter = i;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static bool _upb_Message_NextExtension(const upb_Message* msg,
|
|
const upb_MiniTable* m,
|
|
const upb_MiniTableExtension** out_e,
|
|
upb_MessageValue* out_v, size_t* iter) {
|
|
size_t count;
|
|
const upb_Extension* exts = UPB_PRIVATE(_upb_Message_Getexts)(msg, &count);
|
|
size_t i = *iter;
|
|
|
|
if (++i < count) {
|
|
*out_e = exts[i].ext;
|
|
*out_v = exts[i].data;
|
|
*iter = i;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool upb_Message_IsEmpty(const upb_Message* msg, const upb_MiniTable* m) {
|
|
if (upb_Message_ExtensionCount(msg)) return false;
|
|
|
|
const upb_MiniTableField* f;
|
|
upb_MessageValue v;
|
|
size_t iter = kUpb_BaseField_Begin;
|
|
return !_upb_Message_NextBaseField(msg, m, &f, &v, &iter);
|
|
}
|
|
|
|
static bool _upb_Array_IsEqual(const upb_Array* arr1, const upb_Array* arr2,
|
|
upb_CType ctype, const upb_MiniTable* m,
|
|
int options) {
|
|
// Check for trivial equality.
|
|
if (arr1 == arr2) return true;
|
|
|
|
// Must have identical element counts.
|
|
const size_t size1 = arr1 ? upb_Array_Size(arr1) : 0;
|
|
const size_t size2 = arr2 ? upb_Array_Size(arr2) : 0;
|
|
if (size1 != size2) return false;
|
|
|
|
for (size_t i = 0; i < size1; i++) {
|
|
const upb_MessageValue val1 = upb_Array_Get(arr1, i);
|
|
const upb_MessageValue val2 = upb_Array_Get(arr2, i);
|
|
|
|
if (!upb_MessageValue_IsEqual(val1, val2, ctype, m, options)) return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool _upb_Map_IsEqual(const upb_Map* map1, const upb_Map* map2,
|
|
const upb_MiniTable* m, int options) {
|
|
// Check for trivial equality.
|
|
if (map1 == map2) return true;
|
|
|
|
// Must have identical element counts.
|
|
size_t size1 = map1 ? upb_Map_Size(map1) : 0;
|
|
size_t size2 = map2 ? upb_Map_Size(map2) : 0;
|
|
if (size1 != size2) return false;
|
|
|
|
const upb_MiniTableField* f = upb_MiniTable_MapValue(m);
|
|
const upb_MiniTable* m2_value = upb_MiniTable_SubMessage(m, f);
|
|
const upb_CType ctype = upb_MiniTableField_CType(f);
|
|
|
|
upb_MessageValue key, val1, val2;
|
|
size_t iter = kUpb_Map_Begin;
|
|
while (upb_Map_Next(map1, &key, &val1, &iter)) {
|
|
if (!upb_Map_Get(map2, key, &val2)) return false;
|
|
if (!upb_MessageValue_IsEqual(val1, val2, ctype, m2_value, options))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool _upb_Message_BaseFieldsAreEqual(const upb_Message* msg1,
|
|
const upb_Message* msg2,
|
|
const upb_MiniTable* m,
|
|
int options) {
|
|
// Iterate over all base fields for each message.
|
|
// The order will always match if the messages are equal.
|
|
size_t iter1 = kUpb_BaseField_Begin;
|
|
size_t iter2 = kUpb_BaseField_Begin;
|
|
|
|
for (;;) {
|
|
const upb_MiniTableField *f1, *f2;
|
|
upb_MessageValue val1, val2;
|
|
|
|
const bool got1 = _upb_Message_NextBaseField(msg1, m, &f1, &val1, &iter1);
|
|
const bool got2 = _upb_Message_NextBaseField(msg2, m, &f2, &val2, &iter2);
|
|
|
|
if (got1 != got2) return false; // Must have identical field counts.
|
|
if (!got1) return true; // Loop termination condition.
|
|
if (f1 != f2) return false; // Must have identical fields set.
|
|
|
|
const upb_MiniTable* subm = upb_MiniTable_SubMessage(m, f1);
|
|
const upb_CType ctype = upb_MiniTableField_CType(f1);
|
|
|
|
bool eq;
|
|
switch (UPB_PRIVATE(_upb_MiniTableField_Mode)(f1)) {
|
|
case kUpb_FieldMode_Array:
|
|
eq = _upb_Array_IsEqual(val1.array_val, val2.array_val, ctype, subm,
|
|
options);
|
|
break;
|
|
case kUpb_FieldMode_Map:
|
|
eq = _upb_Map_IsEqual(val1.map_val, val2.map_val, subm, options);
|
|
break;
|
|
case kUpb_FieldMode_Scalar:
|
|
eq = upb_MessageValue_IsEqual(val1, val2, ctype, subm, options);
|
|
break;
|
|
}
|
|
if (!eq) return false;
|
|
}
|
|
}
|
|
|
|
static bool _upb_Message_ExtensionsAreEqual(const upb_Message* msg1,
|
|
const upb_Message* msg2,
|
|
const upb_MiniTable* m,
|
|
int options) {
|
|
// Must have identical extension counts.
|
|
if (upb_Message_ExtensionCount(msg1) != upb_Message_ExtensionCount(msg2)) {
|
|
return false;
|
|
}
|
|
|
|
const upb_MiniTableExtension* e;
|
|
upb_MessageValue val1;
|
|
|
|
// Iterate over all extensions for msg1, and search msg2 for each extension.
|
|
size_t iter1 = kUpb_Extension_Begin;
|
|
while (_upb_Message_NextExtension(msg1, m, &e, &val1, &iter1)) {
|
|
const upb_Extension* ext2 = UPB_PRIVATE(_upb_Message_Getext)(msg2, e);
|
|
if (!ext2) return false;
|
|
|
|
const upb_MessageValue val2 = ext2->data;
|
|
const upb_MiniTableField* f = &e->UPB_PRIVATE(field);
|
|
const upb_MiniTable* subm = upb_MiniTableField_IsSubMessage(f)
|
|
? upb_MiniTableExtension_GetSubMessage(e)
|
|
: NULL;
|
|
const upb_CType ctype = upb_MiniTableField_CType(f);
|
|
|
|
bool eq;
|
|
switch (UPB_PRIVATE(_upb_MiniTableField_Mode)(f)) {
|
|
case kUpb_FieldMode_Array:
|
|
eq = _upb_Array_IsEqual(val1.array_val, val2.array_val, ctype, subm,
|
|
options);
|
|
break;
|
|
case kUpb_FieldMode_Map:
|
|
UPB_UNREACHABLE(); // Maps cannot be extensions.
|
|
break;
|
|
case kUpb_FieldMode_Scalar: {
|
|
eq = upb_MessageValue_IsEqual(val1, val2, ctype, subm, options);
|
|
break;
|
|
}
|
|
}
|
|
if (!eq) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool upb_Message_IsEqual(const upb_Message* msg1, const upb_Message* msg2,
|
|
const upb_MiniTable* m, int options) {
|
|
if (UPB_UNLIKELY(msg1 == msg2)) return true;
|
|
|
|
if (!_upb_Message_BaseFieldsAreEqual(msg1, msg2, m, options)) return false;
|
|
if (!_upb_Message_ExtensionsAreEqual(msg1, msg2, m, options)) return false;
|
|
|
|
if (!(options & kUpb_CompareOption_IncludeUnknownFields)) return true;
|
|
|
|
// Check the unknown fields.
|
|
size_t usize1, usize2;
|
|
const char* uf1 = upb_Message_GetUnknown(msg1, &usize1);
|
|
const char* uf2 = upb_Message_GetUnknown(msg2, &usize2);
|
|
|
|
// The wire encoder enforces a maximum depth of 100 so we match that here.
|
|
return UPB_PRIVATE(_upb_Message_UnknownFieldsAreEqual)(
|
|
uf1, usize1, uf2, usize2, 100) == kUpb_UnknownCompareResult_Equal;
|
|
}
|