ControllerManager::ControllerManager(hardware_interface::RobotHW *robot_hw, const ros::NodeHandle& nh) :
robot_hw_(robot_hw),
root_nh_(nh),
cm_node_(nh, "controller_manager"),
start_request_(0),
stop_request_(0),
please_switch_(false),
current_controllers_list_(0),
used_by_realtime_(-1)
{
// create controller loader
controller_loaders_.push_back( LoaderPtr(new ControllerLoader<controller_interface::ControllerBase>("controller_interface",
"controller_interface::ControllerBase") ) );
// Advertise services (this should be the last thing we do in init)
srv_list_controllers_ = cm_node_.advertiseService("list_controllers", &ControllerManager::listControllersSrv, this);
srv_list_controller_types_ = cm_node_.advertiseService("list_controller_types", &ControllerManager::listControllerTypesSrv, this);
srv_load_controller_ = cm_node_.advertiseService("load_controller", &ControllerManager::loadControllerSrv, this);
srv_unload_controller_ = cm_node_.advertiseService("unload_controller", &ControllerManager::unloadControllerSrv, this);
srv_switch_controller_ = cm_node_.advertiseService("switch_controller", &ControllerManager::switchControllerSrv, this);
srv_reload_libraries_ = cm_node_.advertiseService("reload_controller_libraries", &ControllerManager::reloadControllerLibrariesSrv, this);
}
void Medusa::LoadModules(std::wstring const& rModulesPath)
{
try
{
const boost::filesystem::path CurDir = rModulesPath;
Module Module;
Log::Write("core") << "Module directory: " << boost::filesystem::system_complete(CurDir) << LogEnd;
boost::filesystem::directory_iterator End;
for (boost::filesystem::directory_iterator It(CurDir);
It != End; ++It)
{
std::wstring const& rFilename = It->path().wstring();
if (rFilename.substr(rFilename.find_last_of(L".") + 1) != Module::GetExtension())
continue;
std::wstring FullPath = boost::filesystem::system_complete(*It).wstring();
Log::Write("core") << "Module: \"" << rFilename << "\" ";
void* pMod = Module.Load(FullPath);
if (pMod == nullptr)
continue;
TGetLoader pGetLoader = Module.Load<TGetLoader>(pMod, "GetLoader");
if (pGetLoader != nullptr)
{
Log::Write("core") << "is a loader ";
Loader* pLoader = pGetLoader(m_Database);
if (pLoader->IsSupported())
{
Loader::SharedPtr LoaderPtr(pLoader);
m_Loaders.push_back(LoaderPtr);
Log::Write("core") << "(loaded)" << LogEnd;
}
else
{
Log::Write("core") << "(unloaded)" << LogEnd;
delete pLoader;
}
continue;
}
TGetArchitecture pGetArchitecture = Module.Load<TGetArchitecture>(pMod, "GetArchitecture");
if (pGetArchitecture != nullptr)
{
Log::Write("core") << "is an Architecture" << LogEnd;
Architecture* pArchitecture = pGetArchitecture();
Architecture::SharedPtr ArchitecturePtr(pArchitecture);
m_AvailableArchitectures.push_back(ArchitecturePtr);
continue;
}
TGetOperatingSystem pGetOperatingSystem = Module.Load<TGetOperatingSystem>(pMod, "GetOperatingSystem");
if (pGetOperatingSystem != nullptr)
{
Log::Write("core") << "is an operating system" << LogEnd;
OperatingSystem* pOperatingSystem = pGetOperatingSystem(m_Database);
OperatingSystem::SharedPtr spOperatingSystem(pOperatingSystem);
m_CompatibleOperatingSystems.push_back(spOperatingSystem);
continue;
}
TGetEmulator pGetEmulator = Module.Load<TGetEmulator>(pMod, "GetEmulator");
if (pGetEmulator != nullptr)
{
Log::Write("core") << "is an Emulator" << LogEnd;
Emulator* pEmulator = pGetEmulator(nullptr, nullptr, nullptr);
m_Emulators[pEmulator->GetName()] = pGetEmulator;
continue;
}
Log::Write("core") << "is unknown (ignored)" << LogEnd;
}
}
catch (std::exception &e)
{
Log::Write("core") << e.what() << LogEnd;
}
}
TextureCollection::LoaderPtr TextureCollection::loader() const {
return LoaderPtr(new TextureCollectionLoader(m_path));
}
void SceneManager::initLoaders() {
this->loader = LoaderPtr(new Loader(staticShader->programId));
this->guiLoader = LoaderPtr(new Loader(guiShader->programId));
}
