mitk::PropertyPersistence::InfoResultType mitk::PropertyPersistence::GetInfo(const std::string &propertyName, const MimeTypeNameType &mime, bool allowMimeWildCard, bool allowNameRegEx) const { SelectFunctionType select = [propertyName, mime](const InfoMap::value_type &x) { return infoPredicate(x, propertyName, mime); }; InfoMap selection = SelectInfo(m_InfoMap, select); if (allowNameRegEx) { select = [propertyName, mime](const InfoMap::value_type &x) { return infoPredicateRegEx(x, propertyName, mime); }; InfoMap regExSelection = SelectInfo(m_InfoMap, select); selection.insert(regExSelection.begin(), regExSelection.end()); } if (selection.empty() && allowMimeWildCard) { // no perfect match => second run through with "any mime type" select = [propertyName](const InfoMap::value_type &x) { return infoPredicate(x, propertyName, PropertyPersistenceInfo::ANY_MIMETYPE_NAME()); }; selection = SelectInfo(m_InfoMap, select); if (allowNameRegEx) { select = [propertyName](const InfoMap::value_type &x) { return infoPredicateRegEx(x, propertyName, PropertyPersistenceInfo::ANY_MIMETYPE_NAME()); }; InfoMap regExSelection = SelectInfo(m_InfoMap, select); selection.insert(regExSelection.begin(), regExSelection.end()); } } InfoResultType result; for (const auto &pos : selection) { result.push_back(pos.second->UnRegExByName(propertyName).GetPointer()); } return result; }
inline static QString toString(const InfoMap &infoMap, const QString sep="\n") { QString str(""); InfoMap::const_iterator it = infoMap.begin(); for (; it != infoMap.end() ; ++it) str += QString("[%1]:%2%3").arg(it.key()).arg(*it).arg(sep); return str; }
bool MediaAddonServer::QuitRequested() { CALLED(); InfoMap::iterator iterator = fInfoMap.begin(); for (iterator = fInfoMap.begin(); iterator != fInfoMap.end(); iterator++) _DestroyInstantiatedFlavors(iterator->second); BMediaRoster::CurrentRoster()->Lock(); BMediaRoster::CurrentRoster()->Quit(); for (iterator = fInfoMap.begin(); iterator != fInfoMap.end(); iterator++) _PutAddonIfPossible(iterator->second); return true; }
inline int UserInfoCache::updateUserInfo(int userId, UserInfo *userInfo) { int ret = 1; //.. // Although we intend to update the information, we first acquire a *read* // *lock* to locate the item. This allows other threads to read the list while // we find the item. If we do not locate the item we can simply release the // *read* *lock* and return an error without causing any other *reading* thread // to block. (Again, other writers *will* block until this *read* *lock* is // released.) //.. d_lock.lockRead(); InfoMap::iterator it = d_infoMap.find(userId); if (d_infoMap.end() != it) { //.. // Since 'it != end()', we found the item. Now we need to upgrade to a *write* // *lock*. If we can't do this atomically, then we need to locate the item // again. This is because another thread may have changed 'd_infoMap' during // the time between our *read* and *write* locks. //.. if (d_lock.upgradeToWriteLock()) { it = d_infoMap.find(userId); } //.. // This is a little more costly, but since we don't expect many concurrent // writes, it should not happen often. In the (likely) event that we do // upgrade to a *write* *lock* atomically, then the second lookup above is not // performed. In any case, we can now update the information and release the // lock, since we already have a pointer to the item and we know that the list // could not have been changed by anyone else. //.. if (d_infoMap.end() != it) { it->second = *userInfo; ret = 0; } d_lock.unlock(); } else { d_lock.unlock(); } return ret; }
void MythGenericTree::SetTextFromMap(const InfoMap &infoMap, const QString &state) { InfoMap::const_iterator map_it = infoMap.begin(); while (map_it != infoMap.end()) { TextProperties textprop; textprop.text = (*map_it); textprop.state = state; m_strings[map_it.key()] = textprop; ++map_it; } }
inline int UserInfoCache::getUserInfo(int userId, UserInfo *userInfo) { int ret = 1; //.. // Getting the user info does not require any write access. We do, however, // need read access to 'd_infoMap', which is controlled by 'd_lock'. (Note // that writers *will* block until this *read* *lock* is released, but // concurrent reads are allowed.) The user info is copied into the // caller-owned location 'userInfo'. //.. d_lock.lockRead(); InfoMap::iterator it = d_infoMap.find(userId); if (d_infoMap.end() != it) { *userInfo = it->second; ret = 0; } d_lock.unlock(); return ret; }
void MediaAddonServer::_AddOnRemoved(ino_t fileNode) { // TODO: locking? FileMap::iterator foundFile = fFileMap.find(fileNode); if (foundFile == fFileMap.end()) { ERROR("MediaAddonServer::_AddOnRemoved: inode %Ld removed, but no " "media add-on found\n", fileNode); return; } media_addon_id id = foundFile->second; fFileMap.erase(foundFile); int32 oldFlavorCount; InfoMap::iterator foundInfo = fInfoMap.find(id); if (foundInfo == fInfoMap.end()) { ERROR("MediaAddonServer::_AddOnRemoved: couldn't get addon info for " "add-on %ld\n", id); oldFlavorCount = 1000; } else { AddOnInfo& info = foundInfo->second; oldFlavorCount = info.flavor_count; _DestroyInstantiatedFlavors(info); _PutAddonIfPossible(info); if (info.addon) { ERROR("MediaAddonServer::_AddOnRemoved: couldn't unload addon " "%ld since flavors are in use\n", id); } fInfoMap.erase(foundInfo); } gDormantNodeManager->UnregisterAddOn(id); BPrivate::media::notifications::FlavorsChanged(id, 0, oldFlavorCount); }
void MediaAddonServer::_ScanAddOnFlavors(BMediaAddOn* addon) { ASSERT(addon->AddonID() > 0); TRACE("MediaAddonServer::_ScanAddOnFlavors: id %ld\n", addon->AddonID()); // cache the media_addon_id in a local variable to avoid // calling BMediaAddOn::AddonID() too often media_addon_id addonID = addon->AddonID(); // update the cached flavor count, get oldflavorcount and newflavorcount InfoMap::iterator found = fInfoMap.find(addonID); ASSERT(found != fInfoMap.end()); AddOnInfo& info = found->second; int32 oldFlavorCount = info.flavor_count; int32 newFlavorCount = addon->CountFlavors(); info.flavor_count = newFlavorCount; TRACE("%ld old flavors, %ld new flavors\n", oldflavorcount, newFlavorCount); // during the first update (i == 0), the server removes old dormant_flavor_infos for (int i = 0; i < newFlavorCount; i++) { const flavor_info* flavorInfo; TRACE("flavor %d:\n", i); if (addon->GetFlavorAt(i, &flavorInfo) != B_OK) { ERROR("MediaAddonServer::_ScanAddOnFlavors GetFlavorAt failed for " "index %d!\n", i); continue; } #if DEBUG >= 2 DumpFlavorInfo(flavorInfo); #endif dormant_flavor_info dormantFlavorInfo; dormantFlavorInfo = *flavorInfo; dormantFlavorInfo.node_info.addon = addonID; dormantFlavorInfo.node_info.flavor_id = flavorInfo->internal_id; strlcpy(dormantFlavorInfo.node_info.name, flavorInfo->name, B_MEDIA_NAME_LENGTH); size_t flattenedSize = dormantFlavorInfo.FlattenedSize(); size_t messageSize = flattenedSize + sizeof(server_register_dormant_node_command); server_register_dormant_node_command* message = (server_register_dormant_node_command*)malloc(messageSize); if (message == NULL) break; // The server should remove previously registered "dormant_flavor_info"s // during the first update, but after the first iteration, we don't // want the server to anymore remove old dormant_flavor_infos message->purge_id = i == 0 ? addonID : 0; message->type = dormantFlavorInfo.TypeCode(); message->flattened_size = flattenedSize; dormantFlavorInfo.Flatten(message->flattened_data, flattenedSize); status_t status = SendToServer(SERVER_REGISTER_DORMANT_NODE, message, messageSize); if (status != B_OK) { ERROR("MediaAddonServer::_ScanAddOnFlavors: couldn't register " "dormant node: %s\n", strerror(status)); } free(message); } // TODO: we currently pretend that all old flavors have been removed, this // could probably be done in a smarter way BPrivate::media::notifications::FlavorsChanged(addonID, newFlavorCount, oldFlavorCount); }
void MediaAddonServer::ReadyToRun() { if (!be_roster->IsRunning("application/x-vnd.Be.media-server")) { // the media server is not running, let's quit fprintf(stderr, "The media_server is not running!\n"); Quit(); return; } // the control thread is already running at this point, // so we can talk to the media server and also receive // commands for instantiation ASSERT(fStartup == true); // The very first thing to do is to create the system time source, // register it with the server, and make it the default SYSTEM_TIME_SOURCE BMediaNode *timeSource = new SystemTimeSource; status_t result = fMediaRoster->RegisterNode(timeSource); if (result != B_OK) { fprintf(stderr, "Can't register system time source : %s\n", strerror(result)); debugger("Can't register system time source"); } if (timeSource->ID() != NODE_SYSTEM_TIMESOURCE_ID) debugger("System time source got wrong node ID"); media_node node = timeSource->Node(); result = MediaRosterEx(fMediaRoster)->SetNode(SYSTEM_TIME_SOURCE, &node); if (result != B_OK) debugger("Can't setup system time source as default"); // During startup, first all add-ons are loaded, then all // nodes (flavors) representing physical inputs and outputs // are instantiated. Next, all add-ons that need autostart // will be autostarted. Finally, add-ons that don't have // any active nodes (flavors) will be unloaded. char parameter[32]; size_t parameterLength = sizeof(parameter); bool safeMode = false; if (_kern_get_safemode_option(B_SAFEMODE_SAFE_MODE, parameter, ¶meterLength) == B_OK) { if (!strcasecmp(parameter, "enabled") || !strcasecmp(parameter, "on") || !strcasecmp(parameter, "true") || !strcasecmp(parameter, "yes") || !strcasecmp(parameter, "enable") || !strcmp(parameter, "1")) safeMode = true; } fMonitorHandler = new MonitorHandler(this); AddHandler(fMonitorHandler); BMessage pulse(B_PULSE); fPulseRunner = new BMessageRunner(fMonitorHandler, &pulse, 1000000LL); // the monitor handler needs a pulse to check if add-ons are ready // load dormant media nodes const directory_which directories[] = { B_USER_ADDONS_DIRECTORY, B_COMMON_ADDONS_DIRECTORY, B_SYSTEM_ADDONS_DIRECTORY }; // when safemode, only B_SYSTEM_ADDONS_DIRECTORY is used for (uint32 i = safeMode ? 2 : 0; i < sizeof(directories) / sizeof(directory_which); i++) { BDirectory directory; node_ref nodeRef; BPath path; if (find_directory(directories[i], &path) == B_OK && path.Append("media") == B_OK && directory.SetTo(path.Path()) == B_OK && directory.GetNodeRef(&nodeRef) == B_OK) fMonitorHandler->AddDirectory(&nodeRef); } #ifdef USER_ADDON_PATH node_ref nodeRef; if (entry.SetTo(USER_ADDON_PATH) == B_OK && entry.GetNodeRef(&nodeRef) == B_OK) fMonitorHandler->AddDirectory(&nodeRef); #endif fStartup = false; InfoMap::iterator iterator = fInfoMap.begin(); for (; iterator != fInfoMap.end(); iterator++) _InstantiatePhysicalInputsAndOutputs(iterator->second); for (iterator = fInfoMap.begin(); iterator != fInfoMap.end(); iterator++) _InstantiateAutostartFlavors(iterator->second); for (iterator = fInfoMap.begin(); iterator != fInfoMap.end(); iterator++) _PutAddonIfPossible(iterator->second); server_rescan_defaults_command cmd; SendToServer(SERVER_RESCAN_DEFAULTS, &cmd, sizeof(cmd)); }