+/** @addtogroup GRAS_dd Data description
+ * @brief Describing data to be exchanged (Communication facility)
+ *
+ * Since GRAS takes care of potential representation conversion when the platform is heterogeneous,
+ * any data which transits on the network must be described beforehand.
+ *
+ * There is several possible interfaces for this, ranging from the really completely automatic parsing to
+ * completely manual. Let's study each of them from the simplest to the more advanced:
+ *
+ * - Section \ref GRAS_dd_basic presents how to retrieve and use an already described type.
+ * - Section \ref GRAS_dd_auto shows how to get GRAS parsing your type description automagically. This
+ * is unfortunately not always possible (only works for some structures), but if it is for your data,
+ * this is definitly the way to go.
+ * - Section \ref GRAS_dd_manual presents how to build a description manually. This is useful when you want
+ * to describe an array or a pointer of pre-defined structures.
+ * - You sometimes need to exchange informations between descriptions at send or receive time. This is
+ * for example useful when your structure contains an array which size is given by another field of the
+ * structure.
+ * - Section \ref GRAS_dd_cb_simple provides a simple interface to do so, allowing to share integers stored on a stack.
+ * - Section \ref GRAS_dd_cb_full provides a full featured interface to do so, but it may reveal somehow difficult to use.
+ **/
+
+/** @defgroup GRAS_dd_basic Basic operations on data descriptions
+ * @ingroup GRAS_dd
+ * \htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Basics" --> \endhtmlonly
+ *
+ * If you only want to send pre-existing types, simply retrieve the pre-defined description with
+ * the \ref gras_datadesc_by_name function. Existing types entail:
+ * - char (both signed and unsigned)
+ * - int (short, regular, long and long long, both signed and unsigned)
+ * - float and double
+ * - string (which is indeed a reference to a dynamically sized array of char, strlen being used to retrive the size)
+ *
+ * Example:\verbatim gras_datadesc_type_t i = gras_datadesc_by_name("int");
+ gras_datadesc_type_t uc = gras_datadesc_by_name("unsigned char");
+ gras_datadesc_type_t str = gras_datadesc_by_name("string");\endverbatim
+ *
+ */
+/* @{ */
+
+/** @brief Opaque type describing a type description. */
+typedef struct s_gras_datadesc_type *gras_datadesc_type_t;
+
+/** \brief Search a type description from its name */
+gras_datadesc_type_t gras_datadesc_by_name(const char *name);
+
+/* @} */
+
+/** @defgroup GRAS_dd_auto Automatic parsing of data descriptions
+ * @ingroup GRAS_dd
+ * \htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Automatic parsing" --> \endhtmlonly
+ *
+ * If you need to declare a new datatype, this is the simplest way to describe it to GRAS. Simply
+ * enclose its type definition into a \ref GRAS_DEFINE_TYPE macro call, and you're set. Here is
+ * an type declaration example: \verbatim GRAS_DEFINE_TYPE(mytype,struct mytype {
+ int myfirstfield;
+ char mysecondfield;
+ });\endverbatim
+ * The type is then both copied verbatim into your source file and stored for further parsing. This allows
+ * you to let GRAS parse the exact version you are actually using in your program.
+ * You can then retrieve the corresponding type description with \ref gras_datadesc_by_symbol.
+ * Don't worry too much for the performances, the type is only parsed once and a binary representation
+ * is stored and used in any subsequent calls.
+ *
+ * If your structure contains any pointer, you have to explain GRAS the size of the pointed array. This
+ * can be 1 in the case of simple references, or more in the case of regular arrays. For that, use the
+ * \ref GRAS_ANNOTE macro within the type declaration you are passing to \ref GRAS_DEFINE_TYPE. This macro
+ * rewrites itself to nothing in the declaration (so they won't pollute the type definition copied verbatim
+ * into your code), and give some information to GRAS about your pointer.
+
+ * GRAS_ANNOTE takes two arguments being the key name and the key value. For now, the only accepted key name
+ * is "size", to specify the length of the pointed array. It can either be:
+ * - the string "1" (without the quote),
+ * - the name of another field of the structure
+ * - a sort of computed expression for multidimensional arrays (see below -- pay attention to the warnings below).
+ *
+ * Here is an example:\verbatim GRAS_DEFINE_TYPE(s_clause,
+ struct s_array {
+ struct s_array *father GRAS_ANNOTE(size,1);
+ int length;
+ int *data GRAS_ANNOTE(size,length);
+ int rows;
+ int cols;
+ int *matrix GRAS_ANNOTE(size,rows*cols);
+ }
+;)\endverbatim
+ * It specifies that the structure s_array contains five fields, that the \a father field is a simple reference,
+ * that the size of the array pointed by \a data is the \a length field, and that the \a matrix field is an array
+ * which size is the result of \a rows times \a cols.
+ *
+ * \warning The mecanism for multidimensional arrays is known to be fragile and cumbersome. If you want to use it,
+ * you have to understand how it is implemented: the multiplication is performed using the sizes stack. In previous example,
+ * a \ref gras_datadesc_cb_push_int callback is added to the \a rows field and a \ref gras_datadesc_cb_push_int_mult one is
+ * added to \a cols. So, when the structure is sent, the rows field push its value onto the stack, then the \a cols field
+ * retrieve this value from the stack, compute (and push) the multiplication value. The \a matrix field can then retrive this
+ * value by poping the array. There is several ways for this to go wrong:
+ * - if the matrix field is placed before the sizes, the right value won't get pushed into the stack soon enough. Reorder your structure fields if needed.
+ * - if you write GRAS_ANNOTE(size,cols*rows); in previous example (inverting rows and cols in annotation),
+ * \a rows will be given a \ref gras_datadesc_cb_push_int_mult. This cannot work since it will try to
+ * pop the value which will be pushed by \a cols <i>afterward</i>.
+ * - if you have more than one matrix in your structure, don't interleave the size. They are pushed/poped in the structure order.
+ * - if some of the sizes are used in more than one matrix, you cannot use this mecanism -- sorry.
+ *
+ * If you cannot express your datadescs with this mechanism, you'll have to use the more advanced
+ * (and somehow complex) one described below.
+ *
+ * \warning Since GRAS_DEFINE_TYPE is a macro, you shouldn't put any comma in your type definition
+ * (comma separates macro args). For example, change \verbatim int a, b;\endverbatim to \verbatim int a;
+ int b;\endverbatim
+ */
+/** @{ */