]> git.lizzy.rs Git - minetest.git/blobdiff - src/database-leveldb.cpp
Do the same for LevelDB interface
[minetest.git] / src / database-leveldb.cpp
index e0ab4f0902219919c0190f3ec86920a7c8a50137..ec28198b5e8984ec8afbfdf5edaceb93f177e474 100644 (file)
@@ -1,3 +1,22 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program 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 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser 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.
+*/
+
 #include "config.h"
 
 #if USE_LEVELDB
@@ -6,25 +25,16 @@ LevelDB databases
 */
 
 
+#include "database-leveldb.h"
+#include "leveldb/db.h"
+
 #include "map.h"
 #include "mapsector.h"
 #include "mapblock.h"
+#include "serialization.h"
 #include "main.h"
-#include "filesys.h"
-#include "voxel.h"
-#include "porting.h"
-#include "mapgen.h"
-#include "nodemetadata.h"
 #include "settings.h"
 #include "log.h"
-#include "profiler.h"
-#include "nodedef.h"
-#include "gamedef.h"
-#include "util/directiontables.h"
-#include "rollback_interface.h"
-
-#include "database-leveldb.h"
-#include "leveldb/db.h"
 
 Database_LevelDB::Database_LevelDB(ServerMap *map, std::string savedir)
 {
@@ -82,71 +92,84 @@ MapBlock* Database_LevelDB::loadBlock(v3s16 blockpos)
        v2s16 p2d(blockpos.X, blockpos.Z);
 
        std::string datastr;
-       leveldb::Status s = m_database->Get(leveldb::ReadOptions(), i64tos(getBlockAsInteger(blockpos)), &datastr);
+       leveldb::Status s = m_database->Get(leveldb::ReadOptions(),
+               i64tos(getBlockAsInteger(blockpos)), &datastr);
+       if (datastr.length() == 0) {
+               errorstream << "Blank block data in database (datastr.length() == 0) ("
+                       << blockpos.X << "," << blockpos.Y << "," << blockpos.Z << ")" << std::endl;
+
+               if (g_settings->getBool("ignore_world_load_errors")) {
+                       errorstream << "Ignoring block load error. Duck and cover! "
+                               << "(ignore_world_load_errors)" << std::endl;
+               } else {
+                       throw SerializationError("Blank block data in database");
+               }
+       }
 
-        if(s.ok()) {
-                /*
-                        Make sure sector is loaded
-                */
-                MapSector *sector = srvmap->createSector(p2d);
+       if (s.ok()) {
+               /*
+                       Make sure sector is loaded
+               */
+               MapSector *sector = srvmap->createSector(p2d);
 
                try {
-                       std::istringstream is(datastr, std::ios_base::binary);
-                       u8 version = SER_FMT_VER_INVALID;
-                       is.read((char*)&version, 1);
-
-                       if(is.fail())
-                               throw SerializationError("ServerMap::loadBlock(): Failed"
-                                                    " to read MapBlock version");
-
-                       MapBlock *block = NULL;
-                       bool created_new = false;
-                       block = sector->getBlockNoCreateNoEx(blockpos.Y);
-                       if(block == NULL)
-                       {
-                               block = sector->createBlankBlockNoInsert(blockpos.Y);
-                               created_new = true;
-                       }
-                       // Read basic data
-                       block->deSerialize(is, version, true);
-                       // If it's a new block, insert it to the map
-                       if(created_new)
-                               sector->insertBlock(block);
-                       /*
-                               Save blocks loaded in old format in new format
-                       */
-
-                       //if(version < SER_FMT_VER_HIGHEST || save_after_load)
-                       // Only save if asked to; no need to update version
-                       //if(save_after_load)
-                        //             saveBlock(block);
-                       // We just loaded it from, so it's up-to-date.
-                       block->resetModified();
-
-               }
-               catch(SerializationError &e)
-               {
-                       errorstream<<"Invalid block data in database"
-                                     <<" ("<<blockpos.X<<","<<blockpos.Y<<","<<blockpos.Z<<")"
-                                     <<" (SerializationError): "<<e.what()<<std::endl;
-                     // TODO: Block should be marked as invalid in memory so that it is
-                     // not touched but the game can run
-
-                       if(g_settings->getBool("ignore_world_load_errors")){
-                             errorstream<<"Ignoring block load error. Duck and cover! "
-                                             <<"(ignore_world_load_errors)"<<std::endl;
-                       } else {
-                             throw SerializationError("Invalid block data in database");
-                             //assert(0);
-                       }
-               }
-
-                return srvmap->getBlockNoCreateNoEx(blockpos);  // should not be using this here
-        }
-       return(NULL);
+                       std::istringstream is(datastr, std::ios_base::binary);
+                       u8 version = SER_FMT_VER_INVALID;
+                       is.read((char *)&version, 1);
+
+                       if (is.fail())
+                               throw SerializationError("ServerMap::loadBlock(): Failed"
+                                       " to read MapBlock version");
+
+                       MapBlock *block = NULL;
+                       bool created_new = false;
+                       block = sector->getBlockNoCreateNoEx(blockpos.Y);
+                       if (block == NULL)
+                       {
+                               block = sector->createBlankBlockNoInsert(blockpos.Y);
+                               created_new = true;
+                       }
+
+                       // Read basic data
+                       block->deSerialize(is, version, true);
+
+                       // If it's a new block, insert it to the map
+                       if (created_new)
+                               sector->insertBlock(block);
+
+                       /*
+                               Save blocks loaded in old format in new format
+                       */
+                       //if(version < SER_FMT_VER_HIGHEST || save_after_load)
+                       // Only save if asked to; no need to update version
+                       //if(save_after_load)
+                       //      saveBlock(block);
+                       // We just loaded it from, so it's up-to-date.
+                       block->resetModified();
+               }
+               catch (SerializationError &e)
+               {
+                       errorstream << "Invalid block data in database"
+                               << " (" << blockpos.X << "," << blockpos.Y << "," << blockpos.Z
+                               << ") (SerializationError): " << e.what() << std::endl;
+                       // TODO: Block should be marked as invalid in memory so that it is
+                       // not touched but the game can run
+
+                       if (g_settings->getBool("ignore_world_load_errors")) {
+                               errorstream << "Ignoring block load error. Duck and cover! "
+                                       << "(ignore_world_load_errors)" << std::endl;
+                       } else {
+                               throw SerializationError("Invalid block data in database");
+                               //assert(0);
+                       }
+               }
+
+               return srvmap->getBlockNoCreateNoEx(blockpos);  // should not be using this here
+       }
+       return NULL;
 }
 
-void Database_LevelDB::listAllLoadableBlocks(core::list<v3s16> &dst)
+void Database_LevelDB::listAllLoadableBlocks(std::list<v3s16> &dst)
 {
        leveldb::Iterator* it = m_database->NewIterator(leveldb::ReadOptions());
        for (it->SeekToFirst(); it->Valid(); it->Next()) {