void TGlobalStatistics::append(const TStat& Stat)
{
TSharedMemoryLocker Locker(m_pSharedMemory);
Q_UNUSED(Locker);
if (m_pStat2 != NULL)
{
if (m_pStat2->Readed)
*m_pStat2 += Stat;
else
qWarning("TGlobalStatistics::append. Data not readed.");
}
else {
qWarning("TGlobalStatistics::append. Data pointer is NULL.");
}
}
IFaces::RetCode IStatementImpl::Fetch()
{
Common::ISyncObject Locker(GetSynObj());
if (!Statement.Get())
return IFaces::retFail;
try
{
if (!Statement->Fetch())
return IFaces::retFalse;
}
catch (std::exception &)
{
return IFaces::retFail;
}
return IFaces::retOk;
}
RetCode IStreamFileImpl::GetSize(unsigned long *size) const
{
if (!size)
return retBadParam;
Common::ISyncObject Locker(GetSynObj());
if (!File.Get())
return retFail;
try
{
*size = File->GetSize();
}
catch (std::exception &)
{
return retFail;
}
return retOk;
}
bool KillTimer(int timerID)
{
CCriticalSectionLocker Locker(m_ClientsLock);
int i;
for (i = 0; (unsigned int)i < m_ClientVector.size(); ++i)
{
//const ObjectData& Data = m_Objects2[i];
if(m_ClientVector[i].TimerID == timerID)
{
m_ClientVector.erase(m_ClientVector.begin() + i);
return true;
}
}
LogEvent(LE_ERROR, "CTimerWnd::KillTimer() failed to kill timer %d", timerID);
return false;
}
// -------------------------------------------------------------
void TRasterMapsDialog::keyReleaseEvent(QKeyEvent *Event_)
{
switch(Event_->key()) {
case Qt::Key_Control:
{
QMutexLocker Locker(&m_KeyControlMutex);
if(m_Mode == Consts::LinkingMode && m_KeyControlPressed) {
m_KeyControlPressed = false;
w_MapWidget->restoreMouseMode();
popHint();
}
break;
}
default:
break;
}
}
IFaces::RetCode IStatementImpl::ExecuteDirect(const char *str)
{
if (!str)
return IFaces::retBadParam;
Common::ISyncObject Locker(GetSynObj());
if (!Statement.Get())
return IFaces::retFail;
try
{
Statement->ExecuteDirect(str);
}
catch (std::exception &)
{
return IFaces::retFail;
}
return IFaces::retOk;
}
IFaces::RetCode IStatementImpl::GetFieldsCount(unsigned *count) const
{
if (!count)
return IFaces::retBadParam;
Common::ISyncObject Locker(GetSynObj());
if (!Statement.Get())
return IFaces::retFail;
try
{
*count = Statement->GetFieldsCount();
}
catch (std::exception &)
{
return IFaces::retFail;
}
return IFaces::retOk;
}
RetCode IStreamFileImpl::Read(void *buf, unsigned long bufSize, unsigned long *readBytes)
{
if (!readBytes)
return retBadParam;
Common::ISyncObject Locker(GetSynObj());
if (!File.Get())
return retFail;
try
{
*readBytes = File->Read(buf, bufSize);
}
catch (std::exception &)
{
return retFail;
}
return retOk;
}
ELTE_INT32 CEventMgr::PushEvent(ELTE_INT32 iEventType, const ELTE_VOID* pEventData, ELTE_UINT32 uiBufSize)
{
MutexLocker Locker(m_MutexEventQueue);
EVENT_DATA* pstEventData = new EVENT_DATA;
if(NULL == pstEventData)
{
LOG_RUN_ERROR("New eventdata failed.");
return eLTE_SDK_ERR_CREATE_OBJECT;
}
eSDK_MEMSET(pstEventData, 0x0, sizeof(EVENT_DATA));
pstEventData->iEventType = iEventType;
if(NULL != pEventData)
{
ELTE_CHAR* pEventBuf = new ELTE_CHAR[uiBufSize + 1];
if(NULL == pEventBuf)
{
delete pstEventData;
LOG_RUN_ERROR("New event data buffer failed.");
return eLTE_SDK_ERR_FAILED;
}
eSDK_MEMSET(pEventBuf, 0x00, uiBufSize + 1);
eSDK_MEMCPY(pEventBuf, uiBufSize + 1, pEventData, uiBufSize);
pstEventData->pEventData = (ELTE_VOID*)pEventBuf;
pstEventData->uiBufSize = uiBufSize + 1;
}
if(MAX_EVENT_QUEUE_LEN <= m_eventQueue.size())
{
LOG_RUN_DEBUG("Event queue is over max size[%d], front event will be discarded", MAX_EVENT_QUEUE_LEN);
EVENT_DATA* pstEventFront = m_eventQueue.front();
if(NULL != pstEventFront && NULL != pstEventFront->pEventData)
{
delete [] ((ELTE_CHAR*)(pstEventFront->pEventData));
pstEventFront->pEventData = NULL;
delete pstEventFront;
pstEventFront = NULL;
}//lint !e438
m_eventQueue.pop();
}//lint !e438
m_eventQueue.push(pstEventData);
return eLTE_SDK_ERR_SUCCESS;//lint !e429
}
UINT AddTimer(UINT ElapseInMilli, ITimerManagerEvents *Sink)
{
CCriticalSectionLocker Locker(m_ClientsLock);
if (!Sink)
{
LogEvent(LE_ERROR, "CTimerWnd::AddTimer: Sink=NULL\n");
return 0;
}
int NewID = GetNextTimerID();
ClientData NewClient(NewID, Sink, ElapseInMilli);
m_ClientVector.push_back(NewClient);
#ifdef _DEBUG
m_ClientVector.reserve(1000);
#endif
return NewClient.TimerID;
}
bool CFileHashSet::SetHashSet(const QList<QByteArray>& HashSet)
{
ASSERT(!CanHashParts());
if(HashSet.size() != GetPartCount() || HashSet.isEmpty() || HashSet.at(0).size() != m_uSize)
{
ASSERT(0);
return false;
}
m_HashSet.reserve(HashSet.size());
foreach(const QByteArray& Hash, HashSet)
{
byte* pHash = (byte*)hash_malloc(m_uSize);
memcpy(pHash,Hash.data(),m_uSize);
QWriteLocker Locker(&m_SetMutex);
m_HashSet.append(pHash);
}
IFaces::RetCode IStatementImpl::GetParameter(unsigned index, IFaces::DBIFaces::IParameter **prm)
{
if (!prm || *prm)
return IFaces::retBadParam;
Common::ISyncObject Locker(GetSynObj());
if (!Statement.Get())
return IFaces::retFail;
try
{
Common::RefObjPtr<IParameterImpl> NewPrm = Common::IBaseImpl<IParameterImpl>::CreateWithSyn(GetSynObj());
NewPrm->Init(Connection, Statement, index);
return NewPrm.QueryInterface(prm);
}
catch (std::exception &)
{
}
return IFaces::retFail;
}
IFaces::RetCode IStatementImpl::GetField(unsigned index, IFaces::DBIFaces::IField **fld) const
{
if (!fld || *fld)
return IFaces::retBadParam;
Common::ISyncObject Locker(GetSynObj());
if (!Statement.Get())
return IFaces::retFail;
try
{
Common::RefObjPtr<IFieldImpl> NewFld = Common::IBaseImpl<IFieldImpl>::CreateWithSyn(GetSynObj());
NewFld->Init(Connection, Statement, index);
return NewFld.QueryInterface(fld);
}
catch (std::exception &)
{
}
return IFaces::retFail;
}
// virtual
void CopasiPlot::replot()
{
if (mNextPlotTime < CCopasiTimeVariable::getCurrentWallTime())
{
CCopasiTimeVariable Delta = CCopasiTimeVariable::getCurrentWallTime();
{
QMutexLocker Locker(&mMutex);
updateCurves(C_INVALID_INDEX);
}
QwtPlot::replot();
Delta = CCopasiTimeVariable::getCurrentWallTime() - Delta;
mNextPlotTime = CCopasiTimeVariable::getCurrentWallTime() + 3 * Delta.getMicroSeconds();
}
mReplotFinished = true;
}
void CMiniUPnP::closeOld()
{
QMutexLocker Locker(&m_Mutex);
while(!m_OldPorts.isEmpty())
{
SPort* Port = m_OldPorts.takeFirst();
Port->Enabled = false;
Locker.unlock();
DoForwarding(Port);
upnpClose(Port->pUPnP);
natpmpClose(Port->pNatPMP);
Locker.relock();
}
}
ELTE_INT32 CMediaMgr::StopRealPlay(const ELTE_CHAR* pResourceID) const
{
LOG_TRACE();
if(NULL == m_pUserMgr)
{
LOG_RUN_ERROR("UserMgr is null.");
return eLTE_SDK_ERR_NULL_POINTER;
}
CXml reqXml;
(void)reqXml.AddElem("Content");
(void)reqXml.AddChildElem("ResourceID");
(void)reqXml.IntoElem();
(void)reqXml.SetElemValue(pResourceID);
//发送消息
SSL_Socket& socket = const_cast<SSL_Socket&>(m_pUserMgr->GetSSLSocket());
MutexLocker Locker(m_pUserMgr->GetMutexHandle());
ELTE_INT32 iRet = socket.SendMsg(ELTE_SERVICE_STOPREALPLAY_REQ, reqXml, TRUE);
if(eLTE_SDK_ERR_SUCCESS != iRet)
{
return iRet;
}
iRet = m_pUserMgr->WaitObject(WAIT_OBJECT_TIME);
if (eLTE_SDK_ERR_SUCCESS != iRet)
{
CServerMgr& serverMgr = const_cast<CServerMgr&>(m_pUserMgr->GetServerMgr());
if(!serverMgr.ServerIsRunning() || 0 != m_pUserMgr->GetServerStatus())
{
m_pUserMgr->SetServerStatus(0);
return eLTE_SDK_ERR_SERVER_NOT_RUNNING;
}
return iRet;
}
iRet = m_pUserMgr->GetPacketData().RspCode;
::ResetEvent(m_pUserMgr->GetEventHandle());
if(eLTE_SDK_ERR_SUCCESS == iRet && !CUserMgr::m_iBypass)
{
SharedMemoryMgr::Instance().DeleteSharedMemory(pResourceID);
}
return iRet;
}
ELTE_INT32 CMediaMgr::PTZControl(const ELTE_CHAR* pResourceID, ELTE_UINT32 iPTZControlCode, ELTE_UINT32 iPTZControlValue) const
{
LOG_TRACE();
if(NULL == m_pUserMgr)
{
LOG_RUN_ERROR("UserMgr is null.");
return eLTE_SDK_ERR_NULL_POINTER;
}
CXml reqXml;
(void)reqXml.AddElem("Content");
(void)reqXml.AddChildElem("ResourceID");
(void)reqXml.IntoElem();
(void)reqXml.SetElemValue(pResourceID);
(void)reqXml.AddElem("PTZControlCode");
(void)reqXml.SetElemValue(eLTE_Tool::UInt2String(iPTZControlCode).c_str());
(void)reqXml.AddElem("PTZControlValue");
(void)reqXml.SetElemValue(eLTE_Tool::UInt2String(iPTZControlValue).c_str());
//发送消息
SSL_Socket& socket = const_cast<SSL_Socket&>(m_pUserMgr->GetSSLSocket());
MutexLocker Locker(m_pUserMgr->GetMutexHandle());
ELTE_INT32 iRet = socket.SendMsg(ELTE_SERVICE_PTZCONTROL_REQ, reqXml, TRUE);
if(eLTE_SDK_ERR_SUCCESS != iRet)
{
return iRet;
}
iRet = m_pUserMgr->WaitObject(WAIT_OBJECT_TIME);
if (eLTE_SDK_ERR_SUCCESS != iRet)
{
CServerMgr& serverMgr = const_cast<CServerMgr&>(m_pUserMgr->GetServerMgr());
if(!serverMgr.ServerIsRunning() || 0 != m_pUserMgr->GetServerStatus())
{
m_pUserMgr->SetServerStatus(0);
return eLTE_SDK_ERR_SERVER_NOT_RUNNING;
}
return iRet;
}
iRet = m_pUserMgr->GetPacketData().RspCode;
::ResetEvent(m_pUserMgr->GetEventHandle());
return iRet;
}
void CLogger::AddLogLine(time_t uStamp, uint32 uFlag, const CLogMsg& Line)
{
CLog::AddLogLine(uStamp, uFlag, Line);
if((uFlag & LOG_EXT) != 0)
return;
#ifndef win32
QDateTime then = QDateTime::fromTime_t(uStamp).toLocalTime();
qDebug() << then.toString().append(": ").append(Line.Print());
#endif
QMutexLocker Locker(&m_LogMutex);
if (m_LogStream)
{
QDateTime then = QDateTime::fromTime_t(uStamp).toLocalTime();
*m_LogStream << then.toString().append(": ").append(Line.Print());
endl(*m_LogStream);
}
}
// -------------------------------------------------------------
void TRasterMapsDialog::keyPressEvent(QKeyEvent *Event_)
{
switch(Event_->key()) {
case Qt::Key_Control:
{
QMutexLocker Locker(&m_KeyControlMutex);
if(m_Mode == Consts::LinkingMode && m_MapAnchors.size() < 3) {
m_KeyControlPressed = true;
w_MapWidget->saveMouseMode();
w_MapWidget->setMouseMode(TMapControl::SelectPoint);
pushHint();
hint(QNetMapTranslator::tr("Click left mouse button on the reference point"
/* Ru: Выберите точку привязки и щелкните мышью */));
}
break;
}
default:
break;
}
}
bool CNeoCore::CheckLogin(const QString &LoginToken)
{
QMutexLocker Locker(&m_Mutex);
//if(Cfg(false)->GetString("Core/UserName").isEmpty() && Cfg(false)->GetString("Core/Password").isEmpty())
if(Cfg(false)->GetString("Core/Password").isEmpty())
return true;
if(m_Logins.contains(LoginToken))
{
if(m_Logins.value(LoginToken) + Cfg(false)->GetUInt("Core/TockenTimeOut") > GetTime()
|| m_Server->HasLoginToken(LoginToken)) // in this order the slower server sheck will be done selfom if at all
{
m_Logins[LoginToken] = GetTime();
return true;
}
m_Logins.remove(LoginToken);
Locker.unlock();
SaveLoginTokens();
}
return false;
}
int CMiniUPnP::GetStaus(const QString& Name, int* pPort, QString* pProtoStr)
{
QMutexLocker Locker(&m_Mutex);
SPort* Port = m_Ports.value(Name);
if(!Port)
return -1;
if(pPort)
*pPort = Port->Port;
if(pProtoStr)
{
switch(Port->Proto)
{
case PORT_TCP: *pProtoStr = "TCP"; break;
case PORT_UDP: *pProtoStr = "UDP"; break;
}
}
return Port->Status;
}
// virtual
bool CProgressBar::setName(const std::string & name)
{
if (mpMainThread != NULL &&
QThread::currentThread() != mpMainThread)
{
QMutexLocker Locker(&mMutex);
mSlotFinished = false;
emit signalSetName(FROM_UTF8(name));
if (!mSlotFinished)
{
mWaitSlot.wait(&mMutex);
}
}
else
{
slotSetName(FROM_UTF8(name));
}
return true;
}
RetCode IStreamFileImpl::Write(const void *buf, unsigned long bytes)
{
Common::ISyncObject Locker(GetSynObj());
if (!File.Get())
return retFail;
try
{
const char *Buf = reinterpret_cast<const char *>(buf);
for (unsigned long i = bytes ; i ; )
{
unsigned long WriteBytes = File->Write(&Buf[bytes - i], i);
if (!WriteBytes)
return retFalse;
i -= WriteBytes;
}
}
catch (std::exception &)
{
return retFail;
}
return retOk;
}
ELTE_VOID CEventMgr::ClearEvents()
{
MutexLocker Locker(m_MutexEventQueue);
while(!m_eventQueue.empty())
{
EVENT_DATA* pstEventFront = m_eventQueue.front();
if(NULL != pstEventFront)
{
ELTE_CHAR* pTmp = (ELTE_CHAR*)(pstEventFront->pEventData);
if(NULL != pTmp)
{
delete [] pTmp;
pTmp = NULL;
}
delete pstEventFront;
pstEventFront = NULL;
}//lint !e438
m_eventQueue.pop();
}//lint !e438
}
ArpRef<AmFilterAddOn> AmFilterRoster::FindFilterAddOn(const BMessage* config) const
{
BAutolock _l(Locker());
AmFilterAddOnHandle* match = NULL;
float matchQuality = -1;
const int32 N = CountAddOns();
for (int32 i=0; i<N; i++) {
BAddOnHandle* h = AddOnAt(i);
AmFilterAddOnHandle* fh = dynamic_cast<AmFilterAddOnHandle*>(h);
if (fh) {
float q = fh->CheckInstantiation(config);
if (q >= 0 && q > matchQuality) {
matchQuality = q;
match = fh;
}
}
}
if (match) return match->Instantiate();
return ArpRef<AmFilterAddOn>();
}
bool CProgressBar::progressItem(const unsigned C_INT32 & handle)
{
if (!isValidHandle(handle) || mProgressItemList[handle] == NULL) return false;
QDateTime currDateTime = QDateTime::currentDateTime();
if (mNextEventProcessing >= currDateTime)
return mProceed;
mNextEventProcessing = currDateTime.addSecs(1);
if (mPause)
{
mWaitPause.wait(&mMutex);
}
if (mpMainThread != NULL &&
QThread::currentThread() != mpMainThread)
{
QMutexLocker Locker(&mMutex);
mSlotFinished = false;
emit signalProgressAll();
if (!mSlotFinished)
{
mWaitSlot.wait(&mMutex);
}
}
else
{
slotProgressAll();
}
return mProceed;
}
bool CProgressBar::finishItem(const unsigned C_INT32 & handle)
{
if (!isValidHandle(handle) || mProgressItemList[handle] == NULL) return false;
if (mpMainThread != NULL &&
QThread::currentThread() != mpMainThread)
{
QMutexLocker Locker(&mMutex);
mSlotFinished = false;
emit signalFinishItem(handle);
if (!mSlotFinished)
{
mWaitSlot.wait(&mMutex);
}
}
else
{
slotFinishItem(handle);
}
return (CProcessReport::finishItem(handle) && mProceed);
}
void Inc()
{
Common::SyncObject<System::Mutex> Locker(Mtx);
++Counter;
}
void Dec()
{
Common::SyncObject<System::Mutex> Locker(Mtx);
--Counter;
}
unsigned long GetCounter()
{
Common::SyncObject<System::Mutex> Locker(Mtx);
return Counter;
}
