Index: uspace/lib/cpp/include/internal/rbtree.hpp
===================================================================
--- uspace/lib/cpp/include/internal/rbtree.hpp	(revision 2a482ee40885f39a3c30ddcc530c64bdc712a5bf)
+++ uspace/lib/cpp/include/internal/rbtree.hpp	(revision be9eb152c94a7442901d1280328ff0294332548f)
@@ -56,4 +56,7 @@
             using const_iterator       = ConstIterator;
 
+            using reverse_iterator       = std::reverse_iterator<iterator>;
+            using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
             using node_type = rbtree_node<value_type>;
 
@@ -63,11 +66,30 @@
             { /* DUMMY BODY */ }
 
-            rbtree(const rbtree& other);
-
-            rbtree(rbtree&& other);
-
-            rbtree& operator=(const rbtree& other);
-
-            rbtree& operator=(rbtree&& other);
+            rbtree(const rbtree& other); // TODO:
+
+            rbtree(rbtree&& other)
+                : root_{other.root_}, size_{other.size_},
+                  key_compare_{move(other.key_compare_)},
+                  key_extractor_{move(other.key_extractor_)}
+            {
+                other.root_ = nullptr;
+                other.size_ = size_type{};
+            }
+
+            rbtree& operator=(const rbtree& other)
+            {
+                auto tmp{other};
+                tmp.swap(*this);
+
+                return *this;
+            }
+
+            rbtree& operator=(rbtree&& other)
+            {
+                rbtree tmp{move(other)};
+                tmp.swap(*this);
+
+                return *this;
+            }
 
             bool empty() const noexcept
@@ -106,4 +128,24 @@
             }
 
+            reverse_iterator rbegin()
+            {
+                return make_reverse_iterator(end());
+            }
+
+            const_reverse_iterator rbegin() const
+            {
+                return make_reverse_iterator(cend());
+            }
+
+            reverse_iterator rend()
+            {
+                return make_reverse_iterator(begin());
+            }
+
+            const_reverse_iterator rend() const
+            {
+                return make_reverse_iterator(cbegin());
+            }
+
             const_iterator cbegin() const
             {
@@ -114,4 +156,14 @@
             {
                 return const_iterator{find_largest_(), true};
+            }
+
+            const_reverse_iterator crbegin() const
+            {
+                return make_reverse_iterator(cend());
+            }
+
+            const_reverse_iterator crend() const
+            {
+                return make_reverse_iterator(cbegin());
             }
 
@@ -191,10 +243,18 @@
             iterator find(const key_type& key)
             {
-                // TODO: implement
-            }
-
-            const_iterator find(const key_type&& key) const
-            {
-                // TODO: implement
+                auto node = find_(key);
+                if (node)
+                    return iterator{node, false};
+                else
+                    return end();
+            }
+
+            const_iterator find(const key_type& key) const
+            {
+                auto node = find_(key);
+                if (node)
+                    return const_iterator{node, false};
+                else
+                    return end();
             }
 
@@ -273,4 +333,20 @@
             key_extract key_extractor_;
 
+            node_type* find_(const key_type& key) const
+            {
+                auto current = root_;
+                while (current != nullptr)
+                {
+                    if (key_compare_(key, key_extractor_(current->value)))
+                        current = current->left;
+                    else if (key == key_extractor_(current->value))
+                        return current;
+                    else
+                        current = current->right;
+                }
+
+                return nullptr;
+            }
+
             node_type* find_smallest_() const
             {
@@ -304,4 +380,9 @@
             }
 
+            void repair_after_erase_(node_type* node)
+            {
+                // TODO: implement
+            }
+
             friend Policy;
     };