Wie implementiert man begrenzte E/A in C für Protokollpuffer?

Begrenzte E/A-Funktionen in Protokollpuffern: C-Äquivalente

In Szenarien, in denen mehrere Protokollpuffernachrichten aus Dateien in beiden gelesen oder geschrieben werden In C und Java ist es erforderlich, Längenpräfixe an die Nachrichten anzuhängen. Während die Java-API für diesen Zweck dedizierte „getrennte“ I/O-Funktionen bereitstellt, sind ihre entsprechenden Gegenstücke in C möglicherweise nicht ohne weiteres erkennbar.

Das jüngste Update weist darauf hin, dass sich solche C-Äquivalente jetzt in google/protobuf/util befinden /delimited_message_util.h als Teil von Version 3.3.0. Vor diesem Update gab es jedoch alternative Implementierungen, die diese Anforderung effizient erfüllten.

Eine solche Implementierung, bereitgestellt von einem ehemaligen Autor der C- und Java-Protobuf-Bibliotheken, enthält Optimierungen, die potenzielle Fehler nach 64 MB Eingabe verhindern . Diese unten dargestellten Implementierungen erzwingen das 64-MB-Limit für einzelne Nachrichten und stellen so sicher, dass das Streaming nahtlos fortgesetzt wird, ohne das Gesamtlimit zu überschreiten.

Optimierte Delimited I/O-Implementierungen für 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>

Diese optimierten Implementierungen verarbeiten Nachrichten unterschiedlicher Größe effektiv und bieten eine zuverlässige Lösung für begrenzte E/A in C.

Das obige ist der detaillierte Inhalt vonWie implementiert man begrenzte E/A in C für Protokollpuffer?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!