lookup.h

Go to the documentation of this file.

 
#pragma once
 
#include <config.h>
 
#include <cassert>
 
#include <string>
#include <initializer_list>
 
#include "fundamentals.h"
 
template <class EnumClass> class StandardLookupValues {
public:
    const char *name;
    EnumClass value;
};
 
template <class EnumClass,
class LookupTableType = StandardLookupValues <EnumClass> > class LookupTable {
    const LookupTableType *table = NULL;
    const int table_size = 0;
    bool release = false; // True when table was allocated from free store.
public:
    LookupTable () = delete;
    LookupTable (const LookupTable <EnumClass, LookupTableType> &) = delete;
    LookupTable (const LookupTable <EnumClass, LookupTableType> &&) = delete;
    LookupTable (const LookupTableType *tab) {
        table = tab;
        int i = 0;
        for (i = 0; tab [i].name; i++) /* just looking */;
        *const_cast <int *> (&this->table_size) = i;
    }
    LookupTable (const std::initializer_list<LookupTableType> tab) :
    table_size (tab.size()) {
        LookupTableType *iniz = new LookupTableType [tab.size() + 1];
        int i = 0;
        for (auto item : tab) {
            assert (item.name);
            iniz [i].name = item.name;
            iniz [i++].value = item.value;
        }
        iniz [i].name = NULL;
        table = iniz;
        release = true;
    }
    ~LookupTable () {
        if (release) {
            delete[] table;
        }
    };
 
 
    virtual const LookupTableType *get (const char *s) const noexcept {
        for (const LookupTableType *l = table; l->name != NULL; l++) {
            if (strcasecmp (s, l->name) == 0) {
                return l;
            }
        }
        return NULL;
    }
 
    const EnumClass operator[] (const char *s) const {
        const LookupTableType *item = get (s);
        if (!item) {
            throw CommandError (E_INVALID, s);
        }
        return item->value;
    }
 
    inline const EnumClass operator[] (const std::string &s) const {
        return (*this) [s.c_str()];
    }
    const bool tryGetValue (const char *s, EnumClass *value) const {
        const LookupTableType *item = get (s);
        if (!item) return false;
        *value = item->value;
        return true;
    }
    inline const bool tryGetValue (const std::string &s, EnumClass *value) const {
        return tryGetValue (s.c_str(), value);
    }
 
    const LookupTableType *get (const EnumClass id) const {
        for (const LookupTableType *l = table; l->name != NULL; l++) {
            if (id == l->value) {
                return l;
            }
        }
        assert (0);
        return NULL;
    }
    const char *operator[] (const EnumClass id) const {
        const LookupTableType *item = get (id);
        if (!item) return nullptr;
        return item->name;
    }
 
    const LookupTableType *begin () const {
        return &table [0];
    }
 
    const LookupTableType *end () const {
        return &table [table_size];
    }
};