C++ Work类代码示例

TEST(AWorkObject, DefaultsFunctionToNullObject) {
   Work work;
   try {
      work.execute();
   }
   catch(...) {
      FAIL("unable to execute function");
   }
}

int main()
{
	std::deque<Proceso*> procesos;
	Work archivo;
	procesos = archivo.inserta("texto.txt");
	std::sort(procesos.begin(), procesos.end(), archivo.comparaArrival);
	archivo.print(procesos);
	archivo.roundRobin(procesos);
	//archivo.SJF(procesos);
}

int Worker::Run() {
	while (!workQueue.IsShutdown()){
		Work* now = workQueue.GetWork();
		if (now == NULL) continue;
		int ret = now->DoWork();
		if (ret){
			//printf("Woerker error code : %d\n", ret);
		}
	}
	return 0;
}

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    Work work;
    work.setAutoDelete(false);
    QThreadPool *threadPool = QThreadPool::globalInstance();
    threadPool->start(&work);
    qDebug() << "hello from GUI thread " << QThread::currentThread();
    threadPool->waitForDone();
}

 void impl(Work w)
 {
   try {
     w();
   } catch (const boost::exception& e) {
     ECTO_LOG_DEBUG("post thrower(boost::exception) %s", __PRETTY_FUNCTION__);
     w.post(thrower(boost::current_exception()));
   } catch (const std::exception& e) {
     ECTO_LOG_DEBUG("post thrower (std::exception) %s", __PRETTY_FUNCTION__);
     w.post(thrower(boost::current_exception()));
   }
   w.post(boost::bind(&runandjoin::join, this));
 }

void esp::Worklist::solveWorklist(){
  while(works.size() != 0){
    Work *currentWork = selectAWork();
    removeFromWorklist(currentWork);
    //do real work here
    if(currentWork != NULL)
      doEachWork(currentWork);

    printDebugMsg("Instructions in worklist:");
    for(set<Work*>::iterator it = works.begin(); it!=works.end(); it++){
      Work *workInList = (*it);
      workInList->printContent();
    }
  }
}

int Worker::Run() {
    // TODO: 工作循环
    while (1) {
	Work* work = workQueue.GetWork();
	if (work != NULL) {
	    work->DoWork();
	    if (work->NeedDelete()) {
		delete work;
	    }
	}
	else if (workQueue.IsShutdown())
	    break;
    }

    return 0;
}

void CreateDatabaseDialogue::OnWorkCrashed(wxCommandEvent& event)
{
  Work *work = static_cast<Work*>(event.GetClientData());
  wxLogDebug(_T("%p: work crashed (on create database dialogue)"), work);

  if (!work->GetCrashMessage().empty()) {
    wxLogError(_T("%s\n%s"), _("An unexpected error occurred interacting with the database. Failure will ensue."), work->GetCrashMessage().c_str());
  }
  else {
    wxLogError(_T("%s"), _("An unexpected and unidentified error occurred interacting with the database. Failure will ensue."));
  }

  if (work->crashHandler != NULL)
    CALL_WORK_COMPLETION(*this, work->crashHandler)(work);

  delete work;
}

void Worker::workLoopAnyWork()
{
   log.log(4, std::string("Ready (TID: ") + StringTk::uint64ToStr(System::getTID() ) + ")");

   workQueue->incNumWorkers(); // add this worker to queue stats

   while(!getSelfTerminate() || !maySelfTerminateNow() )
   {
      //log.log(4, "Waiting for work...");

      Work* work = workQueue->waitForAnyWork(stats);

      //log.log(4, "Got work");

      #ifdef FHGFS_DEBUG_PROFILING
         Time workStartTime;
      #endif

      HighResolutionStatsTk::resetStats(&stats); // prepare stats

      // process the work packet
      work->process(bufIn, bufInLen, bufOut, bufOutLen);

      // update stats
      stats.incVals.workRequests = 1;
      HighResolutionStatsTk::addHighResIncStats(*work->getHighResolutionStats(), stats);

      #ifdef FHGFS_DEBUG_PROFILING
      Time workEndTime;
      int workElapsedMS = workEndTime.elapsedSinceMS(&workStartTime);
      int workElapsedMicro = workEndTime.elapsedSinceMicro(&workStartTime);

      if(workEndTime.elapsedSinceMS(&workStartTime) )
         LOG_DEBUG("Worker::workLoop", Log_DEBUG, "Work processed. Elapsed ms: " +
            StringTk::intToStr(workElapsedMS) );
      else
         LOG_DEBUG("Worker::workLoop", Log_DEBUG, "Work processed. Elapsed us: " +
            StringTk::intToStr(workElapsedMicro) );
      #endif

      // cleanup
      delete(work);
   }
}

int _tmain(int argc, _TCHAR* argv[])
{
	Work wk1("Vilka", 25, 400);
	Work* pwk;
	Work *wk[10];

	pwk=&wk1;
	//Work wk2(wk1);
	Work wk2=wk1;
	
	cout<<"headworker:\n FIO:"<<pwk->GetFio()<<" Age:"<<pwk->GetAge()<<" Wage:"<<pwk->GetWage()<<endl;
	cout<<"Copy of headworker:\n FIO:"<<wk2.GetFio()<<" Age:"<<wk2.GetAge()<<" Wage:"<<wk2.GetWage()<<endl;

	int i, ai, wi, tw;
	tw=wk1.GetWage()+wk2.GetWage();

	wk[0]=new Work;
	wk[1]=new Work(18);
	wk[2]=new Work(18, 300);
	wk[3]=new Work(wk2);
	wk[4]=new Work("Sting", 19, 300);
	wk[5]=new Work("Bingo", 28, 350);
	wk[6]=new Work("Flicr", 38, 200);
	wk[7]=new Work("Dream", 34, 330);
	wk[8]=new Work("Steam", 25, 300);
	wk[9]=new Work("Roar", 18, 180);

	for (i=0, ai=18, wi=300;i<10;i++,ai=ai+3,wi=wi+20)
	{
		//wk[i]->SetAge(ai);
		//wk[i]->SetWage(wi);
		tw=tw+wk[i]->GetWage();
		cout<<i+1<<" worker info:\n FIO:"<<wk[i]->GetFio()<<" Age:"<<wk[i]->GetAge()<<" Wage:"<<wk[i]->GetWage()<<endl;
	}

	cout<<"Total m_wage: "<<tw<<endl;

	system("pause");
	return 0;
}

Move::Move(Work& work, db::Comment const& comment, unsigned varNo, unsigned varCount)
	:KeyNode(work.key)
	,m_ply(0)
{
	if (!work.isFolded && !comment.isEmpty())
	{
		db::Comment comm(comment);
		comm.strip(*work.wantedLanguages);

		if (!comm.isEmpty())
		{
			work.pushSpaceOrParagraph(Spacing::Comment);
			work.pop(m_list);
			m_list.push_back(new Comment(comm, move::Post, Comment::AtEnd));
		}
	}

	if (work.m_level > 0)
	{
		Node::Bracket bracket;

		if (work.isFolded)
			bracket = Node::Fold;
		else if (/*varCount > 1 && */(work.m_displayStyle & display::ShowVariationNumbers))
			bracket = Node::End;
		else
			bracket = Node::Close;

		work.pushClose(varNo == varCount);
	   m_list.push_back(new Space(bracket, varNo == varCount));
	}
	else
	{
		m_list.push_back(new Space(0));
	}
}

//int main(int argc, char** argv)
int main()
{
	
	vector<Token> ex_list;
	//ex_list = sc.scan(argv[1]);
	ex_list = sc.scan("parcertest1.txt");
	//sc.scan("parcertest1.txt", "parceresport.txt");
	p.get_vector(ex_list);
	 
	DLP vect = p.datalogprogram("DLPEXPORT.txt");
	
	w.importDLP(vect);
	//string temp = argv[2];
	string temp = "a.txt";
	ofstream out(temp);
	w.doWork(out);
	w.factEval(out);
	w.printfacts(out);
	w.further_work(out);

	// out.close();


	//vector<Predicate> sh = vect.getSchemes();


	/*
	for (int i = 0; i < sh.size(); i++)
	{
		cout << sh[i].toString() << endl;
	}*/
	 
	
	//system("pause");
	return 0;
}

void UnloadWorker<BATB>::operator()(Work& work)
{
    // (this is done in other GL context!)

    // unknown how many steps to be taken
    work.indefinite(); 

    try
    {
        // unload Demo
        demo::end( batb.demo );

        // unload race
        //race::begin( batb.race );

        // unload forest
        forest::end( batb.forest );

        // unload the non-core part of run
        run::end( batb.run );


        // unload AL
        work.state( "AL" );
        al::end( batb.al );

        // unload OGRE
        // FIXME!!! current thread is not main. 
        //          OGRE::frameBegin is calledafter delete!
        work.state( "OGRE" );
        ogre::end( batb.ogre );

#ifdef LOAD_PROXY
        work.state( "Proxy library B" );
        std::this_thread::sleep_for( std::chrono::seconds( 2 ) );
        work.state( "Proxy library A" );
        std::this_thread::sleep_for( std::chrono::seconds( 2 ) );
#endif

    } 
    catch (std::exception& e)
    {
        batb.log << "error unloading : " << e.what() << std::endl; 
    }

    // must be done to signalize completion
    work.finish();
}

int main()
{
	Work * emp = new Work();
	emp->SetHour(9);
	emp->WriteProgram();
	emp->SetHour(10);
	emp->WriteProgram();
	emp->SetHour(11);
	emp->WriteProgram();
	emp->SetHour(12);
	emp->WriteProgram();
	emp->SetHour(13);
	emp->WriteProgram();
	emp->SetHour(14);
	emp->WriteProgram();
	emp->SetHour(17);
	
	emp->TaskFinished(false);
	emp->WriteProgram();
	emp->SetHour(19);
	emp->WriteProgram();
	emp->SetHour(22);
	emp->WriteProgram();
	return 0;
}

void ButtonBox::OnAdd(Work& work) {
	for (auto& button : buttons_) {
		work.addWidget(button);
	}
}