Clean up the comments in pb_encode.h and pb_decode.h

pb_decode.h

@@ -1,33 +1,77 @@
+/* pb_decode.h: Functions to decode protocol buffers. Depends on pb_decode.c.
+ * The main function is pb_decode. You also need an input stream, and the
+ * field descriptions created by nanopb_generator.py.
+ */
+
 #ifndef _PB_DECODE_H_
 #define _PB_DECODE_H_
 
-/* pb_decode.h: Functions to decode protocol buffers. Depends on pb_decode.c.
- * The main function is pb_decode. You will also need to create an input
- * stream, which is easiest to do with pb_istream_from_buffer().
- * 
- * You also need structures and their corresponding pb_field_t descriptions.
- * These are usually generated from .proto-files with a script.
- */
-
 #include "pb.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/* Lightweight input stream.
+/***************************
- * You can provide a callback function for reading or use
+ * Main decoding functions *
- * pb_istream_from_buffer.
+ ***************************/
+ 
+/* Decode a single protocol buffers message from input stream into a C structure.
+ * Returns true on success, false on any failure.
+ * The actual struct pointed to by dest must match the description in fields.
+ * Callback fields of the destination structure must be initialized by caller.
+ * All other fields will be initialized by this function.
+ *
+ * Example usage:
+ *    MyMessage msg = {};
+ *    uint8_t buffer[64];
+ *    pb_istream_t stream;
+ *    
+ *    // ... read some data into buffer ...
+ *
+ *    stream = pb_istream_from_buffer(buffer, count);
+ *    pb_decode(&stream, MyMessage_fields, &msg);
+ */
+bool pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct);
+
+/* Same as pb_decode, except does not initialize the destination structure
+ * to default values. This is slightly faster if you need no default values
+ * and just do memset(struct, 0, sizeof(struct)) yourself.
+ *
+ * This can also be used for 'merging' two messages, i.e. update only the
+ * fields that exist in the new message.
+ */
+bool pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct);
+
+
+/**************************************
+ * Functions for manipulating streams *
+ **************************************/
+
+/* Create an input stream for reading from a memory buffer.
+ *
+ * Alternatively, you can use a custom stream that reads directly from e.g.
+ * a file or a network socket.
+ */
+pb_istream_t pb_istream_from_buffer(uint8_t *buf, size_t bufsize);
+
+/* Function to read from a pb_istream_t. You can use this if you need to
+ * read some custom header data, or to read data in field callbacks.
+ */
+bool pb_read(pb_istream_t *stream, uint8_t *buf, size_t count);
+
+/* Structure for defining custom input streams. You will need to provide
+ * a callback function to read the bytes from your storage, which can be
+ * for example a file or a network socket.
  * 
- * Rules for callback:
+ * The callback must conform to these rules:
+ *
  * 1) Return false on IO errors. This will cause decoding to abort.
- * 
  * 2) You can use state to store your own data (e.g. buffer pointer),
- * and rely on pb_read to verify that no-body reads past bytes_left.
+ *    and rely on pb_read to verify that no-body reads past bytes_left.
- * 
  * 3) Your callback may be used with substreams, in which case bytes_left
- * is different than from the main stream. Don't use bytes_left to compute
+ *    is different than from the main stream. Don't use bytes_left to compute
- * any pointers.
+ *    any pointers.
  */
 struct _pb_istream_t
 {
@@ -49,24 +93,10 @@ struct _pb_istream_t
 #endif
 };
 
-pb_istream_t pb_istream_from_buffer(uint8_t *buf, size_t bufsize);
-bool pb_read(pb_istream_t *stream, uint8_t *buf, size_t count);
 
-/* Decode from stream to destination struct.
+/************************************************
- * Returns true on success, false on any failure.
+ * Helper functions for writing field callbacks *
- * The actual struct pointed to by dest must match the description in fields.
+ ************************************************/
- */
-bool pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct);
-
-/* Same as pb_decode, except does not initialize the destination structure
- * to default values. This is slightly faster if you need no default values
- * and just do memset(struct, 0, sizeof(struct)) yourself.
- */
-bool pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct);
-
-/* --- Helper functions ---
- * You may want to use these from your caller or callbacks.
- */
 
 /* Decode the tag for the next field in the stream. Gives the wire type and
  * field tag. At end of the message, returns false and sets eof to true. */
@@ -95,10 +125,10 @@ bool pb_decode_fixed64(pb_istream_t *stream, void *dest);
 bool pb_make_string_substream(pb_istream_t *stream, pb_istream_t *substream);
 void pb_close_string_substream(pb_istream_t *stream, pb_istream_t *substream);
 
-/* --- Internal functions ---
+
- * These functions are not terribly useful for the average library user, but
+/*******************************
- * are exported to make the unit testing and extending nanopb easier.
+ * Internal / legacy functions *
- */
+ *******************************/
 
 #ifdef NANOPB_INTERNALS
 bool pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest);

pb_encode.h

@@ -1,33 +1,82 @@
+/* pb_encode.h: Functions to encode protocol buffers. Depends on pb_encode.c.
+ * The main function is pb_encode. You also need an output stream, and the
+ * field descriptions created by nanopb_generator.py.
+ */
+
 #ifndef _PB_ENCODE_H_
 #define _PB_ENCODE_H_
 
-/* pb_encode.h: Functions to encode protocol buffers. Depends on pb_encode.c.
- * The main function is pb_encode. You also need an output stream, structures
- * and their field descriptions (just like with pb_decode).
- */
-
 #include "pb.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/* Lightweight output stream.
+/***************************
- * You can provide callback for writing or use pb_ostream_from_buffer.
+ * Main encoding functions *
- * 
+ ***************************/
- * Alternatively, callback can be NULL in which case the stream will just
+
- * count the number of bytes that would have been written. In this case
+/* Encode a single protocol buffers message from C structure into a stream.
- * max_size is not checked.
+ * Returns true on success, false on any failure.
+ * The actual struct pointed to by src_struct must match the description in fields.
+ * All required fields in the struct are assumed to have been filled in.
+ *
+ * Example usage:
+ *    MyMessage msg = {};
+ *    uint8_t buffer[64];
+ *    pb_ostream_t stream;
+ *
+ *    msg.field1 = 42;
+ *    stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
+ *    pb_encode(&stream, MyMessage_fields, &msg);
+ */
+bool pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct);
+
+
+/**************************************
+ * Functions for manipulating streams *
+ **************************************/
+
+/* Create an output stream for writing into a memory buffer.
+ * The number of bytes written can be found in stream.bytes_written after
+ * encoding the message.
+ *
+ * Alternatively, you can use a custom stream that writes directly to e.g.
+ * a file or a network socket.
+ */
+pb_ostream_t pb_ostream_from_buffer(uint8_t *buf, size_t bufsize);
+
+/* Pseudo-stream for measuring the size of a message without actually storing
+ * the encoded data.
+ * 
+ * Example usage:
+ *    MyMessage msg = {};
+ *    pb_ostream_t stream = PB_OSTREAM_SIZING;
+ *    pb_encode(&stream, MyMessage_fields, &msg);
+ *    printf("Message size is %d\n", stream.bytes_written);
+ */
+#ifndef PB_NO_ERRMSG
+#define PB_OSTREAM_SIZING {0,0,0,0,0}
+#else
+#define PB_OSTREAM_SIZING {0,0,0,0}
+#endif
+
+/* Function to write into a pb_ostream_t stream. You can use this if you need
+ * to append or prepend some custom headers to the message.
+ */
+bool pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count);
+
+/* Structure for defining custom output streams. You will need to provide
+ * a callback function to write the bytes to your storage, which can be
+ * for example a file or a network socket.
+ *
+ * The callback must conform to these rules:
  *
- * Rules for callback:
  * 1) Return false on IO errors. This will cause encoding to abort.
- * 
  * 2) You can use state to store your own data (e.g. buffer pointer).
- * 
  * 3) pb_write will update bytes_written after your callback runs.
- * 
+ * 4) Substreams will modify max_size and bytes_written. Don't use them
- * 4) Substreams will modify max_size and bytes_written. Don't use them to
+ *    to calculate any pointers.
- * calculate any pointers.
  */
 struct _pb_ostream_t
 {
@@ -42,42 +91,26 @@ struct _pb_ostream_t
 #else
     bool (*callback)(pb_ostream_t *stream, const uint8_t *buf, size_t count);
 #endif
-    void *state; /* Free field for use by callback implementation */
+    void *state;          /* Free field for use by callback implementation. */
-    size_t max_size; /* Limit number of output bytes written (or use SIZE_MAX). */
+    size_t max_size;      /* Limit number of output bytes written (or use SIZE_MAX). */
-    size_t bytes_written;
+    size_t bytes_written; /* Number of bytes written so far. */
     
 #ifndef PB_NO_ERRMSG
     const char *errmsg;
 #endif
 };
 
-pb_ostream_t pb_ostream_from_buffer(uint8_t *buf, size_t bufsize);
-bool pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count);
 
-/* Stream type for use in computing message sizes */
+/************************************************
-#ifndef PB_NO_ERRMSG
+ * Helper functions for writing field callbacks *
-#define PB_OSTREAM_SIZING {0,0,0,0,0}
+ ************************************************/
-#else
-#define PB_OSTREAM_SIZING {0,0,0,0}
-#endif
 
-/* Encode struct to given output stream.
+/* Encode field header based on type and field number defined in the field
- * Returns true on success, false on any failure.
+ * structure. Call this from the callback before writing out field contents. */
- * The actual struct pointed to by src_struct must match the description in fields.
- * All required fields in the struct are assumed to have been filled in.
- */
-bool pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct);
-
-/* --- Helper functions ---
- * You may want to use these from your caller or callbacks.
- */
-
-/* Encode field header based on LTYPE and field number defined in the field structure.
- * Call this from the callback before writing out field contents. */
 bool pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field);
 
-/* Encode field header by manually specifing wire type. You need to use this if
+/* Encode field header by manually specifing wire type. You need to use this
- * you want to write out packed arrays from a callback field. */
+ * if you want to write out packed arrays from a callback field. */
 bool pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, uint32_t field_number);
 
 /* Encode an integer in the varint format.
@@ -100,15 +133,16 @@ bool pb_encode_fixed32(pb_ostream_t *stream, const void *value);
 bool pb_encode_fixed64(pb_ostream_t *stream, const void *value);
 
 /* Encode a submessage field.
- * You need to pass the pb_field_t array and pointer to struct, just like with pb_encode().
+ * You need to pass the pb_field_t array and pointer to struct, just like
- * This internally encodes the submessage twice, first to calculate message size and then to actually write it out.
+ * with pb_encode(). This internally encodes the submessage twice, first to
+ * calculate message size and then to actually write it out.
  */
 bool pb_encode_submessage(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct);
 
-/* --- Internal functions ---
+
- * These functions are not terribly useful for the average library user, but
+/*******************************
- * are exported to make the unit testing and extending nanopb easier.
+ * Internal / legacy functions *
- */
+ *******************************/
 
 #ifdef NANOPB_INTERNALS
 bool pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src);