C++ (Cpp) Unpause Examples

Example #1

File: filetransfer.cpp Project: StefanRoss/mythtv

long long FileTransfer::Seek(long long curpos, long long pos, int whence)
{
    if (pginfo)
        pginfo->UpdateInUseMark();

    if (!rbuffer)
        return -1;
    if (!readthreadlive)
        return -1;

    ateof = false;

    Pause();

    if (whence == SEEK_CUR)
    {
        long long desired = curpos + pos;
        long long realpos = rbuffer->GetReadPosition();

        pos = desired - realpos;
    }

    long long ret = rbuffer->Seek(pos, whence);

    Unpause();

    if (pginfo)
        pginfo->UpdateInUseMark();

    return ret;
}

Example #2

File: MockSensorTest.cpp Project: jeffkilpatrick/thermocouple

TEST(MockSensorTest, Pause) {
    const auto pollInterval = std::chrono::milliseconds(5);
    const ISensor::SubscriptionId subId = 1;

    auto listener = std::make_shared<RecordingListener>();
    auto& values = listener->GetValues();
    {
        auto poller = std::make_unique<SensorPoller>(pollInterval);
        auto s = poller->CreateSensor<MockSensor>("mock", MockSensor::ValuesVec{ 35.0 });
        s->AddNotification(subId, std::make_shared<OnChangeSubscription>(listener, 0.5));
        poller->Start();

        std::this_thread::sleep_for(pollInterval * 2);
        EXPECT_EQ(1, values.size());

        s->SetValues({ 36.0 });
        std::this_thread::sleep_for(pollInterval * 2);
        EXPECT_EQ(2, values.size());

        s->Pause(1);
        EXPECT_EQ(Subscription::Status::PAUSED, s->GetStatus(1));

        s->SetValues({ 37.0 });
        std::this_thread::sleep_for(pollInterval * 2);
        EXPECT_EQ(2, values.size());

        s->Unpause(1);
        EXPECT_EQ(Subscription::Status::ACTIVE, s->GetStatus(1));

        std::this_thread::sleep_for(pollInterval * 2);
        EXPECT_EQ(3, values.size());
    }
}

Example #3

File: BaseWorker.cpp Project: asceth/synapi

bool BaseWorker::Stop(bool flush_cancel)
{
	if (m_state == Worker_Invalid || m_state == Worker_Stopped)
	{
		return false;
	}

	if (m_state == Worker_Paused)
	{
		if (!Unpause())
		{
			return false;
		}
	}

	m_state = Worker_Stopped;
	Flush(flush_cancel);

	if (m_pHooks)
	{
		m_pHooks->OnWorkerStop(this);
	}

	return true;
}

Example #4

File: BaseWorker.cpp Project: Chuvi-w/amxmodx

bool BaseWorker::Stop(bool flush_cancel)
{
	if (m_state == Worker_Invalid || m_state == Worker_Stopped)
		return false;

	if (m_state == Worker_Paused)
	{
		if (!Unpause())
			return false;
	}

	m_state = Worker_Stopped;
	Flush(flush_cancel);

	return true;
}

Example #5

File: ThreadWorker.cpp Project: Arkshine/amxmodx

bool ThreadWorker::Stop(bool flush_cancel)
{
	if (m_state == Worker_Invalid || m_state == Worker_Stopped)
		return false;

	WorkerState oldstate;

	//set new state
	m_StateLock->Lock();
	oldstate = m_state;
	m_state = Worker_Stopped;
	m_FlushType = flush_cancel;
	m_StateLock->Unlock();

	if (oldstate == Worker_Paused)
	{
		Unpause();
	} else {
		m_QueueLock->Lock();
		if (m_Waiting)
		{
			m_AddSignal->Signal();
		}
		m_QueueLock->Unlock();
	}

	me->WaitForThread();
	//destroy it
	me->DestroyThis();
	//flush all remaining events
	Flush(true);

	//free mutex locks
	m_QueueLock->DestroyThis();
	m_StateLock->DestroyThis();
	m_PauseSignal->DestroyThis();
	m_AddSignal->DestroyThis();

	//invalidizzle
	m_QueueLock = NULL;
	m_StateLock = NULL;
	m_PauseSignal = NULL;
	m_AddSignal = NULL;
	me = NULL;

	return true;
}

Example #6

void HK_StateLoadSlot(int num, bool justPressed)
{
	if (romloaded && justPressed)
	{
		BOOL wasPaused = paused;
		Pause();
		loadstate_slot(num);		//Loadstate
		lastSaveState = num;		//Set last savestate used

		UpdateToolWindows();

		if(!wasPaused)
			Unpause();
		else
			Display();

		AutoFrameSkip_IgnorePreviousDelay();
	}
}