sm_namehashset.h

Go to the documentation of this file.

#ifndef _include_sourcemod_namehashset_h_
#define _include_sourcemod_namehashset_h_

#include <am-allocator-policies.h>
#include <am-hashmap.h>
#include <am-string.h>
#include "sm_stringhashmap.h"

namespace SourceMod
{

// The HashPolicy type must have this method:
//              static bool matches(const char *key, const T &value);
//
// Depending on what lookup types are used.
//
// If these members are available on T, then the HashPolicy type can be left
// default. It is okay to use |T *|, the functions will still be looked up
// on |T|.
template <typename T, typename KeyPolicy = T>
class NameHashSet : public ke::SystemAllocatorPolicy
{
        typedef detail::CharsAndLength CharsAndLength;

        // Default policy type: the two types are different. Use them directly.
        template <typename KeyType, typename KeyPolicyType>
        struct Policy
        {
                typedef KeyType Payload;

                static uint32_t hash(const CharsAndLength &key)
                {
                        return key.hash();
                }

                static bool matches(const CharsAndLength &key, const KeyType &value)
                {
                        return KeyPolicyType::matches(key.chars(), value);
                }
        };

        // Specialization: the types are equal, and T is a pointer. Strip the
        // pointer off so we can access T:: for match functions.
        template <typename KeyType>
        struct Policy<KeyType *, KeyType *>
        {
                typedef KeyType *Payload;

                static uint32_t hash(const detail::CharsAndLength &key)
                {
                        return key.hash();
                }

                static bool matches(const CharsAndLength &key, const KeyType *value)
                {
                        return KeyType::matches(key.chars(), value);
                }
        };

        typedef ke::HashTable<Policy<T, KeyPolicy>, ke::SystemAllocatorPolicy> Internal;

public:
        NameHashSet()
        {
                if (!table_.init())
                        this->reportOutOfMemory();
        }

        typedef typename Internal::Result Result;
        typedef typename Internal::Insert Insert;
        typedef typename Internal::iterator iterator;

        Result find(const char *aKey)
        {
                return table_.find(aKey);
        }

        Insert findForAdd(const char *aKey)
        {
                return table_.findForAdd(aKey);
        }

        void add(Insert &i, const T &value)
        {
                return table_.add(i, value);
        }

        void add(Insert &i, ke::Moveable<T> value)
        {
                return table_.add(i, value);
        }

        bool retrieve(const char *aKey, T *value)
        {
                CharsAndLength key(aKey);
                Result r = table_.find(aKey);
                if (!r.found())
                        return false;
                *value = *r;
                return true;
        }

        bool insert(const char *aKey, const T &value)
        {
                CharsAndLength key(aKey);
                Insert i = table_.findForAdd(key);
                if (i.found())
                        return false;
                return table_.add(i, value);
        }

        bool insert(const char *aKey, ke::Moveable<T> value)
        {
                CharsAndLength key(aKey);
                Insert i = table_.findForAdd(key);
                if (i.found())
                        return false;
                return table_.add(i, value);
        }

        bool contains(const char *aKey)
        {
                CharsAndLength key(aKey);
                Result r = table_.find(aKey);
                return r.found();
        }

        bool remove(const char *aKey)
        {
                CharsAndLength key(aKey);
                Result r = table_.find(key);
                if (!r.found())
                        return false;
                table_.remove(r);
                return true;
        }

        void remove(Result &r)
        {
                table_.remove(r);
        }

        void clear()
        {
                table_.clear();
        }

        size_t mem_usage() const
        {
                return table_.estimateMemoryUse();
        }

        iterator iter()
        {
                return iterator(&table_);
        }

private:
        Internal table_;
};

}

#endif // _include_sourcemod_namehashset_h_