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_lite.h

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

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

Define MessageLite, a interface abstrata implementada por todos os objetos de mensagem de protocolo (lite e não Lite).

Turmas neste arquivo

Interface para mensagens de protocolo de peso leve.

Participantes do arquivo

Essas definições não fazem parte de nenhuma classe.
void
ShutdownProtobufLibrary()
Encerre toda a biblioteca de buffers de protocolo, excluindo todos os objetos de duração estática alocados pela biblioteca ou por arquivos .pb.cc gerados. mais…

void protobuf::ShutdownProtobufLibrary()

Encerre toda a biblioteca de buffers de protocolo, excluindo todos os objetos de duração estática alocados pela biblioteca ou por arquivos .pb.cc gerados.

Existem dois motivos para chamá-lo:

  • Use uma definição drástica de "vazamento de memória" em que você espera que cada malloc() tenha um free() correspondente, mesmo para objetos que estejam até a saída do programa.
  • Você está criando uma biblioteca carregada dinamicamente que precisa ser limpa depois de descarregada.

É seguro chamar isso várias vezes. No entanto, não é seguro usar nenhuma outra parte da biblioteca de buffers de protocolo depois que ShutdownProtobufLibrary() é chamado. Além disso, essa chamada não é thread-safe, e o usuário precisa sincronizar várias chamadas.

classe MessageLite

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

Interface para mensagens de protocolo de peso leve.

Essa interface é implementada por todos os objetos de mensagem de protocolo. As mensagens que não são do Lite também implementam a interface Message, que é uma subclasse de MessageLite. Use MessageLite quando você só precisar do subconjunto de recursos compatíveis, ou seja, de nada que use descritores ou reflexão. Você pode instruir o compilador de protocolos a gerar classes que implementem apenas MessageLite, não a interface Message completa, adicionando a seguinte linha ao arquivo .proto:

option optimize_for = LITE_RUNTIME;

Isso é particularmente útil em sistemas com recursos restritos, em que a biblioteca de tempo de execução de buffers completos do protocolo é muito grande.

Em sistemas não restritos (por exemplo, servidores) é necessário vincular a muitas definições de protocolo para reduzir o consumo total de código. Basta usar optimize_for = CODE_SIZE. Isso diminuirá o código gerado e ainda oferecerá suporte aos mesmos recursos (à custa de velocidade). optimize_for = LITE_RUNTIME é melhor quando você tem apenas um pequeno número de tipos de mensagens vinculados ao seu binário. Nesse caso, o tamanho do próprio buffer de protocolo é o maior problema.

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

Subclasses conhecidas:

Participantes

enum
ParseFlags
protected internal::InternalMetadata
_internal_metadata_
constexpr
MessageLite()
virtual
~MessageLite()
template bool
ParseFrom(const T & input)
virtual uint8 *
_InternalSerialize(uint8 * ptr, io::EpsCopyOutputStream * stream) const = 0
Caminho rápido quando as condições são atendidas (por exemplo, mais…
bool
IsInitializedWithErrors() const
Idêntico a IsInitialized(), exceto por registrar uma mensagem de erro.
protected template static T *
CreateMaybeMessage(Arena * arena)
protected explicit
MessageLite(Arena * arena)
protected Arena *
GetOwningArena() const
Retorna a arena, se houver, que é a proprietária direta da mensagem e da memória interna dela. Arena::Own é diferente porque a arena não é a proprietária direta da memória interna. mais...
protected Arena *
GetArenaForAllocation() const
Retorna a arena, usada para alocar objetos internos(por exemplo, mensagens filhas etc.) ou proprietários de objetos de entrada (por exemplo, definidos como alocados).

Operações básicas

virtual std::string
GetTypeName() const = 0
Receba o nome desse tipo de mensagem, por exemplo, "foo.bar.BazProto".
virtual MessageLite *
New() const = 0
Crie uma nova instância do mesmo tipo. mais…
virtual MessageLite *
New(Arena * arena) const
Crie uma nova instância na arena. mais…
Arena *
GetArena() const
O mesmo que GetOwningArena.
void *
GetMaybeArenaPointer() const
Receba um ponteiro que seja igual ou não à arena desta mensagem. mais…
virtual void
Clear() = 0
Limpe todos os campos da mensagem e os defina para os valores padrão. mais…
virtual bool
IsInitialized() const = 0
Verifique rapidamente se todos os campos obrigatórios têm valores definidos.
virtual std::string
InitializationErrorString() const
Isso não é implementado para mensagens do Lite, apenas retorna "(não é possível determinar campos ausentes para mensagem do Lite)". mais…
virtual void
CheckTypeAndMergeFrom(const MessageLite & other) = 0
Se |other| for exatamente a mesma classe, isso o chama MergeFrom(). mais...
std::string
DebugString() const
Esses métodos retornam um resumo legível da mensagem. mais…
std::string
ShortDebugString() const
std::string
Utf8DebugString() const
MessageLite::DebugString já é segura para Utf8. mais...

Análise

Métodos para análise no formato de buffer do protocolo.

A maioria deles são apenas wrappers simples em torno de MergeFromCodedStream(). Clear() será chamado antes de mesclar a entrada.

PROTOBUF_ATTRIBUTE_REINITIALIZES bool
ParseFromCodedStream(io::CodedInputStream * input)
Preencher a mensagem com um buffer de protocolo analisado a partir do stream de entrada especificado. mais…
PROTOBUF_ATTRIBUTE_REINITIALIZES bool
ParsePartialFromCodedStream(io::CodedInputStream * input)
Semelhante a ParseFromCodedStream(), mas aceita mensagens que não tenham campos obrigatórios.
PROTOBUF_ATTRIBUTE_REINITIALIZES bool
ParseFromZeroCopyStream(io::ZeroCopyInputStream * input)
Lê um buffer de protocolo do stream de entrada especificado de zero cópia. mais…
PROTOBUF_ATTRIBUTE_REINITIALIZES bool
ParsePartialFromZeroCopyStream(io::ZeroCopyInputStream * input)
Semelhante a ParseFromZeroCopyStream(), mas aceita mensagens que não tenham campos obrigatórios.
PROTOBUF_ATTRIBUTE_REINITIALIZES bool
ParseFromFileDescriptor(int file_descriptor)
Analisa um buffer de protocolo de um descritor de arquivo. mais…
PROTOBUF_ATTRIBUTE_REINITIALIZES bool
ParsePartialFromFileDescriptor(int file_descriptor)
Semelhante a ParseFromFileDescriptor(), mas aceita mensagens que não tenham campos obrigatórios.
PROTOBUF_ATTRIBUTE_REINITIALIZES bool
ParseFromIstream(std::istream * input)
Analisar um buffer de protocolo de um istream C++. mais…
PROTOBUF_ATTRIBUTE_REINITIALIZES bool
ParsePartialFromIstream(std::istream * input)
Semelhante a ParseFromIstream(), mas aceita mensagens que não têm campos obrigatórios.
bool
MergePartialFromBoundedZeroCopyStream(io::ZeroCopyInputStream * input, int size)
Lê um buffer de protocolo do determinado stream de entrada sem cópia, esperando que a mensagem tenha exatamente bytes de tamanho. mais…
bool
MergeFromBoundedZeroCopyStream(io::ZeroCopyInputStream * input, int size)
Semelhante a ParseFromBoundedZeroCopyStream(), mas aceita mensagens que não tenham campos obrigatórios.
PROTOBUF_ATTRIBUTE_REINITIALIZES bool
ParseFromBoundedZeroCopyStream(io::ZeroCopyInputStream * input, int size)
PROTOBUF_ATTRIBUTE_REINITIALIZES bool
ParsePartialFromBoundedZeroCopyStream(io::ZeroCopyInputStream * input, int size)
Semelhante a ParseFromBoundedZeroCopyStream(), mas aceita mensagens que não tenham campos obrigatórios.
PROTOBUF_ATTRIBUTE_REINITIALIZES bool
ParseFromString(ConstStringParam data)
Analisa um buffer de protocolo contido em uma string. mais…
PROTOBUF_ATTRIBUTE_REINITIALIZES bool
ParsePartialFromString(ConstStringParam data)
Semelhante a ParseFromString(), mas aceita mensagens que não tenham campos obrigatórios.
PROTOBUF_ATTRIBUTE_REINITIALIZES bool
ParseFromArray(const void * data, int size)
Analisa um buffer de protocolo contido em uma matriz de bytes.
PROTOBUF_ATTRIBUTE_REINITIALIZES bool
ParsePartialFromArray(const void * data, int size)
Semelhante a ParseFromArray(), mas aceita mensagens que não tenham campos obrigatórios.
bool
MergeFromCodedStream(io::CodedInputStream * input)
Lê um buffer de protocolo do stream e o mescla nesta Message. mais...
bool
MergePartialFromCodedStream(io::CodedInputStream * input)
Semelhante a MergeFromCodedStream(), mas bem-sucedido mesmo se os campos obrigatórios estiverem ausentes na entrada. mais...
bool
MergeFromString(ConstStringParam data)
Mescla um buffer de protocolo contido em uma string.

serialização

Métodos para serializar no formato de buffer de protocolo.

A maioria deles são apenas wrappers simples em torno de ByteSize() e SerializeWithCachedSizes().

bool
SerializeToCodedStream(io::CodedOutputStream * output) const
Grave um buffer de protocolo dessa mensagem na saída fornecida. mais…
bool
SerializePartialToCodedStream(io::CodedOutputStream * output) const
Semelhante a SerializeToCodedStream(), mas permite campos obrigatórios ausentes.
bool
SerializeToZeroCopyStream(io::ZeroCopyOutputStream * output) const
Grave a mensagem no stream de saída de cópia zero. mais…
bool
SerializePartialToZeroCopyStream(io::ZeroCopyOutputStream * output) const
Semelhante a SerializeToZeroCopyStream(), mas permite campos obrigatórios ausentes.
bool
SerializeToString(std::string * output) const
Serializa a mensagem e a armazena na string fornecida. mais…
bool
SerializePartialToString(std::string * output) const
Semelhante a SerializeToString(), mas permite campos ausentes.
bool
SerializeToArray(void * data, int size) const
Serializa a mensagem e a armazena na matriz de bytes especificada. mais…
bool
SerializePartialToArray(void * data, int size) const
Semelhante a SerializeToArray(), mas permite campos obrigatórios ausentes.
std::string
SerializeAsString() const
Crie uma string que codifique a mensagem. mais…
std::string
SerializePartialAsString() const
Semelhante a SerializeAsString(), mas permite campos ausentes.
bool
SerializeToFileDescriptor(int file_descriptor) const
Serializa a mensagem e a grava no descritor de arquivo fornecido. mais…
bool
SerializePartialToFileDescriptor(int file_descriptor) const
Semelhante a SerializeToFileDescriptor(), mas permite campos obrigatórios ausentes.
bool
SerializeToOstream(std::ostream * output) const
Serializa a mensagem e a grava no ostream C++ fornecido. mais…
bool
SerializePartialToOstream(std::ostream * output) const
Semelhante a SerializeToOstream(), mas permite campos obrigatórios ausentes.
bool
AppendToString(std::string * output) const
Semelhante a SerializeToString(), mas anexa aos dados ao conteúdo existente da string. mais...
bool
AppendPartialToString(std::string * output) const
Semelhante a AttachToString(), mas permite campos obrigatórios ausentes.
virtual size_t
ByteSizeLong() const = 0
Calcula o tamanho serializado da mensagem. mais…
int
ByteSize() const
API ByteSize() legada.
void
SerializeWithCachedSizes(io::CodedOutputStream * output) const
Serializa a mensagem sem recalcular o tamanho. mais…
uint8 *
SerializeWithCachedSizesToArray(uint8 * target) const
Como SerializeWithCachedSizes, mas grava diretamente em *destino, retornando um ponteiro para o byte imediatamente após o último byte gravado. mais…
virtual int
GetCachedSize() const = 0
Retorna o resultado da última chamada para ByteSize(). mais...
virtual const char *
_InternalParse(const char * , internal::ParseContext * )

enum MessageLite::ParseFlags {
  kMerge = = 0,
  kParse = = 1,
  kMergePartial = = 2,
  kParsePartial = = 3,
  kMergeWithAliasing = = 4,
  kParseWithAliasing = = 5,
  kMergePartialWithAliasing = = 6,
  kParsePartialWithAliasing = = 7
}

Mesclar
kParse
kMergePartial
kParsePartial
kMergeWithAlias
kParseWithAliasing
kMergePartialWithAliasing
kParsePartialWithAliasing

virtual uint8 * MessageLite::_InternalSerialize(
        uint8 * ptr,
        io::EpsCopyOutputStream * stream) const = 0

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

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


protected Arena * MessageLite::GetOwningArena() const

Retorna a arena, se houver, que é a proprietária direta da mensagem e da memória interna dela. Arena::Own é diferente porque a arena não é a proprietária direta da memória interna.

Esse método é usado na implementação do proto para troca, migração e configuração alocada, para decidir se a propriedade dessa mensagem ou da memória interna dela pode ser alterada.


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

Crie uma nova instância do mesmo tipo.

A propriedade é transmitida ao autor da chamada.


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

Crie uma nova instância na arena.

A propriedade será transmitida ao autor da chamada se a arena for NULL. Implementação padrão para compatibilidade com versões anteriores.


void * MessageLite::GetMaybeArenaPointer() const

Receba um ponteiro que seja igual ou não à arena desta mensagem.

Se o valor retornado por esse método for igual a algum ponteiro de arena, a mensagem estará nela. No entanto, se essa mensagem estiver em uma arena, esse método poderá ou não retornar o ponteiro dessa arena. Como compensação, esse método pode ser mais eficiente do que GetArena(). A intenção é permitir representações subjacentes que usam, por exemplo, ponteiros de tag, às vezes, para armazenar o ponteiro da arena diretamente e, às vezes, de forma mais indireta, além de permitir uma comparação de caminho rápido com o ponteiro da área quando for fácil de conseguir.


virtual void MessageLite::Clear() = 0

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 std::string MessageLite::InitializationErrorString() const

Isso não é implementado para mensagens do Lite, apenas retorna "(não é possível determinar campos ausentes para mensagem do Lite)".

No entanto, ele é implementado para mensagens completas. Consulte message.h.


virtual void MessageLite::CheckTypeAndMergeFrom(
        const MessageLite & other) = 0

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

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


std::string MessageLite::DebugString() const

Esses métodos retornam um resumo legível da mensagem.

Como a interface MessageLite não é compatível com reflexão, há poucas informações que esses métodos possam fornecer. Elas são ocultadas por métodos de mesmo nome na interface Message que fornecem muito mais informações. Os métodos usados aqui são principalmente para facilitar a reutilização de códigos em uma lógica que precisa interoperar com protótipos completos e leves.

O formato da string retornada está sujeito a mudanças. Portanto, não presuma que ela vai permanecer estável ao longo do tempo.


std::string MessageLite::Utf8DebugString() const

MessageLite::DebugString já é segura para Utf8.

Isso é feito para aumentar a compatibilidade com Message.


PROTOBUF_ATTRIBUTE_REINITIALIZES bool
    MessageLite::ParseFromCodedStream(
        io::CodedInputStream * input)

Preencher a mensagem com um buffer de protocolo analisado a partir do stream de entrada especificado.

Retorna "false" em um erro de leitura ou se a entrada está no formato errado. Uma devolução bem-sucedida não indica que toda a entrada é consumida. É necessário chamar ConsumedFullMessage() para verificar isso, se aplicável.


PROTOBUF_ATTRIBUTE_REINITIALIZES bool
    MessageLite::ParseFromZeroCopyStream(
        io::ZeroCopyInputStream * input)

Lê um buffer de protocolo do stream de entrada especificado de zero cópia.

Se for bem-sucedida, toda a entrada será consumida.


PROTOBUF_ATTRIBUTE_REINITIALIZES bool
    MessageLite::ParseFromFileDescriptor(
        int file_descriptor)

Analisa um buffer de protocolo de um descritor de arquivo.

Se for bem-sucedida, toda a entrada será consumida.


PROTOBUF_ATTRIBUTE_REINITIALIZES bool
    MessageLite::ParseFromIstream(
        std::istream * input)

Analisar um buffer de protocolo de um istream C++.

Se for bem-sucedida, toda a entrada será consumida.


bool MessageLite::MergePartialFromBoundedZeroCopyStream(
        io::ZeroCopyInputStream * input,
        int size)

Lê um buffer de protocolo do determinado stream de entrada sem cópia, esperando que a mensagem tenha exatamente bytes de tamanho.

Se for bem-sucedido, exatamente esta quantidade de bytes terá sido consumida a partir da entrada.


PROTOBUF_ATTRIBUTE_REINITIALIZES bool
    MessageLite::ParseFromString(
        ConstStringParam data)

Analisa um buffer de protocolo contido em uma string.

Retorna verdadeiro em caso de sucesso. Essa função usa uma string no formato de fio binário (não legível) correspondente à saída de codificação por MessageLite::SerializeToString(). Se você quiser converter uma string legível em um objeto de buffer de protocolo, consulte google::protobuf::TextFormat::ParseFromString().


bool MessageLite::MergeFromCodedStream(
        io::CodedInputStream * input)

Lê um buffer de protocolo do stream e o mescla nesta Message.

Os campos singulares lidos do que já está em Message e os campos repetidos são anexados aos que já estão presentes.

É responsabilidade do autor da chamada chamar input->LastTagWas() (para grupos) ou input->ConsumedFullMessage() (para não grupos) depois disso para verificar se o final da mensagem foi delimitado corretamente.

ParseFromCodedStream() é implementado como Clear() seguido por MergeFromCodedStream().


bool MessageLite::MergePartialFromCodedStream(
        io::CodedInputStream * input)

Semelhante a MergeFromCodedStream(), mas bem-sucedido mesmo se os campos obrigatórios estiverem ausentes na entrada.

MergeFromCodedStream() é implementado como MergePartialFromCodedStream() seguido por IsInitialized().


bool MessageLite::SerializeToCodedStream(
        io::CodedOutputStream * output) const

Grave um buffer de protocolo dessa mensagem na saída fornecida.

Retorna falso em um erro de gravação. Se a mensagem não tiver os campos obrigatórios, talvez o GOOGLE_CHECK falhe.


bool MessageLite::SerializeToZeroCopyStream(
        io::ZeroCopyOutputStream * output) const

Grave a mensagem no stream de saída de cópia zero.

Todos os campos obrigatórios precisam ser definidos.


bool MessageLite::SerializeToString(
        std::string * output) const

Serializa a mensagem e a armazena na string fornecida.

Todos os campos obrigatórios precisam ser definidos.


bool MessageLite::SerializeToArray(
        void * data,
        int size) const

Serializa a mensagem e a armazena na matriz de bytes especificada.

Todos os campos obrigatórios precisam ser definidos.


std::string MessageLite::SerializeAsString() const

Crie uma string que codifique a mensagem.

É equivalente a chamar SerializeToString() em uma string e usá-la. Retorna a string vazia se SerializeToString() retornar um erro. Observação: se você pretende gerar muitas dessas strings, reduza a fragmentação de heap reutilizando o mesmo objeto de string com chamadas para SerializeToString().


bool MessageLite::SerializeToFileDescriptor(
        int file_descriptor) const

Serializa a mensagem e a grava no descritor de arquivo fornecido.

Todos os campos obrigatórios precisam ser definidos.


bool MessageLite::SerializeToOstream(
        std::ostream * output) const

Serializa a mensagem e a grava no ostream C++ fornecido.

Todos os campos obrigatórios precisam ser definidos.


bool MessageLite::AppendToString(
        std::string * output) const

Semelhante a SerializeToString(), mas anexa aos dados ao conteúdo existente da string.

Todos os campos obrigatórios precisam ser definidos.


virtual size_t MessageLite::ByteSizeLong() const = 0

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.


void MessageLite::SerializeWithCachedSizes(
        io::CodedOutputStream * output) const

Serializa a mensagem sem recalcular o tamanho.

A mensagem não pode ter sido alterada desde a última chamada para ByteSize(), e o valor retornado por ByteSize não pode ser negativo. Caso contrário, os resultados são indefinidos.


uint8 * MessageLite::SerializeWithCachedSizesToArray(
        uint8 * target) const

Como SerializeWithCachedSizes, mas grava diretamente em *destino, retornando um ponteiro para o byte imediatamente após o último byte gravado.

"target" precisa apontar para uma matriz de bytes de pelo menos ByteSize(). O uso de serialização determinística, por exemplo, mapas em ordem classificada, é determinado por CodedOutputStream::IsDefaultSerializationDeterministic().


virtual int MessageLite::GetCachedSize() const = 0

Retorna o resultado da última chamada para ByteSize().

O tamanho de uma mensagem incorporada é necessário para serializá-la (porque as mensagens incorporadas são delimitadas por comprimento) e calcular o tamanho da mensagem externa. O armazenamento em cache do tamanho evita que isso seja feito várias vezes.

O ByteSize() não usa automaticamente o tamanho em cache quando disponível porque isso exigiria a validação toda vez que a mensagem fosse modificada, o que seria muito difícil e caro. Por exemplo, se uma submensagem profundamente aninhada for alterada, todos os tamanhos em cache dos pais precisarão ser invalidados, o que é muito trabalho para um método setter in-line.