#include <callback_counter_semaphore.h>

Collaboration diagram for smacc::CallbackCounterSemaphore:

Public Member Functions
	CallbackCounterSemaphore (std::string name, int count=0)

bool	acquire ()

void	release ()

void	finalize ()

void	addConnection (boost::signals2::connection conn)

Private Attributes
int	count_

std::mutex	mutex_

std::condition_variable	cv_

std::vector< boost::signals2::connection >	connections_

bool	finalized = false

std::string	name_

Detailed Description

Definition at line 18 of file callback_counter_semaphore.h.

Constructor & Destructor Documentation

◆ CallbackCounterSemaphore()

smacc::CallbackCounterSemaphore::CallbackCounterSemaphore	(	std::string	name,
		int	count = `0`
	)

Definition at line 17 of file callback_counter_semaphore.cpp.

17: count_(count), name_(name) {}

smacc::CallbackCounterSemaphore::count_

int count_

Definition: callback_counter_semaphore.h:30

smacc::CallbackCounterSemaphore::name_

std::string name_

Definition: callback_counter_semaphore.h:35

Member Function Documentation

◆ acquire()

bool smacc::CallbackCounterSemaphore::acquire ( )

Definition at line 19 of file callback_counter_semaphore.cpp.

                                           {
        std::unique_lock<std::mutex> lock(mutex_);
        ROS_DEBUG("[CallbackCounterSemaphore] acquire callback %s %ld",name_.c_str(), (long)this);
 
        if(finalized)
        {
            ROS_DEBUG("[CallbackCounterSemaphore] callback rejected %s %ld",name_.c_str(), (long)this);
            return false;
        }
 
        ++count_;
        cv_.notify_one();
 
        ROS_DEBUG("[CallbackCounterSemaphore] callback accepted %s %ld",name_.c_str(), (long)this);
        return true;
    }

References count_, cv_, finalized, mutex_, and name_.

◆ addConnection()

void smacc::CallbackCounterSemaphore::addConnection ( boost::signals2::connection conn )

Definition at line 61 of file callback_counter_semaphore.cpp.

    {
        std::unique_lock<std::mutex> lock(mutex_);
 
        if(finalized)
        {
            ROS_DEBUG("[CallbackCounterSemaphore] ignoring adding callback, already finalized %s %ld",name_.c_str(), (long)this);
            return;
        }
 
        connections_.push_back(conn);
    }

References connections_, finalized, mutex_, and name_.

◆ finalize()

void smacc::CallbackCounterSemaphore::finalize ( )

Definition at line 44 of file callback_counter_semaphore.cpp.

                                            {
        std::unique_lock<std::mutex> lock(mutex_);
 
        while (count_ > 0) {
            cv_.wait(lock);
        }
        finalized = true;
 
        for(auto conn: connections_)
        {
            conn.disconnect();
        }
 
        connections_.clear();
        ROS_DEBUG("[CallbackCounterSemaphore] callbacks finalized %s %ld",name_.c_str(), (long)this);
    }

References connections_, count_, cv_, finalized, mutex_, and name_.

◆ release()

void smacc::CallbackCounterSemaphore::release ( )

Definition at line 36 of file callback_counter_semaphore.cpp.

                                           {
        std::unique_lock<std::mutex> lock(mutex_);
        --count_;
        cv_.notify_one();
 
        ROS_DEBUG("[CallbackCounterSemaphore] callback finished %s %ld",name_.c_str(), (long)this);
    }