QuickVars.h

#ifndef QuickVars_h
#define QuickVars_h

#if !defined(PikaScriptImpl_h)
#include "PikaScriptImpl.h"
#endif

namespace Pika {

// TODO : documentation with use example
// TODO : I think this one could be based on an arbitrary variables class and use assign, lookup etc of the super-class instead of accessing vars directly. The question is if it would affect performance?
template<class Super, unsigned int CACHE_SIZE = 11> class QuickVars : public Super {
        public:         typedef typename Super::ForScript::String String;
        public:         typedef typename Super::ForScript::Value Value;
        public:         typedef std::pair<String, Value> CacheEntry;
                        
        public:         unsigned int hash(const String& s) {
                                        unsigned int l = static_cast<unsigned int>(s.size());
                                        if (s.size() == 1 && s[0] >= 'a' && s[0] <= 'z') return (s[0] - 'a') % CACHE_SIZE;
                                        if (s.size() == 2 && s[0] == '$' && s[1] >= '0' && s[1] <= '9') return s[1] - '0';
                                        return (s[0] * 1733 + s[l >> 2] * 2069 + s[l >> 1] * 2377 + s[l - 1] * 2851) % CACHE_SIZE;
                                }

        public:         virtual bool assign(const String& identifier, const Value& value) {
                                        if (identifier.empty()) return false;
                                        unsigned int i = hash(identifier);
                                        if (cache[i].first == identifier) { cache[i] = CacheEntry(identifier, value); return true; }
                                        if (!cache[i].first.empty()) Super::vars[cache[i].first] = cache[i].second;
                                        cache[i] = CacheEntry(identifier, value);
                                        return true;
                                }

        public:         virtual bool erase(const String& identifier) {
                                        bool erased = (Super::vars.erase(identifier) != 0);
                                        unsigned int i = hash(identifier);
                                        if (cache[i].first == identifier) { cache[i] = std::pair<const String, Value>(); erased = true; }
                                        return erased;
                                }

        public:         virtual bool lookup(const String& identifier, Value& result) {
                                        if (identifier.empty()) return false;
                                        unsigned int i = hash(identifier);
                                        if (cache[i].first == identifier) { result = cache[i].second; return true; }
                                        typename Super::VariableMap::const_iterator it = Super::vars.find(identifier);
                                        if (it == Super::vars.end()) return false;
                                        if (!cache[i].first.empty()) Super::vars[cache[i].first] = cache[i].second;
                                        cache[i] = CacheEntry(identifier, it->second);
                                        result = it->second;
                                        return true;
                                }

        public:         virtual void list(const String& key, typename Super::ForScript::Variables::VarList& list) {
                                        for (unsigned int i = 0; i < CACHE_SIZE; ++i)
                                                if (!cache[i].first.empty()) Super::vars[cache[i].first] = cache[i].second;
                                        for (typename Super::VariableMap::const_iterator it = Super::vars.lower_bound(key)
                                                        ; it != Super::vars.end() && it->first.substr(0, key.size()) == key; ++it)
                                                list.push_back(*it);
                                }

        protected:      CacheEntry cache[CACHE_SIZE];
};

} // namespace Pika

#endif