Docs: convierto a doxygen (#174)

* docs: doxygenize bitarray.h

* docs: doxygenize config.h

* docs: doxygenize dictionary.h

* docs: doxygenize error.h

* docs: corrections in config.h and dictionary.h

* docs: doxygenize list.h

* docs: doxygenize memory.h

* docs: doxygenize process.h

* docs: doxygenize queue.h

* docs: doxygenize temporal.h

* docs: doxygenize txt.h

* docs: doxygenize temporal test

* docs: doxygenize log.h

* chore: ignore .idea files

* docs: doxygenize string.h

* docs: corrections in bitarray.h

* docs: corrections in config.h

* docs: corrections in dictionary.h

* docs: corrections in list.h

.gitignore

@@ -1,3 +1,4 @@
+.idea
 .project
 .cproject
 .settings

src/commons/bitarray.h

@@ -25,17 +25,19 @@
 	#define BIT_CHAR(bit)         ((bit) / CHAR_BIT)
 
 	/**
-	 * Define el orden bajo el cual se guardarán los bits a la hora de llenar los bytes.
-	 * La mayoría de las implementaciones de bitmap usan LSB_FIRST. Si no estás seguro
-	 * de cuál usar, probablemente quieras usar esta.
+	 * @brief Define el orden bajo el cual se guardarán los bits a la hora de llenar los bytes.
+	 * @note  La mayoría de las implementaciones de bitmap usan LSB_FIRST. Si no estás seguro
+	 *        de cuál usar, probablemente quieras usar esta.
 	 */
 	typedef enum {
-		/* Completa los bits en un byte priorizando el bit menos significativo:
-		 * 00000001 00000000
+		/**
+		 *  @brief   Completa los bits en un byte priorizando el bit menos significativo:
+		 *  @example 00000001 00000000
 		 */
 		LSB_FIRST,
-		/* Completa los bits en un byte priorizando el bit más significativo:
-		 * 10000000 00000000
+		/**
+		 *  @brief   Completa los bits en un byte priorizando el bit más significativo:
+		 *  @example 10000000 00000000
 		 */
 		MSB_FIRST
 	} bit_numbering_t;
@@ -47,62 +49,66 @@
 	} t_bitarray;
 
 	/**
-	* @DEPRECATED: La firma de esta función se encuentra en revisión y probablemente cambie
-	* 			   en próximas versiones. Usar bitarray_create_with_mode.
+	* @deprecated Esta función se encuentra en revisión y probablemente cambie en próximas versiones.
+	*             Usar bitarray_create_with_mode.
 	*
-	* @NAME: bitarray_create
-	* @DESC: Crea y devuelve un puntero a una estructura t_bitarray con formato LSB_FIRST
-	* @PARAMS:
-	* 		bitarray - el bloque de memoria que contiene los bits a leer/escribir
-	*		size - la cantidad de bits del bitarray, expresada en bytes (1 byte = 8 bits)
+	* @fn    bitarray_create
+	* @brief Crea y devuelve un puntero a una estructura t_bitarray con formato LSB_FIRST
 	*
-	*		ejemplo: bitarray de 8 posiciones (bits), 
-	*			void* puntero_a_bits = //un byte de memoria, como por ejemplo malloc(1)
-	*			bitarray_create(puntero_a_bits, 1)
+	* @param bitarray El bloque de memoria que contiene los bits a leer/escribir
+	* @param size     La cantidad de bits del bitarray, expresada en bytes (1 byte = 8 bits)
+	*
+	* @example bitarray de 8 posiciones (bits),
+	* @code
+	* void* puntero_a_bits = //un byte de memoria, como por ejemplo malloc(1)
+	* bitarray_create(puntero_a_bits, 1)
+	* @endcode
 	*/
-	t_bitarray 	*bitarray_create(char *bitarray, size_t size);
+	t_bitarray 	*bitarray_create(char *bitarray, size_t size) __attribute__((deprecated));
 
 	/**
-	* @NAME: bitarray_create_with_mode
-	* @DESC: Crea y devuelve un puntero a una estructura t_bitarray
-	* @PARAMS:
-	* 		bitarray - el bloque de memoria que contiene los bits a leer/escribir
-	*		size - la cantidad de bits del bitarray, expresada en bytes (1 byte = 8 bits)
-	*		mode - LSB_FIRST ó MSB_FIRST
+	* @fn    bitarray_create_with_mode
+	* @brief Crea y devuelve un puntero a una estructura t_bitarray
+	*
+	* @param bitarray El bloque de memoria que contiene los bits a leer/escribir
+	* @param size     La cantidad de bits del bitarray, expresada en bytes (1 byte = 8 bits)
+	* @param mode     LSB_FIRST o MSB_FIRST @see bit_numbering_t
 	*
-	*		ejemplo: bitarray de 8 posiciones (bits) con LSB_FIRST, 
-	*			void* puntero_a_bits = //un byte de memoria, como por ejemplo malloc(1)
-	*			bitarray_create_with_mode(puntero_a_bits, 1, LSB_FIRST)
+	* @example bitarray de 8 posiciones (bits) con LSB_FIRST,
+	* @code
+	* void* puntero_a_bits = //un byte de memoria, como por ejemplo malloc(1)
+	* bitarray_create_with_mode(puntero_a_bits, 1, LSB_FIRST)
+	* @endcode
 	*/
 	t_bitarray	*bitarray_create_with_mode(char *bitarray, size_t size, bit_numbering_t mode);
 
 	/**
-	* @NAME: bitarray_test_bit
-	* @DESC: Devuelve el valor del bit de la posicion indicada
+	* @fn    bitarray_test_bit
+	* @brief Devuelve el valor del bit de la posicion indicada
 	*/
 	bool 		 bitarray_test_bit(t_bitarray*, off_t bit_index);
 
 	/**
-	* @NAME: bitarray_set_bit
-	* @DESC: Setea el valor del bit de la posicion indicada
+	* @fn    bitarray_set_bit
+	* @brief Setea el valor del bit de la posicion indicada
 	*/
 	void		 bitarray_set_bit(t_bitarray*, off_t bit_index);
 
 	/**
-	* @NAME: bitarray_clean_bit
-	* @DESC: Limpia el valor del bit de la posicion indicada
+	* @fn    bitarray_clean_bit
+	* @brief Limpia el valor del bit de la posicion indicada
 	*/
 	void		 bitarray_clean_bit(t_bitarray*, off_t bit_index);
 
 	/**
-	* @NAME: bitarray_get_max_bit
-	* @DESC: Devuelve la cantidad de bits en el bitarray
+	* @fn    bitarray_get_max_bit
+	* @brief Devuelve la cantidad de bits en el bitarray
 	*/
 	size_t		 bitarray_get_max_bit(t_bitarray*);
 
 	/**
-	* @NAME: bitarray_destroy
-	* @DESC: Destruye el bit array
+	* @fn    bitarray_destroy
+	* @brief Destruye el bit array
 	*/
 	void 		 bitarray_destroy(t_bitarray*);
 

src/commons/collections/dictionary.c

@@ -222,10 +222,6 @@ static void dictionary_resize(t_dictionary *self, int new_max_size) {
 	free(old_table);
 }
 
-/*
- * @NAME: dictionary_clean
- * @DESC: Destruye todos los elementos del diccionario
-*/
 static void internal_dictionary_clean_and_destroy_elements(t_dictionary *self, void(*data_destroyer)(void*)) {
 	int table_index;
 

src/commons/collections/dictionary.h

@@ -31,95 +31,94 @@
 	} t_dictionary;
 
 	/**
-	* @NAME: dictionary_create
-	* @DESC: Crea el diccionario
+	* @fn    dictionary_create
+	* @brief Crea el diccionario
 	*/
 	t_dictionary *dictionary_create();
 
 	/**
-	* @NAME: dictionary_put
-	* @DESC: Inserta un nuevo par (key->element) al diccionario, en caso de ya existir la key actualiza el elemento.
-	* [Warning] - Tener en cuenta que esto no va a liberar la memoria del `element` original.
+	* @fn    dictionary_put
+	* @brief Inserta un nuevo par (key->element) al diccionario, en caso de ya existir la key actualiza el elemento.
+	*
+	* @warning Tener en cuenta que esto no va a liberar la memoria del `element` original.
 	*/
 	void 		  dictionary_put(t_dictionary *, char *key, void *element);
 
 	/**
-	* @NAME: dictionary_get
-	* @DESC: Obtiene el elemento asociado a la key.
+	* @fn    dictionary_get
+	* @brief Obtiene el elemento asociado a la key.
 	*/
 	void 		 *dictionary_get(t_dictionary *, char *key);
 
 	/**
-	* @NAME: dictionary_remove
-	* @DESC: Remueve un elemento del diccionario y lo retorna.
+	* @fn    dictionary_remove
+	* @brief Remueve un elemento del diccionario y lo retorna.
 	*/
 	void 		 *dictionary_remove(t_dictionary *, char *key);
 
 	/**
-	* @NAME: dictionary_remove_and_destroy
-	* @DESC: Remueve un elemento del diccionario y lo destruye.
+	* @fn    dictionary_remove_and_destroy
+	* @brief Remueve un elemento del diccionario y lo destruye.
 	*/
 	void 		  dictionary_remove_and_destroy(t_dictionary *, char *, void(*element_destroyer)(void*));
 
 	/**
-	* @NAME: dictionary_iterator
-	* @DESC: Aplica closure a todos los elementos del diccionario.
-	*
-	* La función que se pasa por paremtro recibe (char* key, void* element)
+	* @fn    dictionary_iterator
+	* @brief Aplica closure a todos los elementos del diccionario.
 	*/
-	void 		  dictionary_iterator(t_dictionary *, void(*closure)(char*,void*));
+	void 		  dictionary_iterator(t_dictionary *, void(*closure)(char* key, void* element));
 
 	/**
-	* @NAME: dictionary_clean
-	* @DESC: Quita todos los elementos del diccionario
+	* @fn    dictionary_clean
+	* @brief Quita todos los elementos del diccionario
 	*/
 	void 		  dictionary_clean(t_dictionary *);
 
 	/**
-	* @NAME: dictionary_clean_and_destroy_elements
-	* @DESC: Quita todos los elementos del diccionario y los destruye
+	* @fn    dictionary_clean_and_destroy_elements
+	* @brief Quita todos los elementos del diccionario y los destruye
 	*/
 	void 		  dictionary_clean_and_destroy_elements(t_dictionary *, void(*element_destroyer)(void*));
 
 	/**
-	* @NAME: dictionary_has_key
-	* @DESC: Retorna true si key se encuentra en el diccionario
+	* @fn    dictionary_has_key
+	* @brief Retorna true si key se encuentra en el diccionario
 	*/
 	bool 		  dictionary_has_key(t_dictionary *, char* key);
 
 	/**
-	* @NAME: dictionary_is_empty
-	* @DESC: Retorna true si el diccionario está vacío
+	* @fn    dictionary_is_empty
+	* @brief Retorna true si el diccionario está vacío
 	*/
 	bool 		  dictionary_is_empty(t_dictionary *);
 
 	/**
-	* @NAME: dictionary_size
-	* @DESC: Retorna la cantidad de elementos del diccionario
+	* @fn    dictionary_size
+	* @brief Retorna la cantidad de elementos del diccionario
 	*/
 	int 		  dictionary_size(t_dictionary *);
 
 	/**
-	* @NAME: dictionary_keys
-	* @DESC: Retorna todas las keys en una lista
+	* @fn    dictionary_keys
+	* @brief Retorna todas las keys en una lista
 	*/
 	t_list 		  *dictionary_keys(t_dictionary *self);
 
 	/**
-	* @NAME: dictionary_elements
-	* @DESC: Retorna todos los elementos en una lista
+	* @fn    dictionary_elements
+	* @brief Retorna todos los elementos en una lista
 	*/
 	t_list 		  *dictionary_elements(t_dictionary *self);
 
 	/**
-	* @NAME: dictionary_destroy
-	* @DESC: Destruye el diccionario
+	* @fn    dictionary_destroy
+	* @brief Destruye el diccionario
 	*/
 	void 		  dictionary_destroy(t_dictionary *);
 
 	/**
-	* @NAME: dictionary_destroy_and_destroy_elements
-	* @DESC: Destruye el diccionario y destruye sus elementos
+	* @fn    dictionary_destroy_and_destroy_elements
+	* @brief Destruye el diccionario y destruye sus elementos
 	*/
 	void 		  dictionary_destroy_and_destroy_elements(t_dictionary *, void(*element_destroyer)(void*));