Line data    Source code

       1             : /*
       2             : Minetest
       3             : Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
       4             : 
       5             : This program is free software; you can redistribute it and/or modify
       6             : it under the terms of the GNU Lesser General Public License as published by
       7             : the Free Software Foundation; either version 2.1 of the License, or
       8             : (at your option) any later version.
       9             : 
      10             : This program is distributed in the hope that it will be useful,
      11             : but WITHOUT ANY WARRANTY; without even the implied warranty of
      12             : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      13             : GNU Lesser General Public License for more details.
      14             : 
      15             : You should have received a copy of the GNU Lesser General Public License along
      16             : with this program; if not, write to the Free Software Foundation, Inc.,
      17             : 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
      18             : */
      19             : 
      20             : #ifndef STATICOBJECT_HEADER
      21             : #define STATICOBJECT_HEADER
      22             : 
      23             : #include "irrlichttypes_bloated.h"
      24             : #include <string>
      25             : #include <sstream>
      26             : #include <vector>
      27             : #include <map>
      28             : #include "debug.h"
      29             : 
      30           0 : struct StaticObject
      31             : {
      32             :         u8 type;
      33             :         v3f pos;
      34             :         std::string data;
      35             : 
      36           0 :         StaticObject():
      37             :                 type(0),
      38           0 :                 pos(0,0,0)
      39             :         {
      40           0 :         }
      41           0 :         StaticObject(u8 type_, v3f pos_, const std::string &data_):
      42             :                 type(type_),
      43             :                 pos(pos_),
      44           0 :                 data(data_)
      45             :         {
      46           0 :         }
      47             : 
      48             :         void serialize(std::ostream &os);
      49             :         void deSerialize(std::istream &is, u8 version);
      50             : };
      51             : 
      52        1502 : class StaticObjectList
      53             : {
      54             : public:
      55             :         /*
      56             :                 Inserts an object to the container.
      57             :                 Id must be unique (active) or 0 (stored).
      58             :         */
      59           0 :         void insert(u16 id, StaticObject obj)
      60             :         {
      61           0 :                 if(id == 0)
      62             :                 {
      63           0 :                         m_stored.push_back(obj);
      64             :                 }
      65             :                 else
      66             :                 {
      67           0 :                         if(m_active.find(id) != m_active.end())
      68             :                         {
      69           0 :                                 dstream<<"ERROR: StaticObjectList::insert(): "
      70           0 :                                                 <<"id already exists"<<std::endl;
      71           0 :                                 FATAL_ERROR("StaticObjectList::insert()");
      72             :                         }
      73           0 :                         m_active[id] = obj;
      74             :                 }
      75           0 :         }
      76             : 
      77           0 :         void remove(u16 id)
      78             :         {
      79             :                 assert(id != 0); // Pre-condition
      80           0 :                 if(m_active.find(id) == m_active.end())
      81             :                 {
      82           0 :                         dstream<<"WARNING: StaticObjectList::remove(): id="<<id
      83           0 :                                         <<" not found"<<std::endl;
      84           0 :                         return;
      85             :                 }
      86           0 :                 m_active.erase(id);
      87             :         }
      88             : 
      89             :         void serialize(std::ostream &os);
      90             :         void deSerialize(std::istream &is);
      91             :         
      92             :         /*
      93             :                 NOTE: When an object is transformed to active, it is removed
      94             :                 from m_stored and inserted to m_active.
      95             :                 The caller directly manipulates these containers.
      96             :         */
      97             :         std::vector<StaticObject> m_stored;
      98             :         std::map<u16, StaticObject> m_active;
      99             : 
     100             : private:
     101             : };
     102             : 
     103             : #endif
     104             :