Wie kodieren und dekodieren Sie Protokollpuffernachrichten in C mithilfe begrenzter E/A?

C-Äquivalente für Javas Protokollpuffer, begrenzte E/A-Funktionen

Sowohl in C als auch in Java besteht die Notwendigkeit, mehrere Protokolle zu lesen und zu schreiben Puffert Nachrichten aus Dateien. Java Version 2.1.0 bietet zu diesem Zweck eine Reihe von „Delimited“ I/O-Funktionen:

• parseDelimitedFrom
• mergeDelimitedFrom
• writeDelimitedTo

Diese Funktionen erleichtern das Anhängen von Längenpräfixen vor jeder Nachricht. Es bleibt jedoch unklar, ob solche Fähigkeiten in C vorhanden sind.

Existenz von C-Äquivalenten

Anfangs gab es keine direkten C-Äquivalente zu diesen Java-Funktionen. Ab Version 3.3.0 bietet C jedoch nun Dienstprogrammfunktionen für durch Trennzeichen getrennte Nachrichten in google/protobuf/util/delimited_message_util.h.

Format der Größenpräfixe

Für Für Benutzer, die vor der Veröffentlichung dieser offiziellen Dienstprogramme ihre eigenen Parser in C implementieren möchten, ist es wichtig, das Wire-Format für die von der Java-API angehängten Größenpräfixe zu verstehen. Das Format folgt den folgenden Richtlinien:

• Die Trennzeichen müssen bereits vor der ersten Nachricht vorhanden sein.
• Die Größe der Nachricht wird als 32-Bit-Variante codiert.
• Ein 1-Byte-Trennbyte (0x0A) beendet jede Nachricht und die nächste Nachricht mit Längenpräfix beginnt unmittelbar danach.

Optimierte C-Implementierungen

Nach der Veröffentlichung der offiziellen C-Utility-Funktionen wurden mehrere Optimierungen entdeckt, die in den ursprünglich vorgeschlagenen Implementierungen fehlen. Diese optimierten Funktionen, die unten bereitgestellt werden, bieten eine verbesserte Leistung und vermeiden potenzielle Fehler:

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

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

  // Serialize the message directly to the output buffer if possible.
  uint8_t* buffer = output.GetDirectBufferForNBytesAndAdvance(size);
  if (buffer != NULL) {
    message.SerializeWithCachedSizesToArray(buffer);
  } else {
    // Use a slower path if the message spans multiple buffers.
    message.SerializeWithCachedSizes(&amp;output);
    if (output.HadError()) return false;
  }

  return true;
}

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

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

  // Set a read limit to enforce the 64 MB per-message size constraint.
  google::protobuf::io::CodedInputStream::Limit limit =
      input.PushLimit(size);

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

  // Remove the read limit.
  input.PopLimit(limit);

  return true;
}</code>

Das obige ist der detaillierte Inhalt vonWie kodieren und dekodieren Sie Protokollpuffernachrichten in C mithilfe begrenzter E/A?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!