---

loader.cc

Go to the documentation of this file.

#include <dlfcn.h>
#include "register.hh"
#include <list>

namespace anoid {
    namespace loader {

        using namespace std;
        using namespace config;

        Loader loader;

        Loader::Loader() {
        }

        Loader::~Loader() {
        }

        void Loader::includeInformation(Configuration &c) {
            cout << "Loading class information" << endl;
            if (c.getName() == "classes") {
                list<Configuration *> classes = c.getChildren();
                
                list<DynamicLoadableModuleInfo *> unprocessed;
                list<DynamicLoadableModuleInfo *> nextstep;

                for (list<Configuration *>::iterator i = classes.begin(); i != classes.end(); ++i) {
                    if ((*i)->getName() == "class") {
                        DynamicLoadableModuleInfo *dlmi = new DynamicLoadableModuleInfo((*i)->getString("name"), (*i)->getString("url")); 
                        list<Configuration *> depends = (*i)->getChildren();
                        for (list<Configuration *>::iterator j = depends.begin(); j != depends.end(); ++j) {
                            if ((*j)->getName() == "requires")
                                dlmi->requires.push_back((*j)->getString("ref"));
                            delete (*j);
                        }
                        nextstep.push_back(dlmi);
                    }

                    delete (*i);
                }

                while (unprocessed.size() != nextstep.size()) {
                    unprocessed = nextstep;
                    nextstep.clear();
                    for (list<DynamicLoadableModuleInfo *>::iterator i = unprocessed.begin(); i != unprocessed.end(); ++i) {
                        bool clean = true;
                        for (list<string>::iterator j = (*i)->requires.begin(); j != (*i)->requires.end(); ++j) {
                            if (modules.count(*j) == 0)
                                clean = false;
                        }
                        if (clean) {
                            cout << "Registering " << (*i)->name << endl;
                            modules[(*i)->name] = (*i);
                        } else
                            nextstep.push_back(*i);
                    }
                }

                if (!unprocessed.empty()) {
                    for (list<DynamicLoadableModuleInfo *>::iterator i = unprocessed.begin(); i != unprocessed.end(); ++i) {
                        cerr << "Module `" << (*i)->name << "' has unsatisfied dependencies." << endl;
                    }
                }
            }
        }

        void Loader::associate(const string &name, RegisterBase *factory) {
            cout << "Associating " << name << endl;
            if (factoryMap[name] == NULL) {
                factoryMap[name] = factory;
            } // else error
        }

        void Loader::disassociate(const string &name) {
            factoryMap.erase(name);
        }

        void Loader::load(const std::string &name) {
            if (DLLMap[name] == NULL) {
                DynamicLoadableModuleInfo *d = modules[name];
                if (d) {
                    cout << "Loading " << name << endl;
                    for (list<string>::iterator i = d->requires.begin(); i != d->requires.end(); ++i) {
                        load(*i);
                    }
                    void *tmp = dlopen(d->location.c_str(), RTLD_NOW);
                    if (tmp) {
                        DLLMap[name] = tmp;
                    } else {
                        cerr << "Could not load library `" << name << "'." << endl
                            << "Loading failed with `" << dlerror() << "'." << endl;
                    }
                    cout << "Done loading " << name << endl;
                    return;
                } else {
                    cerr << "Could not find module `" << name << "'." << endl;
                }
            } // else error

        }

        void Loader::unload(const std::string &library) {
            void *tmp = DLLMap[library];
            if (tmp != NULL) {
                dlclose(tmp);
            }
            DLLMap.erase(library);
        }

        Base *Loader::getInstance(const std::string &name) {
            RegisterBase *factory = factoryMap[name];
            if (factory == NULL) {
                load(name);
                factory = factoryMap[name];
            }
            if (factory != NULL) {
                return factory->instantiate();
            } // else error
            return NULL;
        }
    };
};

---

Anoid NG © Michael Westergaard, Martin Stig Stissing, Ronni Michael Laursen, and Kristian Bisgaard Lassen