116 lines
3.7 KiB
C++
116 lines
3.7 KiB
C++
// commenting everything out when I commit so all commits my code technically
|
|
// compiles
|
|
#include <algorithm>
|
|
#include <initializer_list>
|
|
#include <iterator>
|
|
#include <optional>
|
|
#include <stdexcept>
|
|
#include <utility>
|
|
#include <vector>
|
|
namespace cs440 {
|
|
|
|
template <typename Key_T, typename Mapped_T> class Map {
|
|
private:
|
|
using ValueType = std::pair<const Key_T, Mapped_T>;
|
|
// idx 0 = root
|
|
// left = parent * 2 + 1
|
|
// right = parent * 2 + 2
|
|
std::vector<std::optional<ValueType>> store;
|
|
|
|
public:
|
|
// TODO: Iterator functionality
|
|
class Iterator {
|
|
using underlying = typename std::vector<std::optional<ValueType>>::iterator;
|
|
underlying store_iter;
|
|
|
|
public:
|
|
Iterator() = delete;
|
|
Iterator(underlying iter) : store_iter{iter} {}
|
|
};
|
|
class ConstIterator {
|
|
using underlying =
|
|
typename std::vector<std::optional<ValueType>>::const_iterator;
|
|
underlying store_iter;
|
|
|
|
public:
|
|
ConstIterator() = delete;
|
|
ConstIterator(underlying iter) : store_iter{iter} {}
|
|
};
|
|
class ReverseIterator {
|
|
using underlying = typename std::vector<std::optional<ValueType>>::iterator;
|
|
underlying store_iter;
|
|
|
|
public:
|
|
ReverseIterator() = delete;
|
|
ReverseIterator(underlying store_iter) : store_iter{store_iter} {}
|
|
};
|
|
Map() : store{} {}
|
|
Map(const Map &rhs) : store{rhs.store} {}
|
|
Map &operator=(const Map &rhs) { this->store = rhs.store; }
|
|
Map(std::initializer_list<ValueType> elems) : store{} {
|
|
this->insert(elems.begin(), elems.end());
|
|
}
|
|
// who cares we're using vector
|
|
~Map() {}
|
|
|
|
size_t size() const { return this->store.size(); }
|
|
bool empty() const { return this->store.empty(); }
|
|
// TODO: iterator creation
|
|
Iterator begin() {
|
|
Key_T const &start =
|
|
std::min_element(store.begin(), store.end(),
|
|
[](std::optional<ValueType> const &lhs,
|
|
std::optional<ValueType> const &rhs) {
|
|
if (lhs.has_value() != rhs.has_value()) {
|
|
return lhs.has_value();
|
|
}
|
|
|
|
return lhs.value().first < rhs.value().first;
|
|
})
|
|
->first;
|
|
return Iterator(*this, start);
|
|
}
|
|
Iterator end() { std::optional return Iterator(*this, ); }
|
|
ConstIterator begin() const { return ConstIterator(*this, ); }
|
|
ConstIterator end() const { return this->cbegin(); }
|
|
ConstIterator cbegin() const { return this->cend(); }
|
|
ConstIterator cend() const { return ConstIterator(*this, ); }
|
|
ReverseIterator rbegin() { return Iterator(*this, ); }
|
|
ReverseIterator rend() { return Iterator(*this, ); }
|
|
Iterator find(const Key_T &) {}
|
|
ConstIterator find(const Key_T &) const;
|
|
Mapped_T &at(const Key_T &key) {}
|
|
const Mapped_T &at(const Key_T &key) const {}
|
|
Mapped_T &operator[](const Key_T &) {}
|
|
std ::pair<Iterator, bool> insert(const ValueType &) {}
|
|
template <typename IT_T> void insert(IT_T range_beg, IT_T range_end) {
|
|
std::for_each(range_beg, range_end,
|
|
[&](ValueType &val) { this->insert(val); });
|
|
}
|
|
// TODO: erase via iterator
|
|
void erase(Iterator pos) {}
|
|
void erase(const Key_T &key) { this->erase(this->find(key)); }
|
|
void clear() { this->store = {}; }
|
|
friend bool operator==(const Map &lhs, const Map &rhs) {
|
|
if (lhs.store.size() != rhs.store.size()) {
|
|
return false;
|
|
}
|
|
auto liter = lhs.cbegin();
|
|
auto riter = rhs.cbegin();
|
|
// both must be the same length so this is fine
|
|
while (liter != lhs.cend()) {
|
|
if (*liter != *riter) {
|
|
return false;
|
|
}
|
|
liter++;
|
|
riter++;
|
|
}
|
|
return true;
|
|
}
|
|
friend bool operator!=(const Map &lhs, const Map &rhs) {
|
|
return !(lhs == rhs);
|
|
}
|
|
// TODO < operator
|
|
friend bool operator<(const Map &lhs, const Map &rhs) {}
|
|
};
|
|
} // namespace cs440
|