---

nci/suif/suif2b/basesuif/suifkernel/cascading_map.h

Go to the documentation of this file.

#ifndef IOKERNEL__CASCADINGMAP_H
#define IOKERNEL__CASCADINGMAP_H

#include "iokernel/object.h"
#include "iokernel/iokernel_forwarders.h"
#include "iokernel/object_factory.h"
#include "iokernel/meta_class.h"
#include "suif_env.h"
#include "common/suif_vector.h"

template < class T >
class CascadingMap {
public:
    CascadingMap( SuifEnv* suif, T defaultvalue );
    ~CascadingMap();
    
    void assign( const LString &className, T data);
                         
    // returns defaultvalue if not found;
    T lookup( const Object* object );
    
    // low level interface
    T lookup( const MetaClass* metaClass );
    void assign( MetaClass* mc, T newdata );
    
private:
    T defaultvalue;
    suif_vector<T>* entries;
    SuifEnv* suif;
    suif_vector<bool>* cached;
    suif_vector<bool>* valid;
    void clear_cache();
    void expand_to(MetaClassId to_id);
private:
    CascadingMap(const CascadingMap &other);
    CascadingMap& operator=(const CascadingMap &other);
};


class SuifEnv;

template < class T >
CascadingMap<T>::CascadingMap( SuifEnv* suif_env, T defaultvalue0 ) :
    defaultvalue(defaultvalue0), entries(0), suif(suif_env), cached(0),
    valid(0)
{
    //  this->suif = suif;
    unsigned num = suif->get_object_factory()->get_last_id();
    entries = new suif_vector<T>( num );
    cached = new suif_vector<bool>( num );
    valid = new suif_vector<bool>( num );
    for (unsigned i = 0; i < num; i++) {
        (*entries)[i] = defaultvalue;
        (*cached)[i] = false;
        (*valid)[i] = false;
    }
}

template< class T >
void CascadingMap<T>::clear_cache() {
    unsigned num = cached->size();
    for (unsigned i = 0; i < num; i++) {
        (*cached)[i] = false;
    }
}

template < class T >
CascadingMap<T>::~CascadingMap() {
    delete entries;
    delete cached;
    delete valid;
}

template < class T >
void CascadingMap<T>::assign( const LString &className,
                              T data ) {
  MetaClass *mc = suif->get_object_factory()->lookupMetaClass( className );
  suif_assert_message( mc, 
                       ("No metaclass registered for %s."
                        "Perhaps another dll is required.",
                        className.c_str() ));
  assign(mc, data);
}

template < class T >
void CascadingMap<T>::expand_to( MetaClassId id ) {
  while( id >= (MetaClassId)entries->size()){
    entries->push_back(defaultvalue);
    valid->push_back(false);
    cached->push_back(false);
  }
  return;
}


template < class T >
void CascadingMap<T>::assign( MetaClass* mc, T data ) {
    clear_cache();
    suif_assert_message( mc, 
                         ("Cascading Map can not Map the NULL MetaClass\n"));
    MetaClassId id = mc->get_meta_class_id();
    
    expand_to(id);

    (*entries)[id] = data;
    (*valid)[id] = true;
}

template < class T >
T CascadingMap<T>::lookup( const Object* object ) {
    return lookup( object->get_meta_class() );
}

template < class T > 
T CascadingMap<T>::lookup( const MetaClass* mc ) {
    MetaClassId id = mc->get_meta_class_id();
    expand_to(id);
    
    if ((*valid)[id] || (*cached)[id]) {
        return (*entries)[ id ];
    } else {
        MetaClass *parent = mc->get_link_meta_class();
        if (parent) {
            T res = lookup(parent);
            (*entries)[id] = res;
            (*cached)[id] = true;
            return res;
        } else {
            (*entries)[id] = defaultvalue;
            (*cached)[id] = true;
            return defaultvalue;
        }
    }
}

#endif

---