From 7d6dac04d53ea6ebc936e73613a34d8bf94916bf Mon Sep 17 00:00:00 2001 From: Jessica James Date: Mon, 19 Dec 2016 16:57:58 -0500 Subject: [PATCH] Hash_Table: * Renamed m_pairs to m_entries * Added begin() and end() * Remove now returns bool instead of copy of value --- Jupiter/Hash_Table.h | 20 ++++++++-- Jupiter/Hash_Table_Imp.h | 81 +++++++++++++++++++++------------------- 2 files changed, 60 insertions(+), 41 deletions(-) diff --git a/Jupiter/Hash_Table.h b/Jupiter/Hash_Table.h index c0d72f4..4ec2776 100644 --- a/Jupiter/Hash_Table.h +++ b/Jupiter/Hash_Table.h @@ -85,7 +85,7 @@ namespace Jupiter * @param in_key Key of the entry to search for * @return Value of the entry which was removed on success, nullptr otherwise */ - ValueT *remove(const InKeyT &in_key); + bool remove(const InKeyT &in_key); /** * @brief Erases all entries from the bucket @@ -131,9 +131,23 @@ namespace Jupiter ~Bucket(); /** List of entries in the bucket */ - Jupiter::SLList m_pairs; + Jupiter::SLList m_entries; }; + /** + * @brief Returns an iterator positioned at the beginning of the table + * + * @brief Iterator at beginning of m_buckets + */ + Bucket *begin() const; + + /** + * @brief Returns an iterator positioned at the end of the table + * + * @return Iterator at end of m_buckets + */ + Bucket *end() const; + /** * @brief Fetches the value of an entry based on its key * @@ -157,7 +171,7 @@ namespace Jupiter * @param in_key Key of the entry to remove * @return Value of the entry that was removed if it exists, nullptr otherwise */ - ValueT *remove(const InKeyT &in_key); + bool remove(const InKeyT &in_key); /** * @brief Returns the number of entries in the table diff --git a/Jupiter/Hash_Table_Imp.h b/Jupiter/Hash_Table_Imp.h index d76f286..49ce408 100644 --- a/Jupiter/Hash_Table_Imp.h +++ b/Jupiter/Hash_Table_Imp.h @@ -65,7 +65,7 @@ Jupiter::Hash_Table::Bucket::Entry::Entry template ValueT *Jupiter::Hash_Table::Bucket::get(const InKeyT &in_key) const { - for (Jupiter::SLList::Node *node = m_pairs.getHead(); node != nullptr; node = node->next) + for (Jupiter::SLList::Node *node = m_entries.getHead(); node != nullptr; node = node->next) if (node->data->key == in_key) return &node->data->value; @@ -75,36 +75,31 @@ ValueT *Jupiter::Hash_Table::Bucket::get( template bool Jupiter::Hash_Table::Bucket::set(const InKeyT &in_key, const InValueT &in_value) { - for (Jupiter::SLList::Node *node = m_pairs.getHead(); node != nullptr; node = node->next) + for (Jupiter::SLList::Node *node = m_entries.getHead(); node != nullptr; node = node->next) if (node->data->key == in_key) { node->data->value = in_value; return false; } - m_pairs.add(new Entry(in_key, in_value)); + m_entries.add(new Entry(in_key, in_value)); return true; } template -ValueT *Jupiter::Hash_Table::Bucket::remove(const InKeyT &in_key) +bool Jupiter::Hash_Table::Bucket::remove(const InKeyT &in_key) { - Jupiter::SLList::Node *node = m_pairs.getHead(); - Entry *pair; - ValueT *result; + Jupiter::SLList::Node *node = m_entries.getHead(); // No nodes in the bucket if (node == nullptr) - return nullptr; + return false; // Check if the head is the desired node if (node->data->key == in_key) { - pair = m_pairs.removeHead(); - result = new ValueT(std::move(pair->value)); - delete pair; - - return result; + delete m_entries.removeHead(); + return true; } // iterate through list @@ -113,23 +108,20 @@ ValueT *Jupiter::Hash_Table::Bucket::remo if (node->next->data->key == in_key) { // The next node is the desired node - pair = m_pairs.removeNext(node); - result = new ValueT(std::move(pair->value)); - delete pair; - - return result; + delete m_entries.removeNext(node); + return true; } node = node->next; } - return nullptr; + return false; } template size_t Jupiter::Hash_Table::Bucket::erase() { - size_t length = m_pairs.size(); - m_pairs.eraseAndDelete(); + size_t length = m_entries.size(); + m_entries.eraseAndDelete(); return length; } @@ -137,9 +129,9 @@ size_t Jupiter::Hash_Table::Bucket::erase template typename Jupiter::Hash_Table::Bucket &Jupiter::Hash_Table::Bucket::operator=(const Bucket &in_bucket) { - m_pairs.eraseAndDelete(); - for (Jupiter::SLList::Node *node = in_bucket.m_pairs.getHead(); node != nullptr; node = node->next) - m_pairs.add(new Entry(node->data->key, node->data->value)); + m_entries.eraseAndDelete(); + for (Jupiter::SLList::Node *node = in_bucket.m_entries.getHead(); node != nullptr; node = node->next) + m_entries.add(new Entry(node->data->key, node->data->value)); return *this; } @@ -147,31 +139,43 @@ typename Jupiter::Hash_Table::Bucket &Jup template typename Jupiter::Hash_Table::Bucket &Jupiter::Hash_Table::Bucket::operator=(Bucket &&in_bucket) { - m_pairs = std::move(in_bucket.m_pairs); + m_entries = std::move(in_bucket.m_entries); return *this; } template Jupiter::Hash_Table::Bucket::Bucket(const Bucket &in_bucket) { - for (Jupiter::SLList::Node *node = in_bucket.m_pairs.getHead(); node != nullptr; node = node->next) - m_pairs.add(new Entry(node->data->key, node->data->value)); + for (Jupiter::SLList::Node *node = in_bucket.m_entries.getHead(); node != nullptr; node = node->next) + m_entries.add(new Entry(node->data->key, node->data->value)); } template Jupiter::Hash_Table::Bucket::Bucket(Bucket &&in_bucket) { - m_pairs = std::move(in_bucket.m_pairs); + m_entries = std::move(in_bucket.m_entries); } template Jupiter::Hash_Table::Bucket::~Bucket() { - m_pairs.eraseAndDelete(); + m_entries.eraseAndDelete(); } /** Hash_Table */ +template +typename Jupiter::Hash_Table::Bucket *Jupiter::Hash_Table::begin() const +{ + return m_buckets; +} + +template +typename Jupiter::Hash_Table::Bucket *Jupiter::Hash_Table::end() const +{ + return m_buckets + m_buckets_size; +} + template ValueT *Jupiter::Hash_Table::get(const InKeyT &in_key) const { @@ -193,14 +197,15 @@ bool Jupiter::Hash_Table::set(const InKey } template -ValueT *Jupiter::Hash_Table::remove(const InKeyT &in_key) +bool Jupiter::Hash_Table::remove(const InKeyT &in_key) { - ValueT *value = m_buckets[HashF(in_key) % m_buckets_size].remove(in_key); - - if (value != nullptr) + if (m_buckets[HashF(in_key) % m_buckets_size].remove(in_key)) + { --m_length; + return true; + } - return value; + return false; } template @@ -249,9 +254,9 @@ typename Jupiter::Hash_Table &Jupiter::Ha size_t index = 0; while (index != in_table.m_buckets_size) { - in_table.m_buckets[index].m_pairs.eraseAndDelete(); + in_table.m_buckets[index].m_entries.eraseAndDelete(); - for (node = in_table.m_buckets[index].m_pairs.getHead(); node != nullptr; node = node->next) + for (node = in_table.m_buckets[index].m_entries.getHead(); node != nullptr; node = node->next) m_buckets[HashF(node->data->key) % m_buckets_size].set(node->data->key, node->data->value); ++index; @@ -259,7 +264,7 @@ typename Jupiter::Hash_Table &Jupiter::Ha while (index != m_buckets_size) { - in_table.m_buckets[index].m_pairs.eraseAndDelete(); + in_table.m_buckets[index].m_entries.eraseAndDelete(); ++index; } } @@ -380,7 +385,7 @@ void Jupiter::Hash_Table::copy_to_buckets Jupiter::SLList::Node *node; for (size_t index = 0; index != m_buckets_size; ++index) - for (node = m_buckets[index].m_pairs.getHead(); node != nullptr; node = node->next) + for (node = m_buckets[index].m_entries.getHead(); node != nullptr; node = node->next) in_buckets[HashF(node->data->key) % in_buckets_size].set(node->data->key, node->data->value); }