///////////////////////////////////////////////////////////////
//
// CDatabaseJobQueueImpl::FreeCommand
//
// Throw away result when this job is done
// Returns false if jobHandle not correct
//
///////////////////////////////////////////////////////////////
bool CDatabaseJobQueueImpl::FreeCommand ( CDbJobData* pJobData )
{
if ( !MapContains ( m_ActiveJobHandles, pJobData->GetId () ) )
{
CLogger::ErrorPrintf ( "FreeCommand: Serious problem #1 here\n" );
return false;
}
if ( pJobData->result.bIgnoreResult )
return false; // Already ignoring query handle
// if in command or result queue, then put in ignore result list
bool bFound;
shared.m_Mutex.Lock ();
bFound = ListContains ( shared.m_CommandQueue, pJobData ) || ListContains ( shared.m_ResultQueue, pJobData );
shared.m_Mutex.Unlock ();
if ( !bFound )
{
// Must be in finished list
if ( !MapContains ( m_FinishedList, pJobData ) )
CLogger::ErrorPrintf ( "FreeCommand: Serious problem #2 here\n" );
return false;
}
IgnoreJobResults ( pJobData );
return true;
}
///////////////////////////////////////////////////////////////
//
// CResourceFileDownloadManager::AddPendingFileDownload
//
// Add resource file to the list of files to be downloaded
//
///////////////////////////////////////////////////////////////
void CResourceFileDownloadManager::AddPendingFileDownload(CDownloadableResource* pResourceFile)
{
assert(!ListContains(m_PendingFileDownloadList, pResourceFile));
assert(!ListContains(m_ActiveFileDownloadList, pResourceFile));
m_PendingFileDownloadList.push_back(pResourceFile);
pResourceFile->SetIsWaitingForDownload(true);
AddDownloadSize(pResourceFile->GetDownloadSize());
}
///////////////////////////////////////////////////////////////
//
// CClientPerfStatManagerImpl::AddModule
//
//
//
///////////////////////////////////////////////////////////////
void CClientPerfStatManagerImpl::AddModule(CClientPerfStatModule* pModule)
{
if (!ListContains(m_ModuleList, pModule))
{
m_ModuleList.push_back(pModule);
}
}
CLuaTimer* CLuaTimerManager::GetTimerFromScriptID ( uint uiScriptID )
{
CLuaTimer* pLuaTimer = (CLuaTimer*) CIdArray::FindEntry ( uiScriptID, EIdClass::TIMER );
if ( !pLuaTimer )
return NULL;
if ( !ListContains ( m_TimerList, pLuaTimer ) )
return NULL;
return pLuaTimer;
}
///////////////////////////////////////////////////////////////
//
// CCompressorJobQueueImpl::DoPulse
//
// Check if any callback functions are due
//
///////////////////////////////////////////////////////////////
void CCompressorJobQueueImpl::DoPulse ( void )
{
shared.m_Mutex.Lock ();
again:
// Delete finished
for ( std::set < CCompressJobData* >::iterator iter = m_FinishedList.begin () ; iter != m_FinishedList.end () ; )
{
CCompressJobData* pJobData = *iter;
m_FinishedList.erase ( iter++ );
// Check not refed
assert ( !ListContains ( shared.m_CommandQueue, pJobData ) );
assert ( !ListContains ( shared.m_ResultQueue, pJobData ) );
assert ( !MapContains ( m_IgnoreResultList, pJobData ) );
assert ( !MapContains ( m_FinishedList, pJobData ) );
assert ( !pJobData->HasCallback () );
SAFE_DELETE( pJobData );
}
// Remove ignored
RemoveUnwantedResults ();
// Do pending callbacks
for ( std::list < CCompressJobData* >::iterator iter = shared.m_ResultQueue.begin () ; iter != shared.m_ResultQueue.end () ; ++iter )
{
CCompressJobData* pJobData = *iter;
if ( pJobData->HasCallback () )
{
shared.m_Mutex.Unlock ();
pJobData->ProcessCallback ();
shared.m_Mutex.Lock ();
// Redo from the top to ensure everything is consistent
goto again;
}
}
shared.m_Mutex.Unlock ();
}
///////////////////////////////////////////////////////////////
//
// CResourceFileDownloadManager::DownloadFinished
//
// Callback when file download has finished
//
///////////////////////////////////////////////////////////////
void CResourceFileDownloadManager::DownloadFinished(const SHttpDownloadResult& result)
{
CDownloadableResource* pResourceFile = ResolveDownloadContextString((SString*)result.pObj);
if (!pResourceFile)
return;
assert(ListContains(m_ActiveFileDownloadList, pResourceFile));
if (result.bSuccess)
{
CChecksum checksum = CChecksum::GenerateChecksumFromFile(pResourceFile->GetName());
if (checksum != pResourceFile->GetServerChecksum())
{
// Checksum failed - Try download on next server
if (BeginResourceFileDownload(pResourceFile, pResourceFile->GetHttpServerIndex() + 1))
{
// Was re-added - Add size again to total.
AddDownloadSize(pResourceFile->GetDownloadSize());
SString strMessage("External HTTP file mismatch (Retrying this file with internal HTTP) [%s]", *ConformResourcePath(pResourceFile->GetName()));
g_pClientGame->TellServerSomethingImportant(1011, strMessage, 3);
return;
}
}
}
else
{
// Download failed due to connection type problem
CNetHTTPDownloadManagerInterface* pHTTP = g_pNet->GetHTTPDownloadManager(m_HttpServerList[pResourceFile->GetHttpServerIndex()].downloadChannel);
SString strHTTPError = pHTTP->GetError();
// Disable server from being used (if possible)
if (DisableHttpServer(pResourceFile->GetHttpServerIndex()))
{
// Try download on next server
if (BeginResourceFileDownload(pResourceFile, pResourceFile->GetHttpServerIndex() + 1))
{
// Was re-added - Add size again to total.
AddDownloadSize(pResourceFile->GetDownloadSize());
SString strMessage("External HTTP file download error:[%d] %s (Disabling External HTTP) [%s]", result.iErrorCode, *strHTTPError,
*ConformResourcePath(pResourceFile->GetName()));
g_pClientGame->TellServerSomethingImportant(1012, strMessage, 3);
return;
}
}
m_strLastHTTPError = strHTTPError;
}
// File now done (or failed)
ListRemove(m_ActiveFileDownloadList, pResourceFile);
pResourceFile->SetIsWaitingForDownload(false);
}
///////////////////////////////////////////////////////////////
//
// CCompressorJobQueueImpl::FreeCommand
//
// Throw away result when this job is done
// Returns false if jobHandle not correct
//
///////////////////////////////////////////////////////////////
bool CCompressorJobQueueImpl::FreeCommand ( CCompressJobData* pJobData )
{
if ( MapContains ( m_IgnoreResultList, pJobData ) )
return false; // Already ignoring query handle
// if in command or result queue, then put in ignore result list
bool bFound;
shared.m_Mutex.Lock ();
bFound = ListContains ( shared.m_CommandQueue, pJobData ) || ListContains ( shared.m_ResultQueue, pJobData );
shared.m_Mutex.Unlock ();
if ( !bFound )
{
// Must be in finished list
if ( !MapContains ( m_FinishedList, pJobData ) )
OutputDebugLine ( "FreeCommand: Serious problem #2 here\n" );
return false;
}
IgnoreJobResults ( pJobData );
return true;
}
void CLuaTimerManager::RemoveTimer ( CLuaTimer* pLuaTimer )
{
assert ( pLuaTimer );
// Check if already removed
if ( !ListContains ( m_TimerList, pLuaTimer ) )
return;
// Remove all references
ListRemove ( m_TimerList, pLuaTimer );
ListRemove ( m_ProcessQueue, pLuaTimer );
if ( m_pProcessingTimer == pLuaTimer )
{
assert ( !m_pPendingDelete );
pLuaTimer->RemoveScriptID ();
m_pPendingDelete = pLuaTimer;
}
else
delete pLuaTimer;
}
bool CObject::SetLowLodObject ( CObject* pNewLowLodObject )
{
// This object has to be high lod
if ( m_bIsLowLod )
return false;
// Set or clear?
if ( !pNewLowLodObject )
{
// Check if already clear
if ( !m_pLowLodObject )
return false;
// Verify link
assert ( ListContains ( m_pLowLodObject->m_HighLodObjectList, this ) );
// Clear there and here
ListRemove ( m_pLowLodObject->m_HighLodObjectList, this );
m_pLowLodObject = NULL;
return true;
}
else
{
// new object has to be low lod
if ( !pNewLowLodObject->m_bIsLowLod )
return false;
// Remove any previous link
SetLowLodObject ( NULL );
// Make new link
m_pLowLodObject = pNewLowLodObject;
pNewLowLodObject->m_HighLodObjectList.push_back ( this );
return true;
}
}
bool CPedManager::Exists(CPed* pPed)
{
return ListContains(m_List, pPed);
}
bool CElementDeleter::IsBeingDeleted ( CElement* pElement )
{
return ListContains ( m_List, pElement );
}
CAccountManager::CAccountManager ( const SString& strDbPathFilename )
: m_AccountProtect( 6, 30000, 60000 * 1 ) // Max of 6 attempts per 30 seconds, then 1 minute ignore
{
m_llLastTimeSaved = GetTickCount64_ ();
m_bChangedSinceSaved = false;
m_iAccounts = 1;
m_pDatabaseManager = g_pGame->GetDatabaseManager ();
m_strDbPathFilename = strDbPathFilename;
m_hDbConnection = INVALID_DB_HANDLE;
//Load internal.db
ReconnectToDatabase();
// Check if new installation
CRegistryResult result;
m_pDatabaseManager->QueryWithResultf ( m_hDbConnection, &result, "SELECT name FROM sqlite_master WHERE type='table' AND name='accounts'" );
bool bNewInstallation = ( result->nRows == 0 );
//Create all our tables (Don't echo the results)
m_pDatabaseManager->Execf ( m_hDbConnection, "CREATE TABLE IF NOT EXISTS accounts (id INTEGER PRIMARY KEY, name TEXT, password TEXT, ip TEXT, serial TEXT)" );
m_pDatabaseManager->Execf ( m_hDbConnection, "CREATE TABLE IF NOT EXISTS userdata (id INTEGER PRIMARY KEY, userid INTEGER, key TEXT, value TEXT, type INTEGER)" );
m_pDatabaseManager->Execf ( m_hDbConnection, "CREATE TABLE IF NOT EXISTS serialusage (id INTEGER PRIMARY KEY, userid INTEGER, "
"serial TEXT, "
"added_ip TEXT, "
"added_date INTEGER, "
"auth_who INTEGER, "
"auth_date INTEGER, "
"last_login_ip TEXT, "
"last_login_date INTEGER, "
"last_login_http_date INTEGER )" );
m_pDatabaseManager->Execf ( m_hDbConnection, "CREATE INDEX IF NOT EXISTS IDX_SERIALUSAGE_USERID on serialusage(userid)" );
m_pDatabaseManager->Execf ( m_hDbConnection, "CREATE UNIQUE INDEX IF NOT EXISTS IDX_SERIALUSAGE_USERID_SERIAL_U on serialusage(userid,serial)" );
// Check if unique index on accounts exists
m_pDatabaseManager->QueryWithResultf ( m_hDbConnection, &result, "SELECT name FROM sqlite_master WHERE type='index' AND name='IDX_ACCOUNTS_NAME_U'" );
if ( result->nRows == 0 )
{
// Need to add unique index on accounts
if ( !bNewInstallation )
CLogger::LogPrintNoStamp ( "Updating accounts table...\n" );
// Make sure we have a non-unique index to speed up the duplication removal
m_pDatabaseManager->Execf ( m_hDbConnection, "CREATE INDEX IF NOT EXISTS IDX_ACCOUNTS_NAME on accounts(name)" );
// Remove any duplicate name entries
m_pDatabaseManager->Execf ( m_hDbConnection, "DELETE FROM accounts WHERE rowid in "
" (SELECT A.rowid"
" FROM accounts A, accounts B"
" WHERE A.rowid > B.rowid AND A.name = B.name)" );
// Remove non-unique index
m_pDatabaseManager->Execf ( m_hDbConnection, "DROP INDEX IF EXISTS IDX_ACCOUNTS_NAME" );
// Add unique index
m_pDatabaseManager->Execf ( m_hDbConnection, "CREATE UNIQUE INDEX IF NOT EXISTS IDX_ACCOUNTS_NAME_U on accounts(name)" );
}
// Check if unique index on userdata exists
m_pDatabaseManager->QueryWithResultf ( m_hDbConnection, &result, "SELECT name FROM sqlite_master WHERE type='index' AND name='IDX_USERDATA_USERID_KEY_U'" );
if ( result->nRows == 0 )
{
// Need to add unique index on userdata
if ( !bNewInstallation )
CLogger::LogPrintNoStamp ( "Updating userdata table...\n" );
// Make sure we have a non-unique index to speed up the duplication removal
m_pDatabaseManager->Execf ( m_hDbConnection, "CREATE INDEX IF NOT EXISTS IDX_USERDATA_USERID_KEY on userdata(userid,key)" );
// Remove any duplicate userid+key entries
m_pDatabaseManager->Execf ( m_hDbConnection, "DELETE FROM userdata WHERE rowid in "
" (SELECT A.rowid"
" FROM userdata A, userdata B"
" WHERE A.rowid > B.rowid AND A.userid = B.userid AND A.key = B.key)" );
// Remove non-unique index
m_pDatabaseManager->Execf ( m_hDbConnection, "DROP INDEX IF EXISTS IDX_USERDATA_USERID_KEY" );
// Add unique index
m_pDatabaseManager->Execf ( m_hDbConnection, "CREATE UNIQUE INDEX IF NOT EXISTS IDX_USERDATA_USERID_KEY_U on userdata(userid,key)" );
}
// Ensure old indexes are removed
m_pDatabaseManager->Execf ( m_hDbConnection, "DROP INDEX IF EXISTS IDX_ACCOUNTS_NAME" );
m_pDatabaseManager->Execf ( m_hDbConnection, "DROP INDEX IF EXISTS IDX_USERDATA_USERID" );
m_pDatabaseManager->Execf ( m_hDbConnection, "DROP INDEX IF EXISTS IDX_USERDATA_USERID_KEY" );
// Check if httppass has been added yet
m_pDatabaseManager->QueryWithResultf(m_hDbConnection, &result, "PRAGMA table_info(accounts)");
if (ListContains(result->ColNames, "httppass") == false)
{
m_pDatabaseManager->Execf(m_hDbConnection, "ALTER TABLE accounts ADD COLUMN httppass TEXT");
}
}
CAccount* CAccountManager::GetAccountFromScriptID ( uint uiScriptID )
{
CAccount* pAccount = (CAccount*) CIdArray::FindEntry ( uiScriptID, EIdClass::ACCOUNT );
dassert ( !pAccount || ListContains ( m_List, pAccount ) );
return pAccount;
}
bool CRadarAreaManager::Exists ( CRadarArea* pArea )
{
return ListContains ( m_List, pArea );
}
///////////////////////////////////////////////////////////////
//
// CDatabaseJobQueueImpl::DoPulse
//
// Check if any callback functions are due
//
///////////////////////////////////////////////////////////////
void CDatabaseJobQueueImpl::DoPulse ( void )
{
// Check if any connection needs a flush
while ( m_PendingFlushMap.size () )
{
SConnectionHandle connectionHandle = *m_PendingFlushMap.begin ();
MapRemove ( m_PendingFlushMap, connectionHandle );
CDbJobData* pJobData = AddCommand ( EJobCommand::FLUSH, connectionHandle, "" );
FreeCommand ( pJobData );
}
shared.m_Mutex.Lock ();
again:
// Delete finished
for ( std::set < CDbJobData* >::iterator iter = m_FinishedList.begin () ; iter != m_FinishedList.end () ; )
{
CDbJobData* pJobData = *iter;
m_FinishedList.erase ( iter++ );
// Check not refed
dassert ( !ListContains ( shared.m_CommandQueue, pJobData ) );
dassert ( !ListContains ( shared.m_ResultQueue, pJobData ) );
dassert ( !MapContains ( m_FinishedList, pJobData ) );
dassert ( MapContains ( m_ActiveJobHandles, pJobData->GetId () ) );
MapRemove ( m_ActiveJobHandles, pJobData->GetId () );
dassert ( !pJobData->HasCallback () );
SAFE_DELETE( pJobData );
g_pStats->iDbJobDataCount--;
}
// Do pending callbacks
for ( CJobQueueType::iterator iter = shared.m_ResultQueue.begin () ; iter != shared.m_ResultQueue.end () ; )
{
CDbJobData* pJobData = *iter;
if ( pJobData->result.bIgnoreResult )
{
// Ignored results won't be collected, so move to finished list here
iter = shared.m_ResultQueue.erase ( iter );
pJobData->stage = EJobStage::FINISHED;
MapInsert ( m_FinishedList, pJobData );
// Still allow callback incase any cleanup is needed
}
else
++iter;
if ( pJobData->HasCallback () )
{
shared.m_Mutex.Unlock ();
pJobData->ProcessCallback ();
shared.m_Mutex.Lock ();
// Redo from the top ensure everything is consistent
goto again;
}
}
shared.m_Mutex.Unlock ();
UpdateDebugData ();
}
CTextItem* CLuaMain::GetTextItemFromScriptID ( uint uiScriptID )
{
CTextItem* pTextItem = (CTextItem*) CIdArray::FindEntry ( uiScriptID, EIdClass::TEXT_ITEM );
dassert ( !pTextItem || ListContains ( m_TextItems, pTextItem ) );
return pTextItem;
}
bool CTeamManager::Exists(CTeam* pTeam)
{
return ListContains(m_List, pTeam);
}
CAccessControlList* CAccessControlListManager::GetACLFromScriptID ( uint uiScriptID )
{
CAccessControlList* pACL = (CAccessControlList*) CIdArray::FindEntry ( uiScriptID, EIdClass::ACL );
dassert ( !pACL || ListContains ( m_ACLs, pACL ) );
return pACL;
}
bool CClientObjectManager::Exists ( CClientObject* pObject )
{
return ListContains( m_Objects, pObject );
}
////////////////////////////////////////////////////////////////
//
// CRenderWareSA::ModelInfoTXDAddTextures
//
// Adds texture into the TXD of a model.
// Returns true if model was affected.
//
////////////////////////////////////////////////////////////////
bool CRenderWareSA::ModelInfoTXDAddTextures ( SReplacementTextures* pReplacementTextures, ushort usModelId )
{
// Already done for this modelid?
if ( ListContains ( pReplacementTextures->usedInModelIds, usModelId ) )
return false;
// Get valid textures info for this model
CModelTexturesInfo* pInfo = GetModelTexturesInfo ( usModelId );
if ( !pInfo )
return false;
// Remember which models this set has been applied to
pReplacementTextures->usedInModelIds.push_back ( usModelId );
// Already done for this txd?
if ( ListContains ( pReplacementTextures->usedInTxdIds, pInfo->usTxdId ) )
return true; // Return true as model may need restreaming
//
// Add section for this txd
//
pReplacementTextures->perTxdList.push_back ( SReplacementTextures::SPerTxd () );
SReplacementTextures::SPerTxd& perTxdInfo = pReplacementTextures->perTxdList.back ();
perTxdInfo.usTxdId = pInfo->usTxdId;
perTxdInfo.bTexturesAreCopies = ( pReplacementTextures->usedInTxdIds.size () > 0 );
// Copy / clone textures
for ( std::vector < RwTexture* >::iterator iter = pReplacementTextures->textures.begin () ; iter != pReplacementTextures->textures.end () ; iter++ )
{
RwTexture* pNewTexture = *iter;
// Use a copy if not first txd
if ( perTxdInfo.bTexturesAreCopies )
{
// Reuse the given texture's raster
RwTexture* pCopyTex = RwTextureCreate ( pNewTexture->raster );
// Copy over additional properties
MemCpyFast ( &pCopyTex->name, &pNewTexture->name, RW_TEXTURE_NAME_LENGTH );
MemCpyFast ( &pCopyTex->mask, &pNewTexture->mask, RW_TEXTURE_NAME_LENGTH );
pCopyTex->flags = pNewTexture->flags;
pNewTexture = pCopyTex;
}
perTxdInfo.usingTextures.push_back ( pNewTexture );
}
//
// Add each texture to the target txd
//
for ( std::vector < RwTexture* >::iterator iter = perTxdInfo.usingTextures.begin () ; iter != perTxdInfo.usingTextures.end () ; iter++ )
{
RwTexture* pNewTexture = *iter;
// If there is a name clash with an existing texture, replace it
RwTexture* pExistingTexture = RwTexDictionaryFindNamedTexture ( pInfo->pTxd, pNewTexture->name );
if ( pExistingTexture )
{
RwTexDictionaryRemoveTexture ( pInfo->pTxd, pExistingTexture );
}
// Add the texture
dassert ( !RwTexDictionaryContainsTexture ( pInfo->pTxd, pNewTexture ) );
RwTexDictionaryAddTexture ( pInfo->pTxd, pNewTexture );
}
// Remember which txds this set has been applied to
pReplacementTextures->usedInTxdIds.push_back ( pInfo->usTxdId );
dassert ( !ListContains ( pInfo->usedByReplacements, pReplacementTextures ) );
pInfo->usedByReplacements.push_back ( pReplacementTextures );
return true;
}
bool CObjectManager::Exists ( CObject* pObject )
{
return ListContains ( m_List, pObject );
}
bool CPickupManager::Exists(CPickup* pPickup)
{
return ListContains(m_List, pPickup);
}
/*
Looks for energy sources that can potentially drive an opamp feedback branch.
*/
void circuit_t::LookForOpampDrivingSources (const node_t* start, const node_t* output,
list<branch_t*>& covered_branches, list<element_t*>& energy_sources) const
{
/*
To keep track of how many energy sources we found
*/
unsigned int initial_energy_source_count = energy_sources.size();
/*
First, we get a list of all branches going in/out of the starting aid.
*/
list<branch_t*> all_branches = start->VirtualBranchList();
/*
Special case: no branches exist, look for sources connected directly to the terminal
*/
if (all_branches.size() == 0)
{
// Search for VSRC whose actnode is this
for (list<element_t*>::const_iterator e = start->elements.begin(); e != start->elements.end(); e++)
{
element_t* elm = (*e);
/* Look for energy sources */
if ((elm->type == E_VSRC || elm->type == E_CSRC)
&& (elm->OtherNode (start) != output))
energy_sources.push_back (elm);
} /* for */
/* Look for opamp sources */
if (start->IsOpampOutput())
for (list<element_t*>::const_iterator e = start->elements.begin(); e != start->elements.end(); e++)
{
element_t* elm = (*e);
if (elm->type == E_OPAMP_INV)
energy_sources.push_back (elm);
} /* for */
} /* if */
else
{
/*
An array to store filtered results in
*/
list<branch_t*> filtered_results;
/*
If checks for energy sources in this actnode's branches
fail, we will run recursively until all a source is found
or all branches have been tried.
*/
for (list<branch_t*>::const_iterator b = all_branches.begin(); b != all_branches.end(); b++)
{
/*
Filter out branches that go to the output node
*/
if (((*b)->TopNode() == output)
|| ((*b)->BottomNode() == output)
|| ListContains (covered_branches, *b ))
continue;
filtered_results.push_back (*b);
/*
We now have a list of branches that we know don't come from or
go to the output node.
We first check the remaining branches for energy sources;
*/
if ((*b)->HasElement (E_CSRC) || (*b)->HasElement (E_VSRC) || (*b)->HasElement (E_OPAMP_INV))
{
list<element_t*> csrc_list = (*b)->GetElements (E_CSRC);
list<element_t*> vsrc_list = (*b)->GetElements (E_VSRC);
list<element_t*> ooi_list = (*b)->GetElements (E_OPAMP_INV);
energy_sources.insert (energy_sources.end(), csrc_list.begin(), csrc_list.end());
energy_sources.insert (energy_sources.end(), vsrc_list.begin(), vsrc_list.end());
energy_sources.insert (energy_sources.end(), ooi_list.begin(), ooi_list.end());
} /* if */
} /* for */
/*
No immediate energy sources were found,
re-iterate through all loops
*/
if (initial_energy_source_count == energy_sources.size())
{
// Add all branches as covered branches
for (list<branch_t*>::const_iterator b = filtered_results.begin(); b != filtered_results.end(); b++)
{
covered_branches.push_back (*b);
} /* for */
// iterate through all actnodes
for (list<branch_t*>::const_iterator b = filtered_results.begin(); b != filtered_results.end(); b++)
{
/*
Recursiveness
*/
LookForOpampDrivingSources ((*b)->OtherSupernode (start), output, covered_branches, energy_sources);
} /* for */
} /* if */
} /* else */
} /* circuit_t::LookForOpampDrivingSources */
bool CVehicleManager::Exists ( CVehicle* pVehicle )
{
return ListContains ( m_List, pVehicle );
}
void CScriptDebugging::OnLuaMainDestroy ( CLuaMain* pLuaMain )
{
dassert ( !ListContains ( m_LuaMainStack, pLuaMain ) );
ListRemove ( m_LuaMainStack, pLuaMain );
}
///////////////////////////////////////////////////////////////
//
// CDatabaseJobQueueImpl::PollCommand
//
// Find result for previous command
// Returns false if result not ready.
//
///////////////////////////////////////////////////////////////
bool CDatabaseJobQueueImpl::PollCommand ( CDbJobData* pJobData, uint uiTimeout )
{
bool bFound = false;
uint uiTotalWaitTime = 0;
uint uiWaitTimeWarnThresh = TICKS_FROM_SECONDS( 60 );
shared.m_Mutex.Lock ();
while ( true )
{
// Should not be called for ignored results
dassert ( !pJobData->result.bIgnoreResult );
// Should not be called for collected results
dassert ( pJobData->stage != EJobStage::FINISHED );
// See if result has come in yet
if ( ListContains( shared.m_ResultQueue, pJobData ) )
{
ListRemove( shared.m_ResultQueue, pJobData );
pJobData->stage = EJobStage::FINISHED;
MapInsert ( m_FinishedList, pJobData );
// Do callback incase any cleanup is needed
if ( pJobData->HasCallback () )
{
shared.m_Mutex.Unlock ();
pJobData->ProcessCallback ();
shared.m_Mutex.Lock ();
}
bFound = true;
}
if ( bFound || uiTimeout == 0 )
{
shared.m_Mutex.Unlock ();
break;
}
CElapsedTime timer;
shared.m_Mutex.Wait (std::min( uiTimeout, 1000U ) );
uint uiDelta = (uint)timer.Get() + 1;
uiTotalWaitTime += uiDelta;
// If not infinite, subtract time actually waited
if ( uiTimeout != (uint)-1 )
{
if ( uiDelta < uiTimeout )
uiTimeout -= uiDelta;
else
uiTimeout = 0;
}
// Issue warning if it's taking a long time
if ( uiTotalWaitTime > uiWaitTimeWarnThresh )
{
shared.m_Mutex.Unlock ();
g_pGame->GetScriptDebugging()->LogWarning( pJobData->m_LuaDebugInfo, "dbPoll is waiting a long time (%d seconds so far). [Query: %s]", uiTotalWaitTime / 1000, *pJobData->GetCommandStringForLog() );
shared.m_Mutex.Lock ();
uiWaitTimeWarnThresh += TICKS_FROM_SECONDS( 60 );
}
}
// Make sure if wait was infinite, we have a result
assert ( uiTimeout != (uint)-1 || bFound );
return bFound;
}
CTextDisplay* CLuaMain::GetTextDisplayFromScriptID ( uint uiScriptID )
{
CTextDisplay* pTextDisplay = (CTextDisplay*) CIdArray::FindEntry ( uiScriptID, EIdClass::TEXT_DISPLAY );
dassert ( !pTextDisplay || ListContains ( m_Displays, pTextDisplay ) );
return pTextDisplay;
}
////////////////////////////////////////////////////////////////
//
// CRenderWareSA::ModelInfoTXDRemoveTextures
//
// Remove the textures from the txds that are using them.
//
////////////////////////////////////////////////////////////////
void CRenderWareSA::ModelInfoTXDRemoveTextures ( SReplacementTextures* pReplacementTextures )
{
// For each using txd
for ( uint i = 0 ; i < pReplacementTextures->perTxdList.size () ; i++ )
{
SReplacementTextures::SPerTxd& perTxdInfo = pReplacementTextures->perTxdList[i];
// Get textures info
ushort usTxdId = perTxdInfo.usTxdId;
CModelTexturesInfo* pInfo = MapFind ( ms_ModelTexturesInfoMap, usTxdId );
// Validate
dassert ( MapFind ( ms_ModelTexturesInfoMap, usTxdId ) );
dassert ( ListContains ( pInfo->usedByReplacements, pReplacementTextures ) );
// Remove replacement textures
for ( uint i = 0 ; i < perTxdInfo.usingTextures.size () ; i++ )
{
RwTexture* pOldTexture = perTxdInfo.usingTextures[i];
RwTexDictionaryRemoveTexture ( pInfo->pTxd, pOldTexture );
dassert ( !RwTexDictionaryContainsTexture ( pInfo->pTxd, pOldTexture ) );
if ( perTxdInfo.bTexturesAreCopies )
{
// Destroy the copy (but not the raster as that was not copied)
pOldTexture->raster = NULL;
RwTextureDestroy ( pOldTexture );
}
}
// Ensure there are original named textures in the txd
for ( uint i = 0 ; i < pInfo->originalTextures.size () ; i++ )
{
RwTexture* pOriginalTexture = pInfo->originalTextures[i];
if ( !RwTexDictionaryFindNamedTexture ( pInfo->pTxd, pOriginalTexture->name ) )
RwTexDictionaryAddTexture ( pInfo->pTxd, pOriginalTexture );
}
// Remove refs
ListRemove ( pInfo->usedByReplacements, pReplacementTextures );
// If no refs left, check original state and then remove info
if ( pInfo->usedByReplacements.empty () )
{
// txd should now contain the same textures as 'originalTextures'
#ifdef MTA_DEBUG
std::vector < RwTexture* > currentTextures;
GetTxdTextures ( currentTextures, pInfo->pTxd );
assert ( currentTextures.size () == pInfo->originalTextures.size () );
for ( uint i = 0 ; i < pInfo->originalTextures.size () ; i++ )
{
RwTexture* pOriginalTexture = pInfo->originalTextures[i];
assert ( ListContains ( currentTextures, pOriginalTexture ) );
ListRemove ( currentTextures, pOriginalTexture );
}
assert ( currentTextures.empty () );
#endif
// Remove info
CTxdStore_RemoveRef ( pInfo->usTxdId );
MapRemove ( ms_ModelTexturesInfoMap, usTxdId );
}
}
// Destroy replacement textures
for ( uint i = 0 ; i < pReplacementTextures->textures.size () ; i++ )
{
RwTexture* pOldTexture = pReplacementTextures->textures[i];
DestroyTexture ( pOldTexture );
}
pReplacementTextures->textures.clear ();
}
CAccessControlListGroup* CAccessControlListManager::GetGroupFromScriptID ( uint uiScriptID )
{
CAccessControlListGroup* pGroup = (CAccessControlListGroup*) CIdArray::FindEntry ( uiScriptID, EIdClass::ACL_GROUP );
dassert ( !pGroup || ListContains ( m_Groups, pGroup ) );
return pGroup;
}
bool CColManager::Exists ( CColShape* pShape )
{
return ListContains ( m_List, pShape );
}
