Clean up the comments in pb_encode.h and pb_decode.h
diff --git a/pb_decode.h b/pb_decode.h
index e5d98c5..85efa21 100644
--- a/pb_decode.h
+++ b/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
- * pb_istream_from_buffer.
+/***************************
+ * Main decoding functions *
+ ***************************/
+
+/* 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
- * any pointers.
+ * is different than from the main stream. Don't use bytes_left to compute
+ * any pointers.
*/
struct _pb_istream_t
{
@@ -49,24 +93,10 @@
#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.
- * 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.
- */
+/************************************************
+ * Helper functions for writing field 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_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);
diff --git a/pb_encode.h b/pb_encode.h
index 773b717..d9e0336 100644
--- a/pb_encode.h
+++ b/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.
- *
- * 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
- * max_size is not checked.
+/***************************
+ * Main encoding functions *
+ ***************************/
+
+/* Encode a single protocol buffers message from C structure into a stream.
+ * 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.
*
- * Rules for callback:
+ * 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:
+ *
* 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 to
- * calculate any pointers.
+ * 4) Substreams will modify max_size and bytes_written. Don't use them
+ * to calculate any pointers.
*/
struct _pb_ostream_t
{
@@ -42,42 +91,26 @@
#else
bool (*callback)(pb_ostream_t *stream, const uint8_t *buf, size_t count);
#endif
- 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 bytes_written;
+ 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 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
-#define PB_OSTREAM_SIZING {0,0,0,0,0}
-#else
-#define PB_OSTREAM_SIZING {0,0,0,0}
-#endif
+/************************************************
+ * Helper functions for writing field callbacks *
+ ************************************************/
-/* Encode struct to given output stream.
- * 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.
- */
-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. */
+/* Encode field header based on type 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
- * you want to write out packed arrays from a callback field. */
+/* Encode field header by manually specifing wire type. You need to use this
+ * 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_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().
- * This internally encodes the submessage twice, first to calculate message size and then to actually write it out.
+ * You need to pass the pb_field_t array and pointer to struct, just like
+ * 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);
