table.cpp

/*
 * Implementation of the Table class.
 * Represents an in-memory key/value store table.
 * 
 * CSF Assignment 5
 * 
 * Ifrah Attar - iattar1@jh.edu
 * Morgan Huberty - mhubert3@jh.edu
 * 
 */

 #include <cassert>
 #include "table.h"
 #include "guard.h"
 
 /**
  * @brief Constructs a new Table with a given name.
  * Initializes the table's name and its mutex.
  * @param name The name of the table.
  */
 Table::Table( const std::string &name )
   : m_name( name )
 {
   pthread_mutex_init(&m_lock, nullptr);
 }
 
 /**
  * @brief Destroys the Table, cleaning up its mutex.
  */
 Table::~Table()
 {
   pthread_mutex_destroy(&m_lock);
 }
 
 /**
  * @brief Acquires the table's lock (blocking).
  */
 void Table::lock()
 {
   pthread_mutex_lock(&m_lock);
 }
 
 /**
  * @brief Releases the table's lock.
  */
 void Table::unlock()
 {
   pthread_mutex_unlock(&m_lock);
 }
 
 /**
  * @brief Tries to acquire the table's lock (non-blocking).
  * @return True if the lock was acquired, false otherwise.
  */
 bool Table::trylock()
 {
   return pthread_mutex_trylock(&m_lock) == 0;
 }
 
 /**
  * @brief Proposes setting a key to a specific value.
  * @param key The key to set.
  * @param value The value to associate with key.
  */
 void Table::set( const std::string &key, const std::string &value )
 {
   m_pending_data[key] = value;
   m_pending_deletions.erase(key);
 }
 
 /**
  * @brief Gets value associated with a key.
  * @param key The key whose value to retrieve.
  * @return The value associated with the key.
  * @throw OperationException if key does not exist.
  */
 std::string Table::get( const std::string &key )
 {
   if (m_pending_data.count(key)) {
     return m_pending_data.at(key);
   }
 
   if(m_pending_deletions.count(key)) {
       throw OperationException("Key not found");
   }
 
   if (m_data.count(key)) {
     return m_data.at(key);
   }
 
   throw OperationException("Key not found");
 }
 
 /**
  * @brief Checks if a key exists in table.
  * @param key The key to check.
  * @return True if the key exists, false otherwise.
  */
 bool Table::has_key( const std::string &key )
 {
   if(m_pending_deletions.count(key)) {
       return false;
   }
   
   return m_pending_data.count(key) || m_data.count(key);
 }
 
 /**
  * @brief Commits all pending changes to the table.
  */
 void Table::commit_changes()
 {
   for (const auto& pair : m_pending_data) {
     m_data[pair.first] = pair.second;
   }
   for (const auto& key : m_pending_deletions) {
     m_data.erase(key);
   }
   rollback_changes();
 }
 
 /**
  * @brief Rolls back all pending changes.
  */
 void Table::rollback_changes()
 {
   m_pending_data.clear();
   m_pending_deletions.clear();
 }