Question

Here is my issue.
I have a class to create timed events. It takes in:

A function pointer of void (*func)(void* arg)

A void* to the argument

A delay

The issue is I may want to create on-the-fly variables that I dont want to be a static variable in the class, or a global variable. If either of these are not met, I cant do something like:

void doStuff(void *arg)
{
   somebool = *(bool*)arg;
}

void makeIt()
{
bool a = true;
   container->createTimedEvent(doStuff,(void*)&a,5); 
}

That wont work because the bool gets destroyed when the function returns. So I’d have to allocate these on the heap. The issue then becomes, who allocates and who deletes. what I’d like to do is to be able to take in anything, then copy its memory and manage it in the timed event class. But I dont think I can do memcpy since I dont know the tyoe.

What would be a good way to acheive this where the time event is responsible for memory managment.

Thanks

I do not use boost

class AguiTimedEvent {
    void (*onEvent)(void* arg);
    void* argument;
    AguiWidgetBase* caller;
    double timeStamp;
public:
    void call() const;

    bool expired() const;
    AguiWidgetBase* getCaller() const;
    AguiTimedEvent();
    AguiTimedEvent(void(*Timefunc)(void* arg),void* arg, double timeSec, AguiWidgetBase* caller);
};

void AguiWidgetContainer::handleTimedEvents()
{
    for(std::vector<AguiTimedEvent>::iterator it = timedEvents.begin(); it != timedEvents.end();)
    {
        if(it->expired())
        {

            it->call();
            it = timedEvents.erase(it);
        }
        else
            it++;
    }
}

void AguiWidgetBase::createTimedEvent( void (*func)(void* data),void* data,double timeInSec )
{
    if(!getWidgetContainer())
        return;
    getWidgetContainer()->addTimedEvent(AguiTimedEvent(func,data,timeInSec,this));
}


void AguiWidgetContainer::addTimedEvent( const AguiTimedEvent &timedEvent )
{
    timedEvents.push_back(timedEvent);
}

Answer 1

Why would you not use boost::shared_ptr?

It offers storage duration you require since an underlying object will be destructed only when all shared_ptrs pointing to it will have been destructed.

Also it offers full thread safety.