Comment implémenter des E/S délimitées en C pour les tampons de protocole ?

Fonctions d'E/S délimitées dans les tampons de protocole : équivalents C

Dans les scénarios où plusieurs messages de tampons de protocole sont lus ou écrits à partir de fichiers dans les deux C et Java, il devient nécessaire d'attacher des préfixes de longueur aux messages. Bien que l'API Java fournisse des fonctions d'E/S « délimitées » dédiées à cet effet, leurs équivalents en C peuvent ne pas être facilement apparents.

La récente mise à jour indique que ces équivalents en C résident désormais dans google/protobuf/util /delimited_message_util.h dans le cadre de la version 3.3.0. Cependant, avant cette mise à jour, il existait des implémentations alternatives qui répondaient efficacement à cette exigence.

Une de ces implémentations, fournie par un ancien auteur des bibliothèques protobuf C et Java, inclut des optimisations qui empêchent les échecs potentiels après 64 Mo d'entrée. . Ces implémentations, comme illustrées ci-dessous, appliquent la limite de 64 Mo sur les messages individuels, garantissant ainsi que la diffusion se poursuit de manière transparente sans dépasser la limite globale.

Implémentations d'E/S délimitées optimisées pour C

<code class="cpp">bool writeDelimitedTo(
    const google::protobuf::MessageLite&amp; message,
    google::protobuf::io::ZeroCopyOutputStream* rawOutput) {
  // Initialize a CodedOutputStream for each message.
  google::protobuf::io::CodedOutputStream output(rawOutput);

  // Determine the message size and write it as a Varint.
  int size = message.ByteSize();
  output.WriteVarint32(size);

  // Optimize for messages fitting into a single buffer.
  uint8_t* buffer = output.GetDirectBufferForNBytesAndAdvance(size);
  if (buffer != NULL) message.SerializeWithCachedSizesToArray(buffer);
  else message.SerializeWithCachedSizes(&amp;output);

  return true;
}

bool readDelimitedFrom(
    google::protobuf::io::ZeroCopyInputStream* rawInput,
    google::protobuf::MessageLite* message) {
  // Initialize a CodedInputStream for each message.
  google::protobuf::io::CodedInputStream input(rawInput);

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

  // Restrict reading to the determined message size.
  google::protobuf::io::CodedInputStream::Limit limit =
      input.PushLimit(size);

  // Parse the message and verify it fits within the limit.
  if (!message->MergeFromCodedStream(&amp;input)) return false;
  if (!input.ConsumedEntireMessage()) return false;

  // Lift the reading restriction.
  input.PopLimit(limit);

  return true;
}</code>

Ces implémentations optimisées gèrent efficacement des messages de différentes tailles et fournissent une solution fiable pour les E/S délimitées en C.

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!