DoTypeTable.hpp

#ifndef DOTYPETABLE_HPP
#define DOTYPETABLE_HPP


// A helper class to make locating and linking base clases efficient.
// A tailor made hash table for type and base type lookup 

#include "DoType.h"

template<class T, int N>
struct DynObjTypeTableBase { 
    DynObjTypeTableBase() { IterReset(); } 
    enum { TableSize=1<<N }; 
    
    ExpArrP<T*,short> _types[TableSize];
    
    void Insert( T* pdt ){
        int ix = Hash(GetTypeLookupName(pdt)) & (TableSize-1);
        _types[ix].Push(pdt);
    }
    
    T* Lookup( const char* type ){
        int ix = Hash(type) & (TableSize-1);
        ExpArrP<T*,short>& slot = _types[ix];
        for( int jx=slot.Size()-1; jx>=0; jx-- ){
            if( !strcmp(GetTypeLookupName(slot[jx]),type) )
                return slot[jx];
        }
        return NULL;
    }
    
    T* Remove( const char* type ){
        int ix = Hash(type) & (TableSize-1);
        int n_remove = 0;
        ExpArrP<T*,short>& slot = _types[ix];
        for( int jx=slot.Size()-1; jx>=0; jx-- ){
            if( !strcmp(GetTypeLookupName(slot[jx]),type) ){
                T * pdt = slot.RemoveIndex(jx);
                n_remove++;
                return pdt;
            }
        }
        return NULL;
        //return n_remove>0;
    }
    
    //virtual const char* GetTypeLookupName( T *pdt ) = 0;
    
    short m_it_line, m_it_pos;
    int m_it_ix;
    
    void IterReset( ){
        m_it_line = 0; 
        m_it_pos = -1; 
        m_it_ix = -1;
    }
    
    bool IterStep( ){
        if( m_it_line>=TableSize ) return false;
        while( ++m_it_pos>=_types[m_it_line].Size() ){
            m_it_pos = -1;
            if( ++m_it_line>=TableSize ) 
                return false;
        }
        m_it_ix++;
        return true;
    }
    
    T* operator [] (int ix ){
        if( ix<m_it_ix ) 
            IterReset();
        while( m_it_ix<ix )
            if( !IterStep() )
                return NULL;
        return _types[m_it_line][m_it_pos];
    }
    
    static int Hash( const char *ps ){ 
        if( !ps ) return 0;
        int sum = 0;
        int sl = (int)strlen(ps);
        int p0 = 4*(sl>>2);
        const char* pe = ps + p0;
        while( ps<pe ){
            sum += *(int*)ps;
            ps += 4;
        }
        while( sl&3 ){
            sum += *ps++;
            sl--;
        }
        return sum; 
    }

    // Builtin specialization for DynObjType
    const char* GetTypeLookupName( DynObjType *pdt ){
        // Return actual type name
        return pdt->_type;
    }

    // Built in specialization for DoBaseNode
    const char* GetTypeLookupName( DoBaseNode* pbn ){
        // Return base class name
        DO_ASSERT_MSG(pbn && pbn->Unresolved(), "DynObjBaseTable::GetTypeLookupName - Should have unresolved DoBaseNode");
        return pbn->_base_type;
    }

};

template <int N>
struct DynObjTypeTable : public DynObjTypeTableBase<DynObjType,N> {
    // Cannot use typedef since we have a template
};

template <int N>
struct DynObjBaseTable : public DynObjTypeTableBase<DoBaseNode,N> {
    // Cannot use typedef since we have a template
};

#endif // DOTYPETABLE_HPP

---