C++ AddEvent函數代碼示例

TestResult xUnitTest::Run()
{
    for (auto &recorder : testEventRecorders)
    {
        recorder->Tie([&](TestEvent &&evt) { AddEvent(std::move(evt)); });
    }

    testStart = Time::Clock::now();

    try
    {
        test();
    }
    catch (const xUnitAssert &assert)
    {
        AddEvent(TestEvent(EventLevel::Assert, assert));
    }
    catch (const std::exception &e)
    {
        AddEvent(TestEvent(e));
    }
    catch (...)
    {
        AddEvent(TestEvent(EventLevel::Fatal, "Unknown exception caught: test has crashed."));
    }

    testStop = Time::Clock::now();

    return failureEventLogged ? TestResult::Failure : TestResult::Success;
}

int CEventQueue::Restore( IRestore &restore )
{
	// clear the event queue
	Clear();

	// rebuild the event queue by restoring all the queue items
	EventQueuePrioritizedEvent_t tmpEvent;

	// load the number of items saved
	if ( !restore.ReadFields( "EventQueue", this, NULL, m_DataMap.dataDesc, m_DataMap.dataNumFields ) )
		return 0;
	
	for ( int i = 0; i < m_iListCount; i++ )
	{
		if ( !restore.ReadFields( "PEvent", &tmpEvent, NULL, tmpEvent.m_DataMap.dataDesc, tmpEvent.m_DataMap.dataNumFields ) )
			return 0;

		// add the restored event into the list
		if ( tmpEvent.m_pEntTarget )
		{
			AddEvent( tmpEvent.m_pEntTarget, STRING(tmpEvent.m_iTargetInput), tmpEvent.m_VariantValue, tmpEvent.m_flFireTime - gpGlobals->curtime, tmpEvent.m_pActivator, tmpEvent.m_pCaller, tmpEvent.m_iOutputID );
		}
		else
		{
			AddEvent( STRING(tmpEvent.m_iTarget), STRING(tmpEvent.m_iTargetInput), tmpEvent.m_VariantValue, tmpEvent.m_flFireTime - gpGlobals->curtime, tmpEvent.m_pActivator, tmpEvent.m_pCaller, tmpEvent.m_iOutputID );
		}
	}

	return 1;
}

BOOL COSMCtrlMapOperationsDlg::DeleteCachedTilesHelper()
{
  //What will be the return value from this function (assume the best)
  BOOL bSuccess = TRUE;

  //Accumulate how many tiles we have deleted and not deleted
  int nTilesDeleted = 0;
  int nTilesNotDeleted = 0;

  //Work thro all the tiles
  CString sCacheDirectory(m_pOSMCtrl->GetCacheDirectory());
  for (std::vector<COSMCtrlMapOperationsDlgTile>::size_type i=0; (i<m_Tiles.size()) && bSuccess; i++)
  {
    //Pull out the tile we are working on
    const COSMCtrlMapOperationsDlgTile& tile = m_Tiles[i];

    //Do the deletion of the tile        
    CString sTile(m_pOSMCtrl->GetTileCachePath(sCacheDirectory, tile.m_nZoom, tile.m_nTileX, tile.m_nTileY, FALSE));
    COSMCtrlMapOperationsDlgEvent dlgEvent;
    if (GetFileAttributes(sTile) != INVALID_FILE_ATTRIBUTES) //Don't bother doing anything if the tile does not already exist
    {
      if (DeleteFile(sTile))
      {
        //Update the stats
        ++nTilesDeleted;
        
        dlgEvent.m_bSuccess = true;
      }
      else
      {
        //Update the stats
        ++nTilesNotDeleted;
        
        dlgEvent.m_bSuccess = false;
      }
    }

    //Update the UI          
    dlgEvent.m_Event = COSMCtrlMapOperationsDlgEvent::SimpleStringStatus;
    dlgEvent.m_sString = sTile;
    dlgEvent.m_nItemData = i + 1;
    AddEvent(dlgEvent);
    
    //Check if we have been cancelled before we loop around
    bSuccess = (WaitForSingleObject(m_WorkerTerminateEvent, 0) == WAIT_TIMEOUT);
  }
  
  //Finally add a event about how many items have been deleted
  COSMCtrlMapOperationsDlgEvent dlgEvent;
  dlgEvent.m_Event = COSMCtrlMapOperationsDlgEvent::SimpleStringStatus;
  CString sTilesDeleted;
  sTilesDeleted.Format(_T("%d"), nTilesDeleted);
  CString sTilesNotDeleted;
  sTilesNotDeleted.Format(_T("%d"), nTilesNotDeleted);
  AfxFormatString2(dlgEvent.m_sString, IDS_OSMCTRL_DELETE_FILES_STATS, sTilesDeleted, sTilesNotDeleted);
  AddEvent(dlgEvent);
  
  return bSuccess;
}

void Extension::SaveReceivedBinaryToFile(int Position, int Size, char * Filename)
{
    if (Position < 0)
        CreateError("Cannot save received binary; Position less than 0.");
    else if (Size <= 0)
        CreateError("Cannot save received binary; Size equal or less than 0.");
    else if (!Filename || Filename[0] == '\0')
        CreateError("Cannot save received binary; filename is invalid.");
    else if (ThreadData.ReceivedMsg.Size - Size <= 0)
        CreateError("Cannot save received binary; Message is too small.");
    else
    {
        FILE * File = NULL;
        if (fopen_s(&File, Filename, "wb") || !File)
        {
            char errorval[20];
            SaveExtInfo &S = AddEvent(0);
            std::string Error = "Cannot save received binary to file, error ";
            if (_itoa_s(*_errno(), &errorval[0], 20, 10))
            {
                Error += " with opening the file, and with converting error number.";
            }
            else
            {
                Error += "number [";
                Error += &errorval[0];
                Error += "] occured with opening the file.";
            }
            Error += "\r\nThe message has not been modified.";
            S.Error.Text = _strdup(Error.c_str());
            return;
        }
        // Jump to end
        fseek(File, 0, SEEK_END);
        // Read current position as file size
        long long filesize = _ftelli64(File);
        // Go back to start
        fseek(File, 0, SEEK_SET);
        long l;
        if ((l = fwrite(ThreadData.ReceivedMsg.Content + Position, 1, Size, File)) != Size)
        {
            char sizeastext[20];
            SaveExtInfo &S = AddEvent(0);
            std::string Error = "Couldn't save the received binary to file, ";
            if (_itoa_s(errno, &sizeastext[0], 20, 10))
            {
                Error += " and error copying size.";
            }
            else
            {
                Error += &sizeastext[0];
                Error += " bytes managed to be written.";
            }
            S.Error.Text = _strdup(Error.c_str());
        }
        fclose(File);
    }
}

CUAC_Thread::CUAC_Thread(int processId)
{
	m_processId = processId;

	AddEvent(UAC_PASTE, StrF(_T("Global\\UAC_PASTE_%d"), m_processId));
	AddEvent(UAC_COPY, StrF(_T("Global\\UAC_COPY_%d"), m_processId));
	AddEvent(UAC_CUT, StrF(_T("Global\\UAC_CUT_%d"), m_processId));

	AddEvent(UAC_EXIT, StrF(_T("Global\\UAC_EXIT_%d"), m_processId));

	m_waitTimeout = 30000;
}

void CInputJoystick::StartUp(void)
{

	AddEvent(EVENT_TYPE_SDL, SDL_JOYAXISMOTION);
	AddEvent(EVENT_TYPE_SDL, SDL_JOYBALLMOTION);
	AddEvent(EVENT_TYPE_SDL, SDL_JOYHATMOTION);
	AddEvent(EVENT_TYPE_SDL, SDL_JOYBUTTONDOWN);
	AddEvent(EVENT_TYPE_SDL, SDL_JOYBUTTONUP);
	RegisterEventManager();

	LoadJoysticks();
}

 void OnEvent(int id) {
   if (id == m_event_open)
   {
     if (connected < antal)
     {
       TestSocket *p = new TestSocket(static_cast<EventHandler&>(Handler()));
       p -> SetDeleteByHandler();
       p -> Open(host, port);
       Handler().Add(p);
     }
     else
     {
       printf("Finished connecting. %d connected / %d failed / %d lost\n", connected, failed, lost);
     }
     m_event_open = AddEvent(interval / 1000, (interval % 1000) * 1000);
   }
   else
   if (id == m_event_request)
   {
     if (m_req_index < full_request.size())
     {
       if (full_request[m_req_index] == '\r')
       {
         printf("<CR>");
         fflush(stdout);
       }
       if (full_request[m_req_index] == '\n')
       {
         printf("<LF>");
         fflush(stdout);
       }
       SendBuf( &full_request[m_req_index], 1 );
       m_req_index++;
       m_event_request = AddEvent(delay / 1000, (delay % 1000) * 1000);
     }
     else
     {
       m_event_restart = AddEvent(3, 0);
     }
   }
   else
   if (id == m_event_restart)
   {
     m_req_index = 0;
     m_event_request = AddEvent(delay / 1000, (delay % 1000) * 1000);
   }
   else
   {
     fprintf(stderr, "%9lu %5u Unknown event id\n", UniqueIdentifier(), GetSockPort());
     SetCloseAndDelete();
   }
 }

void CastleScene::Initialize(void) {
	boost::optional<boost::shared_ptr<Error> > error;
	if(error = AddEvent(EVENT_TYPE_NEXT_STEP)) {
		error.get()->Abort();
		BOOST_ASSERT(false);
	}
	if(error = AddEvent(EVENT_TYPE_INPUT_STRING)) {
		error.get()->Abort();
		BOOST_ASSERT(false);
	}
	if(error = AddEvent(EVENT_TYPE_ON_SELECT)) {
		error.get()->Abort();
		BOOST_ASSERT(false);
	}
}

	//! Take the existing events and put them in bins
	void Bin(int no_bins, T min, T max) {
		typename std::map<T,int>::iterator f;
		if (events.empty()) return;
		EventCounter binned_cntr;

		T delta = (max - min) / no_bins;
		std::cout << "Delta is " << delta << std::endl;
		for (f = events.begin(); f != events.end(); ++f) {
			T value = (*f).first;
			int bin_id = 0;
			if (value >= min) bin_id = (value - min) / delta;
			if (value > max) bin_id = no_bins;
			T bin_value = min + delta * bin_id;
//			std::cout << "Bin id is " << bin_id << "(" << value << "-" << min << ") /" << no_bins << " and bin value thus: " << bin_value << std::endl;
			binned_cntr.AddEvent(bin_value, (*f).second);
		}
		int size = events.size();
		events.clear();
		for (f = binned_cntr.getEvents().begin(); f != binned_cntr.getEvents().end(); ++f) {
			AddEvent(f->first, f->second);
		}
		std::cerr << "Goes from size " << size << " to " << events.size() << std::endl;
		if (events.size() < 10) {
			std::cerr << "Maybe use more than " << no_bins << " bins" << std::endl;
		}

		// add e.g. assert on nr of events (should be the same)
	}

VSCPanel::VSCPanel(QWidget *parent, Qt::WindowFlags flags)
    : QWidget(parent, flags)
{
	ui.setupUi(this);
	setAcceptDrops(true);
	setMouseTracking(true);
	ui.scrollArea->setBackgroundRole(QPalette::Light);

	/* Setup connection */
	connect(ui.pbView, SIGNAL(clicked()), this, SIGNAL(AddSurveillance()));
	connect(ui.pbSearch, SIGNAL(clicked()), this, SIGNAL(Search()));
	connect(ui.pbMining, SIGNAL(clicked()), this, SIGNAL(AddDmining()));
	connect(ui.pbEmap, SIGNAL(clicked()), this, SIGNAL(AddEmap()));
	connect(ui.pbRecordPlan, SIGNAL(clicked()), this, SIGNAL(AddRecordPlan())); 

	connect(ui.pbRecorder, SIGNAL(clicked()), this, SIGNAL(AddRecorder()));
	connect(ui.pbCamera, SIGNAL(clicked()), this, SIGNAL(AddCamera()));

	connect(ui.pbSetting, SIGNAL(clicked()), this, SIGNAL(Setting()));
	connect(ui.pbAlarm, SIGNAL(clicked()), this, SIGNAL(AddEvent()));
	connect(ui.pbVIPC, SIGNAL(clicked()), this, SIGNAL(AddVIPC()));

	connect(ui.pbTasklist, SIGNAL(clicked()), this, SLOT(UpdateTaskList()));


	UpdateTaskList();
}

bool WrappedOpenGL::Serialise_glDebugMessageInsert(SerialiserType &ser, GLenum source, GLenum type,
                                                   GLuint id, GLenum severity, GLsizei length,
                                                   const GLchar *buf)
{
  std::string name = buf ? std::string(buf, buf + (length > 0 ? length : strlen(buf))) : "";

  // unused, just for the user's benefit
  SERIALISE_ELEMENT(source);
  SERIALISE_ELEMENT(type);
  SERIALISE_ELEMENT(id);
  SERIALISE_ELEMENT(severity);
  SERIALISE_ELEMENT(name);

  SERIALISE_CHECK_READ_ERRORS();

  if(IsReplayingAndReading())
  {
    GLMarkerRegion::Set(name);

    if(IsLoading(m_State))
    {
      DrawcallDescription draw;
      draw.name = name;
      draw.flags |= DrawFlags::SetMarker;

      AddEvent();
      AddDrawcall(draw, false);
    }
  }

  return true;
}

bool WrappedOpenGL::Serialise_glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
{
	SERIALISE_ELEMENT(GLenum, buf, buffer);
	SERIALISE_ELEMENT(int32_t, draw, drawbuffer);
	SERIALISE_ELEMENT(float, d, depth);
	SERIALISE_ELEMENT(int32_t, s, stencil);
	
	if(m_State <= EXECUTING)
		m_Real.glClearBufferfi(buf, draw, d, s);
	
	const string desc = m_pSerialiser->GetDebugStr();

	if(m_State == READING)
	{
		AddEvent(CLEARBUFFERFI, desc);
		string name = "glClearBufferfi(" +
						ToStr::Get(buf) + ", " +
						ToStr::Get(draw) + ")";

		FetchDrawcall draw;
		draw.name = widen(name);
		draw.flags |= eDraw_Clear;

		AddDrawcall(draw, true);
	}

	return true;
}

void ElunaEventProcessor::Update(uint32 diff, Eluna* E, WorldObject* obj)
{
    m_time += diff;
    for (EventList::iterator it = eventList.begin(); it != eventList.end() && it->first <= m_time; it = eventList.begin())
    {
        LuaEvent* luaEvent = it->second;
        eventList.erase(it);

        if (!luaEvent->abort)
        {
            bool remove = luaEvent->repeats == 1;
            if (!remove)
                AddEvent(*luaEvent, true); // Reschedule before calling incase RemoveEvents used

            // Call the timed event
            E->OnTimedEvent(luaEvent->funcRef, luaEvent->delay, luaEvent->repeats ? luaEvent->repeats-- : luaEvent->repeats, obj);

            if (!remove)
                continue;
        }

        // Event should be deleted (executed last time or set to be aborted)
        luaL_unref(E->L, LUA_REGISTRYINDEX, luaEvent->funcRef);
        eventMap.erase(luaEvent->funcRef);
    }
}

IOEventRef IOEventLoop::AddWriteEvent(int fd,
                                      const std::function<bool()>& callback) {
  if (!MakeFdNonBlocking(fd)) {
    return nullptr;
  }
  return AddEvent(fd, EV_WRITE | EV_PERSIST, nullptr, callback);
}

CMainFrmThread::CMainFrmThread(void)
{
    for(int eventEnum = 0; eventEnum < ECMAINFRMTHREADEVENTS_COUNT; eventEnum++)
    {
        AddEvent(eventEnum);
    }
}