model.h

/***************************************************************************
 *   Copyright (C) 2006-2011 by the FIFE team                              *
 *   http://www.fifengine.net                                              *
 *   This file is part of FIFE.                                            *
 *                                                                         *
 *   FIFE is free software; you can redistribute it and/or                 *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library 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     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
 ***************************************************************************/

#ifndef FIFE_MODEL_H
#define FIFE_MODEL_H

// Standard C++ library includes
#include <list>
#include <map>
#include <vector>
#include <utility>

// 3rd party library includes

// FIFE includes
// These includes are split up in two parts, separated by one empty line
// First block: files included from the FIFE root src directory
// Second block: files included from the same folder
#include "util/base/fifeclass.h"

#include "model/structures/map.h"
#include "model/metamodel/timeprovider.h"

namespace FIFE {

    class RenderBackend;
    class RendererBase;
    class MetaModel;
    class IPather;
    class Object;

    class Model: public FifeClass {
    public:

        Model(RenderBackend* renderbackend, const std::vector<RendererBase*>& renderers);

        ~Model();

        Map* createMap(const std::string& identifier);

        void deleteMap(Map*);

        const std::list<Map*>& getMaps() const { return m_maps; }

        Map* getMap(const std::string& identifier) const;

        uint32_t getMapCount() const;

        void deleteMaps();

        std::list<std::string> getNamespaces() const;

        Object* createObject(const std::string& identifier, const std::string& name_space, Object* parent=0);

        bool deleteObject(Object*);

        bool deleteObjects();

        Object* getObject(const std::string& id, const std::string& name_space);

        std::list<Object*> getObjects(const std::string& name_space) const;

        void adoptPather(IPather* pather);

        IPather* getPather(const std::string& pathername);

        void adoptCellGrid(CellGrid* grid);

        CellGrid* getCellGrid(const std::string& gridtype);

        void update();

        void setTimeMultiplier(float multip) { m_timeprovider.setMultiplier(multip); }

        double getTimeMultiplier() const { return m_timeprovider.getMultiplier(); }

    private:

        std::list<Map*> m_maps;

        typedef std::map<std::string,Object*> objectmap_t;
        typedef std::pair<std::string,objectmap_t> namespace_t;
        std::list<namespace_t> m_namespaces;

        namespace_t* m_last_namespace;

        namespace_t* selectNamespace(const std::string& name_space);

        const namespace_t* selectNamespace(const std::string& name_space) const;

        std::vector<IPather*> m_pathers;
        std::vector<CellGrid*> m_created_grids;
        std::vector<CellGrid*> m_adopted_grids;
        //std::vector<CellGrid*> m_created_grids;
        TimeProvider m_timeprovider;

        RenderBackend* m_renderbackend;

        std::vector<RendererBase*> m_renderers;
    };

}; //FIFE
#endif