modules.h

#ifndef MODULES_HEADER_
#define MODULES_HEADER_

//  Forwards for all classes visible outside this header
class Module;
class ModuleFactory;
template <class Iface> class Interface;



class Module {
    friend class ModuleFactory; 
//  Type definitions
public:
    enum CloneMethod { ShallowCopy, DeepCopy };
    enum ChoiceType {
        Stop,       
        Int,        
        IntLog2,    
        Float,      
        ModuleCombo,
        Combo       
    };
    union SettingValue {
        int i;      
        float f;    
    };
    struct SettingType {
        ChoiceType type;        
        SettingValue defaults;  

        union {
            int i[2];           
            float f[2];         
            const char *text;   

            const std::vector<int> *compatIDs;
        } data;             
    };

    struct SettingTypeItem {
        static const SettingTypeItem stopper; 

        const char *label   
        , *desc;            
        SettingType type;   
    };

    struct SettingItem {
        Module *m;  
        SettingValue val;   

        SettingItem(): m(0) { DEBUG_ONLY( val.f= std::numeric_limits<float>::quiet_NaN(); ) }

        SettingItem(const SettingTypeItem &typeItem): m(0), val(typeItem.type.defaults) {}

        ~SettingItem() { delete m; }
    };

    struct TypeInfo {
        int id;                         
        const char *name                
        , *desc;                        
        int setLength;                  
        const SettingTypeItem *setType; 
    };

//  Data definitions
protected:
    SettingItem *settings; 

private:
    SettingItem* copySettings(CloneMethod method) const;
    void initDefaultModuleLinks();
    void nullModuleLinks();
    void createDefaultSettings();

    Module& operator=(const Module&);
    Module(const Module&);
protected:
    Module(): settings(0) {}

    virtual Module* abstractClone(CloneMethod method) const =0;
public: // public because of GCC-3 versions
    template<class M> M* concreteClone(CloneMethod method) const;
    
public:
    virtual ~Module()
        { delete[] settings; }

    virtual const TypeInfo& info() const =0;

    DECLARE_debugModule_empty

public:
    virtual void adjustSettings( int which, QTreeWidgetItem *myTree, QGroupBox *setBox );
protected:
    void widget2settings( const QWidget *widget, int which );
    void settings2widget( QWidget *widget, int which );
    void settingsType2widget( QWidget *widget, const SettingTypeItem &typeItem );

//  Other methods
protected:
    void file_saveAllSettings(std::ostream &stream);
    void file_loadAllSettings(std::istream &stream);
    void file_saveModuleType( std::ostream &os, int which );
    void file_loadModuleType( std::istream &is, int which );
    int& settingsInt(int index)
        { return settings[index].val.i; }
    int settingsInt(int index) const
        { return settings[index].val.i; }

    static SettingType settingInt(int min,int defaults,int max,ChoiceType type=Int) {
        ASSERT( type==Int || type==IntLog2 );
        SettingType result;
        result.type= type;
        result.defaults.i= defaults;
        result.data.i[0]= min;
        result.data.i[1]= max;
        return result;
    }
    static SettingType settingFloat(float min,float defaults,float max) {
        SettingType result;
        result.type= Float;
        result.defaults.f= defaults;
        result.data.f[0]= min;
        result.data.f[1]= max;
        return result;
    }
    static SettingType settingCombo(const char *text,int defaults) {
        ASSERT( defaults>=0 && defaults<1+countEOLs(text) );
        SettingType result;
        result.type= Combo;
        result.defaults.i= defaults;
        result.data.text= text;
        return result;
    }
    template<class Iface> static SettingType settingModule(int defaultID) {
        const std::vector<int> &compMods= Iface::getCompMods();
        int index=  find( compMods.begin(), compMods.end(), defaultID ) - compMods.begin();
        ASSERT( index < (int)compMods.size() );
        SettingType result;
        result.type= ModuleCombo;
        result.defaults.i= index;
        result.data.compatIDs= &compMods;
        return result;
    }
    template<class Iface> static SettingType settingModule() {
        return settingModule<Iface>( Iface::getCompMods().front() );
    }
}; // Module class



#define DECLARE_TypeInfo_helper(CNAME_,NAME_,DESC_,SETTYPE_...) \
 \
    friend class Module; /* Needed for concreteClone */ \
    /*friend class ModuleFactory;*/ \
    friend struct ModuleFactory::Creator<CNAME_>; /* Needed for GCC-3 and ICC */ \
public: \
    CNAME_* abstractClone(CloneMethod method=DeepCopy) const \
        { return concreteClone<CNAME_>(method); } \
 \
    const TypeInfo& info() const { \
        static SettingTypeItem setType_[]= {SETTYPE_}; \
        static TypeInfo info_= { \
            id: ModuleFactory::getModuleID<CNAME_>(), \
            name:NAME_, \
            desc: DESC_, \
            setLength: sizeof(setType_)/sizeof(*setType_)-1, \
            setType: setType_ \
        }; \
        return info_; \
    } \
 \


#define DECLARE_TypeInfo_noSettings(CNAME_,NAME_,DESC_) \
    DECLARE_TypeInfo_helper(CNAME_,NAME_,DESC_,SettingTypeItem::stopper)

#define DECLARE_TypeInfo(CNAME_,NAME_,DESC_,SETTYPE_...) \
    DECLARE_TypeInfo_helper(CNAME_,NAME_,DESC_,SETTYPE_,SettingTypeItem::stopper)



class ModuleFactory {
    static ModuleFactory *instance;
    std::vector<Module*> prototypes;

    ModuleFactory() {}
    ~ModuleFactory() {
        for_each( prototypes, std::mem_fun(&Module::nullModuleLinks) );
        clearContainer(prototypes);
    }
    void initialize();

public:
    template<class M> static int getModuleID();

    static void init()
        { ASSERT(!instance); (instance=new ModuleFactory)->initialize(); }
    static void destroy()
        { delete instance; instance=0; }

    static const Module& prototype(int id) {
        ASSERT( instance && instance->prototypes.at(id) );
        return *instance->prototypes[id];
    }
    static Module* newModule( int id, Module::CloneMethod method=Module::DeepCopy )
        { return prototype(id).abstractClone(method); }

    static void changeDefaultSettings(const Module &module);

#ifndef __ICC
private:
#endif
//  some helper stuff
    template<class T> struct Creator {
        T* operator()() const { return new T; }
    };
private:
    template<class T> struct Instantiator {
        int operator()() const;
    };
    static void instantiateModules();
}; // ModuleFactory class


template<class Iface> class Interface: public Module {
    static std::vector<int> compMods_; 
public:
    static const std::vector<int>& getCompMods();
    static const Iface& compatiblePrototype(int index=0) {
        ASSERT( index>=0 && index<(int)getCompMods().size() );
        return *debugCast<const Iface*>(&ModuleFactory::prototype( getCompMods()[index] ));
    }
    static Iface* newCompatibleModule(int index=0)
        { return compatiblePrototype(index).clone(); }
        
    Iface* clone(CloneMethod method=DeepCopy) const
        { return debugCast<Iface*>( abstractClone(method) ); }
};

#endif // MODULES_HEADER_

---