void processCurrentAuthCandidate() { if (currentAuthCandidate!=authCandidates.end() && hueComm.findInProgress) { // try to authorize FOCUSLOG("Auth candidate: uuid=%s, baseURL=%s -> try creating user", currentAuthCandidate->first.c_str(), currentAuthCandidate->second.c_str()); JsonObjectPtr request = JsonObject::newObj(); request->add("username", JsonObject::newString(userName)); request->add("devicetype", JsonObject::newString(deviceType)); hueComm.apiAction(httpMethodPOST, currentAuthCandidate->second.c_str(), request, boost::bind(&BridgeFinder::handleCreateUserAnswer, this, _1, _2), true); } else { // done with all candidates (or find aborted in hueComm) if (authCandidates.size()>0 && MainLoop::now()<startedAuth+authTimeWindow && hueComm.findInProgress) { // we have still candidates and time to do a retry in a second, and find is not aborted retryLoginTicket = MainLoop::currentMainLoop().executeOnce(boost::bind(&BridgeFinder::attemptPairingWithCandidates, this), 1*Second); return; } else { // all candidates tried, nothing found in given time LOG(LOG_NOTICE, "Could not register with a hue bridge"); hueComm.findInProgress = false; callback(ErrorPtr(new HueCommError(HueCommErrorNoRegistration, "No hue bridge found ready to register"))); // done! keepAlive.reset(); // will delete object if nobody else keeps it return; } } }
void processCurrentBridgeCandidate() { if (currentBridgeCandidate!=bridgeCandiates.end()) { // request description XML hueComm.bridgeAPIComm.httpRequest( (currentBridgeCandidate->second).c_str(), boost::bind(&BridgeFinder::handleServiceDescriptionAnswer, this, _1, _2), "GET" ); } else { // done with all candidates if (refind) { // failed getting description, return error callback(ErrorPtr(new HueCommError(HueCommErrorDescription))); keepAlive.reset(); // will delete object if nobody else keeps it return; // done } else { // finding new bridges - attempt user login bridgeCandiates.clear(); // now attempt to pair with one of the candidates startedAuth = MainLoop::now(); attemptPairingWithCandidates(); } } }
const TCHAR *GetECLType(const std::_tstring & colID) const { clib::recursive_mutex::scoped_lock proc(m_mutex); StringStringMap::const_iterator found = m_schemaMap.find(colID); if (found != m_schemaMap.end()) { return found->second.c_str(); } return NULL; }
const char * GetPath(const std::string & _label) { split_vector_type labels; boost::algorithm::split(labels, _label, boost::algorithm::is_any_of(","), boost::algorithm::token_compress_on); for(split_vector_type::const_iterator itr = labels.begin(); itr != labels.end(); ++itr) { StringStringMap::const_iterator found = m_familynamePath.find(*itr); if (found != m_familynamePath.end()) return found->second.c_str(); found = m_stemPath.find(*itr); if (found != m_stemPath.end()) return found->second.c_str(); } return GetDefaultPath(); }
void bridgeRefindHandler(SsdpSearchPtr aSsdpSearch, ErrorPtr aError) { if (!Error::isOK(aError)) { // could not find bridge, return error callback(ErrorPtr(new HueCommError(HueCommErrorUuidNotFound))); keepAlive.reset(); // will delete object if nobody else keeps it return; // done } else { // found, now get description to get baseURL // - put it into queue as the only candidate bridgeCandiates.clear(); bridgeCandiates[aSsdpSearch->uuid.c_str()] = aSsdpSearch->locationURL.c_str(); // process the candidate currentBridgeCandidate = bridgeCandiates.begin(); processCurrentBridgeCandidate(); } }
static int handle_request(void* /*cls*/, MHD_Connection* connection, const char* url, const char* method, const char*, const char*, unsigned int*, void** /*con_cls*/) { if (std::string(method) != "GET") { return report_error(connection, MHD_HTTP_NOT_IMPLEMENTED, "501 Not Implemented"); } if (mp3d_debug_httpd) { MHD_get_connection_values(connection, MHD_HEADER_KIND, dump_key, NULL); MHD_get_connection_values(connection, MHD_COOKIE_KIND, dump_key, NULL); MHD_get_connection_values(connection, MHD_GET_ARGUMENT_KIND, dump_key, NULL); std::cout << "*** " << method << " request for '" << url << "'" << std::endl; } const char* q = MHD_lookup_connection_value(connection, MHD_GET_ARGUMENT_KIND, "mp3d_q"); const std::string request_url(url); if (request_url == "/") { std::string page_data; make_main_page(page_data, q); return send_string_response(connection, MHD_HTTP_OK, page_data); } else if (boost::starts_with(request_url, "/static/")) { StringStringMap::const_iterator it = static_file_map.find(request_url); if (it == static_file_map.end()) { return report_error(connection, MHD_HTTP_NOT_FOUND, "404 Not Found"); } return send_string_response(connection, MHD_HTTP_OK, it->second); } else if (boost::starts_with(request_url, "/play/")) { const size_t id = strtoul(request_url.substr(6).c_str(), 0, 10); // FIXME: error checking. play_queue.clear(); play_queue.push_back(all_mp3s[id]); // FIXME: lookup by id (don't assume id == index). return see_other(connection, "/"); } else if (boost::starts_with(request_url, "/add/")) { const size_t id = strtoul(request_url.substr(5).c_str(), 0, 10); // FIXME: error checking. play_queue.push_back(all_mp3s[id]); // FIXME: lookup by id (don't assume id == index). return see_other(connection, "/"); } else if (boost::starts_with(request_url, "/remove/")) { const size_t id = strtoul(request_url.substr(8).c_str(), 0, 10); // FIXME: error checking. play_queue.remove(id); // FIXME: is this set-like behavior the behavior we want? return see_other(connection, "/"); } else { return report_error(connection, MHD_HTTP_NOT_FOUND, "404 Not Found"); } }
BEGIN_CUNKNOWN END_CUNKNOWN CFontResolver() { m_ftLibraryLoaded = false; FT_Error error = FT_Init_FreeType(&m_ftLibrary); if (!error) m_ftLibraryLoaded = true; split_vector_type searchFolders; boost::algorithm::split(searchFolders, DEFAULT_FONTPATH, boost::algorithm::is_any_of(";"), boost::algorithm::token_compress_on); for(split_vector_type::const_iterator itr = searchFolders.begin(); itr != searchFolders.end(); ++itr) { findFilesByExt(*itr, ".ttf", m_stemPath); findFilesByExt(*itr, ".ttc", m_stemPath); } split_vector_type defaultFonts; boost::algorithm::split(defaultFonts, DEFAULT_FONT, boost::algorithm::is_any_of(";"), boost::algorithm::token_compress_on); for(split_vector_type::const_iterator itr = defaultFonts.begin(); itr != defaultFonts.end(); ++itr) { StringStringMap::const_iterator found = m_stemPath.find(*itr); if (found != m_stemPath.end()) { m_defaultPath = found->second; break; } } if (m_defaultPath.empty()) { #if defined WIN32 m_defaultPath = "c:/windows/fonts/verdana.ttf"; #else m_defaultPath = "/usr/share/fonts/truetype/freefont/FreeSans.ttf"; #endif } }
void fillAndPrint(StringStringMap& coll) { //fill insert elements in random order coll["Deutschland"] = "Germany"; coll["deutsch"] = "German"; coll["Haken"] = "snag"; coll["arbeiten"] = "work"; coll["Hund"] = "dog"; coll["gehen"] = "go"; coll["Unternehmen"] = "enterprise"; coll["unternehmen"] = "undertake"; coll["gehen"] = "walk"; coll["Bestatter"] = "undertaker"; //print elements StringStringMap::iterator pos; cout.setf(ios::left, ios::adjustfield); for (pos=coll.begin(); pos!=coll.end(); ++pos) { cout << setw(15) << pos->first.c_str() << " " << pos->second << endl; } cout << endl; }
void herschel::xml::displayStringStringMap(Port<Octet>& port, zstring outerTagName, zstring tagName, zstring firstPairTagName, zstring secPairTagName, const StringStringMap& strMap) { if (!strMap.empty()) displayOpenTag(port, outerTagName); for (StringStringMap::const_iterator it = strMap.begin(); it != strMap.end(); it++) { displayOpenTag(port, tagName); displayTag(port, firstPairTagName, it->first); displayTag(port, secPairTagName, it->second); displayCloseTag(port, tagName); } if (!strMap.empty()) displayCloseTag(port, outerTagName); }
void bridgeDiscoveryHandler(SsdpSearchPtr aSsdpSearch, ErrorPtr aError) { if (Error::isOK(aError)) { // check device for possibility of being a hue bridge if (aSsdpSearch->server.find("IpBridge")!=string::npos) { LOG(LOG_INFO, "hue bridge candidate device found at %s, server=%s, uuid=%s", aSsdpSearch->locationURL.c_str(), aSsdpSearch->server.c_str(), aSsdpSearch->uuid.c_str()); // put into map bridgeCandiates[aSsdpSearch->uuid.c_str()] = aSsdpSearch->locationURL.c_str(); } } else { FOCUSLOG("discovery ended, error = %s (usually: timeout)", aError->description().c_str()); aSsdpSearch->stopSearch(); // now process the results currentBridgeCandidate = bridgeCandiates.begin(); processCurrentBridgeCandidate(); } }
void findNewBridge(const char *aUserName, const char *aDeviceType, MLMicroSeconds aAuthTimeWindow, HueComm::HueBridgeFindCB aFindHandler) { refind = false; callback = aFindHandler; userName = nonNullCStr(aUserName); deviceType = nonNullCStr(aDeviceType); authTimeWindow = aAuthTimeWindow; if (hueComm.fixedBaseURL.empty()) { // actually search for a bridge keepAlive = BridgeFinderPtr(this); bridgeDetector->startSearch(boost::bind(&BridgeFinder::bridgeDiscoveryHandler, this, _1, _2), NULL); } else { // we have a pre-known base URL for the hue API, use this without any find operation keepAlive = BridgeFinderPtr(this); // - just put it in as the only auth candidate authCandidates.clear(); authCandidates[PSEUDO_UUID_FOR_FIXED_API] = hueComm.fixedBaseURL; startedAuth = MainLoop::now(); attemptPairingWithCandidates(); } };
void Update(const ns6__ECLResult * c) { clib::recursive_mutex::scoped_lock proc(m_mutex); SAFE_ASSIGN2CSTRING(m_name, c->Name); SAFE_ASSIGN(m_sequence, c->Sequence); SAFE_ASSIGN2CSTRING(m_value, c->Value); SAFE_ASSIGN2CSTRING(m_link, c->Link); SAFE_ASSIGN(IsSupplied, c->IsSupplied); SAFE_ASSIGN(m_total, c->Total); SAFE_ASSIGN2CSTRING(m_fileName, c->FileName); if (c->ECLSchemas) { m_schemaMap.clear(); for(std::size_t i = 0; i < c->ECLSchemas->ECLSchemaItem.size(); ++i) { if (c->ECLSchemas->ECLSchemaItem[i]->ColumnName && c->ECLSchemas->ECLSchemaItem[i]->ColumnType) { m_schemaMap[*c->ECLSchemas->ECLSchemaItem[i]->ColumnName] = *c->ECLSchemas->ECLSchemaItem[i]->ColumnType; } } } }
void Clear() { nvs.clear(); }
void attemptPairingWithCandidates() { currentAuthCandidate = authCandidates.begin(); processCurrentAuthCandidate(); }
int CGraphItem::GetProperties(StringStringMap & results) const { results = m_propStringString; return results.size(); }