MMFs + a scaled down hash set to use them with

common/fixed_memory_hash_set.h

@@ -0,0 +1,226 @@
+#ifndef _EQEMU_FIXED_MEMORY_HASHSET_H
+#define _EQEMU_FIXED_MEMORY_HASHSET_H
+
+#include <string.h>
+#include "eqemu_exception.h"
+#include "types.h"
+
+namespace EQEmu {
+
+    /*! Simple HashSet designed to be used in fixed memory that may be difficult to use an 
+    allocator for (shared memory), we assume all keys are unsigned int
+    */
+    template<class T>
+    class FixedMemoryHashSet {
+        typedef uint32 key_type;
+        typedef T value_type;
+        typedef uint8 byte;
+        typedef value_type& reference;
+        typedef const value_type& const_reference;
+        typedef size_t size_type;
+    public:
+        /*!
+            Constructor which initializes the hash set
+        \param data Raw data
+        \param size Raw data size
+        \param element_count Max number of possible unique elements that can be inserted. 
+        \param max_element_id Number of offsets to store: eg highest "key" that will be used.
+        */
+        FixedMemoryHashSet(byte *data, size_type size, key_type element_count, key_type max_element_id) {
+            data_ = data;
+            size_ = size;
+
+            byte *ptr = data;
+            *reinterpret_cast<key_type*>(ptr) = max_element_id;
+            offset_count_ = max_element_id;
+            ptr += sizeof(key_type);
+
+            *reinterpret_cast<key_type*>(ptr) = element_count;
+            max_elements_ = element_count;
+            ptr += sizeof(key_type);
+
+            *reinterpret_cast<key_type*>(ptr) = 0;
+            current_elements_ = 0;
+            ptr += sizeof(key_type);
+
+            offsets_ = reinterpret_cast<key_type*>(ptr);
+            memset(ptr, 0xFFFFFFFFU, sizeof(key_type) * max_element_id);
+            ptr += sizeof(key_type) * max_element_id;
+
+            elements_ = reinterpret_cast<value_type*>(ptr);
+        }
+
+        /*!
+            Constructor which does not initialize the hash set.  Builds the hash set from what data is 
+            stored in the data pointer passed.
+        \param data Raw data
+        \param size Raw data size
+        */
+        FixedMemoryHashSet(byte *data, size_type size) {
+            data_ = data;
+            size_ = size;
+
+            byte *ptr = data;
+
+            offset_count_ = *reinterpret_cast<key_type*>(ptr);
+            ptr += sizeof(key_type);
+
+            max_elements_ = *reinterpret_cast<key_type*>(ptr);
+            ptr += sizeof(key_type);
+
+            current_elements_ = *reinterpret_cast<key_type*>(ptr);
+            ptr += sizeof(key_type);
+
+            offsets_ = reinterpret_cast<key_type*>(ptr);
+            ptr += sizeof(key_type) * offset_count_;
+
+            elements_ = reinterpret_cast<value_type*>(ptr);
+        }
+
+        //! Copy Constructor
+        FixedMemoryHashSet(const FixedMemoryHashSet& other) :
+            data_(other.data_),
+            size_(other.size_),
+            offset_count_(other.offset_count_),
+            max_elements_(other.max_elements_),
+            current_elements_(other.current_elements_),
+            offsets_(other.offsets_),
+            elements_(other.elements_)
+        {
+        }
+
+        //! RValue-Move Constructor
+        FixedMemoryHashSet(FixedMemoryHashSet&& other) :
+            data_(other.data_),
+            size_(other.size_),
+            offset_count_(other.offset_count_),
+            max_elements_(other.max_elements_),
+            current_elements_(other.current_elements_),
+            offsets_(other.offsets_),
+            elements_(other.elements_)
+        {
+        }
+
+        //! Destructor
+        ~FixedMemoryHashSet() {
+        }
+
+        //! Assignment operator
+        const FixedMemoryHashSet& operator=(const FixedMemoryHashSet& other) {
+            data_ = other.data_;
+            size_ = other.size_;
+            offset_count_ = other.offset_count_;
+            max_elements_ = other.max_elements_;
+            current_elements_ = other.current_elements_;
+            offsets_ = other.offsets_;
+            elements_ = other.elements_;
+            return *this;
+        }
+    
+        //! Returns whether the set is empty (has 0 elements) or not
+        bool empty() const {
+            return current_elements_ == 0;
+        }
+
+        //! Returns the number of unique elements in the set currently
+        size_type size() const {
+            return current_elements_;
+        }
+
+        //! Returns the maximum number of elements one can insert into the set.
+        size_type max_size() const {
+            return max_elements_;
+        }
+        
+        /*!
+            Retrieve value operator
+        \param i Index to retrieve the value from
+        */
+        reference operator[](const key_type& i) {
+            if(i >= offset_count_) {
+                EQ_EXCEPT("Fixed Memory Hash Set", "Index out of range");
+            }
+
+            if(offsets_[i] == 0xFFFFFFFFU) {
+                EQ_EXCEPT("Fixed Memory Hash Set", "Element not found.");
+            }
+
+            return elements_[offsets_[i]];
+        }
+
+        /*!
+            Retrieve value function
+        \param i Index to retrieve the value from
+        */
+        reference at(const key_type& i) {
+            if(i >= offset_count_) {
+                EQ_EXCEPT("Fixed Memory Hash Set", "Index out of range.");
+            }
+
+            if(offsets_[i] == 0xFFFFFFFFU) {
+                EQ_EXCEPT("Fixed Memory Hash Set", "Element not found.");
+            }
+
+            return elements_[offsets_[i]];
+        }
+
+        /*!
+            Checks if there is a value at a certain index
+        \param i Index to check for a value
+        */
+        bool exists(const key_type& i) const {
+            if(i >= offset_count_) {
+                return false;
+            }
+
+            if(offsets_[i] == 0xFFFFFFFFU) {
+                return false;
+            }
+
+            return true;
+        }
+
+        /*!
+            Inserts a value into the set at a specific index
+        \param i Index to insert the value at
+        \param v Value to insert
+        */
+        void insert(const key_type& i, const_reference v) {
+            if(i >= offset_count_) {
+                EQ_EXCEPT("Fixed Memory Hash Set", "Index out of range.");
+            }
+
+            if(offsets_[i] != 0xFFFFFFFFU) {
+                elements_[offsets_[i]] = v;
+            } else {
+                if(current_elements_ >= max_elements_) {
+                    EQ_EXCEPT("Fixed Memory Hash Set", "Insert pointer out of range.");
+                }
+
+                offsets_[i] = current_elements_;
+                memcpy(&elements_[current_elements_], &v, sizeof(value_type));
+                ++current_elements_;
+                *reinterpret_cast<key_type*>(data_ + (sizeof(key_type) * 2)) = current_elements_;
+            }
+        }
+
+        //! Calculates how much memory we should allocate based on element size and count 
+        static size_type estimated_size(key_type element_count, key_type max_elements) {
+            size_type total_size = 3 * sizeof(key_type);
+            total_size += sizeof(key_type) * max_elements;
+            total_size += sizeof(T) * element_count;
+            return total_size;
+        }
+
+    private:
+        unsigned char *data_;
+        size_type size_;
+        key_type offset_count_;
+        key_type max_elements_;
+        key_type current_elements_;
+        key_type *offsets_;
+        value_type *elements_;
+    };
+} // EQEmu
+
+#endif