OBSERVAÇÃO:este site foi descontinuado. O site será desativado após 31 de janeiro de 2023, e o tráfego será redirecionado para o novo site em https://protobuf.dev. Enquanto isso, as atualizações serão feitas apenas para protobuf.dev.

mensagem.h

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

#include <google/protobuf/message.h>
namespace google::protobuf

Define Message, a interface abstrata implementada por objetos de mensagem de protocolo não Lite.

Embora seja possível implementar a interface manualmente, a maioria dos usuários usa o compilador de protocolos para gerar implementações.

Exemplo de uso:

Digamos que você tenha uma mensagem definida como:

message Foo {
  optional string text = 1;
  repeated int32 numbers = 2;
}

Então, se você usasse o compilador de protocolo para gerar uma classe com base na definição acima, você poderia usá-la assim:

std::string data;  // Will store a serialized version of the message.

{
  // Create a message and serialize it.
  Foo foo;
  foo.set_text("Hello World!");
  foo.add_numbers(1);
  foo.add_numbers(5);
  foo.add_numbers(42);

  foo.SerializeToString(&data);
}

{
  // Parse the serialized message and check that it contains the
  // correct data.
  Foo foo;
  foo.ParseFromString(data);

  assert(foo.text() == "Hello World!");
  assert(foo.numbers_size() == 3);
  assert(foo.numbers(0) == 1);
  assert(foo.numbers(1) == 5);
  assert(foo.numbers(2) == 42);
}

{
  // Same as the last block, but do it dynamically via the Message
  // reflection interface.
  Message* foo = new Foo;
  const Descriptor* descriptor = foo->GetDescriptor();

  // Get the descriptors for the fields we're interested in and verify
  // their types.
  const FieldDescriptor* text_field = descriptor->FindFieldByName("text");
  assert(text_field != nullptr);
  assert(text_field->type() == FieldDescriptor::TYPE_STRING);
  assert(text_field->label() == FieldDescriptor::LABEL_OPTIONAL);
  const FieldDescriptor* numbers_field = descriptor->
                                         FindFieldByName("numbers");
  assert(numbers_field != nullptr);
  assert(numbers_field->type() == FieldDescriptor::TYPE_INT32);
  assert(numbers_field->label() == FieldDescriptor::LABEL_REPEATED);

  // Parse the message.
  foo->ParseFromString(data);

  // Use the reflection interface to examine the contents.
  const Reflection* reflection = foo->GetReflection();
  assert(reflection->GetString(*foo, text_field) == "Hello World!");
  assert(reflection->FieldSize(*foo, numbers_field) == 3);
  assert(reflection->GetRepeatedInt32(*foo, numbers_field, 0) == 1);
  assert(reflection->GetRepeatedInt32(*foo, numbers_field, 1) == 5);
  assert(reflection->GetRepeatedInt32(*foo, numbers_field, 2) == 42);

  delete foo;
}

Turmas neste arquivo

Um contêiner para armazenar metadados de mensagens.
Interface abstrata para mensagens de protocolo.
Essa interface contém métodos que podem ser usados para acessar e modificar dinamicamente os campos de uma mensagem de protocolo.
Interface abstrata de uma fábrica para objetos de mensagem.

Participantes do arquivo

Essas definições não fazem parte de nenhuma classe.
template const T *
DynamicCastToGenerated(const Message * from)
Tentar fazer o downgrade desta mensagem para um tipo de mensagem gerado. mais…
template T *
DynamicCastToGenerated(Message * from)
template void
LinkMessageReflection()
Chame esta função para garantir que a reflexão desta mensagem seja vinculada ao binário: mais...
const RepeatedPtrField< std::string > &
Reflection::GetRepeatedPtrFieldInternal< std::string >(const Message & message, const FieldDescriptor * field) const
RepeatedPtrField< std::string > *
Reflection::MutableRepeatedPtrFieldInternal< std::string >(Message * message, const FieldDescriptor * field) const

template const T * protobuf::DynamicCastToGenerated(
        const Message * from)

Tentar fazer o downgrade desta mensagem para um tipo de mensagem gerado.

Retorna nuloptr, se essa classe não for uma instância de T. Isso funcionará mesmo se a RTTI estiver desativada.

Isso também cria uma forte referência ao T, que vai impedir o vinculador de removê-lo no momento da vinculação. Isso pode ser importante se você estiver usando um DynamicMessageFactory que delegue para a fábrica gerada.


template void protobuf::LinkMessageReflection()

Chame esta função para garantir que a reflexão desta mensagem seja vinculada ao binário:

google::protobuf::LinkMessageReflection<FooMessage>();

Isso garante que a seguinte pesquisa seja bem-sucedida:

DescriptorPool::generated_pool()->FindMessageTypeByName("FooMessage");

Como efeito colateral, ele também garante que qualquer outra coisa do mesmo arquivo .proto também esteja disponível para pesquisa no pool gerado.

Como essa função não registra a mensagem, ela não precisa ser chamada antes da pesquisa. No entanto, ela precisa ocorrer em uma função que não pode ser removida do binário (ou seja, precisa ser acessível da principal).

A prática recomendada é chamar essa função o mais perto possível do local em que a reflexão é realmente necessária. Essa função é muito barata, então você não precisa se preocupar com a sobrecarga de execução, exceto nos loops mais apertados (no x86-64, ela é compilada em duas instruções "mov").

Metadados de struct

#include <google/protobuf/message.h>
namespace google::protobuf

Um contêiner para armazenar metadados de mensagens.

Participantes

const Descriptor *
descriptor
const Reflection *
reflection

classe Message: public MessageLite

#include <google/protobuf/message.h>
namespace google::protobuf

Interface abstrata para mensagens de protocolo.

Consulte também MessageLite, que contém a maioria das operações diárias. Message adiciona descritores e reflexão sobre isso.

Os métodos dessa classe que são virtuais, mas não puramente virtuais, têm implementações padrão baseadas em reflexão. As classes Message, que são otimizadas para velocidade, podem substituí-las por implementações mais rápidas. No entanto, é possível que as classes otimizadas para o tamanho do código as mantenham satisfeitas. Veja a opção optimize_for em Descriptor.proto.

Os usuários não podem derivar desta classe. Somente o compilador de protocolos e a biblioteca interna podem criar subclasses.

Participantes

constexpr
Message()
protected virtual Metadata
GetMetadata() const = 0
Consiga uma struct contendo os metadados para a Message, que, por sua vez, é usada para implementar GetDescriptor() e GetReflection() acima.
protected explicit
Message(Arena * arena)
protected static uint64
GetInvariantPerBuild(uint64 salt)

Operações básicas

virtual Message *
New() const = 0
Crie uma nova instância do mesmo tipo. mais…
virtual Message *
New(Arena * arena) const
Crie uma nova instância na arena. mais…
virtual void
CopyFrom(const Message & from)
Transforma esta mensagem em uma cópia da mensagem especificada. mais…
virtual void
MergeFrom(const Message & from)
Mescle os campos da mensagem fornecida nesta mensagem. mais…
void
CheckInitialized() const
Verifica se IsInitialized() retorna verdadeiro. mais...
void
FindInitializationErrors(std::vector< std::string > * errors) const
Crie lentamente uma lista de todos os campos obrigatórios que não foram definidos. mais…
virtual std::string
InitializationErrorString() const
Como FindInitializationErrors, mas mescla todas as strings delimitadas por vírgulas e as retorna.
virtual void
DiscardUnknownFields()
Limpa todos os campos desconhecidos desta mensagem e todas as mensagens incorporadas. mais…
virtual size_t
SpaceUsedLong() const
Calcula (uma estimativa de) o número total de bytes atualmente usados para armazenar a mensagem na memória. mais…
int
SpaceUsed() const

Depuração e testes

std::string
DebugString() const
Gera uma forma legível da mensagem, útil para depuração e outras finalidades.
std::string
ShortDebugString() const
Semelhante a DebugString(), mas com menos espaço em branco.
std::string
Utf8DebugString() const
Semelhante a DebugString(), mas sem escape para sequências de bytes UTF-8.
void
PrintDebugString() const
Função de conveniência útil no GDB. Exibe DebugString() em stdout.

Métodos baseados em reflexão

Esses métodos são virtuais em MessageLite, mas o Message oferece implementações padrão baseadas em reflexão.
virtual std::string
GetTypeName() const
Receba o nome desse tipo de mensagem, por exemplo, "foo.bar.BazProto".
virtual void
Clear()
Limpe todos os campos da mensagem e os defina para os valores padrão. mais…
virtual bool
IsInitialized() const
Retorna se todos os campos obrigatórios tiverem sido definidos. mais…
virtual void
CheckTypeAndMergeFrom(const MessageLite & other)
Se |other| for exatamente a mesma classe, isso chama MergeFrom(). mais...
virtual const char *
_InternalParse(const char * ptr, internal::ParseContext * ctx)
Analisador reflexivo.
virtual size_t
ByteSizeLong() const
Calcula o tamanho serializado da mensagem. mais…
virtual uint8 *
_InternalSerialize(uint8 * ptr, io::EpsCopyOutputStream * stream) const
Caminho rápido quando as condições são atendidas (por exemplo, mais…

Introspecção

const Descriptor *
GetDescriptor() const
Receba um ponteiro que não seja de proprietário de um Descriptor para o tipo desta mensagem. mais...
const Reflection *
GetReflection() const
Receba um ponteiro que não seja proprietário da interface Reflection para esta Message, que pode ser usada para ler e modificar os campos da Message dinamicamente (ou seja, sem saber o tipo de mensagem no tempo de compilação). mais...

virtual Message * Message::New() const = 0

Crie uma nova instância do mesmo tipo.

A propriedade é transmitida ao autor da chamada. Isso também é definido em MessageLite, mas é definido novamente aqui para covariância do tipo de retorno.


virtual Message * Message::New(
        Arena * arena) const

Crie uma nova instância na arena.

A propriedade será transmitida ao autor da chamada se a arena for um nulo. A implementação padrão permite compatibilidade com a API durante a transição de Arena.


virtual void Message::CopyFrom(
        const Message & from)

Transforma esta mensagem em uma cópia da mensagem especificada.

A mensagem fornecida precisa ter o mesmo descritor, mas não precisa ser necessariamente a mesma classe. Por padrão, isso é implementado como "Clear() MergeFrom(from);".


virtual void Message::MergeFrom(
        const Message & from)

Mescle os campos da mensagem fornecida nesta mensagem.

Os campos singulares serão substituídos, se especificados, a partir de, exceto pelas mensagens incorporadas que serão mescladas. Os campos repetidos serão concatenados. A mensagem fornecida precisa ser do mesmo tipo que ela (ou seja, a mesma classe).


void Message::CheckInitialized() const

Verifica se IsInitialized() retorna verdadeiro.

GOOGLE_CHECK: falha com outra mensagem de erro.


void Message::FindInitializationErrors(
        std::vector< std::string > * errors) const

Crie lentamente uma lista de todos os campos obrigatórios que não foram definidos.

Isso é muito mais lento do que IsInitialized(), já que é implementado apenas por reflexão. Geralmente, não é recomendado fazer essa chamada, a menos que você já tenha determinado um erro chamando IsInitialized().


virtual void Message::DiscardUnknownFields()

Limpa todos os campos desconhecidos desta mensagem e todas as mensagens incorporadas.

Normalmente, se forem encontrados números de tag desconhecidos ao analisar uma mensagem, a tag e o valor são armazenados no UnknownFieldSet da mensagem e, em seguida, gravados novamente quando a mensagem é serializada. Isso permite que os servidores que roteiam mensagens para outros servidores passem por mensagens com novas definições de campo que ainda não conhecem. No entanto, esse comportamento pode ter implicações na segurança. Para evitar isso, chame o método após a análise.

Consulte Reflection::GetUnknownFields() para saber mais sobre campos desconhecidos.


virtual size_t Message::SpaceUsedLong() const

Calcula (uma estimativa de) o número total de bytes atualmente usados para armazenar a mensagem na memória.

A implementação padrão chama o método SpaceUsed() do objeto Reflection

O SpaceUsed() é visivelmente mais lento que ByteSize(), porque é implementado usando reflexão (em vez da implementação de código gerada para ByteSize()). Assim como o ByteSize(), o tempo de CPU dele é linear no número de campos definidos para o proto.


virtual void Message::Clear()

Limpe todos os campos da mensagem e os defina para os valores padrão.

Clear() evita a liberação de memória, supondo que qualquer memória alocada para reter partes da mensagem seja necessária novamente para conter a próxima mensagem. Se você realmente quiser liberar a memória usada por uma Mensagem, é preciso excluí-la.


virtual bool Message::IsInitialized() const

Retorna se todos os campos obrigatórios tiverem sido definidos.

Os campos obrigatórios não existem mais a partir do proto3.


virtual void Message::CheckTypeAndMergeFrom(
        const MessageLite & other)

Se |other| for exatamente a mesma classe, isso chama MergeFrom().

Caso contrário, os resultados serão indefinidos e provavelmente vão falhar.


virtual size_t Message::ByteSizeLong() const

Calcula o tamanho serializado da mensagem.

Isso chama ByteSizeLong() recursivamente em todas as mensagens incorporadas.

Em geral, ByteSizeLong() é linear no número de campos definidos para o protótipo.


virtual uint8 * Message::_InternalSerialize(
        uint8 * ptr,
        io::EpsCopyOutputStream * stream) const

Caminho rápido quando as condições são atendidas (por exemplo,

não determinísticos) uint8* _InternalSerialize(uint8* ptr) const;


const Descriptor *
    Message::GetDescriptor() const

Receba um ponteiro que não seja de proprietário de um Descriptor para o tipo desta mensagem.

Descreve quais campos a mensagem contém, os tipos desses campos etc. Esse objeto permanece como propriedade da Message.


const Reflection *
    Message::GetReflection() const

Receba um ponteiro que não seja proprietário da interface Reflection para esta Message, que pode ser usada para ler e modificar os campos da Message dinamicamente (ou seja, sem saber o tipo de mensagem no tempo de compilação).

Esse objeto continua sendo uma propriedade da Message.

classe Reflection

#include <google/protobuf/message.h>
namespace google::protobuf

Essa interface contém métodos que podem ser usados para acessar e modificar dinamicamente os campos de uma mensagem de protocolo.

A semântica dele é semelhante aos acessadores gerados pelo compilador do protocolo.

Para ver a Reflexão de uma determinada Mensagem, chame Message::GetReflection().

Essa interface é separada de Message apenas por motivos de eficiência. A grande maioria das implementações de Message vai compartilhar a mesma implementação de Reflection (GeneratedMessageReflection, definida em generate_message.h), e todas as Mensagens de uma determinada classe precisarão compartilhar o mesmo objeto Reflection (embora você não precise depender do último fato).

Há várias maneiras de usar esses métodos incorretamente. Por exemplo, qualquer uma das condições a seguir pode gerar resultados indefinidos (provavelmente falhas de declaração):

  • O FieldDescriptor não é um campo desse tipo de mensagem.
  • O método chamado não é apropriado para o tipo do campo. Para cada tipo de campo em FieldDescriptor::TYPE_*, há apenas um método Get*(), um método Set*() e um método Add*() válido para esse tipo. Pode ser óbvio qual (exceto talvez para TYPE_BYTES, que são representados usando strings em C++).
  • Um método Get*() ou Set*() para campos singulares é chamado em um campo repetido.
  • GetRepeated*(), SetRepeated*() ou Add*() são chamados em um campo não repetido.
  • O objeto Message transmitido para qualquer método não é do tipo certo para esse objeto Reflection (ou seja, message.GetReflection() != reflete).

Você pode se perguntar por que não há representação abstrata de um campo de tipo arbitrário. Por exemplo, por que não há apenas um método "GetField()" que retorna "const Field&", em que "Field" é alguma classe com acessadores como "GetInt32Value()". O problema é que alguém precisa lidar com a alocação desses objetos de campo. Para as classes de mensagem geradas, ter que alocar espaço para um objeto adicional para envolver todos os campos pelo menos dobraria o consumo de memória da mensagem, provavelmente pior. Por outro lado, alocar os objetos sob demanda seria caro e propenso a vazamentos de memória. Em vez disso, criamos essa interface simples.

Participantes

const UnknownFieldSet &
GetUnknownFields(const Message & message) const
Consiga o UnknownFieldSet da mensagem. mais...
UnknownFieldSet *
MutableUnknownFields(Message * message) const
Receba um ponteiro mutável para o UnknownFieldSet para a mensagem. mais...
size_t
SpaceUsedLong(const Message & message) const
Estime a quantidade de memória usada pelo objeto de mensagem.
int
SpaceUsed(const Message & message) const
bool
HasField(const Message & message, const FieldDescriptor * field) const
Verifique se o campo não repetido está definido.
int
FieldSize(const Message & message, const FieldDescriptor * field) const
Encontre o número de elementos de um campo repetido.
void
ClearField(Message * message, const FieldDescriptor * field) const
Limpe o valor de um campo para que HasField() retorne como falso ou FieldSize() retorne zero.
bool
HasOneof(const Message & message, const OneofDescriptor * oneof_descriptor) const
Verifique se oneof está definido. mais…
void
ClearOneof(Message * message, const OneofDescriptor * oneof_descriptor) const
const FieldDescriptor *
GetOneofFieldDescriptor(const Message & message, const OneofDescriptor * oneof_descriptor) const
Retorna o descritor do campo se oneof estiver definido. Caso contrário, retorna nulo.
void
RemoveLast(Message * message, const FieldDescriptor * field) const
Remove o último elemento de um campo repetido. mais…
PROTOBUF_FUTURE_MUST_USE_RESULT Message *
ReleaseLast(Message * message, const FieldDescriptor * field) const
Remove o último elemento de um campo de mensagem repetido e retorna o ponteiro para o autor da chamada. mais…
void
Swap(Message * message1, Message * message2) const
Trocar o conteúdo completo de duas mensagens.
void
SwapFields(Message * message1, Message * message2, const std::vector< const FieldDescriptor * > & fields) const
Trocar os campos listados no vetor de campos de duas mensagens.
void
SwapElements(Message * message, const FieldDescriptor * field, int index1, int index2) const
Trocar dois elementos de um campo repetido.
void
ListFields(const Message & message, std::vector< const FieldDescriptor * > * output) const
Lista todos os campos da mensagem definidos no momento, exceto campos desconhecidos, mas incluindo a extensão conhecida pelo analisador (por exemplo, more...).
const RepeatedPtrField< Message > &
GetRepeatedPtrFieldInternal(const Message & message, const FieldDescriptor * field) const
RepeatedPtrField< Message > *
MutableRepeatedPtrFieldInternal(Message * message, const FieldDescriptor * field) const

Getters de campo Singular

Eles recebem o valor de um campo não repetido. Eles retornam o valor padrão para os campos que não foram definidos.
int32
GetInt32(const Message & message, const FieldDescriptor * field) const
int64
GetInt64(const Message & message, const FieldDescriptor * field) const
uint32
GetUInt32(const Message & message, const FieldDescriptor * field) const
uint64
GetUInt64(const Message & message, const FieldDescriptor * field) const
float
GetFloat(const Message & message, const FieldDescriptor * field) const
double
GetDouble(const Message & message, const FieldDescriptor * field) const
bool
GetBool(const Message & message, const FieldDescriptor * field) const
std::string
GetString(const Message & message, const FieldDescriptor * field) const
const EnumValueDescriptor *
GetEnum(const Message & message, const FieldDescriptor * field) const
int
GetEnumValue(const Message & message, const FieldDescriptor * field) const
GetEnumValue() retorna o valor de um campo de enumeração como um número inteiro, em vez de um EnumValueDescriptor*. mais...
const Message &
GetMessage(const Message & message, const FieldDescriptor * field, MessageFactory * factory = nullptr) const
Consulte MutableMessage() para ver o significado do parâmetro "factory".
const std::string &
GetStringReference(const Message & message, const FieldDescriptor * field, std::string * scratch) const
Receba um valor de string sem copiar, se possível. mais…

Mutadores de campo singular

Elas modificam o valor de um campo não repetido.
void
SetInt32(Message * message, const FieldDescriptor * field, int32 value) const
void
SetInt64(Message * message, const FieldDescriptor * field, int64 value) const
void
SetUInt32(Message * message, const FieldDescriptor * field, uint32 value) const
void
SetUInt64(Message * message, const FieldDescriptor * field, uint64 value) const
void
SetFloat(Message * message, const FieldDescriptor * field, float value) const
void
SetDouble(Message * message, const FieldDescriptor * field, double value) const
void
SetBool(Message * message, const FieldDescriptor * field, bool value) const
void
SetString(Message * message, const FieldDescriptor * field, std::string value) const
void
SetEnum(Message * message, const FieldDescriptor * field, const EnumValueDescriptor * value) const
void
SetEnumValue(Message * message, const FieldDescriptor * field, int value) const
Defina o valor de um campo de enumeração com um número inteiro em vez de EnumValueDescriptor. mais...
Message *
MutableMessage(Message * message, const FieldDescriptor * field, MessageFactory * factory = nullptr) const
Receber um ponteiro mutável para um campo com um tipo de mensagem. mais…
void
SetAllocatedMessage(Message * message, Message * sub_message, const FieldDescriptor * field) const
Substitui a mensagem especificada por "field" pela sub_mensagem de objeto já alocada, transmitindo a propriedade para a mensagem. mais…
void
UnsafeArenaSetAllocatedMessage(Message * message, Message * sub_message, const FieldDescriptor * field) const
Semelhante a SetAllocatedMessage, mas omite todas as verificações internas de segurança e propriedade. mais...
PROTOBUF_FUTURE_MUST_USE_RESULT Message *
ReleaseMessage(Message * message, const FieldDescriptor * field, MessageFactory * factory = nullptr) const
Libera a mensagem especificada por "field" e retorna o ponteiro. ReleaseMessage() retornará o objeto da mensagem se ela existir. mais...
Message *
UnsafeArenaReleaseMessage(Message * message, const FieldDescriptor * field, MessageFactory * factory = nullptr) const
Semelhante a ReleaseMessage, mas omite todas as verificações internas de segurança e propriedade. mais...

Getters de campo repetido

Eles recebem o valor de um elemento de um campo repetido.
int32
GetRepeatedInt32(const Message & message, const FieldDescriptor * field, int index) const
int64
GetRepeatedInt64(const Message & message, const FieldDescriptor * field, int index) const
uint32
GetRepeatedUInt32(const Message & message, const FieldDescriptor * field, int index) const
uint64
GetRepeatedUInt64(const Message & message, const FieldDescriptor * field, int index) const
float
GetRepeatedFloat(const Message & message, const FieldDescriptor * field, int index) const
double
GetRepeatedDouble(const Message & message, const FieldDescriptor * field, int index) const
bool
GetRepeatedBool(const Message & message, const FieldDescriptor * field, int index) const
std::string
GetRepeatedString(const Message & message, const FieldDescriptor * field, int index) const
const EnumValueDescriptor *
GetRepeatedEnum(const Message & message, const FieldDescriptor * field, int index) const
int
GetRepeatedEnumValue(const Message & message, const FieldDescriptor * field, int index) const
GetRepeatedEnumValue() retorna o valor de um campo de enumeração como um número inteiro, em vez de um EnumValueDescriptor*. mais...
const Message &
GetRepeatedMessage(const Message & message, const FieldDescriptor * field, int index) const
const std::string &
GetRepeatedStringReference(const Message & message, const FieldDescriptor * field, int index, std::string * scratch) const
Consulte GetStringReference() acima.

Mutadores de campo repetidos

Elas modificam o valor de um elemento de um campo repetido.
void
SetRepeatedInt32(Message * message, const FieldDescriptor * field, int index, int32 value) const
void
SetRepeatedInt64(Message * message, const FieldDescriptor * field, int index, int64 value) const
void
SetRepeatedUInt32(Message * message, const FieldDescriptor * field, int index, uint32 value) const
void
SetRepeatedUInt64(Message * message, const FieldDescriptor * field, int index, uint64 value) const
void
SetRepeatedFloat(Message * message, const FieldDescriptor * field, int index, float value) const
void
SetRepeatedDouble(Message * message, const FieldDescriptor * field, int index, double value) const
void
SetRepeatedBool(Message * message, const FieldDescriptor * field, int index, bool value) const
void
SetRepeatedString(Message * message, const FieldDescriptor * field, int index, std::string value) const
void
SetRepeatedEnum(Message * message, const FieldDescriptor * field, int index, const EnumValueDescriptor * value) const
void
SetRepeatedEnumValue(Message * message, const FieldDescriptor * field, int index, int value) const
Defina o valor de um campo de enumeração com um número inteiro em vez de EnumValueDescriptor. mais...
Message *
MutableRepeatedMessage(Message * message, const FieldDescriptor * field, int index) const
Receba um ponteiro mutável para um elemento de um campo repetido com um tipo de mensagem.

Somos de campo repetidos

Eles adicionam um elemento a um campo repetido.
void
AddInt32(Message * message, const FieldDescriptor * field, int32 value) const
void
AddInt64(Message * message, const FieldDescriptor * field, int64 value) const
void
AddUInt32(Message * message, const FieldDescriptor * field, uint32 value) const
void
AddUInt64(Message * message, const FieldDescriptor * field, uint64 value) const
void
AddFloat(Message * message, const FieldDescriptor * field, float value) const
void
AddDouble(Message * message, const FieldDescriptor * field, double value) const
void
AddBool(Message * message, const FieldDescriptor * field, bool value) const
void
AddString(Message * message, const FieldDescriptor * field, std::string value) const
void
AddEnum(Message * message, const FieldDescriptor * field, const EnumValueDescriptor * value) const
void
AddEnumValue(Message * message, const FieldDescriptor * field, int value) const
Adicione um valor inteiro a um campo de enumeração repetido em vez de EnumValueDescriptor. mais...
Message *
AddMessage(Message * message, const FieldDescriptor * field, MessageFactory * factory = nullptr) const
Consulte MutableMessage() para ver comentários sobre o parâmetro "factory".
void
AddAllocatedMessage(Message * message, const FieldDescriptor * field, Message * new_entry) const
Anexa um objeto já alocado "new_input" ao campo repetido especificado por "field" transmitindo a propriedade para a mensagem.
template RepeatedFieldRef< T >
GetRepeatedFieldRef(const Message & message, const FieldDescriptor * field) const
Receba um objeto RepitaedFieldRef que pode ser usado para ler o campo repetido subjacente. mais…
template MutableRepeatedFieldRef< T >
GetMutableRepeatedFieldRef(Message * message, const FieldDescriptor * field) const
Semelhante a GetRepeatedFieldRef(), mas retorna um objeto que também pode ser usado para manipular o campo repetido subjacente.
template const RepeatedField< T > &
GetRepeatedField(const Message & msg, const FieldDescriptor * d) const
OBSOLETO. mais…
template RepeatedField< T > *
MutableRepeatedField(Message * msg, const FieldDescriptor * d) const
OBSOLETO. mais…
template const RepeatedPtrField< T > &
GetRepeatedPtrField(const Message & msg, const FieldDescriptor * d) const
OBSOLETO. mais…
template RepeatedPtrField< T > *
MutableRepeatedPtrField(Message * msg, const FieldDescriptor * d) const
OBSOLETO. mais…

Extensões

const FieldDescriptor *
FindKnownExtensionByName(const std::string & name) const
Tente encontrar uma extensão desse tipo de mensagem pelo nome do campo totalmente qualificado. mais…
const FieldDescriptor *
FindKnownExtensionByNumber(int number) const
Tente encontrar uma extensão desse tipo de mensagem por número de campo. mais…

Sinalizações de recursos

bool
SupportsUnknownEnumValues() const
Essa mensagem permite o armazenamento de valores inteiros arbitrários em campos de enumeração? Se |true|, GetEnumValue/SetEnumValue e as versões do campo repetido associadas recebem valores inteiros arbitrários, e o getEnum() getter legado cria dinamicamente um EnumValueDescriptor para qualquer valor inteiro sem um. mais...
MessageFactory *
GetMessageFactory() const
Retorna o MessageFactory associado a essa mensagem. mais...

const UnknownFieldSet &
    Reflection::GetUnknownFields(
        const Message & message) const

Consiga o UnknownFieldSet da mensagem.

Contém os campos que foram vistos quando a Message foi analisada, mas não foram reconhecidas de acordo com a definição da Message.


UnknownFieldSet *
    Reflection::MutableUnknownFields(
        Message * message) const

Receba um ponteiro mutável para o UnknownFieldSet para a mensagem.

Contém os campos que foram vistos quando a Message foi analisada, mas não foram reconhecidas de acordo com a definição da Message.


bool Reflection::HasOneof(
        const Message & message,
        const OneofDescriptor * oneof_descriptor) const

Verifique se oneof está definido.

Retornará verdadeiro se algum campo em um deles estiver definido. Caso contrário, será falso.


void Reflection::RemoveLast(
        Message * message,
        const FieldDescriptor * field) const

Remove o último elemento de um campo repetido.

Não fornecemos uma maneira de remover qualquer elemento além do último, porque ele convida o uso ineficiente, como loops de filtragem O(n^2) que deveriam ter sido O(n). Se você quiser remover um elemento diferente do último, a melhor maneira de fazer isso é reorganizar os elementos (usando Swap()). Assim, o elemento que você quer remover estará no final e, em seguida, chamar RemoveLast().


PROTOBUF_FUTURE_MUST_USE_RESULT Message *
    Reflection::ReleaseLast(
        Message * message,
        const FieldDescriptor * field) const

Remove o último elemento de um campo de mensagem repetido e retorna o ponteiro para o autor da chamada.

O autor da chamada se torna o proprietário do ponteiro retornado.


void Reflection::ListFields(
        const Message & message,
        std::vector< const FieldDescriptor * > * output) const

Lista todos os campos da mensagem definidos no momento, exceto campos desconhecidos, mas incluindo a extensão conhecida pelo analisador (por exemplo,

compilado em). Os campos simples só serão listados se HasField(field) retornar um valor "true" e os campos repetidos só serão listados se FieldSize(field) retornar um valor diferente de zero. Os campos (campos normais e de extensão) serão listados por número de campo. Use Reflection::GetUnknownFields() ou message.Unknown_fields() para ter acesso também a campos/extensões desconhecidas para o analisador.


int Reflection::GetEnumValue(
        const Message & message,
        const FieldDescriptor * field) const

GetEnumValue() retorna o valor de um campo de enumeração como um número inteiro, em vez de um EnumValueDescriptor*.

Se o valor inteiro não corresponder a um descritor de valor conhecido, um descritor de valor novo vai ser criado. Esse valor só estará presente quando a nova semântica de valor de enumeração desconhecida estiver ativada para uma mensagem.


const std::string &
    Reflection::GetStringReference(
        const Message & message,
        const FieldDescriptor * field,
        std::string * scratch) const

Receba um valor de string sem copiar, se possível.

GetString() necessariamente retorna uma cópia da string. Isso pode ser ineficiente quando o std::string já está armazenado em um objeto std::string na mensagem subjacente. GetStringReference(), neste caso, retornará uma referência ao std::string subjacente. Caso contrário, a string será copiada para *scratch e retornada.

Observação: é perfeitamente razoável e útil escrever um código como este:

str = reflection->GetStringReference(message, field, &str);

Essa linha garante que seja feita apenas uma cópia da string, independentemente da representação subjacente do campo. Ao inicializar uma string recém-construída, no entanto, é igualmente rápido e mais legível usar códigos como:

std::string str = reflection->GetString(message, field);

void Reflection::SetEnumValue(
        Message * message,
        const FieldDescriptor * field,
        int value) const

Defina o valor de um campo de enumeração com um número inteiro em vez de EnumValueDescriptor.

Para proto3, isso é apenas configurar o campo de enumeração para o valor especificado, para proto2 é mais complicado. Se o valor for um valor de enumeração conhecido, o campo será definido como de costume. Se o valor for desconhecido, ele será adicionado ao conjunto de campos desconhecido. Isso corresponde ao comportamento da análise de valores de enumeração desconhecidos. Se várias chamadas com valores desconhecidos acontecerem, todas serão adicionadas ao campo desconhecido definido na ordem das chamadas.


Message * Reflection::MutableMessage(
        Message * message,
        const FieldDescriptor * field,
        MessageFactory * factory = nullptr) const

Receber um ponteiro mutável para um campo com um tipo de mensagem.

Se uma MessageFactory for fornecida, ela será usada para construir instâncias da submensagem. Caso contrário, a fábrica padrão será usada. Se o campo for uma extensão que não está no mesmo pool que o descritor da mensagem contida (por exemplo, está em um pool de sobreposição), será necessário fornecer uma MessageFactory. Se você não sabe o que isso significa, provavelmente não precisa se preocupar com isso (não forneça um MessageFactory). AVISO: se o FieldDescriptor for uma extensão compilada, fábrica->GetPrototype(field->message_type()) PRECISA retornar uma instância da classe compilada para esse tipo, e não DynamicMessage.


void Reflection::SetAllocatedMessage(
        Message * message,
        Message * sub_message,
        const FieldDescriptor * field) const

Substitui a mensagem especificada por "field" pela sub_mensagem de objeto já alocada, transmitindo a propriedade para a mensagem.

Se o campo continha uma mensagem, ela será excluída. Se sub_message for nuloptr, o campo será apagado.


void Reflection::UnsafeArenaSetAllocatedMessage(
        Message * message,
        Message * sub_message,
        const FieldDescriptor * field) const

Semelhante a SetAllocatedMessage, mas omite todas as verificações internas de segurança e propriedade.

Esse método só deve ser usado quando os objetos estiverem na mesma arena ou pareados com uma chamada para UnsafeArenaReleaseMessage.


PROTOBUF_FUTURE_MUST_USE_RESULT Message *
    Reflection::ReleaseMessage(
        Message * message,
        const FieldDescriptor * field,
        MessageFactory * factory = nullptr) const

Libera a mensagem especificada por "field" e retorna o ponteiro. ReleaseMessage() retornará o objeto da mensagem se ela existir.

Caso contrário, ele pode ou não retornar nuloptr. De qualquer forma, se o valor de retorno for não nulo, o autor da chamada assumirá a propriedade do ponteiro. Se existir o campo (HasField() for verdadeiro), o ponteiro retornado vai ser o mesmo que o retornado por MutableMessage(). Essa função tem o mesmo efeito que ClearField().


Message * Reflection::UnsafeArenaReleaseMessage(
        Message * message,
        const FieldDescriptor * field,
        MessageFactory * factory = nullptr) const

Semelhante a ReleaseMessage, mas omite todas as verificações internas de segurança e propriedade.

Esse método só deve ser usado quando os objetos estiverem na mesma arena ou pareados com uma chamada para UnsafeArenaSetAllocatedMessage.


int Reflection::GetRepeatedEnumValue(
        const Message & message,
        const FieldDescriptor * field,
        int index) const

GetRepeatedEnumValue() retorna o valor de um campo de enumeração como um número inteiro, em vez de um EnumValueDescriptor*.

Se o valor inteiro não corresponder a um descritor de valor conhecido, um descritor de valor novo vai ser criado. Esse valor só estará presente quando a nova semântica de valor de enumeração desconhecida estiver ativada para uma mensagem.


void Reflection::SetRepeatedEnumValue(
        Message * message,
        const FieldDescriptor * field,
        int index,
        int value) const

Defina o valor de um campo de enumeração com um número inteiro em vez de EnumValueDescriptor.

Para proto3, isso é apenas configurar o campo de enumeração para o valor especificado, para proto2 é mais complicado. Se o valor for um valor de enumeração conhecido, o campo será definido como de costume. Se o valor for desconhecido, ele será adicionado ao conjunto de campos desconhecido. Isso corresponde ao comportamento da análise de valores de enumeração desconhecidos. Se várias chamadas com valores desconhecidos acontecerem, todas serão adicionadas ao campo desconhecido definido na ordem das chamadas.


void Reflection::AddEnumValue(
        Message * message,
        const FieldDescriptor * field,
        int value) const

Adicione um valor inteiro a um campo de enumeração repetido em vez de EnumValueDescriptor.

Para proto3, isso é apenas configurar o campo de enumeração para o valor especificado, para proto2 é mais complicado. Se o valor for um valor de enumeração conhecido, o campo será definido como de costume. Se o valor for desconhecido, ele será adicionado ao conjunto de campos desconhecido. Isso corresponde ao comportamento da análise de valores de enumeração desconhecidos. Se várias chamadas com valores desconhecidos acontecerem, todas serão adicionadas ao campo desconhecido definido na ordem das chamadas.


template RepeatedFieldRef< T >
    Reflection::GetRepeatedFieldRef(
        const Message & message,
        const FieldDescriptor * field) const

Receba um objeto RepitaedFieldRef que pode ser usado para ler o campo repetido subjacente.

O parâmetro de tipo T precisa ser definido de acordo com o tipo de cpp do campo. A tabela a seguir mostra o mapeamento do tipo de cpp para o T aceitável.

field->cpp_type()      T
CPPTYPE_INT32        int32
CPPTYPE_UINT32       uint32
CPPTYPE_INT64        int64
CPPTYPE_UINT64       uint64
CPPTYPE_DOUBLE       double
CPPTYPE_FLOAT        float
CPPTYPE_BOOL         bool
CPPTYPE_ENUM         generated enum type or int32
CPPTYPE_STRING       std::string
CPPTYPE_MESSAGE      generated message type or google::protobuf::Message

Um objetoRepeatedFieldRef pode ser copiado, e o objeto resultante apontará para o mesmo campo repetido na mesma mensagem. O objeto pode ser usado desde que a mensagem não seja destruída.

Para usar esse método, os usuários precisam incluir o arquivo de cabeçalho "reflection.h" (que define os modelos de classe RepitaedFieldRef).


template const RepeatedField< T > &
    Reflection::GetRepeatedField(
        const Message & msg,
        const FieldDescriptor * d) const

OBSOLETO.

Use GetRepeatedFieldRef().

para T = cabo e todos os tipos escalares protobuf, exceto enumerações.


template RepeatedField< T > *
    Reflection::MutableRepeatedField(
        Message * msg,
        const FieldDescriptor * d) const

OBSOLETO.

Use GetMutableRepeatedFieldRef().

para T = cabo e todos os tipos escalares protobuf, exceto enumerações.


template const RepeatedPtrField< T > &
    Reflection::GetRepeatedPtrField(
        const Message & msg,
        const FieldDescriptor * d) const

OBSOLETO.

Use GetRepeatedFieldRef().

para T = std::string, google::protobuf::internal::StringPieceField

google::protobuf::Message & descendants.

template RepeatedPtrField< T > *
    Reflection::MutableRepeatedPtrField(
        Message * msg,
        const FieldDescriptor * d) const

OBSOLETO.

Use GetMutableRepeatedFieldRef().

para T = std::string, google::protobuf::internal::StringPieceField

google::protobuf::Message & descendants.

const FieldDescriptor *
    Reflection::FindKnownExtensionByName(
        const std::string & name) const

Tente encontrar uma extensão desse tipo de mensagem pelo nome do campo totalmente qualificado.

Retorna nuloptr, caso nenhuma extensão seja conhecida por esse nome ou número.


const FieldDescriptor *
    Reflection::FindKnownExtensionByNumber(
        int number) const

Tente encontrar uma extensão desse tipo de mensagem por número de campo.

Retorna nuloptr, caso nenhuma extensão seja conhecida por esse nome ou número.


bool Reflection::SupportsUnknownEnumValues() const

Essa mensagem permite o armazenamento de valores inteiros arbitrários em campos de enumeração? Se |true|, GetEnumValue/SetEnumValue e as versões do campo repetido associadas recebem valores inteiros arbitrários, e o getEnum() getter legado cria dinamicamente um EnumValueDescriptor para qualquer valor inteiro sem um.

Se |falso|, a definição de um valor de enumeração desconhecido pelos setters baseados em número inteiro resulta em um comportamento indefinido (na prática, GOOGLE_DCHECK-fails).

O código genérico que usa a reflexão para processar mensagens com campos de enumeração precisa verificar essa sinalização antes de usar o setter baseado em número inteiro e fazer downgrade para um valor compatível. Caso contrário, use o UnknownFieldSet. Exemplo:

int new_value = GetValueFromApplicationLogic();
if (reflection->SupportsUnknownEnumValues()) {
  reflection->SetEnumValue(message, field, new_value);
} else {
  if (field_descriptor->enum_type()->
          FindValueByNumber(new_value) != nullptr) {
    reflection->SetEnumValue(message, field, new_value);
  } else if (emit_unknown_enum_values) {
    reflection->MutableUnknownFields(message)->AddVarint(
        field->number(), new_value);
  } else {
    // convert value to a compatible/default value.
    new_value = CompatibleDowngrade(new_value);
    reflection->SetEnumValue(message, field, new_value);
  }
}

MessageFactory * Reflection::GetMessageFactory() const

Retorna o MessageFactory associado a essa mensagem.

Isso é útil para determinar se uma mensagem é gerada ou não. Por exemplo:

if (message->GetReflection()->GetMessageFactory() ==
    google::protobuf::MessageFactory::generated_factory()) {
  // This is a generated message.
}

Ela também pode ser usada para criar mais mensagens desse tipo, embora Message::New() seja uma maneira mais fácil de fazer isso.

classe MessageFactory

#include <google/protobuf/message.h>
namespace google::protobuf

Interface abstrata de uma fábrica para objetos de mensagem.

Subclasses conhecidas:

Participantes

MessageFactory()
virtual
~MessageFactory()
virtual const Message *
GetPrototype(const Descriptor * type) = 0
Dado um Descriptor, recebe ou constrói a Mensagem padrão (prototipo) desse tipo. mais...
static MessageFactory *
generated_factory()
Recebe um MessageFactory que oferece suporte a todas as mensagens compiladas geradas. mais...
static void
InternalRegisterGeneratedFile(const google::protobuf::internal::DescriptorTable * table)
Somente para uso interno: registra um arquivo .proto no momento da inicialização estática para ser colocado em generate_factory. mais…
static void
InternalRegisterGeneratedMessage(const Descriptor * descriptor, const Message * prototype)
Somente para uso interno: registra um tipo de mensagem. mais…

virtual const Message * MessageFactory::GetPrototype(
        const Descriptor * type) = 0

Dado um Descriptor, recebe ou constrói a Mensagem padrão (prototipo) desse tipo.

Em seguida, você pode chamar o método New() dessa mensagem para criar uma mensagem mutável desse tipo.

Chamar esse método duas vezes com o mesmo Descriptor retorna o mesmo objeto. O objeto retornado permanece como propriedade da fábrica. Além disso, os objetos criados chamando o método New() do protótipo compartilham alguns dados com o protótipo, portanto, eles precisam ser destruídos antes que a MessageFactory seja destruída.

O descritor fornecido precisa sobreviver à mensagem retornada e, portanto, sobreviver à MessageFactory.

Algumas implementações não são compatíveis com todos os tipos. GetPrototype() retornará nuloptr se o descritor transmitido não for compatível.

Esse método pode ou não ser thread-safe, dependendo da implementação. Cada implementação precisa documentar o próprio nível de segurança da linha de execução.


static MessageFactory * MessageFactory::generated_factory()

Recebe um MessageFactory que oferece suporte a todas as mensagens compiladas geradas.

Em outras palavras, para qualquer tipo FooMessage compilado, a seguinte condição é verdadeira:

MessageFactory::generated_factory()->GetPrototype(
  FooMessage::descriptor()) == FooMessage::default_instance()

Essa fábrica é compatível com todos os tipos encontrados em DescriptorPool::Generated_pool(). Se houver um descritor de qualquer outro pool, GetPrototype() retornará nuloptr. Também é possível verificar se um descritor é de uma mensagem gerada, verificando se Descriptor->file()->pool() == DescriptorPool::Generated_pool().

Essa fábrica é 100% segura para linhas de execução. Chamar GetPrototype() não modifica dados compartilhados.

Esta fábrica é um Singleton. O autor da chamada não pode excluir o objeto.


static void MessageFactory::InternalRegisterGeneratedFile(
        const google::protobuf::internal::DescriptorTable * table)

Somente para uso interno: registra um arquivo .proto no momento da inicialização estática para ser colocado em generate_factory.

Na primeira vez que GetPrototype() é chamado com um descritor desse arquivo, "register_messages|" será chamado, com o nome do arquivo como parâmetro. Ele precisa chamar InternalRegisterGeneratedMessage() (abaixo) para registrar cada tipo de mensagem no arquivo. Esse mecanismo estranho é necessário porque os descritores são criados lentamente. Portanto, não podemos registrar tipos pelo descritor até sabermos que ele existe. |filename| precisa ser uma string permanente.


static void MessageFactory::InternalRegisterGeneratedMessage(
        const Descriptor * descriptor,
        const Message * prototype)

Somente para uso interno: registra um tipo de mensagem.

Chamado apenas pelas funções que estão registradas com InternalRegisterGeneratedFile() acima.