Index: code/branches/core/src/orxonox/core/Level.cc
===================================================================
--- code/branches/core/src/orxonox/core/Level.cc	(revision 799)
+++ 	(revision )
@@ -1,179 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- */
-
-#include "Level.h"
-#include "Identifier.h"
-#include "BaseObject.h"
-
-namespace orxonox
-{
-    Level::Level(const std::string& file)
-    {
-        this->setFile(file);
-        this->setIncludes(ClassIdentifier<BaseObject>::getIdentifier());
-        this->setExcludes(0);
-    }
-
-    Level::Level(const std::string& file, const Identifier* include)
-    {
-        this->setFile(file);
-        this->setIncludes(include);
-        this->setExcludes(0);
-    }
-
-    Level::Level(const std::string& file, const std::vector<const Identifier*>& includes)
-    {
-        this->setFile(file);
-        this->setIncludes(includes);
-        this->setExcludes(0);
-    }
-
-    Level::Level(const std::string& file, const Identifier* include, const Identifier* exclude)
-    {
-        this->setFile(file);
-        this->setIncludes(include);
-        this->setExcludes(exclude);
-    }
-
-    Level::Level(const std::string& file, const std::vector<const Identifier*>& includes, const Identifier* exclude)
-    {
-        this->setFile(file);
-        this->setIncludes(includes);
-        this->setExcludes(exclude);
-    }
-
-    Level::Level(const std::string& file, const Identifier* include, std::vector<const Identifier*> excludes)
-    {
-        this->setFile(file);
-        this->setIncludes(include);
-        this->setExcludes(excludes);
-    }
-
-    Level::Level(const std::string& file, const std::vector<const Identifier*>& includes, std::vector<const Identifier*> excludes)
-    {
-        this->setFile(file);
-        this->setIncludes(includes);
-        this->setExcludes(excludes);
-    }
-
-
-
-    void Level::setFile(const std::string& file)
-    {
-        this->file_ = file;
-    }
-
-    void Level::setIncludes(const Identifier* include)
-    {
-        this->includes_ = std::vector<const Identifier*>(1, include);
-    }
-
-    void Level::setIncludes(const std::vector<const Identifier*>& includes)
-    {
-        this->includes_ = includes;
-
-        for (std::vector<const Identifier*>::iterator it1 = this->includes_.begin(); it1 < this->includes_.end(); ++it1)
-            for (std::vector<const Identifier*>::iterator it2 = ++it1; it2 < this->includes_.end(); ++it2)
-                if ((*it1) == (*it2))
-                    this->includes_.erase(it2++);
-    }
-
-    void Level::setExcludes(const Identifier* exclude)
-    {
-        this->excludes_ = std::vector<const Identifier*>(1, exclude);
-    }
-
-    void Level::setExcludes(const std::vector<const Identifier*>& excludes)
-    {
-        this->excludes_ = excludes;
-
-        for (std::vector<const Identifier*>::iterator it1 = this->excludes_.begin(); it1 < this->excludes_.end(); ++it1)
-            for (std::vector<const Identifier*>::iterator it2 = ++it1; it2 < this->excludes_.end(); ++it2)
-                if ((*it1) == (*it2))
-                    this->excludes_.erase(it2++);
-    }
-
-
-
-    void Level::addIncludes(const Identifier* include)
-    {
-        for (std::vector<const Identifier*>::const_iterator it = this->includes_.begin(); it < this->includes_.end(); ++it)
-            if ((*it) == include)
-                return;
-
-        this->includes_.insert(this->includes_.end(), include);
-    }
-
-    void Level::addIncludes(const std::vector<const Identifier*>& includes)
-    {
-        for (std::vector<const Identifier*>::const_iterator it = includes.begin(); it < includes.end(); ++it)
-            this->addIncludes(*it);
-    }
-
-    void Level::addExcludes(const Identifier* exclude)
-    {
-        for (std::vector<const Identifier*>::const_iterator it = this->excludes_.begin(); it < this->excludes_.end(); ++it)
-            if ((*it) == exclude)
-                return;
-
-        this->excludes_.insert(this->excludes_.end(), exclude);
-    }
-
-    void Level::addExcludes(const std::vector<const Identifier*>& excludes)
-    {
-        for (std::vector<const Identifier*>::const_iterator it = excludes.begin(); it < excludes.end(); ++it)
-            this->addExcludes(*it);
-    }
-
-
-
-    void Level::removeIncludes(const Identifier* include)
-    {
-        for (std::vector<const Identifier*>::iterator it = this->includes_.begin(); it < this->includes_.end(); ++it)
-            if ((*it) == include)
-                this->includes_.erase(it);
-    }
-
-    void Level::removeIncludes(const std::vector<const Identifier*>& includes)
-    {
-        for (std::vector<const Identifier*>::const_iterator it = includes.begin(); it < includes.end(); ++it)
-            this->removeIncludes(*it);
-    }
-
-    void Level::removeExcludes(const Identifier* exclude)
-    {
-        for (std::vector<const Identifier*>::iterator it = this->excludes_.begin(); it < this->excludes_.end(); ++it)
-            if ((*it) == exclude)
-                this->excludes_.erase(it);
-    }
-
-    void Level::removeExcludes(const std::vector<const Identifier*>& excludes)
-    {
-        for (std::vector<const Identifier*>::const_iterator it = excludes.begin(); it < excludes.end(); ++it)
-            this->removeExcludes(*it);
-    }
-}
Index: code/branches/core/src/orxonox/core/Level.h
===================================================================
--- code/branches/core/src/orxonox/core/Level.h	(revision 799)
+++ 	(revision )
@@ -1,76 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- */
-
-#ifndef _Level_H__
-#define _Level_H__
-
-#include <string>
-#include <vector>
-
-#include "CorePrereqs.h"
-
-namespace orxonox
-{
-    class _CoreExport Level
-    {
-        public:
-            Level(const std::string& file);
-            Level(const std::string& file, const Identifier* include);
-            Level(const std::string& file, const std::vector<const Identifier*>& includes);
-            Level(const std::string& file, const Identifier* include, const Identifier* exclude);
-            Level(const std::string& file, const std::vector<const Identifier*>& includes, const Identifier* exclude);
-            Level(const std::string& file, const Identifier* include, std::vector<const Identifier*> excludes);
-            Level(const std::string& file, const std::vector<const Identifier*>& includes, std::vector<const Identifier*> excludes);
-
-            void setFile(const std::string& file);
-            void setIncludes(const Identifier* include);
-            void setIncludes(const std::vector<const Identifier*>& includes);
-            void setExcludes(const Identifier* exclude);
-            void setExcludes(const std::vector<const Identifier*>& excludes);
-
-            void addIncludes(const Identifier* include);
-            void addIncludes(const std::vector<const Identifier*>& includes);
-            void addExcludes(const Identifier* exclude);
-            void addExcludes(const std::vector<const Identifier*>& excludes);
-
-            void removeIncludes(const Identifier* include);
-            void removeIncludes(const std::vector<const Identifier*>& includes);
-            void removeExcludes(const Identifier* exclude);
-            void removeExcludes(const std::vector<const Identifier*>& excludes);
-
-            inline const std::string& getFile() const { return this->file_; }
-            inline const std::vector<const Identifier*>& getIncludes() const { return this->includes_; }
-            inline const std::vector<const Identifier*>& getExcludes() const { return this->excludes_; }
-
-        private:
-            std::string file_;
-            std::vector<const Identifier*> includes_;
-            std::vector<const Identifier*> excludes_;
-    };
-}
-
-#endif
Index: code/branches/core/src/orxonox/core/Loader.cc
===================================================================
--- code/branches/core/src/orxonox/core/Loader.cc	(revision 799)
+++ 	(revision )
@@ -1,378 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- */
-
-#include "Loader.h"
-#include "Identifier.h"
-#include "Iterator.h"
-#include "BaseObject.h"
-#include "util/tinyxml/tinyxml.h"
-
-namespace orxonox
-{
-    std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > > Loader::files_s;
-
-    // ###############################
-    // ###          open           ###
-    // ###############################
-    // Single file
-    bool Loader::open(const std::string& file)
-    {
-        return Loader::open(file, ClassIdentifier<BaseObject>::getIdentifier());
-    }
-
-    bool Loader::open(const std::string& file, const Identifier* subclassInclude)
-    {
-        return Loader::open(file, subclassInclude, 0);
-    }
-
-    bool Loader::open(const std::string& file, const Identifier* subclassInclude, const Identifier* subclassExclude)
-    {
-        return Loader::open(file, subclassInclude, std::vector<const Identifier*>(1, subclassExclude));
-    }
-
-    bool Loader::open(const std::string& file, const Identifier* subclassInclude, std::vector<const Identifier*> subclassesExclude)
-    {
-        return Loader::open(file, std::vector<const Identifier*>(1, subclassInclude), subclassesExclude);
-    }
-
-    bool Loader::open(const std::string& file, const std::vector<const Identifier*>& subclassesInclude)
-    {
-        return Loader::open(file, subclassesInclude, 0);
-    }
-
-    bool Loader::open(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude)
-    {
-        return Loader::open(file, subclassesInclude, std::vector<const Identifier*>(1, subclassExclude));
-    }
-
-    bool Loader::open(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, std::vector<const Identifier*> subclassesExclude)
-    {
-        return Loader::open(std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >(1, std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > >(file, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> >(subclassesInclude, subclassesExclude))));
-    }
-
-
-    // Multiple files with common conditions
-    bool Loader::open(const std::vector<std::string>& files)
-    {
-        return Loader::open(files, ClassIdentifier<BaseObject>::getIdentifier());
-    }
-
-    bool Loader::open(const std::vector<std::string>& files, const Identifier* subclassInclude)
-    {
-        return Loader::open(files, subclassInclude, 0);
-    }
-
-    bool Loader::open(const std::vector<std::string>& files, const Identifier* subclassInclude, const Identifier* subclassExclude)
-    {
-        return Loader::open(files, subclassInclude, std::vector<const Identifier*>(1, subclassExclude));
-    }
-
-    bool Loader::open(const std::vector<std::string>& files, const Identifier* subclassInclude, std::vector<const Identifier*> subclassesExclude)
-    {
-        return Loader::open(files, std::vector<const Identifier*>(1, subclassInclude), subclassesExclude);
-    }
-
-    bool Loader::open(const std::vector<std::string>& files, const std::vector<const Identifier*>& subclassesInclude)
-    {
-        return Loader::open(files, subclassesInclude, 0);
-    }
-
-    bool Loader::open(const std::vector<std::string>& files, const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude)
-    {
-        return Loader::open(files, subclassesInclude, std::vector<const Identifier*>(1, subclassExclude));
-    }
-
-    bool Loader::open(const std::vector<std::string>& files, const std::vector<const Identifier*>& subclassesInclude, std::vector<const Identifier*> subclassesExclude)
-    {
-        std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > > temp;
-        for (std::vector<std::string>::const_iterator it = files.begin(); it < files.end(); ++it)
-            temp.insert(temp.end(), std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > >(*it, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> >(subclassesInclude, subclassesExclude)));
-
-        return Loader::open(temp);
-    }
-
-
-    // Multiple files with individual conditions
-    bool Loader::open(const std::vector<std::pair<std::string, const Identifier*> >& files)
-    {
-        std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > > temp;
-        for (std::vector<std::pair<std::string, const Identifier*> >::const_iterator it = files.begin(); it < files.end(); ++it)
-            temp.insert(temp.end(), std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > >(it->first, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> >(std::vector<const Identifier*>(1, it->second), std::vector<const Identifier*>(1, (const Identifier*)0))));
-
-        return Loader::open(temp);
-    }
-
-    bool Loader::open(const std::vector<std::pair<std::string, std::pair<const Identifier*, const Identifier*> > >& files)
-    {
-        std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > > temp;
-        for (std::vector<std::pair<std::string, std::pair<const Identifier*, const Identifier*> > >::const_iterator it = files.begin(); it < files.end(); ++it)
-            temp.insert(temp.end(), std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > >(it->first, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> >(std::vector<const Identifier*>(1, it->second.first), std::vector<const Identifier*>(1, it->second.second))));
-
-        return Loader::open(temp);
-    }
-
-    bool Loader::open(const std::vector<std::pair<std::string, std::pair<const Identifier*, std::vector<const Identifier*> > > >& files)
-    {
-        std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > > temp;
-        for (std::vector<std::pair<std::string, std::pair<const Identifier*, std::vector<const Identifier*> > > >::const_iterator it = files.begin(); it < files.end(); ++it)
-            temp.insert(temp.end(), std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > >(it->first, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> >(std::vector<const Identifier*>(1, it->second.first), it->second.second)));
-
-        return Loader::open(temp);
-    }
-
-    bool Loader::open(const std::vector<std::pair<std::string, std::vector<const Identifier*> > >& files)
-    {
-        std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > > temp;
-        for (std::vector<std::pair<std::string, std::vector<const Identifier*> > >::const_iterator it = files.begin(); it < files.end(); ++it)
-            temp.insert(temp.end(), std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > >(it->first, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> >(it->second, std::vector<const Identifier*>(1, (const Identifier*)0))));
-
-        return Loader::open(temp);
-    }
-
-    bool Loader::open(const std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, const Identifier*> > >& files)
-    {
-        std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > > temp;
-        for (std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, const Identifier*> > >::const_iterator it = files.begin(); it < files.end(); ++it)
-            temp.insert(temp.end(), std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > >(it->first, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> >(it->second.first, std::vector<const Identifier*>(1, it->second.second))));
-
-        return Loader::open(temp);
-    }
-
-    bool Loader::open(const std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >& files)
-    {
-        Loader::files_s = files;
-        Loader::unload();
-        return Loader::load(Loader::files_s);
-    }
-
-    // ###############################
-    // ###           add           ###
-    // ###############################
-    bool Loader::add(const std::string& file)
-    {
-        return Loader::add(file, ClassIdentifier<BaseObject>::getIdentifier());
-    }
-
-    bool Loader::add(const std::string& file, const Identifier* subclassInclude)
-    {
-        return Loader::add(file, subclassInclude, 0);
-    }
-
-    bool Loader::add(const std::string& file, const Identifier* subclassInclude, const Identifier* subclassExclude)
-    {
-        return Loader::add(file, std::vector<const Identifier*>(1, subclassInclude), std::vector<const Identifier*>(1, subclassExclude));
-    }
-
-    bool Loader::add(const std::string& file, const Identifier* subclassInclude, std::vector<const Identifier*> subclassesExclude)
-    {
-        return Loader::add(file, std::vector<const Identifier*>(1, subclassInclude), subclassesExclude);
-    }
-
-    bool Loader::add(const std::string& file, const std::vector<const Identifier*>& subclassesInclude)
-    {
-        return Loader::add(file, subclassesInclude, 0);
-    }
-
-    bool Loader::add(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude)
-    {
-        return Loader::add(file, subclassesInclude, std::vector<const Identifier*>(1, subclassExclude));
-    }
-
-    bool Loader::add(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, std::vector<const Identifier*> subclassesExclude)
-    {
-        Loader::files_s.insert(Loader::files_s.end(), std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > >(file, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> >(subclassesInclude, subclassesExclude)));
-        return Loader::load(file, subclassesInclude, subclassesExclude);
-    }
-
-    // ###############################
-    // ###         remove          ###
-    // ###############################
-    void Loader::remove()
-    {
-        Loader::files_s.clear();
-    }
-
-    void Loader::remove(const std::vector<std::string>& files)
-    {
-        for (std::vector<std::string>::const_iterator it = files.begin(); it < files.end(); ++it)
-            Loader::remove(*it);
-    }
-
-    void Loader::remove(const std::string& file)
-    {
-        for (std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >::iterator it = Loader::files_s.begin(); it < Loader::files_s.end(); ++it)
-            if (it->first.compare(file) == 0)
-                Loader::files_s.erase(it);
-    }
-
-    // ###############################
-    // ###         reload          ###
-    // ###############################
-    bool Loader::reload()
-    {
-        return Loader::reload(ClassIdentifier<BaseObject>::getIdentifier());
-    }
-
-    bool Loader::reload(const Identifier* subclassInclude)
-    {
-        return Loader::reload(subclassInclude, 0);
-    }
-
-    bool Loader::reload(const Identifier* subclassInclude, const Identifier* subclassExclude)
-    {
-        return Loader::reload(std::vector<const Identifier*>(1, subclassInclude), std::vector<const Identifier*>(1, subclassExclude));
-    }
-
-    bool Loader::reload(const Identifier* subclassInclude, const std::vector<const Identifier*>& subclassesExclude)
-    {
-        return Loader::reload(std::vector<const Identifier*>(1, subclassInclude), subclassesExclude);
-    }
-
-    bool Loader::reload(const std::vector<const Identifier*>& subclassesInclude)
-    {
-        return Loader::reload(subclassesInclude, 0);
-    }
-
-    bool Loader::reload(const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude)
-    {
-        return Loader::reload(subclassesInclude, std::vector<const Identifier*>(1, subclassExclude));
-    }
-
-    bool Loader::reload(const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude)
-    {
-        Loader::unload(subclassesInclude, subclassesExclude);
-        return Loader::load(Loader::files_s, subclassesInclude, subclassesExclude);
-    }
-
-    // ###############################
-    // ###         unload          ###
-    // ###############################
-    void Loader::unload()
-    {
-        Loader::unload(ClassIdentifier<BaseObject>::getIdentifier());
-    }
-
-    void Loader::unload(const Identifier* subclassInclude)
-    {
-        Loader::unload(subclassInclude, 0);
-    }
-
-    void Loader::unload(const Identifier* subclassInclude, const Identifier* subclassExclude)
-    {
-        Loader::unload(std::vector<const Identifier*>(1, subclassInclude), std::vector<const Identifier*>(1, subclassExclude));
-    }
-
-    void Loader::unload(const Identifier* subclassInclude, const std::vector<const Identifier*>& subclassesExclude)
-    {
-        Loader::unload(std::vector<const Identifier*>(1, subclassInclude), subclassesExclude);
-    }
-
-    void Loader::unload(const std::vector<const Identifier*>& subclassesInclude)
-    {
-        Loader::unload(subclassesInclude, 0);
-    }
-
-    void Loader::unload(const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude)
-    {
-        Loader::unload(subclassesInclude, std::vector<const Identifier*>(1, subclassExclude));
-    }
-
-    void Loader::unload(const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude)
-    {
-        for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it; )
-        {
-            bool isIncluded = false;
-            for (std::vector<const Identifier*>::const_iterator it_in = subclassesInclude.begin(); it_in < subclassesInclude.end(); ++it_in)
-            {
-                if (it->isA(*it_in))
-                {
-                    isIncluded = true;
-                    break;
-                }
-            }
-
-            if (isIncluded)
-            {
-                bool isExcluded = false;
-                for (std::vector<const Identifier*>::const_iterator it_ex = subclassesInclude.begin(); it_ex < subclassesInclude.end(); ++it_ex)
-                {
-                    if (it->isA(*it_ex))
-                    {
-                        isExcluded = true;
-                        break;
-                    }
-                }
-
-                if (!isExcluded)
-                {
-                    delete *(it++);
-                    continue;
-                }
-            }
-
-            ++it;
-        }
-    }
-
-    // ###############################
-    // ###          load           ###
-    // ###############################
-    bool Loader::load(const std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >& files)
-    {
-        bool success = true;
-        for (std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >::const_iterator it = files.begin(); it < files.end(); ++it)
-            if (!Loader::load(it->first, it->second.first, it->second.second))
-                success = false;
-
-        return success;
-    }
-
-    bool Loader::load(const std::vector<std::string>& files, const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude)
-    {
-        bool success = true;
-        for (std::vector<std::string>::const_iterator it = files.begin(); it < files.end(); ++it)
-            if (!Loader::load(*it, subclassesInclude, subclassesExclude))
-                success = false;
-
-        return success;
-    }
-
-    bool Loader::load(const std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >& files, const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude)
-    {
-        bool success = true;
-        for (std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >::const_iterator it = files.begin(); it < files.end(); ++it)
-            if (!Loader::load(it->first, subclassesInclude, subclassesExclude))
-                success = false;
-
-        return success;
-    }
-
-    bool Loader::load(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude)
-    {
-        // ...load... //
-    }
-}
Index: code/branches/core/src/orxonox/core/Loader.h
===================================================================
--- code/branches/core/src/orxonox/core/Loader.h	(revision 799)
+++ 	(revision )
@@ -1,107 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- */
-
-#ifndef _Loader_H__
-#define _Loader_H__
-
-#include <string>
-#include <vector>
-
-#include "CorePrereqs.h"
-
-namespace orxonox
-{
-    class Loader
-    {
-        public:
-            static bool open(const std::string& file);
-            static bool open(const std::string& file, const Identifier* subclassInclude);
-            static bool open(const std::string& file, const Identifier* subclassInclude, const Identifier* subclassExclude);
-            static bool open(const std::string& file, const Identifier* subclassInclude, std::vector<const Identifier*> subclassesExclude);
-            static bool open(const std::string& file, const std::vector<const Identifier*>& subclassesInclude);
-            static bool open(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude);
-            static bool open(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, std::vector<const Identifier*> subclassesExclude);
-
-            static bool open(const std::vector<std::string>& files);
-            static bool open(const std::vector<std::string>& files, const Identifier* subclassInclude);
-            static bool open(const std::vector<std::string>& files, const Identifier* subclassInclude, const Identifier* subclassExclude);
-            static bool open(const std::vector<std::string>& files, const Identifier* subclassInclude, std::vector<const Identifier*> subclassesExclude);
-            static bool open(const std::vector<std::string>& files, const std::vector<const Identifier*>& subclassesInclude);
-            static bool open(const std::vector<std::string>& files, const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude);
-            static bool open(const std::vector<std::string>& files, const std::vector<const Identifier*>& subclassesInclude, std::vector<const Identifier*> subclassesExclude);
-
-            static bool open(const std::vector<std::pair<std::string, const Identifier*> >& files);
-            static bool open(const std::vector<std::pair<std::string, std::pair<const Identifier*, const Identifier*> > >& files);
-            static bool open(const std::vector<std::pair<std::string, std::pair<const Identifier*, std::vector<const Identifier*> > > >& files);
-            static bool open(const std::vector<std::pair<std::string, std::vector<const Identifier*> > >& files);
-            static bool open(const std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, const Identifier*> > >& files);
-            static bool open(const std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >& files);
-
-
-            static bool add(const std::string& file);
-            static bool add(const std::string& file, const Identifier* subclassInclude);
-            static bool add(const std::string& file, const Identifier* subclassInclude, const Identifier* subclassExclude);
-            static bool add(const std::string& file, const Identifier* subclassInclude, std::vector<const Identifier*> subclassesExclude);
-            static bool add(const std::string& file, const std::vector<const Identifier*>& subclassesInclude);
-            static bool add(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude);
-            static bool add(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, std::vector<const Identifier*> subclassesExclude);
-
-
-            static void remove();
-            static void remove(const std::vector<std::string>& files);
-            static void remove(const std::string& file);
-
-
-            static bool reload();
-            static bool reload(const Identifier* subclassInclude);
-            static bool reload(const Identifier* subclassInclude, const Identifier* subclassExclude);
-            static bool reload(const Identifier* subclassInclude, const std::vector<const Identifier*>& subclassesExclude);
-            static bool reload(const std::vector<const Identifier*>& subclassesInclude);
-            static bool reload(const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude);
-            static bool reload(const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude);
-
-
-            static void unload();
-            static void unload(const Identifier* subclassInclude);
-            static void unload(const Identifier* subclassInclude, const Identifier* subclassExclude);
-            static void unload(const Identifier* subclassInclude, const std::vector<const Identifier*>& subclassesExclude);
-            static void unload(const std::vector<const Identifier*>& subclassesInclude);
-            static void unload(const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude);
-            static void unload(const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude);
-
-        private:
-            static bool load(const std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >& files);
-            static bool load(const std::vector<std::string>& files, const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude);
-            static bool load(const std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >& files, const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude);
-            static bool load(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude);
-
-
-            static std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > > files_s;
-    };
-}
-
-#endif /* _Loader_H__ */
