Map* MapManager::CreateMap(uint32 id, const WorldObject* obj) { MANGOS_ASSERT(obj); //if(!obj->IsInWorld()) sLog.outError("GetMap: called for map %d with object (typeid %d, guid %d, mapid %d, instanceid %d) who is not in world!", id, obj->GetTypeId(), obj->GetGUIDLow(), obj->GetMapId(), obj->GetInstanceId()); Guard _guard(*this); Map * m = NULL; const MapEntry* entry = sMapStore.LookupEntry(id); if(!entry) return NULL; if(entry->Instanceable()) { MANGOS_ASSERT(obj->GetTypeId() == TYPEID_PLAYER); //create InstanceMap object if(obj->GetTypeId() == TYPEID_PLAYER) m = CreateInstance(id, (Player*)obj); } else { //create regular Continent map m = FindMap(id); if( m == NULL ) { m = new Map(id, i_gridCleanUpDelay, 0, REGULAR_DIFFICULTY); //add map into container i_maps[MapID(id)] = m; } } return m; }
Map* MapManager::CreateBgMap(uint32 mapid, BattleGround* bg) { sTerrainMgr.LoadTerrain(mapid); Guard _guard(*this); return CreateBattleGroundMap(mapid, sObjectMgr.GenerateInstanceLowGuid(), bg); }
SqlStatement Database::CreateStatement(SqlStatementID& index, const char* fmt) { int nId = -1; //check if statement ID is initialized if (!index.initialized()) { //convert to lower register std::string szFmt(fmt); //count input parameters int nParams = std::count(szFmt.begin(), szFmt.end(), '?'); //find existing or add a new record in registry LOCK_GUARD _guard(m_stmtGuard); PreparedStmtRegistry::const_iterator iter = m_stmtRegistry.find(szFmt); if (iter == m_stmtRegistry.end()) { nId = ++m_iStmtIndex; m_stmtRegistry[szFmt] = nId; } else nId = iter->second; //save initialized statement index info index.init(nId, nParams); } return SqlStatement(index, *this); }
Map* MapManager::CreateBgMap(uint32 mapid, BattleGround* bg) { TerrainInfo * pData = sTerrainMgr.LoadTerrain(mapid); Guard _guard(*this); return CreateBattleGroundMap(mapid, sMapMgr.GenerateInstanceId(), bg); }
Map* MapManager::CreateBgMap(uint32 mapid, BattleGround* bg) { TerrainInfo * pData = sTerrainMgr.LoadTerrain(mapid); Guard _guard(*this); return CreateBattleGroundMap(mapid, sObjectMgr.GenerateLowGuid(HIGHGUID_INSTANCE), bg); }
/// @param id - MapId of the to be created map. @param obj WorldObject for which the map is to be created. Must be player for Instancable maps. Map* MapManager::CreateMap(uint32 id, const WorldObject* obj) { Guard _guard(*this); const MapEntry* entry = sMapStore.LookupEntry(id); if (!entry) return nullptr; Map* m; if (entry->Instanceable()) { MANGOS_ASSERT(obj && obj->GetTypeId() == TYPEID_PLAYER); // create DungeonMap object m = CreateInstance(id, (Player*)obj); // Load active objects for this map sObjectMgr.LoadActiveEntities(m); } else { // create regular non-instanceable map m = FindMap(id); if (m == nullptr) { m = new WorldMap(id, i_gridCleanUpDelay); // add map into container i_maps[MapID(id)] = m; // non-instanceable maps always expected have saved state m->CreateInstanceData(true); } } return m; }
bool Database::DirectExecuteStmt(const SqlStatementID& id, SqlStmtParameters* params) { MANGOS_ASSERT(params); std::auto_ptr<SqlStmtParameters> p(params); //execute statement SqlConnection::Lock _guard(getAsyncConnection()); return _guard->ExecuteStmt(id.ID(), *params); }
const char* ConcreteDatabase::PreparedStmtRegistry::getStmtString( UInt32 stmtId ) const { if(stmtId == 0) return nullptr; RegistryGuardType _guard(_lock); IdMap::const_iterator it = _idMap.find(stmtId); if (it != _idMap.end()) return it->second; return nullptr; }
UInt32 ConcreteDatabase::PreparedStmtRegistry::getStmtId( std::string fmt ) { UInt32 nId; RegistryGuardType _guard(_lock); StatementMap::const_iterator iter = _stringMap.find(fmt); if(iter == _stringMap.end()) { nId = ++_nextId; _insertStmt(nId,fmt); } else nId = iter->second; return nId; }
std::string Database::GetStmtString(const int stmtId) const { LOCK_GUARD _guard(m_stmtGuard); if (stmtId == -1 || stmtId > m_iStmtIndex) return std::string(); PreparedStmtRegistry::const_iterator iter_last = m_stmtRegistry.end(); for (PreparedStmtRegistry::const_iterator iter = m_stmtRegistry.begin(); iter != iter_last; ++iter) { if (iter->second == stmtId) return iter->first; } return std::string(); }
TerrainInfo * TerrainManager::LoadTerrain(const uint32 mapId) { Guard _guard(*this); TerrainInfo * ptr = NULL; TerrainDataMap::const_iterator iter = i_TerrainMap.find(mapId); if(iter == i_TerrainMap.end()) { ptr = new TerrainInfo(mapId); i_TerrainMap[mapId] = ptr; } else ptr = (*iter).second; return ptr; }
void MapManager::DeleteInstance(uint32 mapid, uint32 instanceId) { Guard _guard(*this); MapMapType::iterator iter = i_maps.find(MapID(mapid, instanceId)); if(iter != i_maps.end()) { Map * pMap = iter->second; if (pMap->Instanceable()) { i_maps.erase(iter); pMap->UnloadAll(true); delete pMap; } } }
void TerrainManager::UnloadTerrain(const uint32 mapId) { if(sWorld.getConfig(CONFIG_BOOL_GRID_UNLOAD) == 0) return; Guard _guard(*this); TerrainDataMap::iterator iter = i_TerrainMap.find(mapId); if(iter != i_TerrainMap.end()) { TerrainInfo * ptr = (*iter).second; //lets check if this object can be actually freed if(ptr->IsReferenced() == false) { i_TerrainMap.erase(iter); delete ptr; } } }
Map* MapManager::CreateMap(uint32 id, WorldObject const* obj) { MANGOS_ASSERT(obj); //if(!obj->IsInWorld()) sLog.outError("GetMap: called for map %d with object (typeid %d, guid %d, mapid %d, instanceid %d) who is not in world!", id, obj->GetTypeId(), obj->GetGUIDLow(), obj->GetMapId(), obj->GetInstanceId()); Guard _guard(*this); Map* m = NULL; MapEntry const* entry = sMapStore.LookupEntry(id); if(!entry) return NULL; if (entry->Instanceable()) { //create DungeonMap object if (obj->GetTypeId() == TYPEID_PLAYER) m = CreateInstance(id, (Player*)obj); else if (obj->IsInitialized() && obj->GetObjectGuid().IsMOTransport()) DEBUG_FILTER_LOG(LOG_FILTER_TRANSPORT_MOVES,"MapManager::CreateMap %s try create map %u (no instance given), currently not implemented.",obj->IsInitialized() ? obj->GetObjectGuid().GetString().c_str() : "<uninitialized>", id); else DETAIL_LOG("MapManager::CreateMap %s try create map %u (no instance given), BUG, wrong usage!",obj->IsInitialized() ? obj->GetObjectGuid().GetString().c_str() : "<uninitialized>", id); } else { //create regular non-instanceable map m = FindMap(id); if( m == NULL ) { m = new WorldMap(id, i_gridCleanUpDelay); //add map into container i_maps[MapID(id)] = m; // non-instanceable maps always expected have saved state m->CreateInstanceData(true); } } return m; }
Map* MapManager::CreateMap(uint32 id, const WorldObject* obj) { STRAWBERRY_ASSERT(obj); //if(!obj->IsInWorld()) sLog.outError("GetMap: called for map %d with object (typeid %d, guid %d, mapid %d, instanceid %d) who is not in world!", id, obj->GetTypeId(), obj->GetGUIDLow(), obj->GetMapId(), obj->GetInstanceId()); Guard _guard(*this); Map * m = NULL; const MapEntry* entry = sMapStore.LookupEntry(id); if(!entry) return NULL; if(entry->Instanceable()) { STRAWBERRY_ASSERT(obj->GetTypeId() == TYPEID_PLAYER); //create DungeonMap object if(obj->GetTypeId() == TYPEID_PLAYER) m = CreateInstance(id, (Player*)obj); } else { //create regular non-instanceable map m = FindMap(id); if( m == NULL ) { m = new WorldMap(id, i_gridCleanUpDelay); //add map into container i_maps[MapID(id)] = m; // non-instanceable maps always expected have saved state m->CreateInstanceData(true); } } return m; }
void ConcreteDatabase::PreparedStmtRegistry::insertStmt(UInt32 theId, std::string fmt) { RegistryGuardType _guard(_lock); _insertStmt(theId,std::move(fmt)); }
bool DbUtil::runQuery(const char* sql, const Properties& args, SqlResultSet& rows){ clear_error(); rows.clear(); if (!isConnected()) return false; assert(m_mysql); g_debug << "runQuery: " << endl << " sql: '" << sql << "'" << endl; MYSQL_STMT *stmt= mysql_stmt_init(m_mysql); if (mysql_stmt_prepare(stmt, sql, (unsigned long)strlen(sql))) { report_error("Failed to prepare: ", m_mysql); return false; } uint params= mysql_stmt_param_count(stmt); MYSQL_BIND *bind_param = new MYSQL_BIND[params]; NdbAutoObjArrayPtr<MYSQL_BIND> _guard(bind_param); memset(bind_param, 0, params * sizeof(MYSQL_BIND)); for(uint i= 0; i < mysql_stmt_param_count(stmt); i++) { BaseString name; name.assfmt("%d", i); // Parameters are named 0, 1, 2... if (!args.contains(name.c_str())) { g_err << "param " << i << " missing" << endl; assert(false); } PropertiesType t; Uint32 val_i; const char* val_s; args.getTypeOf(name.c_str(), &t); switch(t) { case PropertiesType_Uint32: args.get(name.c_str(), &val_i); bind_param[i].buffer_type= MYSQL_TYPE_LONG; bind_param[i].buffer= (char*)&val_i; g_debug << " param" << name.c_str() << ": " << val_i << endl; break; case PropertiesType_char: args.get(name.c_str(), &val_s); bind_param[i].buffer_type= MYSQL_TYPE_STRING; bind_param[i].buffer= (char*)val_s; bind_param[i].buffer_length= (unsigned long)strlen(val_s); g_debug << " param" << name.c_str() << ": " << val_s << endl; break; default: assert(false); break; } } if (mysql_stmt_bind_param(stmt, bind_param)) { report_error("Failed to bind param: ", m_mysql); mysql_stmt_close(stmt); return false; } if (mysql_stmt_execute(stmt)) { report_error("Failed to execute: ", m_mysql); mysql_stmt_close(stmt); return false; } /* Update max_length, making it possible to know how big buffers to allocate */ my_bool one= 1; mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, (void*) &one); if (mysql_stmt_store_result(stmt)) { report_error("Failed to store result: ", m_mysql); mysql_stmt_close(stmt); return false; } uint row= 0; MYSQL_RES* res= mysql_stmt_result_metadata(stmt); if (res != NULL) { MYSQL_FIELD *fields= mysql_fetch_fields(res); uint num_fields= mysql_num_fields(res); MYSQL_BIND *bind_result = new MYSQL_BIND[num_fields]; NdbAutoObjArrayPtr<MYSQL_BIND> _guard1(bind_result); memset(bind_result, 0, num_fields * sizeof(MYSQL_BIND)); for (uint i= 0; i < num_fields; i++) { unsigned long buf_len= sizeof(int); switch(fields[i].type){ case MYSQL_TYPE_STRING: buf_len = fields[i].length + 1; break; case MYSQL_TYPE_VARCHAR: case MYSQL_TYPE_VAR_STRING: buf_len= fields[i].max_length + 1; break; case MYSQL_TYPE_LONGLONG: buf_len= sizeof(long long); break; case MYSQL_TYPE_LONG: buf_len = sizeof(long); break; default: break; } bind_result[i].buffer_type= fields[i].type; bind_result[i].buffer= malloc(buf_len); bind_result[i].buffer_length= buf_len; bind_result[i].is_null = (my_bool*)malloc(sizeof(my_bool)); * bind_result[i].is_null = 0; } if (mysql_stmt_bind_result(stmt, bind_result)){ report_error("Failed to bind result: ", m_mysql); mysql_stmt_close(stmt); return false; } while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA) { Properties curr(true); for (uint i= 0; i < num_fields; i++){ if (* bind_result[i].is_null) continue; switch(fields[i].type){ case MYSQL_TYPE_STRING: ((char*)bind_result[i].buffer)[fields[i].max_length] = 0; case MYSQL_TYPE_VARCHAR: case MYSQL_TYPE_VAR_STRING: curr.put(fields[i].name, (char*)bind_result[i].buffer); break; case MYSQL_TYPE_LONGLONG: curr.put64(fields[i].name, *(unsigned long long*)bind_result[i].buffer); break; default: curr.put(fields[i].name, *(int*)bind_result[i].buffer); break; } } rows.put("row", row++, &curr); } mysql_free_result(res); for (uint i= 0; i < num_fields; i++) { free(bind_result[i].buffer); free(bind_result[i].is_null); } } // Save stats in result set rows.put("rows", row); rows.put64("affected_rows", mysql_affected_rows(m_mysql)); rows.put("mysql_errno", mysql_errno(m_mysql)); rows.put("mysql_error", mysql_error(m_mysql)); rows.put("mysql_sqlstate", mysql_sqlstate(m_mysql)); rows.put64("insert_id", mysql_insert_id(m_mysql)); mysql_stmt_close(stmt); return true; }