diferença_mensagem.h

Define uma coleção de descritores de campo.

No caso da base de código interna do Google, estamos usando absl::FixedArray em vez de vetores. Acelera significativamente a comparação de protótipos (cerca de 30%) reduzindo o número de operações malloc/free

OBSOLETO. Use FieldComparator::FloatComparison

Determina se as mensagens fornecidas são iguais.

Igualdade é definida como todos os campos dentro das duas mensagens que estão sendo definidos com o mesmo valor. Os campos e strings primitivos são comparados por valor, enquanto as mensagens/grupos incorporados são comparados como se fossem uma chamada recursiva. Use Compare() com IgnoreField() caso alguns campos sejam ignorados na comparação. Use Compare() com TreatAsSet() se houver campos repetidos em que a ordem não é importante.

Esse método requer que as duas mensagens tenham o mesmo Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).

Determina se as mensagens fornecidas são equivalentes.

A equivalência é definida como todos os campos dentro das duas mensagens que têm o mesmo valor. Isso é diferente do método "Equals" acima, em que os campos com valores padrão são considerados definidos automaticamente para esse valor. Veja mais detalhes sobre como os valores padrão são definidos para cada tipo de campo em . Além disso, Equivalent() ignora campos desconhecidos. Use IgnoreField() e Compare() se alguns campos forem ignorados na comparação.

Esse método requer que as duas mensagens tenham o mesmo Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).

Determina se as mensagens fornecidas são aproximadamente iguais.

A igualdade aproximada é definida como todos os campos dentro das duas mensagens que são aproximadamente iguais. Os campos e strings primitivos (não flutuantes) são comparados por valor, os flutuantes são comparados usando MathUtil::QuaseEquals() e mensagens/grupos incorporados como se fossem uma chamada recursiva. Use IgnoreField() e Compare() se alguns campos forem ignorados na comparação.

Esse método requer que as duas mensagens tenham o mesmo Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).

Determina se as mensagens fornecidas são aproximadamente equivalentes.

A equivalência aproximada é definida como todos os campos nas duas mensagens sendo aproximadamente equivalentes. Assim como em MessageDifferencer::RelativelyEquals, os campos e strings primitivos (não flutuantes) são comparados por valor, os flutuantes são comparados usando MathUtil::QuaseEquals() e mensagens/grupos incorporados como se fossem uma chamada recursiva. No entanto, os campos com valores padrão são considerados definidos como esse valor, de acordo com o MessageDiffencer::Equivalent. Use IgnoreField() e Compare() se alguns campos forem ignorados na comparação.

Esse método requer que as duas mensagens tenham o mesmo Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).

Os elementos do campo repetido serão tratados como um conjunto para fins de diferenciação. Portanto, ordens diferentes dos mesmos elementos serão consideradas iguais.

Os elementos que estão presentes nos dois lados da comparação, mas que mudaram de posição, são informados com ReportMudança(). Os elementos que existem apenas de um lado ou do outro são informados com ReportAdded() e ReportDeleted(), independentemente das posições deles. ReportModified() nunca é usado para esse campo repetido. Se as únicas diferenças entre as mensagens comparadas forem que alguns campos foram movidos, a comparação retornará "true".

Observe que, apesar do nome desse método, isso é na verdade uma comparação de vários conjuntos: se um lado da comparação tiver uma cópia no campo repetido, mas o outro não, isso contará como uma incompatibilidade.

Se o escopo da comparação for definido como PARCIAL, além do que foi mencionado acima, os valores extras adicionados aos campos repetidos da segunda mensagem não farão a comparação falhar.

A comparação definida é O(k * n^2) (em que n é o número total de elementos e k é o tamanho médio de cada elemento). Teoricamente, seria possível usar O(n * k) com uma implementação de hash mais complexa. Fique à vontade para contribuir se a implementação atual estiver lenta demais para você. Se a correspondência parcial também estiver ativada, a complexidade de tempo será O(k * n^2

• n^3) em que n^3 é a complexidade de tempo do algoritmo de correspondência máxima.

REQUISITOS: field->is_Repeated() e campo não registrado em TreatAsMap*

Os elementos do campo repetido serão tratados como uma lista para fins de diferenciação. Sendo assim, ordens diferentes dos mesmos elementos NÃO serão consideradas iguais.

REQUISITOS: field->is_Repeated() e campo não registrado em TreatAsMap*

Os elementos do campo repetido serão tratados como um mapa para fins de diferenciação, em que |key| será a chave do mapa.

Assim, elementos com a mesma chave serão comparados mesmo que não apareçam no mesmo índice. As diferenças são relatadas de maneira semelhante a TreatAsSet(), exceto pelo fato de ReportModified() ser usado para relatar elementos com a mesma chave, mas valores diferentes. Se um elemento for movido e modificado, somente o ReportModified() será chamado. Assim como no TreatAsSet, se as únicas diferenças entre as mensagens comparadas forem que alguns campos foram movidos, a comparação retornará "true". Consulte TreatAsSet para ver observações sobre o desempenho.

REQUISITOS: field->is_Repeated() REQUIRES: field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE REQUISITOS: key->containing_type() == field->message_type()

O mesmo que o TreatAsMap, mas esse método vai usar vários campos como chave em comparação.

Todos os campos especificados em "key_fields" precisam estar presentes nos elementos comparados. Dois elementos serão tratados como tendo a mesma chave se eles tiverem o mesmo valor para cada campo especificado. Há duas etapas no processo de comparação. A primeira é a correspondência de chaves. Cada elemento de uma mensagem será comparado a todos os elementos da outra. Somente os campos de "key_fields" são comparados nesta etapa para decidir se dois elementos têm a mesma chave. A segunda etapa é a comparação de valores. Os pares de elementos com a mesma chave (com valor igual para cada campo em "key_fields") serão comparados nesta etapa. A complexidade temporal da primeira etapa é O(s * m * n ^ 2), em que s é o tamanho médio dos campos especificados em "key_fields", m é o número de campos em "key_fields" e n é o número de elementos. Se a correspondência parcial estiver ativada, um algoritmo O(n^3) extra será gerado pelo algoritmo de correspondência máxima. A segunda etapa é O(k * n), em que k é o tamanho médio de cada elemento.

Igual a TreatAsMapWithMultipleFieldsAsKey, exceto que cada campo não precisa necessariamente ser um subcampo direto.

Cada elemento em key_field_paths indica um caminho da mensagem que está sendo comparada, listando um subcampo sucessivo para chegar ao campo chave.

REQUISITOS:

for key_field_path in key_field_paths:
  key_field_path[[]0]->containing_type() == field->message_type()
  for i in [[]0, key_field_path.size() - 1):
    key_field_path[[]i+1]->containing_type() ==
        key_field_path[[]i]->message_type()
    key_field_path[[]i]->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE
    !key_field_path[[]i]->is_repeated()

Usa um MapKeyComparator personalizado para determinar se dois elementos têm a mesma chave ao comparar um campo repetido como um mapa.

O autor da chamada é responsável por excluir o key_comparator. Esse método varia em TreatAsMapWithMultipleFieldsAsKey apenas na primeira etapa de correspondência de chave. Em vez de comparar alguns campos especificados, ele invoca o método IsMatch do "key_comparator" determinado para decidir se dois elementos têm a mesma chave.

Adicione um critério personalizado "ignore" que é avaliado, além dos campos ignorados adicionados com IgnoreField.

Assumiu a propriedade de ignore_criteria.

Indica que qualquer campo com o descritor especificado deve ser ignorado para comparar duas mensagens.

Isso se aplica a campos aninhados na estrutura da mensagem, bem como aos de nível superior. Quando MessageDifferencer encontra um campo ignorado, o ReportIgnored é chamado no gerador de relatórios, se especificado.

O único status em que o status "ignorado" do campo não é aplicado é quando ele está sendo usado como chave em um campo transmitido para TreatAsMap ou é um dos campos transmitidos para TreatAsMapWithMultipleFieldsAsKey. Nesse caso, ele é comparado na correspondência de chaves, mas depois é ignorado na comparação de valores.

Define o comparador de campo usado para determinar as diferenças entre os campos de buffer de protocolo.

Por padrão, ele é definido como uma instância DefaultFieldComparator. MessageDifferencer não assume a propriedade do objeto transmitido. Esse método precisa ser chamado antes de "Comparar" para que o comparador seja usado.

OBSOLETO.

Passe uma instância DefaultFieldComparator. Define a fração e a margem para a comparação de ponto flutuante de um determinado campo. Usa MathUtil::WithinFractionOrMargin para comparar os valores. OBSERVAÇÃO: esse método não fará nada se o comparador de campo do diferencial tiver sido

set to a custom object.

EXIGEM: field->cpp_type == FieldDescriptor::CPPTYPE_DOUBLE ou

field->cpp_type == FieldDescriptor::CPPTYPE_FLOAT

EXIGEM: float_comparison_ == APPROXIMATE

Informa ao diferencial se deve ou não informar as correspondências.

Esse método precisa ser chamado antes da comparação. O padrão para um novo diferencial é falso.

Informa ao diferencial se deve ou não informar os movimentos (em um campo repetido de "set" ou "map").

Esse método precisa ser chamado antes da comparação. O padrão para um novo diferencial é verdadeiro.

Informa ao diferencial se deve ou não informar os valores ignorados.

Esse método precisa ser chamado antes da comparação. O padrão para um novo diferencial é verdadeiro.

OBSOLETO.

Passe uma instância DefaultFieldComparator. Define o tipo de comparação, conforme definido na enumeração FloatComparison acima, usada por este diferencial na comparação de campos flutuantes (e duplos) em mensagens. OBSERVAÇÃO: esse método não fará nada se o comparador de campo do diferencial tiver sido

set to a custom object.

Compara as duas mensagens especificadas, retornando "true" se elas forem iguais; caso contrário, retorna "false".

Se esse método retornar "false", todas as alterações entre as duas mensagens serão informadas se um Reporter tiver sido especificado por ReportDifferencesTo. Veja também ReportDifferencesToString.

Esse método requer que as duas mensagens tenham o mesmo Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).

Cria automaticamente um gerador de relatórios que gera as diferenças encontradas (se houver) no ponteiro de string de saída especificado.

Esse método precisa ser chamado antes da comparação.

Informa ao MessageDifferencer para informar as diferenças usando o especificador.

Esse método precisa ser chamado antes de "Comparar" para que o repórter seja usado. É responsabilidade do autor da chamada excluir esse objeto. Se o ponteiro fornecido for igual a NULL, o MessageDifferencer vai interromper as diferenças de relatórios para qualquer repórter ou string de saída definido anteriormente.

Retornará "true" se o campo desconhecido precisar ser ignorado.

Observação: isso também será chamado para os campos desconhecidos. Nesse caso,

field.field will be null.

Informa que um campo repetido foi movido para outro local.

Isso se aplica somente ao usar TreatAsSet ou TreatAsMap(). Veja abaixo. Observe também que, para qualquer campo, ReportModified e ReportMudanças são mutuamente exclusivos. Se um campo tiver sido movido e modificado, somente o ReportModified será chamado.

Informa que dois campos coincidem.

Útil para fazer diferenças lado a lado. Essa função é mutuamente exclusiva com ReportModified e ReportMudança. É necessário chamar set_report_matches(true) antes de chamar "Comparar" para usar essa função.

Informa que dois campos teriam sido comparados, mas a comparação foi ignorada porque foi marcado como "ignorado" usando IgnoreField().

Essa função é mutuamente exclusiva com todas as outras funções Report().

O contrato de ReportIgnored é um pouco diferente das outras funções Report(), em que |field_path.back().index| é sempre igual a -1, mesmo que o último campo seja repetido. Isso acontece porque, enquanto as outras funções Report() indicam onde a ação (Adição, Exclusão etc.) aconteceu em um campo repetido, quando um campo repetido é "ignorado", o diferencial simplesmente chama ReportIgnored no campo repetido como um todo e prossegue sem examinar os elementos individuais dele.

Além disso, ReportIgnored() não indica se os campos foram realmente iguais ou não, já que Compare() não inspeciona esses campos. Cabe ao Relator decidir se os campos são iguais ou não (talvez com uma segunda chamada para Compare()), se for importante.

Informar que um campo desconhecido é ignorado.

Veja o comentário acima. Essa é uma função diferente, porque o último SpecificField no caminho do campo tem um campo nulo. Isso pode interromper o Repórter existente.

Para campos conhecidos, o campo é preenchido e "Unknown_field_number" é -1.

Para campos desconhecidos, "field" é NULL, "Unknown_field_number" é o número de campo e "Unknown_field_type" é o tipo.

Se for um campo repetido, "índice" será o índice dentro dele.

Para campos desconhecidos, este é o índice do campo entre todos os campos desconhecidos do mesmo número de campo e tipo.

Se "campo" for um campo repetido que está sendo tratado como um mapa ou conjunto (consulte TreatAsMap() e TreatAsSet() abaixo), new_index indica a posição para a qual o elemento foi movido.

Se o elemento não tiver sido movido, o "new_index" terá o mesmo valor que "index".

Para campos desconhecidos, eles são os ponteiros para o UnknownFieldSet que contém os campos desconhecidos.

Em determinados casos (por exemplo, MessageSet do proto1 ou grupos aninhados de campos desconhecidos), eles podem ser diferentes dos NativeFieldSets internos das mensagens.

Para campos desconhecidos, eles são o índice do campo em UnknownFieldSets.

Um deles será -1 ao informar uma adição ou exclusão.

Quando definido como verdadeiro, o relatório de stream também gera nós agregados (ou seja,

mensagens e grupos) cujos subcampos tenham sido modificados. Quando falso, somente os subcampos individuais serão informados. O padrão é "false".

Informa que um campo repetido foi movido para outro local.

Isso se aplica somente ao usar TreatAsSet ou TreatAsMap(). Veja abaixo. Observe também que, para qualquer campo, ReportModified e ReportMudanças são mutuamente exclusivos. Se um campo tiver sido movido e modificado, somente o ReportModified será chamado.

Informa que dois campos coincidem.

Útil para fazer diferenças lado a lado. Essa função é mutuamente exclusiva com ReportModified e ReportMudança. É necessário chamar set_report_matches(true) antes de chamar "Comparar" para usar essa função.

Informa que dois campos teriam sido comparados, mas a comparação foi ignorada porque foi marcado como "ignorado" usando IgnoreField().

Essa função é mutuamente exclusiva com todas as outras funções Report().

O contrato de ReportIgnored é um pouco diferente das outras funções Report(), em que |field_path.back().index| é sempre igual a -1, mesmo que o último campo seja repetido. Isso acontece porque, enquanto as outras funções Report() indicam onde a ação (Adição, Exclusão etc.) aconteceu em um campo repetido, quando um campo repetido é "ignorado", o diferencial simplesmente chama ReportIgnored no campo repetido como um todo e prossegue sem examinar os elementos individuais dele.

Além disso, ReportIgnored() não indica se os campos foram realmente iguais ou não, já que Compare() não inspeciona esses campos. Cabe ao Relator decidir se os campos são iguais ou não (talvez com uma segunda chamada para Compare()), se for importante.

Informar que um campo desconhecido é ignorado.

Veja o comentário acima. Essa é uma função diferente, porque o último SpecificField no caminho do campo tem um campo nulo. Isso pode interromper o Repórter existente.

Mostra o valor dos campos no buffer.

left_side será verdadeiro se a mensagem especificada for do lado esquerdo da comparação e falso se for a direita. Isso é relevante apenas para decidir se você precisa seguir desconhecido_field_index1 ou desconhecido_field_index2 quando um campo desconhecido é encontrado em field_path.