//--------------------------------------------------------------------------- void Control::TimeOut_Init() { DateTime=QDateTime::currentMSecsSinceEpoch(); if (!Timer) { Timer=new QTimer(this); connect(Timer, SIGNAL(timeout()), this, SLOT(TimeOut())); } TimeOut(); }
/* Test for a simultaneous property If the property isn't independently cached, return false (1) If the simultaneous conversion is more recent, return false (1) Else return the cached value and true (0) */ GOOD_OR_BAD Cache_Get_Simul_Time(enum simul_type type, time_t * dwell_time, const struct parsedname * pn) { // valid cached primary data -- see if a simultaneous conversion should be used instead struct tree_node tn; time_t duration ; time_t time_left ; size_t dsize_simul = 0 ; struct parsedname pn_directory ; duration = TimeOut(ipSimul[type].change); // time allocated this conversion if ( duration <= 0) { // uncachable return gbBAD; } LEVEL_DEBUG("Looking for conversion time "SNformat, SNvar(pn->sn)); FS_LoadDirectoryOnly(&pn_directory, pn); LoadTK(pn_directory.sn, Simul_Marker[type], pn->selected_connection->index, &tn ) ; if ( Get_Stat(&cache_int, Cache_Get_Common(NULL, &dsize_simul, &time_left, &tn)) ) { return gbBAD ; } // duration_simul is time left // duration is time allocated // back-compute dwell time dwell_time[0] = duration - time_left ; return gbGOOD ; }
/////////////////////////////////////////////////////////////////////////////////////// // OutCmd1: Write command and wait for acknowledge of IK 220 with user defined time out /////////////////////////////////////////////////////////////////////////////////////// BOOL OutCmd1 (USHORT Axis, USHORT IK220Cmd) { USHORT RegW; // Register value word DLLInfo = DLLInfo & 0x00FFFFFF; DLLInfo=DLLInfo+0x01000000; // -- 1 -- if (!OutputW (Axis, CmdPort, IK220Cmd)) return FALSE; // Write command to IK 220 DLLInfo=DLLInfo+0x01000000; // -- 2 -- InitTimeOut (TimOutCmd1); // Init timer for time out do { if (!InputW (Axis, Flag1Reg, &RegW)) return FALSE; // Wait until finished } // or time out while ( !(RegW & G28Sem0) && !TimeOut (TimOutCmd1, UserTimeOut1) ); DLLInfo=DLLInfo+0x01000000; // -- 3 -- if (!InputW (Axis, Flag1Reg, &RegW)) return FALSE; // Finished ? if ( !(RegW & G28Sem0) ) { DLLStatus = DLLStatus | DLLStatus_TimeOut; return FALSE; // No, time out } DLLInfo=DLLInfo+0x01000000; // -- 4 -- if (!InputW (Axis, DatPort0, &RegW)) return FALSE; // Verify acknowledge if (RegW!=IK220Cmd) { DLLStatus = DLLStatus | DLLStatus_WrongAck; return FALSE; // Wrong command acknowledge } return TRUE; }
static void Cache_Del(const struct parsedname *pn) { struct tree_node tn; time_t duration; //printf("Cache_Del\n") ; //printf("Cache_Del\n") ; if (!pn) { return; // do check here to avoid needless processing } duration = TimeOut(pn->selected_filetype->change); if (duration <= 0) { return; /* in case timeout set to 0 */ } LoadTK( pn->sn, pn->selected_filetype, pn->extension, &tn ) ; switch (pn->selected_filetype->change) { case fc_persistent: Del_Stat(&cache_pst, Cache_Del_Persistent(&tn)); break ; default: Del_Stat(&cache_ext, Cache_Del_Common(&tn)); break ; } }
/* return 0 if good, 1 if not */ GOOD_OR_BAD Cache_Add_SlaveSpecific(const void *data, const size_t datasize, const struct internal_prop *ip, const struct parsedname *pn) { struct tree_node *tn; time_t duration; //printf("Cache_Add_SlaveSpecific\n"); if (!pn) { return gbGOOD; // do check here to avoid needless processing } duration = TimeOut(ip->change); if (duration <= 0) { return gbGOOD; /* in case timeout set to 0 */ } tn = (struct tree_node *) owmalloc(sizeof(struct tree_node) + datasize); if (!tn) { return gbBAD; } LEVEL_DEBUG("Adding internal data for "SNformat " size=%d", SNvar(pn->sn), (int) datasize); LoadTK( pn->sn, ip->name, EXTENSION_INTERNAL, tn ); tn->expires = duration + NOW_TIME; tn->dsize = datasize; if (datasize) { memcpy(TREE_DATA(tn), data, datasize); } //printf("ADD INTERNAL name= %s size=%d \n",tn->tk.p.nm,tn->dsize); //printf(" ADD INTERNAL data[0]=%d size=%d \n",((BYTE *)data)[0],datasize); switch (ip->change) { case fc_persistent: return Add_Stat(&cache_pst, Cache_Add_Persistent(tn)); default: return Add_Stat(&cache_int, Cache_Add_Common(tn)); } }
int Socket::Receive(void *pBuffer, int nBufLen, bool bCheckData, long lSecond, long lMinSecond) { if (TimeOut(lSecond, lMinSecond)) return SOCKET_ERROR; int nRet = 0, nFlags = 0; if (bCheckData) nFlags = MSG_PEEK; nRet = ::recv(m_hSocket, (char*)pBuffer, nBufLen, nFlags); if (nRet == 0) return SOCKET_ERROR; if (nRet != SOCKET_ERROR) return nRet; #ifdef WIN32 int nErrCode = ::GetLastError(); if (nErrCode == WSAEWOULDBLOCK) return 0; #else if (errno == EAGAIN) return 0; #endif return SOCKET_ERROR; }
/* return 0 if good, 1 if not */ GOOD_OR_BAD Cache_Add_Device(const int bus_nr, const BYTE * sn) { time_t duration = TimeOut(fc_presence); struct tree_node *tn; if (duration <= 0) { return gbGOOD; /* in case timeout set to 0 */ } if ( sn[0] == 0 ) { //bad serial number return gbGOOD ; } tn = (struct tree_node *) owmalloc(sizeof(struct tree_node) + sizeof(int)); if (!tn) { return gbBAD; } LEVEL_DEBUG("Adding device location " SNformat " bus=%d", SNvar(sn), (int) bus_nr); LoadTK(sn, Device_Marker, 0, tn ); tn->expires = duration + NOW_TIME; tn->dsize = sizeof(int); memcpy(TREE_DATA(tn), &bus_nr, sizeof(int)); return Add_Stat(&cache_dev, Cache_Add_Common(tn)); }
list <int> Poller::WaitForData (int timeOut) const { vector <pollfd> pfd (FileDescriptors.size()); for (size_t i = 0; i < FileDescriptors.size(); i++) { pfd[i].fd = FileDescriptors[i]; pfd[i].events = POLLIN; } list <int> descList; int pollRes = poll (&pfd[0], pfd.size(), timeOut); if (pollRes == 0 && timeOut != -1) throw TimeOut (SRC_POS); if (pollRes > 0) { for (size_t i = 0; i < pfd.size(); i++) { if (pfd[i].revents & POLLIN) descList.push_back (pfd[i].fd); } } return descList; }
void Cache_Del_Mixed_Aggregate(const struct parsedname *pn) { struct tree_node tn; time_t duration; //printf("Cache_Del\n") ; if (!pn) { return; // do check here to avoid needless processing } if (pn->selected_filetype->ag==NON_AGGREGATE || pn->selected_filetype->ag->combined!=ag_mixed) { return ; } duration = TimeOut(pn->selected_filetype->change); if (duration <= 0) { return; /* in case timeout set to 0 */ } LoadTK( pn->sn, pn->selected_filetype, EXTENSION_ALL, &tn) ; switch (pn->selected_filetype->change) { case fc_persistent: Del_Stat(&cache_pst, Cache_Del_Persistent(&tn)); break ; default: Del_Stat(&cache_ext, Cache_Del_Common(&tn)); break ; } }
EFI_STATUS TestTimer() { EFI_STATUS Status; EFI_EVENT myEvent; UINTN index=0; UINTN repeats=0; Print(L"Test EVT_TIMER "); Status = gBS->CreateEvent(EVT_TIMER , TPL_CALLBACK, (EFI_EVENT_NOTIFY)NULL, (VOID*)NULL, &myEvent); if(EFI_ERROR(Status)){ Print(L"Fail EVT_TIMER | EVT_RUNTIME %r", Status); return Status; } Status = gBS->SetTimer(myEvent,TimerPeriodic , 15 * 1000 * 1000); while(1) { Status = gBS->WaitForEvent(1, &myEvent, &index); // do something TimeOut(); Print(L"Time out!"); if(repeats ++ == 10){ break; } } Status = gBS->CloseEvent(myEvent); return EFI_SUCCESS; }
/* Look in caches, 0=found and valid, 1=not or uncachable in the first place */ GOOD_OR_BAD Cache_Get(void *data, size_t * dsize, const struct parsedname *pn) { time_t duration; struct tree_node tn; int persistent ; // do check here to avoid needless processing if (IsUncachedDir(pn) || IsAlarmDir(pn)) { return gbBAD; } // Special handling of Mock persistent = IsThisPersistent(pn) ; if ( persistent ) { duration = 1 ; } else { duration = TimeOut(pn->selected_filetype->change); if (duration <= 0) { return gbBAD; /* in case timeout set to 0 */ } } LEVEL_DEBUG(SNformat " size=%d IsUncachedDir=%d", SNvar(pn->sn), (int) dsize[0], IsUncachedDir(pn)); LoadTK( pn->sn, pn->selected_filetype, pn->extension, &tn ); return persistent ? Get_Stat(&cache_pst, Cache_Get_Persistent(data, dsize, &duration, &tn)) : Get_Stat(&cache_ext, Cache_Get_Common(data, dsize, &duration, &tn)); }
//--------------------------------------------------------------------------- void MainWindow::processFile(const QString &FileName) { if (FileName.isEmpty()) return; // Files (must be deleted first in order to stop ffmpeg processes) for (size_t Pos=0; Pos<Files.size(); Pos++) delete Files[Pos]; Files.clear(); ui->fileNamesBox->clear(); // Layout QLayout* Layout=layout(); if (FilesListArea) { ui->verticalLayout->removeWidget(FilesListArea); delete FilesListArea; FilesListArea=NULL; } if (PlotsArea) { ui->verticalLayout->removeWidget(PlotsArea); delete PlotsArea; PlotsArea=NULL; } if (TinyDisplayArea) { ui->verticalLayout->removeWidget(TinyDisplayArea); delete TinyDisplayArea; TinyDisplayArea=NULL; } if (ControlArea) { ui->verticalLayout->removeWidget(ControlArea); delete ControlArea; ControlArea=NULL; } if (InfoArea) { ui->verticalLayout->removeWidget(InfoArea); delete InfoArea; InfoArea=NULL; } // Status statusBar()->showMessage("Scanning "+QFileInfo(FileName).fileName()+"..."); // Launch analysis Files.push_back(new FileInformation(this, FileName)); Files_CurrentPos=0; ui->fileNamesBox->addItem(FileName); // Coherency if (Files[Files_CurrentPos]->Glue->VideoFrameCount==0) { statusBar()->showMessage("Unsupported format", 10000); return; } TimeOut(); }
void Cache_Del_Device(const struct parsedname *pn) { struct tree_node tn; time_t duration = TimeOut(fc_presence); if (duration <= 0) { return; } LoadTK(pn->sn, Device_Marker, 0, &tn) ; Del_Stat(&cache_dev, Cache_Del_Common(&tn)); }
/* return 0 if good, 1 if not */ GOOD_OR_BAD Cache_Add_Dir(const struct dirblob *db, const struct parsedname *pn) { time_t duration = TimeOut(fc_directory); struct tree_node *tn; size_t size = DirblobElements(db) * SERIAL_NUMBER_SIZE; struct parsedname pn_directory; if (pn==NO_PARSEDNAME || pn->selected_connection==NO_CONNECTION) { return gbGOOD; // do check here to avoid needless processing } switch ( get_busmode(pn->selected_connection) ) { case bus_fake: case bus_tester: case bus_mock: case bus_w1: case bus_bad: case bus_unknown: return gbGOOD ; default: break ; } if (duration <= 0) { return 0; /* in case timeout set to 0 */ } if ( DirblobElements(db) < 1 ) { // only cache long directories. // zero (or one?) entry is possibly an error and needs to be repeated more quickly LEVEL_DEBUG("Won\'t cache empty directory"); Cache_Del_Dir( pn ) ; return gbGOOD ; } // allocate space for the node and data tn = (struct tree_node *) owmalloc(sizeof(struct tree_node) + size); if (!tn) { return gbBAD; } LEVEL_DEBUG("Adding directory for " SNformat " elements=%d", SNvar(pn->sn), DirblobElements(db)); // populate node with directory name and dirblob FS_LoadDirectoryOnly(&pn_directory, pn); LoadTK( pn_directory.sn, Directory_Marker, pn->selected_connection->index, tn ); tn->expires = duration + NOW_TIME; tn->dsize = size; if (size) { memcpy(TREE_DATA(tn), db->snlist, size); } return Add_Stat(&cache_dir, Cache_Add_Common(tn)); }
/* Note: done in single-threaded mode so locking not yet needed */ void Cache_Open(void) { memset(&cache, 0, sizeof(struct cache_data)); cache.retired_lifespan = TimeOut(fc_stable); if (cache.retired_lifespan > 3600) { cache.retired_lifespan = 3600; /* 1 hour tops */ } // Flip once (at start) to set up old tree. FlipTree() ; }
bool PushButton::StateChanged() { bool changed = false; if (m_debounce.hasTimedOut()) { m_current = Raw(); if (m_current != m_last) { changed = true; m_last = m_current; m_debounce = TimeOut(50); } } return changed; }
/* Look in caches, 0=found and valid, 1=not or uncachable in the first place */ GOOD_OR_BAD Cache_Get_Device(void *bus_nr, const struct parsedname *pn) { time_t duration = TimeOut(fc_presence); size_t size = sizeof(int); struct tree_node tn; if (duration <= 0) { return gbBAD; } LEVEL_DEBUG("Looking for device "SNformat, SNvar(pn->sn)); LoadTK( pn->sn, Device_Marker, 0, &tn ) ; return Get_Stat(&cache_dev, Cache_Get_Common(bus_nr, &size, &duration, &tn)); }
//--------------------------------------------------------------------------- void MainWindow::addFile_finish() { if (FilesListArea) { FilesListArea->UpdateAll(); FilesListArea->show(); } if (Files.size()>1) ui->actionFilesList->trigger(); else ui->actionGraphsLayout->trigger(); TimeOut(); }
/* Look in caches, 0=found and valid, 1=not or uncachable in the first place */ GOOD_OR_BAD Cache_Get_Dir(struct dirblob *db, const struct parsedname *pn) { time_t duration = TimeOut(fc_directory); struct tree_node tn; struct parsedname pn_directory; DirblobInit(db); if (duration <= 0) { return gbBAD; } LEVEL_DEBUG("Looking for directory "SNformat, SNvar(pn->sn)); FS_LoadDirectoryOnly(&pn_directory, pn); LoadTK( pn_directory.sn, Directory_Marker, pn->selected_connection->index, &tn) ; return Get_Stat(&cache_dir, Cache_Get_Common_Dir(db, &duration, &tn)); }
//--------------------------------------------------------------------------- void MainWindow::processFile(const QString &FileName) { if (FileName.isEmpty()) return; // Files (must be deleted first in order to stop ffmpeg processes) for (size_t Pos=0; Pos<Files.size(); Pos++) delete Files[Pos]; Files.clear(); ui->fileNamesBox->clear(); // Layout if (FilesListArea) { ui->verticalLayout->removeWidget(FilesListArea); delete FilesListArea; FilesListArea=NULL; } if (PlotsArea) { ui->verticalLayout->removeWidget(PlotsArea); delete PlotsArea; PlotsArea=NULL; } if (TinyDisplayArea) { ui->verticalLayout->removeWidget(TinyDisplayArea); delete TinyDisplayArea; TinyDisplayArea=NULL; } if (ControlArea) { ui->verticalLayout->removeWidget(ControlArea); delete ControlArea; ControlArea=NULL; } if (InfoArea) { ui->verticalLayout->removeWidget(InfoArea); delete InfoArea; InfoArea=NULL; } // Status statusBar()->showMessage("Scanning "+QFileInfo(FileName).fileName()+"..."); // Launch analysis Files.push_back(new FileInformation(this, FileName, Prefs->ActiveFilters, Prefs->ActiveAllTracks)); Files_CurrentPos=0; ui->fileNamesBox->addItem(FileName); TimeOut(); }
struct RxReturn RxPacket(void) { struct RxReturn respuesta; byte bCount, bLength, bChecksum; byte Rx_time_out = 0; Sentit_Dades_Rx(); init_A1_timer(); for(bCount = 0; bCount < 4; bCount++) { Reset_Timeout(); Byte_Recibido=false; //No_se_ha_recibido_Byte(); while (!Byte_Recibido) { Rx_time_out=TimeOut(5000); // tiempo en decenas de microsegundos if (Rx_time_out)break; } if (Rx_time_out)break; //sale del for si ha habido Timeout respuesta.StatusPacket[bCount] = DatoLeido_UART; } bLength = bCount; bChecksum=0; if (!Rx_time_out) { if(bLength>3) //podem fer checking { if(respuesta.StatusPacket[0]!=0xff || respuesta.StatusPacket[0]!=0xff) { //WRONG HEADER //netejar buffer } if(respuesta.StatusPacket[3]!=bLength-4) { //WRONG LENGTH //NETEJAR BUFFER } for(bCount = 2; bCount<bLength; bCount++) bChecksum += respuesta.StatusPacket[bCount]; if(bChecksum!=0xff) { //WRONG CHECKSUM //NETEJAR BUFFER } } } return respuesta; }
/* Test for a simultaneous property * return true if simultaneous is the prefered method * bad if no simultaneous, or it's not the best */ static GOOD_OR_BAD Cache_Get_Simultaneous(enum simul_type type, struct one_wire_query *owq) { struct tree_node tn; time_t duration ; time_t time_left ; time_t dwell_time_simul ; struct parsedname * pn = PN(owq) ; size_t dsize = sizeof(union value_object) ; duration = TimeOut(pn->selected_filetype->change); if (duration <= 0) { // probably "uncached" requested return gbBAD; } LoadTK( pn->sn, pn->selected_filetype, pn->extension, &tn ) ; if ( Get_Stat(&cache_ext, Cache_Get_Common( &OWQ_val(owq), &dsize, &time_left, &tn)) == 0 ) { // valid cached primary data -- see if a simultaneous conversion should be used instead time_t dwell_time_data = duration - time_left ; if ( BAD( Cache_Get_Simul_Time( type, &dwell_time_simul, pn)) ) { // Simul not found or timed out LEVEL_DEBUG("Simultaneous conversion not found.") ; OWQ_SIMUL_CLR(owq) ; return gbGOOD ; } if ( dwell_time_simul < dwell_time_data ) { LEVEL_DEBUG("Simultaneous conversion is newer than previous reading.") ; OWQ_SIMUL_SET(owq) ; return gbBAD ; // Simul is newer } // Cached data is newer, so use it OWQ_SIMUL_CLR(owq) ; return gbGOOD ; } // fall through -- no cached primary data if ( BAD( Cache_Get_Simul_Time( type, &dwell_time_simul, pn)) ) { // no simultaneous either OWQ_SIMUL_CLR(owq) ; return gbBAD ; } OWQ_SIMUL_SET(owq) ; return gbBAD ; // Simul is newer }
//--------------------------------------------------------------------------- void Control::TimeOut_Init() { stop(); Time = QTime(); startFrame = FileInfoData->Frames_Pos_Get(); startFrameTimeStamp = QTime::currentTime(); lastRenderedFrame = -1; auto averageFrameRate = FileInfoData->averageFrameRate(); averageFrameDuration = averageFrameRate != 0.0 ? 1000.0 / averageFrameRate : 0.0; if (!Timer) { Thread = new QThread(this); connect(Thread, SIGNAL(finished()), Thread, SLOT(deleteLater())); Timer = new QTimer(); connect(Thread, SIGNAL(started()), Timer, SLOT(start())); connect(Thread, SIGNAL(finished()), Timer, SLOT(stop())); connect(Thread, SIGNAL(finished()), Timer, SLOT(deleteLater())); connect(Timer, SIGNAL(timeout()), this, SLOT(TimeOut()), Qt::DirectConnection); if (playAllFrames) { if(SelectedSpeed == Speed_P0 || SelectedSpeed == Speed_M0) Timer_Duration = ceil(averageFrameRate * 2); else if(SelectedSpeed == Speed_P1 || SelectedSpeed == Speed_M1) Timer_Duration = ceil(averageFrameRate); else if(SelectedSpeed == Speed_P2 || SelectedSpeed == Speed_M2) Timer_Duration = ceil(averageFrameRate / 2); Timer->setInterval(Timer_Duration); } else { Timer->setInterval(averageFrameDuration / 3); } Timer->moveToThread(Thread); Thread->start(); } }
/* 功能:接收数据 参数: lpBuf void* [Out] 保存接收的数据 nBufLen __int32 [Out] 收到数据的长度 lSecond long [In] 超时时间秒 lMinSecond long [In] 超时时间毫秒 返回值:实际接收到的字节数,超时返回-2,断开连接返回-1,其它错误返回-3 */ int Socket::Receive( void* lpBuf, int nBufLen, bool bCheckDataLength, long lSecond, long lMinSecond ) { if ( TimeOut( lSecond, lMinSecond ) ) return seTimeOut;//超时 int nResult; int nFlag = 0; if ( bCheckDataLength ) nFlag = MSG_PEEK; nResult = recv(m_hSocket, (char*)lpBuf, nBufLen, nFlag); if ( 0 == nResult ) return seSocketClose;//断开连接 if ( SOCKET_ERROR != nResult ) return nResult;//无异常发生 //socket发生异常 #ifdef WIN32 int nError = GetLastError(); if ( WSAEWOULDBLOCK == nError ) return 0;//非阻塞recv返回,无数据可接收 return seError; #else if ( EAGAIN == errno ) return 0;//非阻塞recv返回,无数据可接收 return seError; #endif }
//--------------------------------------------------------------------------- void MainWindow::closeFile() { if (Files_CurrentPos==(size_t)-1) return; if (Files.size()==1) { closeAllFiles(); return; } // Launch analysis Files.erase(Files.begin()+Files_CurrentPos); ui->fileNamesBox->removeItem(Files_CurrentPos); if (ui->fileNamesBox->isVisible()) ui->fileNamesBox->setCurrentIndex(Files_CurrentPos<Files.size()?Files_CurrentPos:Files_CurrentPos-1); else Files_CurrentPos=Files_CurrentPos<Files.size()?Files_CurrentPos:Files_CurrentPos-1; TimeOut(); }
/* return 0 if good, 1 if not */ GOOD_OR_BAD Cache_Add_Simul(const enum simul_type type, const struct parsedname *pn) { // Note: pn already points to directory time_t duration = TimeOut(fc_volatile); struct tree_node *tn; if (pn==NO_PARSEDNAME || pn->selected_connection==NO_CONNECTION) { return gbGOOD; // do check here to avoid needless processing } switch ( get_busmode(pn->selected_connection) ) { case bus_fake: case bus_tester: case bus_mock: case bus_bad: case bus_unknown: return gbGOOD ; default: break ; } if (duration <= 0) { return gbGOOD; /* in case timeout set to 0 */ } // allocate space for the node and data LEVEL_DEBUG("Adding for conversion time for "SNformat, SNvar(pn->sn)); tn = (struct tree_node *) owmalloc(sizeof(struct tree_node)); if (!tn) { return gbBAD; } LEVEL_DEBUG(SNformat, SNvar(pn->sn)); // populate node with directory name and dirblob LoadTK( pn->sn, Simul_Marker[type], pn->selected_connection->index, tn) ; LEVEL_DEBUG("Simultaneous add type=%d",type); tn->expires = duration + NOW_TIME; tn->dsize = 0; return Add_Stat(&cache_dir, Cache_Add_Common(tn)); }
bool FMessageRpcClient::HandleTicker(float DeltaTime) { const FDateTime UtcNow = FDateTime::UtcNow(); for (TMap<FGuid, TSharedPtr<IMessageRpcCall>>::TIterator It(Calls); It; ++It) { auto Call = It.Value(); if (UtcNow - Call->GetTimeCreated() > FTimespan::FromSeconds(MESSAGE_RPC_RETRY_TIMEOUT)) { It.RemoveCurrent(); Call->TimeOut(); } else if (UtcNow - Call->GetLastUpdated() > FTimespan::FromSeconds(MESSAGE_RPC_RETRY_INTERVAL)) { SendCall(Call); } } return true; }
/* return 0 if good, 1 if not */ static GOOD_OR_BAD Cache_Add(const void *data, const size_t datasize, const struct parsedname *pn) { struct tree_node *tn; time_t duration; int persistent ; if (!pn || IsAlarmDir(pn)) { return gbGOOD; // do check here to avoid needless processing } // Special handling of Mock persistent = IsThisPersistent(pn) ; if ( persistent ) { duration = 1 ; } else { duration = TimeOut(pn->selected_filetype->change); if (duration <= 0) { return gbGOOD; /* in case timeout set to 0 */ } } // allocate space for the node and data tn = (struct tree_node *) owmalloc(sizeof(struct tree_node) + datasize); if (!tn) { return gbBAD; } LEVEL_DEBUG(SNformat " size=%d", SNvar(pn->sn), (int) datasize); // populate the node structure with data LoadTK( pn->sn, pn->selected_filetype, pn->extension, tn ); tn->expires = duration + NOW_TIME; tn->dsize = datasize; if (datasize) { memcpy(TREE_DATA(tn), data, datasize); } return persistent ? Add_Stat(&cache_pst, Cache_Add_Persistent(tn)) : Add_Stat(&cache_ext, Cache_Add_Common(tn)) ; }
//--------------------------------------------------------------------------- void MainWindow::on_actionGraphsLayout_triggered() { if (ui->actionGoTo) ui->actionGoTo->setVisible(true); if (ui->actionExport_XmlGz_Prompt) ui->actionExport_XmlGz_Prompt->setVisible(true); if (ui->actionExport_XmlGz_Sidecar) ui->actionExport_XmlGz_Sidecar->setVisible(true); //if (ui->actionExport_XmlGz_Custom) // Not implemented action // ui->actionExport_XmlGz_Custom->setVisible(true); if (ui->actionCSV) ui->actionCSV->setVisible(true); //if (ui->actionPrint) // ui->actionPrint->setVisible(true); if (ui->actionZoomIn) ui->actionZoomIn->setVisible(true); if (ui->actionZoomOut) ui->actionZoomOut->setVisible(true); if (ui->actionWindowOut) ui->actionWindowOut->setVisible(false); for (size_t Pos=0; Pos<PlotType_Max; Pos++) if (CheckBoxes[Pos]) CheckBoxes[Pos]->show(); if (ui->fileNamesBox) ui->fileNamesBox->show(); if (PlotsArea) PlotsArea->show(); if (TinyDisplayArea) TinyDisplayArea->show(); if (ControlArea) ControlArea->show(); if (FilesListArea) FilesListArea->hide(); if (ui->fileNamesBox) ui->fileNamesBox->setCurrentIndex(Files_CurrentPos); TimeOut(); }
/* 功能:调用库函数recvFrom接收UDP数据 参数: lpBuf void* [Out] 保存接收的数据 nBufLen int [Out] 收到数据的长度 strFromIP string& [Out] 发送方IP nFromPort int& [Out] 发送方端口 lSecond long [In] 超时时间秒 lMinSecond long [In] 超时时间毫秒 返回值:实际接收到的字节数,超时返回0 */ int Socket::ReceiveFrom( char* lpBuf, int nBufLen, string &strFromIP, int &nFromPort, bool bCheckDataLength, long lSecond, long lMinSecond ) { strFromIP = ""; nFromPort = -1; if ( 0 >= nBufLen ) return 0; sockaddr_in sockAddr; socklen_t nAddrLen = sizeof(sockaddr); /* waiting for receive data */ int nResult; int nFlag = 0; while ( true ) { if ( TimeOut( lSecond, lMinSecond ) ) return seTimeOut; if ( bCheckDataLength )nFlag = MSG_PEEK; nResult = recvfrom(m_hSocket, lpBuf, nBufLen, nFlag, (sockaddr*)&sockAddr, &nAddrLen); if ( nAddrLen > 0 ) GetAddress(sockAddr, strFromIP, nFromPort); if ( SOCKET_ERROR == nResult ) //socket发生异常 { #ifndef WIN32 if ( EAGAIN == errno ) return 0;//非阻塞recv返回,无数据可接收 return seError; #else int nError = GetLastError(); if ( 0 == nError )//之前存在失败的udp发送 { if ( MSG_PEEK == nFlag )//没有删除接收缓冲,从接收缓冲将消息删除 { recvfrom(m_hSocket, lpBuf, nBufLen, 0, (sockaddr*)&sockAddr, &nAddrLen); } continue; } if ( WSAEWOULDBLOCK == nError ) return 0;//非阻塞recv返回,无数据可接收 return seError; #endif } break; } return nResult; }