Use Markdown in doc comments for better source readability.

git-svn-id: http://svn.drobilla.net/lad/trunk/raul@5428 a436a847-0d15-0410-975c-d299462d15a1

5 files changed, 20 insertions, 20 deletions

diff --git a/raul/Maid.hpp b/raul/Maid.hpp
index c1d76c1..0380d64 100644
--- a/raul/Maid.hpp
+++ b/raul/Maid.hpp
@@ -80,7 +80,7 @@ public:
 
 	/** Manage an object held by a shared pointer.
 	 *
-	 * This will hold a reference to @p ptr ensuring it will not be deleted
+	 * This will hold a reference to `ptr` ensuring it will not be deleted
 	 * except by cleanup().  This is mainly useful to allow dropping references
 	 * in real-time threads without causing a deletion.
 	 *
diff --git a/raul/Path.hpp b/raul/Path.hpp
index ee8444a..256c1fc 100644
--- a/raul/Path.hpp
+++ b/raul/Path.hpp
@@ -45,7 +45,7 @@ public:
 
 	/** Construct a Path from a C++ string.
 	 *
-	 * This will throw an exception if @p path is invalid.  To avoid this, use
+	 * This will throw an exception if `path` is invalid.  To avoid this, use
 	 * is_valid() first to check.
 	 */
 	explicit Path(const std::basic_string<char>& path)
@@ -58,7 +58,7 @@ public:
 
 	/** Construct a Path from a C string.
 	 *
-	 * This will throw an exception if @p path is invalid.  To avoid this, use
+	 * This will throw an exception if `path` is invalid.  To avoid this, use
 	 * is_valid() first to check.
 	 */
 	explicit Path(const char* path)
@@ -78,12 +78,12 @@ public:
 		: std::basic_string<char>(path)
 	{}
 
-	/** Return true iff @p c is a valid Path character. */
+	/** Return true iff `c` is a valid Path character. */
 	static inline bool is_valid_char(char c) {
 		return c == '/' || Symbol::is_valid_char(c);
 	}
 
-	/** Return true iff @p str is a valid Path. */
+	/** Return true iff `str` is a valid Path. */
 	static inline bool is_valid(const std::basic_string<char>& str) {
 		if (str.empty() || (str[0] != '/')) {
 			return false;  // Must start with '/'
@@ -111,13 +111,13 @@ public:
 	/** Return true iff this path is the root path ("/"). */
 	inline bool is_root() const { return *this == "/"; }
 
-	/** Return true iff this path is a child of @p parent at any depth. */
+	/** Return true iff this path is a child of `parent` at any depth. */
 	inline bool is_child_of(const Path& parent) const {
 		const std::string parent_base = parent.base();
 		return substr(0, parent_base.length()) == parent_base;
 	}
 
-	/** Return true iff this path is a parent of @p child at any depth. */
+	/** Return true iff this path is a parent of `child` at any depth. */
 	inline bool is_parent_of(const Path& child) const {
 		return child.is_child_of(*this);
 	}
@@ -197,7 +197,7 @@ public:
 		return Path(a.substr(0, last_sep));
 	}
 
-	/** Return true iff @p child is equal to, or a descendant of @p parent. */
+	/** Return true iff `child` is equal to, or a descendant of `parent`. */
 	static inline bool descendant_comparator(const Path& parent,
 	                                         const Path& child) {
 		return (child == parent || child.is_child_of(parent));
diff --git a/raul/Semaphore.hpp b/raul/Semaphore.hpp
index 152d50e..dbebf06 100644
--- a/raul/Semaphore.hpp
+++ b/raul/Semaphore.hpp
@@ -76,7 +76,7 @@ public:
 	/** Attempt Wait/Decrement.  Return true iff decremented. */
 	inline bool try_wait();
 
-	/** Wait for at most @p ms milliseconds.  Return true iff decremented. */
+	/** Wait for at most `ms` milliseconds.  Return true iff decremented. */
 	inline bool timed_wait(unsigned ms);
 
 private:
diff --git a/raul/Symbol.hpp b/raul/Symbol.hpp
index 7af99ba..6f0dd91 100644
--- a/raul/Symbol.hpp
+++ b/raul/Symbol.hpp
@@ -44,7 +44,7 @@ public:
 
 	/** Construct a Symbol from a C++ string.
 	 *
-	 * This will throw an exception if @p symbol is invalid.  To avoid this,
+	 * This will throw an exception if `symbol` is invalid.  To avoid this,
 	 * use is_valid() first to check.
 	 */
 	explicit Symbol(const std::basic_string<char>& symbol)
@@ -57,7 +57,7 @@ public:
 
 	/** Construct a Symbol from a C string.
 	 *
-	 * This will throw an exception if @p symbol is invalid.  To avoid this,
+	 * This will throw an exception if `symbol` is invalid.  To avoid this,
 	 * use is_valid() first to check.
 	 */
 	explicit Symbol(const char* symbol)
@@ -77,17 +77,17 @@ public:
 		: std::basic_string<char>(symbol)
 	{}
 
-	/** Return true iff @p c is a valid Symbol start character. */
+	/** Return true iff `c` is a valid Symbol start character. */
 	static inline bool is_valid_start_char(char c) {
 		return (c == '_') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
 	}
 
-	/** Return true iff @p c is a valid Symbol character. */
+	/** Return true iff `c` is a valid Symbol character. */
 	static inline bool is_valid_char(char c) {
 		return is_valid_start_char(c) || (c >= '0' && c <= '9');
 	}
 
-	/** Return true iff @p str is a valid Symbol. */
+	/** Return true iff `str` is a valid Symbol. */
 	static inline bool is_valid(const std::basic_string<char>& str) {
 		if (str.empty() || (str[0] >= '0' && str[0] <= '9')) {
 			return false;  // Must start with a letter or underscore
diff --git a/raul/URI.hpp b/raul/URI.hpp
index b2ccad7..c84ef2b 100644
--- a/raul/URI.hpp
+++ b/raul/URI.hpp
@@ -37,7 +37,7 @@ public:
 
 	/** Construct a URI from a C++ string.
 	 *
-	 * This will throw an exception if @p uri is invalid.  To avoid this, use
+	 * This will throw an exception if `uri` is invalid.  To avoid this, use
 	 * is_valid() first to check.
 	 */
 	explicit URI(const std::basic_string<char>& uri)
@@ -50,7 +50,7 @@ public:
 
 	/** Construct a URI from a C string.
 	 *
-	 * This will throw an exception if @p uri is invalid.  To avoid this, use
+	 * This will throw an exception if `uri` is invalid.  To avoid this, use
 	 * is_valid() first to check.
 	 */
 	explicit URI(const char* uri)
@@ -70,21 +70,21 @@ public:
 		: std::basic_string<char>(uri)
 	{}
 
-	/** Return true iff @p c is a valid URI start character. */
+	/** Return true iff `c` is a valid URI start character. */
 	static inline bool is_valid_start_char(char c) {
 		return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
 	}
 
-	/** Return true iff @p c is a valid URI scheme character. */
+	/** Return true iff `c` is a valid URI scheme character. */
 	static inline bool is_valid_scheme_char(char c) {
 		// S3.1: scheme ::= ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
 		return is_valid_start_char(c) || (c >= '0' && c <= '9') ||
 			c == '+' || c == '-' || c == '.';
 	}
 
-	/** Return true iff @p str is a valid URI.
+	/** Return true iff `str` is a valid URI.
 	 *
-	 * Currently this only checks that @p starts with a valid URI scheme.
+	 * Currently this only checks that `starts` with a valid URI scheme.
 	 */
 	static inline bool is_valid(const std::basic_string<char>& str) {
 		if (!is_valid_start_char(str[0])) {