Discussion :

[pavel]

Bonjour,

Je souhaite cree un event sur un timer.
Je m explique, j ai un truc du style:

class A
{
boost::timer MyTimer;
A(void){MyTimer = boost::timer();}
void F(void){ // Fait des trucs; }
}

Je cherche donc a faire , sur un objetA:
Si MyTimer > MaxTime --> execute F()

Quelqu un a une idee ?
Je serais plus partant pour utiliser la boost.

[trop_wizz]

Hello,

Bon pour boost je sais pas. (Mais je suis aussi intéressé si quelqu'un a une solution ).

Sous windows:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
void F()
{
   DWORD ret = WaitForSingleObject(event,timeout)
   if (ret==WAIT_TIMEOUT)
   {
      //code de la fonction
   }
}

Si "event" n'est jamais signalé, une fois appelée,la fonction attendra le temps spécifié par timeout pour s'éxécuter.


+++

Frantz

[3DArchi]

Salut,
A ma connaissance, boost.timer est fait pour mesurer un intervalle de temps. Ce n'est pas un timer qui claque au sens où tu peux l'entendre.

[pavel]

Voila en cherchant un peu j ai trouver une solution qui se rapproche de celle que je cherche.Utiliser Boost.Asio

Ca donne un truc du style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
#include <iostream>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
class A
{
  boost::asio::deadline_timer timer_;
  int count_;
 
 A(void){timer_.async_wait(boost::bind(&A::print, this));}
 
 void print()
  {
       if (count_ < 5)
       {
	std::cout << count_ << "\n";
	++count_;
	timer_.expires_at(timer_.expires_at() + boost::posix_time::seconds(10));
	timer_.async_wait(boost::bind(&printer::print, this));
           }
 
  }
 
}
int _tmain(int argc, _TCHAR* argv[])
{
     boost::asio::io_service io;
     A p(io);
     io.run();
     cout<<"END";
     return 0;
}

La fonction print va se declencher toute les 10 secondes.
Le truc c est qu il faut creer un thread qui va faire io.run() sinon
le programme s arrete et attend que io.run() se termine ce qui est genant.

Je regarde d autre piste comme :http://www.boost.org/doc/libs/1_41_0.../tutorial.html


TO BE CONTINUE.....

[bruno_pages]

Hello,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
void F()
{
   DWORD ret = WaitForSingleObject(event,timeout)
   if (ret==WAIT_TIMEOUT)
   {
      //code de la fonction
   }
}

Si "event" n'est jamais signalé, une fois appelée,la fonction attendra le temps spécifié par timeout pour s'éxécuter.

c'est vraiment très schadock comme solution, pour attendre il suffit d'utiliser sleep ou usleep

La fonction print va se declencher toute les 10 secondes.
Le truc c est qu il faut creer un thread qui va faire io.run() sinon
le programme s arrete et attend que io.run() se termine ce qui est genant.

c'est un peu la même chose, s'il n'y a rien d'autre à faire dans le thread dédié alors il suffit de temporiser l'exécution avec un sleep, pas besoin de toutes ces lignes pour gérer le timer

[pavel]

Je pense que tu n as pas bien compris la problematique.
(C est surement de ma faute)

Pour ton code autant faire :

void F()
{
DWORD ret = WaitForSingleObject(event,WAIT_TIMEOUT)
//code de la fonction

}

[3DArchi]

Effectivement, tu devrais mieux reformuler ta problématique.
Souhaites-tu un seul thread qui fait une opération à intervalle régulier et entre les 2 rien ?
Souhaites-tu 2 thread : un qui se déroule en permanence et un second qui est réveillé à intervalle régulier pour dérouler l'opération ?
Es-tu dans un framework IHM (MFC, Qt, wxWidgets, win32) et souhaites-tu avoir un évènement dans la file des messages à intervalle régulier ?

[pavel]

L idee c est d avoir un evenement qui se declenche automatiquement au bout d un certain temps.

Exemple:
J ai un objA, qui vit sa vie, et tout les 10 min, par exemple, on appelle une fonction de l objtA.
Tout ceci de facon plus ou moins simple et transparente pour celui qui utilise l objetA et sans bloquer le programme (wait).

Y a t il dans la boost un truc pour declencher un event ou appelle de fonction au bout d un certain temps.

En gros on l utiliserait ainsi:

ObjetA myObjetA = ObjetA(TIME_MAX)
..... Fait sa vie et au bout de TIME_MAX --> call myObjetA.F();

Peut etre est il possible de faire ca avec la Boost.


Si non on peut utiliser un truc du style:

class ObjetA
{
void F(void)
}

void G()
{
Sleep(MAXTIME)
{
lock(MyObjetA)
MyObjetA.F()
}
}

Static ObjetA MyObjetA();
Main()
{
Thread MyThread = call Asynchrone de G()

//Fait des trucs

}