Parse List docstrings according to doxygen syntax

#include <string>

/**

 * \brief Exception for out of bounds list requests.

 * \brief Exception for out of bounds List requests.

 */

class ListOutOfBoundsException: public std::exception {

protected:

	//! \brief Minimum index defined in the list.

	//! \brief Minimum index defined in the List.

	int min_index;

	//! \brief Maximum index defined in the list.

	//! \brief Maximum index defined in the List.

	int max_index;

	//! \brief Index requested by user.

	//! \brief List index requested by user.

	int requested_index;

public:

 *

 * For this reason, the best use of List objects is to collect all the

 * desired members and then, once the element number is known, to convert

 * the List to C array, by calling List.to_array(). This function returns

 * the List to C array, by calling `List.to_array()`. This function returns

 * a contiguous array of type T[SIZE] that can be used for indexed access.

 */

template<class T> class List {

 public:

  /*! \brief List constructor.

   *

   * Use the constructor List<T>([int length]) to create a new list with a given

   * Use the constructor `List<T>([int length])` to create a new list with a given

   * size. If the required size is not known in advance, it is recommended

   * to create a List with SIZE=1 (this is the default behavior) and then

   * to append the elements dynamically, using List.append(ELEMENT) (where

   * to append the elements dynamically, using `List.append(ELEMENT)` (where

   * ELEMENT needs to be a value of type T, corresponding to the class

   * template specialization). Note that, due to the default behavior, the

   * following calls are equivalent and they both produce an integer List

   * with size equal to 1:

   *

   * a = List<int>(1);

   *

   * b = List<int>();

   * \code{.cpp}

   * List<int> a = List<int>(1);

   * List<int> b = List<int>();

   * \endcode

   *

   * \param length: `int` The size of the list to be constructed [OPTIONAL, default=1].

   */

    }

  }

  /*! \brief Append an element at the end of the list.

  /*! \brief Append an element at the end of the List.

   *

   * To dynamically create a list whose size is not known in advance,

   * elements can be appended in an iterative way. Note that element

   * manipulation is much more effective in a C array than in a List

   * object. For this reason, after the List has been created, it is

   * strongly advised to convert it to a C array by calling the function

   * List.to_array().

   * `List.to_array()`.

   *

   * \param value: `T` The value of the element to be appended.

   */

   *

   * \param index: `int` The index of the element to be retrieved. 0 for first.

   * \return value `T` The value of the element at the requested position.

   * \throws LIST_OUT_OF_BOUNDS_EXCEPTION: Raised if the index is out of bounds.

   * \throws ListOutOfBoundsException: Raised if the index is out of bounds.

   */

  T get(int index) {

    if (index < 0 || index > size - 1) {

    return current->value;

  }

  /*! \brief Get the number of elements in the list.

  /*! \brief Get the number of elements in the List.

   *

   * Get the number of elements currently stored in the list.

   * Get the number of elements currently stored in the List.

   *

   * \return size `int` The size of the list.

   * \return size `int` The size of the List.

   */

  int length() {

    return size;

   *

   * \param index: `int` The index of the element to be set. 0 for first.

   * \param value: `int` The value to store in the pointed element.

   * \throws LIST_OUT_OF_BOUNDS_EXCEPTION: Raised if the index is out of bounds.

   * \throws ListOutOfBoundsException: Raised if the index is out of bounds.

   */

  void set(int index, T value) {

    if (index < 0 || index > size - 1) {

   * resulting object is not contiguosly stored in memory. As a result,

   * access to specific elements in the middle of the list is not very

   * effective, because the list needs to be walked every time up to

   * the desired position. In order to avoid this, List.to_array() makes

   * the desired position. In order to avoid this, `List.to_array()` makes

   * a conversion from List to C array, returning a contiguous object,

   * where indexed access can be used.

   *