Comment obtenir une fonctionnalité d'E/S délimitée par tampons de protocole Java en C ?

Équivalents C pour les fonctions d'E/S délimitées des tampons de protocole Java

Problème :
Les développeurs tentent de lire et d'écrire plusieurs messages de tampons de protocole à partir de fichiers en C et Java peuvent rencontrer des problèmes lors de l'utilisation des fonctions d'E/S « délimitées » disponibles en Java mais apparemment inaccessibles en C .

Solution :
Depuis la version 3.3.0, des fonctions équivalentes de lecture et d'écriture de messages délimités ont été introduites en C au sein du fichier d'en-tête google/protobuf/util/delimited_message_util. h. Ces fonctions sont :

• writeDelimitedTo() : écrit un message délimité dans un google::protobuf::io::ZeroCopyOutputStream.
• readDelimitedFrom() : lit un message délimité à partir d'un google::protobuf::io::ZeroCopyInputStream.

Remarque :
Une implémentation alternative, fournie par l'auteur original des bibliothèques protobuf C et Java, propose des optimisations non présent dans les implémentations de la bibliothèque officielle. Cette implémentation, illustrée ci-dessous, évite les échecs potentiels après 64 Mo d'entrée tout en appliquant la limite de 64 Mo aux messages individuels :

bool writeDelimitedTo(
    const google::protobuf::MessageLite& message,
    google::protobuf::io::ZeroCopyOutputStream* rawOutput) {
  // We create a new coded stream for each message.  Don't worry, this is fast.
  google::protobuf::io::CodedOutputStream output(rawOutput);

  // Write the size.
  const int size = message.ByteSize();
  output.WriteVarint32(size);

  uint8_t* buffer = output.GetDirectBufferForNBytesAndAdvance(size);
  if (buffer != NULL) {
    // Optimization:  The message fits in one buffer, so use the faster
    // direct-to-array serialization path.
    message.SerializeWithCachedSizesToArray(buffer);
  } else {
    // Slightly-slower path when the message is multiple buffers.
    message.SerializeWithCachedSizes(&output);
    if (output.HadError()) return false;
  }

  return true;
}

bool readDelimitedFrom(
    google::protobuf::io::ZeroCopyInputStream* rawInput,
    google::protobuf::MessageLite* message) {
  // We create a new coded stream for each message.  Don't worry, this is fast,
  // and it makes sure the 64MB total size limit is imposed per-message rather
  // than on the whole stream.  (See the CodedInputStream interface for more
  // info on this limit.)
  google::protobuf::io::CodedInputStream input(rawInput);

  // Read the size.
  uint32_t size;
  if (!input.ReadVarint32(&size)) return false;

  // Tell the stream not to read beyond that size.
  google::protobuf::io::CodedInputStream::Limit limit =
      input.PushLimit(size);

  // Parse the message.
  if (!message->MergeFromCodedStream(&input)) return false;
  if (!input.ConsumedEntireMessage()) return false;

  // Release the limit.
  input.PopLimit(limit);

  return true;
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!