From: Amelia Coutard <eliottulio.coutard@gmail.com>
Date: Sat, 4 Jun 2022 14:23:47 +0000 (+0200)
Subject: Added Doxygen comments to all of the phys_ptr class
X-Git-Url: https://git.ameliathe1st.gay/?a=commitdiff_plain;h=70a3a4cef58fee0fd62a4181b210ad633c753f28;p=voyage-au-centre-des-fichiers.git

Added Doxygen comments to all of the phys_ptr class
---

diff --git a/src/phys_ptr.hpp b/src/phys_ptr.hpp
index 256cd5d..bfae710 100644
--- a/src/phys_ptr.hpp
+++ b/src/phys_ptr.hpp
@@ -5,69 +5,119 @@
 
 namespace os {
 
+/** \brief A class that handles the translation from physical to virtual addresses.
+ *
+ * It avoids the risk of translating an address zero or two times, by storing
+ * physical addresses as a different class.
+ */
 template <typename T>
 class phys_ptr {
 public:
+	/** Constructs a phys_ptr corresponding to the given physical address.
+	 */
 	constexpr explicit phys_ptr(std::uintptr_t phys_addr): phys_addr(phys_addr) {}
+	/** Constructs a phys_ptr that doesn't correspond to any place in physical memory.
+	 * It is represented internally by ~0 instead of 0 to allow for access of physical address 0.
+	 */
 	constexpr phys_ptr(std::nullptr_t): phys_addr(~0ull) {}
 
+	/** Access the T at the physical address of the ith element of a T array starting at this physical address.
+	 */
 	T& operator[](std::size_t i) const {
 		return get_virt_addr()[i];
 	}
+	/** Access the T at this physical address.
+	 */
 	T& operator*() const {
 		return *get_virt_addr();
 	}
+	/** Access the T at this physical address.
+	 */
 	T* operator->() const {
 		return get_virt_addr();
 	}
 
+	/** Change the address to that of the following T in physical memory.
+	 * \return New address.
+	 */
 	constexpr phys_ptr<T>& operator++() {
 		return *this += 1;
 	}
+	/** Change the address to that of the following T in physical memory.
+	 * \return Old address.
+	 */
 	constexpr phys_ptr<T> operator++(int) {
 		const auto old = *this;
 		operator++();
 		return old;
 	}
+	/** Change the address to that of the previous T in physical memory.
+	 * \return New address.
+	 */
 	constexpr phys_ptr<T>& operator--() {
 		return *this -= 1;
 	}
+	/** Change the address to that of the previous T in physical memory.
+	 * \return Old address.
+	 */
 	constexpr phys_ptr<T> operator--(int) {
 		const auto old = *this;
 		operator--();
 		return old;
 	}
+	/** Move offset Ts forwards in physical memory.
+	 * \return New address.
+	 */
 	constexpr phys_ptr<T>& operator+=(std::ptrdiff_t offset) {
 		return *this = *this + offset;
 	}
+	/** Move offset Ts backwards in physical memory.
+	 * \return New address.
+	 */
 	constexpr phys_ptr<T>& operator-=(std::ptrdiff_t offset) {
 		return *this = *this - offset;
 	}
 
+	/** \return A new phys_ptr refering to the T offset Ts forward from ptr.
+	 */
 	friend constexpr phys_ptr<T> operator+(phys_ptr<T> ptr, std::ptrdiff_t offset) {
 		return phys_ptr<T>{ptr.phys_addr + offset * sizeof(T)};
 	}
+	/** \return A new phys_ptr refering to the T offset Ts forward from ptr.
+	 */
 	friend constexpr phys_ptr<T> operator+(std::ptrdiff_t offset, phys_ptr<T> ptr) {
 		return ptr + offset;
 	}
+	/** \return A new phys_ptr refering to the T offset Ts backwards from ptr.
+	 */
 	friend constexpr phys_ptr<T> operator-(phys_ptr<T> ptr, std::ptrdiff_t offset) {
 		return phys_ptr<T>{ptr.phys_addr - offset * sizeof(T)};
 	}
+	/** \return The numbers of Ts between the two phys_ptr.
+	 */
 	friend constexpr std::ptrdiff_t operator-(phys_ptr<T> a, phys_ptr<T> b) {
 		return (a.phys_addr - b.phys_addr) / sizeof(T);
 	}
 
+	/** \return This physical address, as a uintptr_t.
+	 */
 	constexpr std::uintptr_t get_phys_addr() const {
 		return phys_addr;
 	}
 
+	/** Compare the physical addresses, an address that's before another one in memory is smaller than that one.
+	 */
 	friend constexpr auto operator<=>(phys_ptr<T> a, phys_ptr<T> b) = default;
 
 private:
+	/** The function used inside of the class to get the virtual address that corresponds to this physical address.
+	 */
 	constexpr T* get_virt_addr() const {
 		return reinterpret_cast<T*>(phys_addr + 0xFFFF800000000000);
 	}
 
+	/** This physical address, as a std::uintptr_t
+	 */
 	std::uintptr_t phys_addr;
 };