Maison > Java > javaDidacticiel > le corps du texte

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

Susan Sarandon
Libérer: 2024-10-30 02:47:03
original
771 Les gens l'ont consulté

 How to Implement Delimited I/O in C   for Protocol Buffers?

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>
Copier après la connexion

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!

source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Derniers articles par auteur
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal
À propos de nous Clause de non-responsabilité Sitemap
Site Web PHP chinois:Formation PHP en ligne sur le bien-être public,Aidez les apprenants PHP à grandir rapidement!