ROSEE::MapActionHandler Class Reference

#include <MapActionHandler.h>

Collaboration diagram for ROSEE::MapActionHandler:

Public Types
typedef std::shared_ptr< MapActionHandler >	Ptr
typedef std::map< std::set< std::string >, ROSEE::ActionPrimitive::Ptr >	ActionPrimitiveMap

Public Member Functions
	MapActionHandler ()
bool	parseAllPrimitives (std::string pathFolder)
bool	parseAllGenerics (std::string pathFolder)
bool	parseAllTimeds (std::string pathFolder)
bool	parseAllActions (std::string pathFolder)
std::vector< ActionPrimitiveMap >	getPrimitiveMap (ROSEE::ActionPrimitive::Type type) const
	getter to take all the primitives maps of one type ( More...
ActionPrimitiveMap	getPrimitiveMap (std::string primitiveName) const
std::map< std::string, ActionPrimitiveMap >	getAllPrimitiveMaps () const
ROSEE::ActionPrimitive::Ptr	getPrimitive (std::string primitiveName, std::set< std::string > key) const
std::vector< ROSEE::ActionPrimitive::Ptr >	getPrimitive (ROSEE::ActionPrimitive::Type, std::set< std::string > key) const
ROSEE::ActionPrimitive::Ptr	getPrimitive (std::string primitiveName, std::vector< std::string > key) const
std::vector< ROSEE::ActionPrimitive::Ptr >	getPrimitive (ROSEE::ActionPrimitive::Type, std::vector< std::string > key) const
ROSEE::ActionPrimitive::Ptr	getPrimitive (std::string primitiveName, std::pair< std::string, std::string > key) const
std::vector< ROSEE::ActionPrimitive::Ptr >	getPrimitive (ROSEE::ActionPrimitive::Type, std::pair< std::string, std::string > key) const
ROSEE::ActionPrimitive::Ptr	getPrimitive (std::string primitiveName, std::string key) const
std::vector< ROSEE::ActionPrimitive::Ptr >	getPrimitive (ROSEE::ActionPrimitive::Type, std::string key) const
std::shared_ptr< ROSEE::ActionGeneric >	getGeneric (std::string name, bool verbose=true) const
std::map< std::string, std::shared_ptr< ROSEE::ActionGeneric > >	getAllGenerics () const
std::shared_ptr< ROSEE::ActionTimed >	getTimed (std::string name) const
std::map< std::string, std::shared_ptr< ROSEE::ActionTimed > >	getAllTimeds () const
std::map< std::string, ROSEE::ActionPrimitive::Ptr >	getPrimitiveSingleJointMultipleTipsMap (unsigned int nFingers) const
	function to return the map that contains all the singleJointMultipleTips primitive with that moves the specific number of fingers nFingers . More...
ROSEE::Action::Ptr	getGrasp (unsigned int nFingers, std::string graspName="grasp")
	This function try to get an action that should be a grasp. More...
std::set< std::string >	getFingertipsForPinch (std::string finger, ROSEE::ActionPrimitive::Type pinchType) const
std::map< std::string, std::set< std::string > >	getPinchTightPairsMap () const
std::map< std::string, std::set< std::string > >	getPinchLoosePairsMap () const
bool	insertSingleGeneric (ROSEE::ActionGeneric::Ptr generic)
	This is needed by rosservicehandler which has to include a new doable action, if received the service. More...

Private Member Functions
void	findPinchPairsMap ()

Private Attributes
std::string	handName
std::map< std::string, ActionPrimitiveMap >	primitives
std::map< std::string, std::shared_ptr< ROSEE::ActionGeneric > >	generics
std::map< std::string, std::shared_ptr< ROSEE::ActionTimed > >	timeds
std::map< std::string, std::set< std::string > >	pinchTightPairsMap
std::map< std::string, std::set< std::string > >	pinchLoosePairsMap

Detailed Description

Todo:

write docs

Definition at line 39 of file MapActionHandler.h.

Member Typedef Documentation

typedef std::map< std::set < std::string >, ROSEE::ActionPrimitive::Ptr > ROSEE::MapActionHandler::ActionPrimitiveMap

Definition at line 47 of file MapActionHandler.h.

typedef std::shared_ptr<MapActionHandler> ROSEE::MapActionHandler::Ptr

Definition at line 43 of file MapActionHandler.h.

Constructor & Destructor Documentation

ROSEE::MapActionHandler::MapActionHandler

(

)

Definition at line 19 of file MapActionHandler.cpp.

{}

Member Function Documentation

void ROSEE::MapActionHandler::findPinchPairsMap ( )

private

Definition at line 389 of file MapActionHandler.cpp.

                                              {
    
    //Assume only one pinch tight, it should be like this now.
    auto maps = getPrimitiveMap(ROSEE::ActionPrimitive::Type::PinchTight);
    
    if (maps.size() != 0 ){
        for (ActionPrimitiveMap map : maps) {
            for (auto mapEl : map) {
        
                for (auto fing : mapEl.first) { //.first is a set
                    
                    //we will insert all the set as value, this means that also will include the key itself,
                    // we remove the key from the values later
                    if (pinchTightPairsMap.count(fing) == 0 ) {
                        pinchTightPairsMap.insert(std::make_pair(fing, mapEl.first)); 
                    } else {
                        pinchTightPairsMap.at(fing).insert (mapEl.first.begin(), mapEl.first.end());
                    }
                }
            }
        }  
        //remove the string key from the values.
        for (auto it : pinchTightPairsMap) {
            it.second.erase(it.first);
        }
    }
    
    //now do the same for the loose pinches
    auto mapsloose = getPrimitiveMap(ROSEE::ActionPrimitive::Type::PinchLoose);
    
    if (mapsloose.size() != 0 ) {
        for (ActionPrimitiveMap map : mapsloose) {
            for (auto mapEl : map) {
        
                for (auto fing : mapEl.first) { //.first is a set
                    
                    //we will insert all the set as value, this means that also will include the key itself,
                    // we remove the key from the values later
                    if (pinchLoosePairsMap.count(fing) == 0 ) {
                        pinchLoosePairsMap.insert(std::make_pair(fing, mapEl.first)); 
                    } else {
                        pinchLoosePairsMap.at(fing).insert (mapEl.first.begin(), mapEl.first.end());
                    }
                }
            }
        }
        //remove the string key from the values.
        for (auto it : pinchLoosePairsMap) {
            it.second.erase(it.first);
        }
    }
}

std::map< std::string, std::shared_ptr< ROSEE::ActionGeneric > > ROSEE::MapActionHandler::getAllGenerics

(

)

const

Definition at line 187 of file MapActionHandler.cpp.

                                                                                                  {
    return generics;
}

std::map< std::string, ROSEE::MapActionHandler::ActionPrimitiveMap > ROSEE::MapActionHandler::getAllPrimitiveMaps

(

)

const

Definition at line 48 of file MapActionHandler.cpp.

                                                                                                            {
    return primitives;
}

std::map< std::string, std::shared_ptr< ROSEE::ActionTimed > > ROSEE::MapActionHandler::getAllTimeds

(

)

const

Definition at line 202 of file MapActionHandler.cpp.

                                                                                             {
    return timeds;
}

std::set< std::string > ROSEE::MapActionHandler::getFingertipsForPinch	(	std::string	finger,
		ROSEE::ActionPrimitive::Type	pinchType
	)		const

Definition at line 256 of file MapActionHandler.cpp.

                                                                                                                         {
    
    std::set <std::string> pairedFinger;
    
    switch (pinchType) {
        
    case ROSEE::ActionPrimitive::Type::PinchTight : {
        
        auto it = pinchTightPairsMap.find(finger);
        
        if ( it != pinchTightPairsMap.end() ) {
            pairedFinger = it->second;
            
        } else {
            std::cerr << "[WARNING MapActionHandler " << __func__ << "] No companions found to make a tight pinch with " << finger << " finger" 
            << std::endl;
        }
        break;
    }
    
    case ROSEE::ActionPrimitive::Type::PinchLoose : {
        
        auto it = pinchLoosePairsMap.find(finger);
        
        if ( it != pinchLoosePairsMap.end() ) {
            pairedFinger = it->second;
            
        } else {
            std::cerr << "[WARNING MapActionHandler " << __func__ << "] No companions found to make a loose pinch with " << finger << " finger" 
            << std::endl;
        } 
        break;
    }
    
    default: {
       
        std::cerr << "[WARNING MapActionHandler " << __func__ << "] Type " <<
        pinchType << " is not a type to look for companions " << std::endl;    
    }
    }
    
    return pairedFinger;
}

std::shared_ptr< ROSEE::ActionGeneric > ROSEE::MapActionHandler::getGeneric	(	std::string	name,
		bool	verbose = true
	)		const

Note

these functions return generics and composed (because composed are a derived class of generic)

Definition at line 174 of file MapActionHandler.cpp.

                                                                                                      {
    
    auto it = generics.find(name);
    if (it == generics.end() ) {
        if (verbose) {
            std::cerr << "[ERROR MapActionHandler " << __func__ << "] No generic function named '" << name << "'" << std::endl;
        }
        return nullptr;
    }
    
    return it->second;
}

ROSEE::Action::Ptr ROSEE::MapActionHandler::getGrasp	(	unsigned int	nFingers,
		std::string	graspName = "grasp"
	)

This function try to get an action that should be a grasp.

A real grasp, until now, can be two things:

• a generic/composed action, composed by trig with all the fingers
• a SingleJointMultipleTips primitive action, where the number of fingers moved is obviously the number of finger of the hand In the second case, if we have more joints that moves all the fingers, we return no action because we do not know which one is "the grasp". If we have only one joint that move all fingers, we return the singleJointMultipleTips action associated with this joint, even if there is the possibility that this is not a grasp (but which hand has only one joint that moves all fingers and it is not for a grasp?)

This function look first for a generic (or composed, that is a derived class of generic) action with name graspName , that should have been created and emitted before calling the parseAllActions (or parseAllGenerics) (e.g. in UniversalFindActions putting all the trigs togheter, but we can also define the grasp in another way).

Parameters

nFingers	the number of the finger of the hand, that is an information that this class hasn't
graspName	name given to the action grasp, default is "grasp"

Returns

pointer to Action, because the pointed object can be a primitive or a generic action.

Todo:

If not found, it tries to create a composed action, done with all trigs, and store this new action??

Warning

Generic and singleJointMultipleTips are different ros msg: singleJointMultipleTips want a element to be set (the joint) so this can cause problems.. so maybe this function should not exist

Definition at line 234 of file MapActionHandler.cpp.

                                                                                         {
    
    auto it = generics.find(graspName);
    if (it != generics.end()) {
        return it->second;
    }
    
    auto moreTip = getPrimitiveSingleJointMultipleTipsMap(nFingers);
    if (moreTip.size() == 1) { //if more than 1 I do not know how to choose the one that effectively "grasp"
        return moreTip.begin()->second;
    }
    
    std::cerr << "[WARNING MapActionHandler::" << __func__ << "] Not found any grasp named " << graspName << " neither a singleJointMultipleTips primitive " 
        << "that move all fingers with a single joint, you should create one action for grasp before calling parseAllActions/parseAllGenerics()"
        << std::endl;

    
    return nullptr;
    
}

std::map< std::string, std::set< std::string > > ROSEE::MapActionHandler::getPinchLoosePairsMap

(

)

const

Definition at line 170 of file MapActionHandler.cpp.

                                                                                         {
    return pinchLoosePairsMap;
}

std::map< std::string, std::set< std::string > > ROSEE::MapActionHandler::getPinchTightPairsMap

(

)

const

Definition at line 166 of file MapActionHandler.cpp.

                                                                                         {
    return pinchTightPairsMap;
}

ROSEE::ActionPrimitive::Ptr ROSEE::MapActionHandler::getPrimitive	(	std::string	primitiveName,
		std::set< std::string >	key
	)		const

Definition at line 52 of file MapActionHandler.cpp.

                                                                                                                {
    
    auto map = getPrimitiveMap(primitiveName);
    
    if (map.size() == 0 ) { 
        return nullptr; //error message already printed in getPrimitiveMap
    }
    
    if (map.begin()->second->getKeyElements().size() != key.size()) {
        std::cerr << "[ERROR MapActionHandler::" << __func__ << "] The action '" 
        << primitiveName << "' has as key a set of dimension " <<
        map.begin()->second->getKeyElements().size() <<
        " and not dimension of passed 2nd argument " << key.size() << std::endl;
        return nullptr;
    }
    
    auto it = map.find(key);
    
    if (it == map.end()) {
        std::cerr << "[ERROR MapActionHandler::" << __func__ << "] Not found any action '" 
            << primitiveName << "' with key [ " ;
        for (auto keyEl : key) {
            std::cerr << keyEl << ", ";
        }
        std::cerr << "] " << std::endl;
        return nullptr;
    }
    
    return it->second;
}

std::vector< ROSEE::ActionPrimitive::Ptr > ROSEE::MapActionHandler::getPrimitive	(	ROSEE::ActionPrimitive::Type	type,
		std::set< std::string >	key
	)		const

Definition at line 101 of file MapActionHandler.cpp.

                                                                                                                                 {
    
    std::vector <ActionPrimitiveMap> maps = getPrimitiveMap(type);
    
    //now we look among the maps, for all the maps that has key size as the size of key passed
    std::vector <ActionPrimitiveMap> theMaps;
    for (int i =0; i<maps.size(); i++) {
        if (maps.at(i).begin()->second->getKeyElements().size() == key.size()) {
            theMaps.push_back(maps.at(i));
        }
    }
    
    if (theMaps.size() == 0 ) {
        std::cerr << "[ERROR MapActionHandler::" << __func__ << "] No primitive action of type '" 
        << type << "' has as key a set of dimension " <<
        key.size() << " (passed 2nd argument)" << std::endl;
        return std::vector<ROSEE::ActionPrimitive::Ptr>();
    }
    
    //now we look, among all the themaps (where key size is the same as the passed arg key)
    // for an action that as effectively the wanted key. We can have more than one action
    // with the wanted key because in theMaps vector we have different primitives (altought 
    // of same type). This is not possible now (because singleJointMultipleTips have as key a joint, so
    // a joint cant move X fingers and ALSO Y fingers) (and multiplePinch action have all 
    // different key set size ( the number of fing used for multpinch). Anyway a vect is
    // returned because we do not know if in future we will have new type of primitives.
    std::vector<ROSEE::ActionPrimitive::Ptr> returnVect;
    for (auto action : theMaps) {
        auto it = action.find(key);
        if (it != action.end()) {
            returnVect.push_back(it->second);
        }
    }
    
    if (returnVect.size() == 0) {
        std::cerr << "[ERROR MapActionHandler::" << __func__ << "] Not found any primitive action of type '" << type << "' with key [ " ;
        for (auto keyEl : key) {
            std::cerr << keyEl << ", ";
        }
        std::cerr << "] " << std::endl;
        return std::vector<ROSEE::ActionPrimitive::Ptr>();
    }
    
    return returnVect;
    
}

ROSEE::ActionPrimitive::Ptr ROSEE::MapActionHandler::getPrimitive	(	std::string	primitiveName,
		std::vector< std::string >	key
	)		const

Definition at line 83 of file MapActionHandler.cpp.

                                                                                                                     {
    
    std::set <std::string> keySet (key.begin(), key.end());
    return getPrimitive(primitiveName, keySet);
}

std::vector< ROSEE::ActionPrimitive::Ptr > ROSEE::MapActionHandler::getPrimitive	(	ROSEE::ActionPrimitive::Type	type,
		std::vector< std::string >	key
	)		const

Definition at line 148 of file MapActionHandler.cpp.

                                                                                                                                      {
    
    std::set <std::string> keySet (key.begin(), key.end());
    return getPrimitive(type, keySet);
}

ROSEE::ActionPrimitive::Ptr ROSEE::MapActionHandler::getPrimitive	(	std::string	primitiveName,
		std::pair< std::string, std::string >	key
	)		const

Definition at line 95 of file MapActionHandler.cpp.

                                                                                                                           {
    
    std::set <std::string> keySet {key.first, key.second};
    return getPrimitive(primitiveName, keySet);
}

std::vector< ROSEE::ActionPrimitive::Ptr > ROSEE::MapActionHandler::getPrimitive	(	ROSEE::ActionPrimitive::Type	type,
		std::pair< std::string, std::string >	key
	)		const

Definition at line 160 of file MapActionHandler.cpp.

                                                                                                                                            {
    
    std::set <std::string> keySet {key.first, key.second};
    return getPrimitive(type, keySet);
}

ROSEE::ActionPrimitive::Ptr ROSEE::MapActionHandler::getPrimitive	(	std::string	primitiveName,
		std::string	key
	)		const

Definition at line 89 of file MapActionHandler.cpp.

                                                                                                        {
    
    std::set <std::string> keySet {key};
    return getPrimitive(primitiveName, keySet);
}

std::vector< ROSEE::ActionPrimitive::Ptr > ROSEE::MapActionHandler::getPrimitive	(	ROSEE::ActionPrimitive::Type	type,
		std::string	key
	)		const

Definition at line 154 of file MapActionHandler.cpp.

                                                                                                                         {
    
    std::set <std::string> keySet {key};
    return getPrimitive(type, keySet);
}

std::vector< ROSEE::MapActionHandler::ActionPrimitiveMap > ROSEE::MapActionHandler::getPrimitiveMap

(

ROSEE::ActionPrimitive::Type

type

)

const

getter to take all the primitives maps of one type (

Parameters

type)

A primitive map is a map where key is the element involved (joints or fingers) and values the action primitive itself It returns a vector (differently from version with string as argument) because we can have more primitives with same type (e.g. a singleJointMultipleTips primitive, which are differente between them because of the joint they move (singleJointMultipleTips_5 , singleJointMultipleTips_4 ... ) , or also multipinch)). This consideration is valid for all the other getPrimitive

type

the primitive type of the action that we want

Returns

vector of all the primitives that are of type

Parameters

type

Warning

Be sure to call parsing functions (parseAll*** ) otherwise no actions are returned never

Definition at line 32 of file MapActionHandler.cpp.

                                                                                                                             {
    
    std::vector<ROSEE::MapActionHandler::ActionPrimitiveMap> vectRet;
    
    for (auto it : primitives) {
        
        if (it.second.begin()->second->getPrimitiveType() == type ){
            vectRet.push_back(it.second);

        }
    }
    
    return vectRet;
    
}

ROSEE::MapActionHandler::ActionPrimitiveMap ROSEE::MapActionHandler::getPrimitiveMap

(

std::string

primitiveName

)

const

Definition at line 21 of file MapActionHandler.cpp.

                                                                                                           {
    
    auto it = primitives.find (primitiveName);
    if (it == primitives.end() ){
        std::cerr << "[ERROR MapActionHandler::" << __func__ << "] Not found any primitive action with name " << primitiveName << std::endl;
        return ActionPrimitiveMap();
    }
    
    return it->second;
}

std::map< std::string, ROSEE::ActionPrimitive::Ptr > ROSEE::MapActionHandler::getPrimitiveSingleJointMultipleTipsMap

(

unsigned int

nFingers

)

const

function to return the map that contains all the singleJointMultipleTips primitive with that moves the specific number of fingers nFingers .

This is in practice, the file singleJointMultipleTips_*nFingers*.yaml

It return only one map because per definition we have only one ActionPrimitiveMap of type singleJointMultipleTips with a defined number of nFinger. (Then inside it we can have more primitives ( when we have a hand with more joints that moves more than 1 finger), but always with the same number of nFinger)

Parameters

nFingers

the number of the finger that the singleJointMultipleTips primitives moves

Returns

A map with key the joint that moves the nFingers and as value the primitive with all the info to command it to the hand. Obvioulsy we can have more joints that move a certain number (nFingers) of fingers

Todo:

return with the key as set instead??? or leave as it is?

Definition at line 207 of file MapActionHandler.cpp.

                                                                                                                                    {
    
    std::map<std::string, ROSEE::ActionPrimitive::Ptr> ret;
    
    for (auto it : primitives) {
        
        if (it.second.begin()->second->getPrimitiveType() ==
            ROSEE::ActionPrimitive::Type::SingleJointMultipleTips && 
            it.second.begin()->second->getnFingersInvolved() == nFingers){
            
            //copy the map into one similar but with as key a strign and not a set
            for (auto itt : it.second) {
                //itt.first is the set of one element
                std::string key = *(itt.first.begin());
                ret.insert(std::make_pair(key, itt.second));
            }

        }
    }
    
    if (ret.size() == 0) {
        std::cerr << "[WARNING MapActionHandler::" << __func__ << "] Not found any singleJointMultipleTips action that moves " << nFingers << " fingers " << std::endl;
    }
    
    return ret;
}

std::shared_ptr< ROSEE::ActionTimed > ROSEE::MapActionHandler::getTimed

(

std::string

name

)

const

Definition at line 191 of file MapActionHandler.cpp.

                                                                                    {
    
    auto it = timeds.find(name);
    if (it == timeds.end() ) {
         std::cerr << "[ERROR MapActionHandler " << __func__ << "] No timed function named '" << name << "'" << std::endl;    
        return nullptr;
    }
    
    return it->second;
}

bool ROSEE::MapActionHandler::insertSingleGeneric

(

ROSEE::ActionGeneric::Ptr

generic

)

This is needed by rosservicehandler which has to include a new doable action, if received the service.

Definition at line 365 of file MapActionHandler.cpp.

                                                                             {
    
    auto it = generics.find(generic->getName());
    
    if (it != generics.end()){
       
         std::cerr << "[ERROR MapActionHandler " << __func__ << "] Trying to insert generic action with name " <<
            generic->getName() << "which already exists" << std::endl;
        
        return false;
    }
    
    //it as hint beause we already did the lookup in the find above
    generics.insert(it, std::make_pair(generic->getName(), generic));
    
    return true;
    
}

bool ROSEE::MapActionHandler::parseAllActions

(

std::string

pathFolder

)

Definition at line 301 of file MapActionHandler.cpp.

                                                                {
    
    bool flag = true;
    if (! parseAllPrimitives(pathFolder + "/primitives/") ) {
        flag = false;
    }
    if (! parseAllGenerics(pathFolder + + "/generics/") ) {
        flag = false;
    }
    if (! parseAllTimeds(pathFolder + + "/timeds/") ) {
        flag = false;
    }
    
    return flag;
    
}

bool ROSEE::MapActionHandler::parseAllGenerics

(

std::string

pathFolder

)

Definition at line 334 of file MapActionHandler.cpp.

                                                                 {

    std::vector <std::string> filenames = ROSEE::Utils::getFilesInDir(pathFolder);
    YamlWorker yamlWorker;
    for (auto file : filenames) {
        
        ROSEE::ActionGeneric::Ptr genericPointer =
            yamlWorker.parseYamlGeneric(pathFolder+file);
        generics.insert (std::make_pair( genericPointer->getName(), genericPointer) ) ;
    }
    
    
    return true;
    
    
}

bool ROSEE::MapActionHandler::parseAllPrimitives

(

std::string

pathFolder

)

Parameters

folder

where the action are. the action will be look in (<pkg_path> + pathFolder + "/" + handName + "/") ;

Definition at line 318 of file MapActionHandler.cpp.

                                                                   {
    
    std::vector <std::string> filenames = ROSEE::Utils::getFilesInDir(pathFolder);
    YamlWorker yamlWorker;
    
     for (auto file : filenames) {
        ActionPrimitiveMap primitive = yamlWorker.parseYamlPrimitive(pathFolder+file);
        primitives.insert (std::make_pair( primitive.begin()->second->getName(), primitive) ) ;
    }
    
    findPinchPairsMap();
    
    return true;
    
}

bool ROSEE::MapActionHandler::parseAllTimeds

(

std::string

pathFolder

)

Definition at line 351 of file MapActionHandler.cpp.

                                                               {
    
    std::vector <std::string> filenames = ROSEE::Utils::getFilesInDir(pathFolder);
    YamlWorker yamlWorker;
    for (auto file : filenames) {
        
        std::shared_ptr < ROSEE::ActionTimed > timed = yamlWorker.parseYamlTimed(pathFolder+file);
        timeds.insert (std::make_pair( timed->getName(), timed) ) ;
    }
    
    return true;
}

Member Data Documentation

std::map<std::string, std::shared_ptr<ROSEE::ActionGeneric> > ROSEE::MapActionHandler::generics

private

Definition at line 167 of file MapActionHandler.h.

std::string ROSEE::MapActionHandler::handName

private

Definition at line 164 of file MapActionHandler.h.

std::map<std::string, std::set<std::string> > ROSEE::MapActionHandler::pinchLoosePairsMap

private

Definition at line 171 of file MapActionHandler.h.

std::map<std::string, std::set<std::string> > ROSEE::MapActionHandler::pinchTightPairsMap

private

Definition at line 170 of file MapActionHandler.h.

std::map<std::string, ActionPrimitiveMap> ROSEE::MapActionHandler::primitives

private

Definition at line 166 of file MapActionHandler.h.

std::map<std::string, std::shared_ptr<ROSEE::ActionTimed> > ROSEE::MapActionHandler::timeds

private

Definition at line 168 of file MapActionHandler.h.

---

The documentation for this class was generated from the following files:

• /home/travis/build/ADVRHumanoids/ROSEndEffector/include/end_effector/MapActionHandler.h
• /home/travis/build/ADVRHumanoids/ROSEndEffector/src/MapActionHandler.cpp