#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
namespace google::protobuf::io
Esse arquivo contém implementações comuns das interfaces definidas em zero_copy_stream.h incluídas na biblioteca protobuf "lite".
Essas implementações abrangem E/S em matrizes e strings brutas, bem como adaptadores que facilitam a implementação de streams com base em streams tradicionais. É claro que muitos usuários vão querer criar suas próprias implementações dessas interfaces específicas para as abstrações específicas de E/S que preferem usar, mas elas devem abranger os casos mais comuns.
Turmas neste arquivo | |
---|---|
Um ZeroCopyInputStream apoiado por uma matriz de bytes na memória. | |
Um ZeroCopyOutputStream apoiado por uma matriz de bytes na memória. | |
Um ZeroCopyOutputStream que anexa bytes a uma string. | |
Uma interface de stream de entrada tradicional e genérica. | |
Um ZeroCopyInputStream que lê um COPYInputStream. | |
Interface de stream de saída tradicional genérica. | |
Um ZeroCopyOutputStream que grava em um COPYOutputStream. | |
Um ZeroCopyInputStream que envolve algum outro stream e o limita a uma contagem de bytes específica. |
Participantes do arquivoEssas definições não fazem parte de nenhuma classe. | |
---|---|
char * | mutable_string_data(std::string * s) Retorna um ponteiro para caracteres mutáveis subjacentes à string fornecida. mais… |
std::pair< char *, bool > | as_string_data(std::string * s) as_string_data(s) é equivalente a ({ char* p = mutable_string_data(s); make_pair(p, p != NULL); }) Às vezes é mais rápido: em alguns cenários p não pode ser NULL e o código pode evitar essa verificação. |
char * io::mutable_string_data(
std::string * s)
std::string * s)
Retorna um ponteiro para caracteres mutáveis subjacentes à string fornecida.
O valor de retorno será válido até a próxima vez em que a string for redimensionada. Confiamos no autor da chamada para tratar o valor de retorno como uma matriz de tamanho s->size().
classe ArrayInputStream: ZeroCopyInputStream público
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
namespace google::protobuf::io
Um ZeroCopyInputStream apoiado por uma matriz de bytes na memória.
Participantes | |
---|---|
| ArrayInputStream(const void * data, int size, int block_size = -1) Crie um InputStream que retorne os bytes apontados por "dados". mais… |
| ~ArrayInputStream() |
implementa ZeroCopyInputStream | |
virtual bool | Next(const void ** data, int * size) Recebe um bloco de dados do stream. mais… |
virtual void | BackUp(int count) |
virtual bool | Skip(int count) Ignora vários bytes. mais… |
virtual int64_t | ByteCount() const Retorna o número total de bytes lidos desde que o objeto foi criado. |
ArrayInputStream::ArrayInputStream(
const void * data,
int size,
int block_size = -1)
const void * data,
int size,
int block_size = -1)
Crie um InputStream que retorne os bytes apontados por "dados".
"data" continua sendo a propriedade do autor da chamada, mas precisa permanecer válido até que o stream seja destruído. Se um block_size for definido, as chamadas para Next() retornarão blocos de dados maiores que o tamanho especificado. Caso contrário, a primeira chamada para Next() retorna toda a matriz. O block_size é útil principalmente para testes. Na produção, é provável que não seja recomendado defini-lo.
virtual bool ArrayInputStream::Next(
const void ** data,
int * size)
const void ** data,
int * size)
Recebe um bloco de dados do stream.
Condições prévias:
- "size" e "data" não são NULL.
Pós-condições:
- Se o valor retornado for falso, não haverá mais dados para retornar ou ocorreu um erro. Todos os erros são permanentes.
- Caso contrário, "size" aponta para o número real de bytes lidos e "data" aponta para um ponteiro para um buffer que contém esses bytes.
- A propriedade desse buffer permanece com o stream e ele permanece válido somente até que algum outro método do stream seja chamado ou que o stream seja destruído.
- É permitido que o buffer retornado tenha tamanho zero, desde que chamar Next() várias vezes produz um buffer com tamanho diferente de zero.
virtual void ArrayInputStream::BackUp(
int count)
int count)
Faz backup de vários bytes, de modo que a próxima chamada para Next() retorna dados que já foram retornados pela última chamada para Next().
Isso é útil ao escrever procedimentos que apenas devem ler um certo ponto da entrada e retornar. Se Next() retornar um buffer que vai além do que você quer ler, use BackUp() para voltar ao ponto em que quer concluir.
Condições prévias:
- O último método chamado precisa ter sido Next().
- a contagem deve ser menor ou igual ao tamanho do último buffer retornado por Next().
Pós-condições:
virtual bool ArrayInputStream::Skip(
int count)
int count)
Ignora vários bytes.
Retorna falso se o final do stream for alcançado ou se ocorrer algum erro de entrada. No caso de fim do stream, ele é avançado para o final (de modo que ByteCount() retorna o tamanho total do stream).
classe ArrayOutputStream: público ZeroCopyOutputStream
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
namespace google::protobuf::io
Um ZeroCopyOutputStream apoiado por uma matriz de bytes na memória.
Participantes | |
---|---|
| ArrayOutputStream(void * data, int size, int block_size = -1) Crie um OutputStream que grave nos bytes apontados por "data". mais… |
| ~ArrayOutputStream() |
implementa ZeroCopyOutputStream | |
virtual bool | Next(void ** data, int * size) Recebe um buffer em que os dados podem ser gravados. mais… |
virtual void | BackUp(int count) |
virtual int64_t | ByteCount() const Retorna o número total de bytes gravados desde que o objeto foi criado. |
ArrayOutputStream::ArrayOutputStream(
void * data,
int size,
int block_size = -1)
void * data,
int size,
int block_size = -1)
Crie um OutputStream que grave nos bytes apontados por "data".
"data" continua sendo a propriedade do autor da chamada, mas precisa permanecer válido até que o stream seja destruído. Se um block_size for definido, as chamadas para Next() retornarão blocos de dados maiores que o tamanho especificado. Caso contrário, a primeira chamada para Next() retorna toda a matriz. O block_size é útil principalmente para testes. Na produção, é provável que não seja recomendado defini-lo.
virtual bool ArrayOutputStream::Next(
void ** data,
int * size)
void ** data,
int * size)
Recebe um buffer em que os dados podem ser gravados.
Todos os dados gravados nesse buffer serão gravados na saída (talvez instantaneamente, talvez mais tarde).
Condições prévias:
- "size" e "data" não são NULL.
Pós-condições:
- Se o valor retornado for “false”, significa que ocorreu um erro. Todos os erros são permanentes.
- Caso contrário, "tamanho" apontará para o número real de bytes no buffer e "dados" aponta para o buffer.
- A propriedade desse buffer permanece com o stream e ele permanece válido somente até que algum outro método do stream seja chamado ou que o stream seja destruído.
- Todos os dados armazenados pelo autor da chamada nesse buffer serão gravados na saída (a menos que BackUp() seja chamado).
- É permitido que o buffer retornado tenha tamanho zero, desde que chamar Next() várias vezes produz um buffer com tamanho diferente de zero.
virtual void ArrayOutputStream::BackUp(
int count)
int count)
Faz backup de vários bytes, de modo que o fim do último buffer retornado por Next() não seja gravado.
Isso é necessário quando você termina de gravar todos os dados que quer gravar, mas o último buffer foi maior do que o necessário. Não é recomendável escrever vários lixo após o término dos dados, então use BackUp() para fazer backup.
Condições prévias:
- O último método chamado precisa ter sido Next().
- a contagem deve ser menor ou igual ao tamanho do último buffer retornado por Next().
- O autor da chamada não pode ter escrito nada para os últimos bytes de "contagem" desse buffer.
Pós-condições:
- Os últimos bytes de "count" do último buffer retornados por Next() serão ignorados.
classe StringOutputStream: público ZeroCopyOutputStream
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
namespace google::protobuf::io
Um ZeroCopyOutputStream que anexa bytes a uma string.
Participantes | |
---|---|
explicit | StringOutputStream(std::string * target) Crie um StringOutputStream que anexe bytes à string fornecida. mais... |
| ~StringOutputStream() |
implementa ZeroCopyOutputStream | |
virtual bool | Next(void ** data, int * size) Recebe um buffer em que os dados podem ser gravados. mais… |
virtual void | BackUp(int count) |
virtual int64_t | ByteCount() const Retorna o número total de bytes gravados desde que o objeto foi criado. |
explicit StringOutputStream::StringOutputStream(
std::string * target)
std::string * target)
Crie um StringOutputStream que anexe bytes à string fornecida.
A string permanece como propriedade do autor da chamada, mas é modificada de maneira arbitrária e NÃO PODE ser acessada de nenhuma forma até o término do stream. Verifique se não há outro uso ou (mais seguro) destrua o stream antes de usar o conteúdo.
Dica: se você chamar target->reserve(n) antes de criar o stream, a primeira chamada para Next() retornará pelo menos n bytes de espaço de buffer.
virtual bool StringOutputStream::Next(
void ** data,
int * size)
void ** data,
int * size)
Recebe um buffer em que os dados podem ser gravados.
Todos os dados gravados nesse buffer serão gravados na saída (talvez instantaneamente, talvez mais tarde).
Condições prévias:
- "size" e "data" não são NULL.
Pós-condições:
- Se o valor retornado for “false”, significa que ocorreu um erro. Todos os erros são permanentes.
- Caso contrário, "tamanho" apontará para o número real de bytes no buffer e "dados" aponta para o buffer.
- A propriedade desse buffer permanece com o stream e ele permanece válido somente até que algum outro método do stream seja chamado ou que o stream seja destruído.
- Todos os dados armazenados pelo autor da chamada nesse buffer serão gravados na saída (a menos que BackUp() seja chamado).
- É permitido que o buffer retornado tenha tamanho zero, desde que chamar Next() várias vezes produz um buffer com tamanho diferente de zero.
virtual void StringOutputStream::BackUp(
int count)
int count)
Faz backup de vários bytes, de modo que o fim do último buffer retornado por Next() não seja gravado.
Isso é necessário quando você termina de gravar todos os dados que quer gravar, mas o último buffer foi maior do que o necessário. Não é recomendável escrever vários lixo após o término dos dados, então use BackUp() para fazer backup.
Condições prévias:
- O último método chamado precisa ter sido Next().
- a contagem deve ser menor ou igual ao tamanho do último buffer retornado por Next().
- O autor da chamada não pode ter escrito nada para os últimos bytes de "contagem" desse buffer.
Pós-condições:
- Os últimos bytes de "count" do último buffer retornados por Next() serão ignorados.
classe CopyInputStream
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
namespace google::protobuf::io
Uma interface de stream de entrada tradicional e genérica.
Muitos streams de entrada tradicionais (por exemplo, descritores de arquivos, streams do C Sdio e iostreams C++) expõem uma interface em que cada leitura envolve a cópia de bytes em um buffer. Se você quiser usar essa interface e criar uma ZeroCopyInputStream com base nela, basta implementar COPYInputStream e usar COPYInputStreamAdaptor.
As implementações de COPYInputStream precisam evitar o armazenamento em buffer, se possível. CopyInputStreamAdaptor faz o próprio buffer e lê dados em blocos grandes.
Participantes | |
---|---|
virtual | ~CopyingInputStream() |
virtual int | Read(void * buffer, int size) = 0 Lê até "size" bytes no buffer especificado. mais… |
virtual int | Skip(int count) Pula os próximos bytes de "contagem" de entrada. mais… |
virtual int CopyingInputStream::Read(
void * buffer,
int size) = 0
void * buffer,
int size) = 0
Lê até "size" bytes no buffer especificado.
Retorna o número de bytes lidos. Read() aguarda até que pelo menos um byte esteja disponível ou retorna zero se nenhum byte estiver disponível (EOF) ou -1 se ocorrer um erro de leitura permanente.
virtual int CopyingInputStream::Skip(
int count)
int count)
Pula os próximos bytes de "contagem" de entrada.
Retorna o número de bytes realmente ignorados. Ele sempre será exatamente igual a "count", a menos que o EOF tenha sido atingido ou um erro de leitura permanente tenha ocorrido.
A implementação padrão chama repetidamente Read() em um buffer de rascunho.
classe CopyInputStreamAdaptor: ZeroCopyInputStream pública
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
namespace google::protobuf::io
Um ZeroCopyInputStream que lê um COPYInputStream.
Isso é útil para implementar ZeroCopyInputStreams que leem de streams tradicionais. Essa classe não é uma cópia zero.
Se você quiser ler descritores de arquivo ou istreams C++, isso já estará implementado para você: use FileInputStream ou IstreamInputStream, respectivamente.
Participantes | |
---|---|
explicit | CopyingInputStreamAdaptor(CopyingInputStream * copying_stream, int block_size = -1) Cria um stream que lê a partir do COPYInputStream fornecido. mais... |
| ~CopyingInputStreamAdaptor() |
void | SetOwnsCopyingStream(bool value) Chame SetOwnsCOPYStream(true) para informar ao COPYInputStreamAdaptor que exclua o COPYInputStream subjacente quando ele for destruído. |
implementa ZeroCopyInputStream | |
virtual bool | Next(const void ** data, int * size) Recebe um bloco de dados do stream. mais… |
virtual void | BackUp(int count) |
virtual bool | Skip(int count) Ignora vários bytes. mais… |
virtual int64_t | ByteCount() const Retorna o número total de bytes lidos desde que o objeto foi criado. |
explicit CopyingInputStreamAdaptor::CopyingInputStreamAdaptor(
CopyingInputStream * copying_stream,
int block_size = -1)
CopyingInputStream * copying_stream,
int block_size = -1)
Cria um stream que lê a partir do COPYInputStream fornecido.
Se um block_size for fornecido, ele especificará o número de bytes que precisam ser lidos e retornados com cada chamada para Next(). Caso contrário, um padrão razoável será usado. O autor da chamada mantém a propriedade de copy_stream, a menos que SetOwnsCOPYStream(true) seja chamado.
virtual bool CopyingInputStreamAdaptor::Next(
const void ** data,
int * size)
const void ** data,
int * size)
Recebe um bloco de dados do stream.
Condições prévias:
- "size" e "data" não são NULL.
Pós-condições:
- Se o valor retornado for falso, não haverá mais dados para retornar ou ocorreu um erro. Todos os erros são permanentes.
- Caso contrário, "size" aponta para o número real de bytes lidos e "data" aponta para um ponteiro para um buffer que contém esses bytes.
- A propriedade desse buffer permanece com o stream e ele permanece válido somente até que algum outro método do stream seja chamado ou que o stream seja destruído.
- É permitido que o buffer retornado tenha tamanho zero, desde que chamar Next() várias vezes produz um buffer com tamanho diferente de zero.
virtual void CopyingInputStreamAdaptor::BackUp(
int count)
int count)
Faz backup de vários bytes, de modo que a próxima chamada para Next() retorna dados que já foram retornados pela última chamada para Next().
Isso é útil ao escrever procedimentos que apenas devem ler um certo ponto da entrada e retornar. Se Next() retornar um buffer que vai além do que você quer ler, use BackUp() para voltar ao ponto em que quer concluir.
Condições prévias:
- O último método chamado precisa ter sido Next().
- a contagem deve ser menor ou igual ao tamanho do último buffer retornado por Next().
Pós-condições:
virtual bool CopyingInputStreamAdaptor::Skip(
int count)
int count)
Ignora vários bytes.
Retorna falso se o final do stream for alcançado ou se ocorrer algum erro de entrada. No caso de fim do stream, ele é avançado para o final (de modo que ByteCount() retorna o tamanho total do stream).
classe CopyOutputStream
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
namespace google::protobuf::io
Interface de stream de saída tradicional genérica.
Muitos streams de saída tradicionais (por exemplo, descritores de arquivos, streams do stdio e iostreams C++) expõem uma interface em que cada gravação envolve a cópia de bytes de um buffer. Se você quiser usar essa interface e criar uma ZeroCopyOutputStream com base nela, basta implementar COPYOutputStream e usar COPYOutputStreamAdaptor.
As implementações de COPYOutputStream devem evitar o armazenamento em buffer, se possível. CopyOutputStreamAdaptor faz o próprio armazenamento em buffer e grava dados em blocos grandes.
Participantes | |
---|---|
virtual | ~CopyingOutputStream() |
virtual bool | Write(const void * buffer, int size) = 0 Grava bytes "size" do buffer especificado na saída. mais… |
virtual bool CopyingOutputStream::Write(
const void * buffer,
int size) = 0
const void * buffer,
int size) = 0
Grava bytes "size" do buffer especificado na saída.
Retornará "true" se for bem-sucedido. "False" em um erro de gravação.
classe CopyOutputStreamAdaptor: ZeroCopyOutputStream público
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
namespace google::protobuf::io
Um ZeroCopyOutputStream que grava em um COPYOutputStream.
Isso é útil para implementar ZeroCopyOutputStreams que gravam em streams tradicionais. Essa classe não é uma cópia zero.
Se você quiser gravar em descritores de arquivo ou ostreams de C++, isso já estará implementado para você: use FileOutputStream ou OstreamOutputStream, respectivamente.
Subclasses conhecidas:
Participantes | |
---|---|
explicit | CopyingOutputStreamAdaptor(CopyingOutputStream * copying_stream, int block_size = -1) Cria um stream que grava no descritor de arquivo Unix fornecido. mais… |
| ~CopyingOutputStreamAdaptor() |
bool | Flush() Grava todos os dados pendentes no stream subjacente. mais… |
void | SetOwnsCopyingStream(bool value) Chame SetOwnsCOPYStream(true) para instruir o COPYOutputStreamAdaptor a excluir o COPYOutputStream subjacente quando ele for destruído. |
implementa ZeroCopyOutputStream | |
virtual bool | Next(void ** data, int * size) Recebe um buffer em que os dados podem ser gravados. mais… |
virtual void | BackUp(int count) |
virtual int64_t | ByteCount() const Retorna o número total de bytes gravados desde que o objeto foi criado. |
virtual bool | WriteAliasedRaw(const void * data, int size) Gravar um determinado bloco de dados na saída. mais… |
virtual bool | AllowsAliasing() const |
explicit CopyingOutputStreamAdaptor::CopyingOutputStreamAdaptor(
CopyingOutputStream * copying_stream,
int block_size = -1)
CopyingOutputStream * copying_stream,
int block_size = -1)
Cria um stream que grava no descritor de arquivo Unix fornecido.
Se um block_size for informado, ele especificará o tamanho dos buffers que serão retornados por Next(). Caso contrário, um padrão razoável será usado.
bool CopyingOutputStreamAdaptor::Flush()
Grava todos os dados pendentes no stream subjacente.
Retorna "false" se um erro de gravação ocorreu no stream subjacente. O stream em si não é necessariamente limpo.
virtual bool CopyingOutputStreamAdaptor::Next(
void ** data,
int * size)
void ** data,
int * size)
Recebe um buffer em que os dados podem ser gravados.
Todos os dados gravados nesse buffer serão gravados na saída (talvez instantaneamente, talvez mais tarde).
Condições prévias:
- "size" e "data" não são NULL.
Pós-condições:
- Se o valor retornado for “false”, significa que ocorreu um erro. Todos os erros são permanentes.
- Caso contrário, "tamanho" apontará para o número real de bytes no buffer e "dados" aponta para o buffer.
- A propriedade desse buffer permanece com o stream e ele permanece válido somente até que algum outro método do stream seja chamado ou que o stream seja destruído.
- Todos os dados armazenados pelo autor da chamada nesse buffer serão gravados na saída (a menos que BackUp() seja chamado).
- É permitido que o buffer retornado tenha tamanho zero, desde que chamar Next() várias vezes produz um buffer com tamanho diferente de zero.
virtual void CopyingOutputStreamAdaptor::BackUp(
int count)
int count)
Faz backup de vários bytes, de modo que o fim do último buffer retornado por Next() não seja gravado.
Isso é necessário quando você termina de gravar todos os dados que quer gravar, mas o último buffer foi maior do que o necessário. Não é recomendável escrever vários lixo após o término dos dados, então use BackUp() para fazer backup.
Condições prévias:
- O último método chamado precisa ter sido Next().
- a contagem deve ser menor ou igual ao tamanho do último buffer retornado por Next().
- O autor da chamada não pode ter escrito nada para os últimos bytes de "contagem" desse buffer.
Pós-condições:
- Os últimos bytes de "count" do último buffer retornados por Next() serão ignorados.
virtual bool CopyingOutputStreamAdaptor::WriteAliasedRaw(
const void * data,
int size)
const void * data,
int size)
Gravar um determinado bloco de dados na saída.
Alguns streams de saída podem implementar isso de modo a evitar a cópia. Verifique AllowAliasing() antes de chamar WriteAliasedRaw(). Ocorrerá uma falha na GOOGLE_CHECK se o WriteAliasedRaw() for chamado em um stream que não permita o alias.
OBSERVAÇÃO: é responsabilidade do autor da chamada garantir que o bloco de memória permaneça ativo até que todos os dados tenham sido consumidos pelo stream.
classe LimitingInputStream: ZeroCopyInputStream pública
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
namespace google::protobuf::io
Um ZeroCopyInputStream que envolve algum outro stream e o limita a uma contagem de bytes específica.
Participantes | |
---|---|
| LimitingInputStream(ZeroCopyInputStream * input, int64 limit) |
| ~LimitingInputStream() |
implementa ZeroCopyInputStream | |
virtual bool | Next(const void ** data, int * size) Recebe um bloco de dados do stream. mais… |
virtual void | BackUp(int count) |
virtual bool | Skip(int count) Ignora vários bytes. mais… |
virtual int64_t | ByteCount() const Retorna o número total de bytes lidos desde que o objeto foi criado. |
virtual bool LimitingInputStream::Next(
const void ** data,
int * size)
const void ** data,
int * size)
Recebe um bloco de dados do stream.
Condições prévias:
- "size" e "data" não são NULL.
Pós-condições:
- Se o valor retornado for falso, não haverá mais dados para retornar ou ocorreu um erro. Todos os erros são permanentes.
- Caso contrário, "size" aponta para o número real de bytes lidos e "data" aponta para um ponteiro para um buffer que contém esses bytes.
- A propriedade desse buffer permanece com o stream e ele permanece válido somente até que algum outro método do stream seja chamado ou que o stream seja destruído.
- É permitido que o buffer retornado tenha tamanho zero, desde que chamar Next() várias vezes produz um buffer com tamanho diferente de zero.
virtual void LimitingInputStream::BackUp(
int count)
int count)
Faz backup de vários bytes, de modo que a próxima chamada para Next() retorna dados que já foram retornados pela última chamada para Next().
Isso é útil ao escrever procedimentos que apenas devem ler um certo ponto da entrada e retornar. Se Next() retornar um buffer que vai além do que você quer ler, use BackUp() para voltar ao ponto em que quer concluir.
Condições prévias:
- O último método chamado precisa ter sido Next().
- a contagem deve ser menor ou igual ao tamanho do último buffer retornado por Next().
Pós-condições:
virtual bool LimitingInputStream::Skip(
int count)
int count)
Ignora vários bytes.
Retorna falso se o final do stream for alcançado ou se ocorrer algum erro de entrada. No caso de fim do stream, ele é avançado para o final (de modo que ByteCount() retorna o tamanho total do stream).