void BuildLayer::deleteModule() { if(NULL == mStation || mStation->getModuleCount() == 1) return; // Find the potential next module to select Module* nextSelection = NULL; ConnectionList connections = mSelectedModule->getConnections(); for(unsigned int iConnection = 0; iConnection < connections.size(); ++iConnection) { if(NULL != connections[iConnection]) { nextSelection = connections[iConnection]; break; } } mStation->getMission()->useActionPoint(); // // Profile: Update number of modules removed // ConfigManager::getPlayer()->mModulesDeleted++; mStation->removeModule(mSelectedModule); if(nextSelection == NULL) { setReadyState(); } else { setSelectedState(nextSelection); } //SoundManager::playSoundEffect("orbit/undocking"); }
ConnectionList CAndroidNetworkManager::GetConnections() { ConnectionList connections; if (!m_ethernetConnection.get()) GetEthernetConnection(); if (!m_currentWifi.get()) GetCurrentWifiConnection(); if (m_wifiAccessPoints.empty()) GetWifiAccessPoints(); if(m_ethernetConnection.get()) connections.push_back(m_ethernetConnection); if(m_currentWifi.get() && !m_currentWifi->GetName().empty() && m_currentWifi->GetState() != NETWORK_CONNECTION_STATE_DISCONNECTED) connections.push_back(m_currentWifi); for(CAndroidConnectionList::iterator i = m_wifiAccessPoints.begin(); i < m_wifiAccessPoints.end(); i++) { CAndroidConnectionPtr connection(*i); if (!connection.get()) continue; if(!connection->GetName().empty() && (!m_currentWifi || (connection->GetName() != m_currentWifi->GetName()) || m_currentWifi->GetState() == NETWORK_CONNECTION_STATE_DISCONNECTED)) connections.push_back(connection); } return connections; }
void CGUIDialogAccessPoints::UpdateConnectionList() { m_connectionsFileList->Clear(); CGUIMessage msgReset(GUI_MSG_LABEL_RESET, GetID(), ACCESS_POINT_LIST); OnMessage(msgReset); int connectedItem = 0; ConnectionList connections = g_application.getNetworkManager().GetConnections(); std::string connection_name; for (size_t i = 0; i < connections.size(); i++) { connection_name = connections[i]->GetName(); CFileItemPtr item(new CFileItem(connection_name)); if (m_use_ipconfig) { if (connection_name.find(m_ipname) != std::string::npos) connectedItem = i; } else { if (connections[i]->GetState() == NETWORK_CONNECTION_STATE_CONNECTED) connectedItem = i; } if (connections[i]->GetType() == NETWORK_CONNECTION_TYPE_WIFI) { int signal, strength = connections[i]->GetStrength(); if (strength == 0 || strength < 20) signal = 1; else if (strength == 20 || strength < 40) signal = 2; else if (strength == 40 || strength < 60) signal = 3; else if (strength == 60 || strength < 80) signal = 4; else signal = 5; if (strength <= 20) item->SetArt("thumb", "ap-signal1.png"); else if (strength <= 40) item->SetArt("thumb", "ap-signal2.png"); else if (strength <= 60) item->SetArt("thumb", "ap-signal3.png"); else if (strength <= 80) item->SetArt("thumb", "ap-signal4.png"); else if (strength <= 100) item->SetArt("thumb", "ap-signal5.png"); item->SetProperty("signal", signal); item->SetProperty("encryption", EncryptionToString(connections[i]->GetEncryption())); } item->SetProperty("type", ConnectionTypeToString(connections[i]->GetType())); item->SetProperty("state", ConnectionStateToString(connections[i]->GetState())); m_connectionsFileList->Add(item); } CGUIMessage msg(GUI_MSG_LABEL_BIND, GetID(), ACCESS_POINT_LIST, connectedItem, 0, m_connectionsFileList); OnMessage(msg); }
void RhsListener::RemoveAllListeners(Connection* pConnection) { // We need to walk the list of all rhs functions, removing this connection for (RhsMapIter mapIter = m_RhsMap.begin() ; mapIter != m_RhsMap.end() ; mapIter++) { std::string function = mapIter->first ; ConnectionList* pList = mapIter->second ; pList->remove(pConnection) ; } }
// Start listening for a specific RHS user function. When it fires we'll call to the client // (over the connection) to implement it. void RhsListener::RemoveRhsListener(char const* pFunctionName, Connection* pConnection) { ConnectionList* pList = GetRhsListeners(pFunctionName) ; // We have no record of anyone listening for this event // That's not an error -- it's OK to call this for all events in turn // to make sure a connection is removed completely. if (pList == NULL || pList->size() == 0) return ; pList->remove(pConnection) ; }
void ConnectionPool::Execute() { while(!m_stopDesired) { time_t nowTime = time(NULL); if(!m_conf_lua_file.empty() && nowTime >= m_nextLoadTime) { time_t lastModify = JG_F::KFileUtil::GetLastModified(m_conf_lua_file.c_str()); if(lastModify != m_lastModifiedTime) { PoolSettings::ConnectionSettingArray cpy(m_settings.m_settings); if(!m_settings.reload(m_conf_lua_file.c_str())) { Log(LOG_WARN, "warn: fail reload pool setting file '%s', recover", m_conf_lua_file.c_str()); m_settings.m_settings = cpy; } m_lastModifiedTime = lastModify; } m_nextLoadTime = nowTime + 10; } if(nowTime > m_nextCheckIdleTime) { JG_S::KAutoThreadMutex mx(m_mx); ConnectionMap::iterator it = m_cnnMap.begin(), ite = m_cnnMap.end(); for(; it != ite; it++) { ConnectionList tmp; ConnectionList& lst = it->second; PooledConnection* cnn; while(cnn = lst.pop_front()) { if(cnn->isExpire(nowTime)) { Log(LOG_DEBUG, "debug: %s expire, abandon", cnn->toString().c_str()); cnn->destroy(); } else { tmp.push_back(cnn); } } while(cnn = tmp.pop_front()) { lst.push_back(cnn); } } m_nextCheckIdleTime = nowTime + 30; } msleep(100); } }
void ConnectionPool::_cleanUpStaleHosts_inlock(Date_t now) { if (now > _lastCleanUpTime + kCleanUpInterval) { for (HostLastUsedMap::iterator itr = _lastUsedHosts.begin(); itr != _lastUsedHosts.end(); itr++) { if (itr->second <= _lastCleanUpTime) { ConnectionList connList = _connections.find(itr->first)->second; _cleanUpOlderThan_inlock(now, &connList); invariant(connList.empty()); itr->second = kNeverTooStale; } } _lastCleanUpTime = now; } }
void Reset(Keys keyUpIn, Keys keyDownIn, std::shared_ptr<Keyboard> const& keyboard) { keyUp = keyUpIn; keyDown = keyDownIn; connections.Disconnect(); auto & connect = connections; connect(keyboard->KeyUp, [this](Keys key) { POMDOG_ASSERT(keyUp != keyDown); if (key == keyUp) { up = ButtonState::Released; } else if (key == keyDown) { down = ButtonState::Released; } }); connect(keyboard->KeyDown, [this](Keys key) { POMDOG_ASSERT(keyUp != keyDown); if (key == keyUp) { up = ButtonState::Pressed; } else if (key == keyDown) { down = ButtonState::Pressed; } }); }
// Start listening for a specific RHS user function. When it fires we'll call to the client // (over the connection) to implement it. void RhsListener::AddRhsListener(char const* pFunctionName, Connection* pConnection) { RhsMapIter mapIter = m_RhsMap.find(pFunctionName) ; ConnectionList* pList = NULL ; // Either create a new list or retrieve the existing list of listeners if (mapIter == m_RhsMap.end()) { pList = new ConnectionList() ; m_RhsMap[pFunctionName] = pList ; } else { pList = mapIter->second ; } pList->push_back(pConnection) ; }
TEST(ConnectionList, Disconnect) { Signal<void(std::string)> nameChanged; ConnectionList connections; std::string name; connections += nameChanged.Connect([&](std::string const& n) { name = n; }); nameChanged("alice"); EXPECT_EQ("alice", name); nameChanged("bob"); EXPECT_EQ("bob", name); nameChanged("chuck"); EXPECT_EQ("chuck", name); connections.Disconnect(); nameChanged("norris"); EXPECT_EQ("chuck", name); }
/************************************************************* * @brief Returns true if at least one filter is registered. *************************************************************/ bool KernelSML::HasFilterRegistered() { ConnectionList* pListeners = m_RhsListener.GetRhsListeners(sml_Names::kFilterName) ; return (pListeners && pListeners->size() > 0) ; }
Bool ConnectObjects( String prefix, const maxon::BaseArray<BaseObject*>& objects, ConnectOptions& options) { // Check if the object can successfully be allocatd for the // specified plugin id. BaseObject* test = BaseObject::Alloc(options.forcePluginId); if (!test) { GeDebugOut("Can not allocate plugin object " + String::IntToString(options.forcePluginId)); return false; } // Get the name of the object so we can use it later. options.forceName = test->GetName(); BaseObject::Free(test); if (!prefix.Content()) prefix = options.forceName + ": "; // Final result of the function. Bool success = true; // Create the ConnectionList for the objects. ConnectionList list; switch (options.connectMode) { case CMB_MODE_ALL: { const auto end = objects.End(); for (auto it=objects.Begin(); it != end; ++it) { for (auto jt=objects.Begin(); jt != end; ++jt) { if (*it == *jt) continue; if (list.HasConnection(*it, *jt)) continue; list.Append(Connection(*it, *jt)); } } break; } case CMB_MODE_NEIGHBOR: { const auto end = objects.End(); for (auto it=objects.Begin(); it != end; ++it) { // Find the nearest object. BaseObject* nearest = nullptr; Float delta; for (auto jt=objects.Begin(); jt != end; ++jt) { if (*it == *jt) continue; if (list.HasConnection(*it, *jt)) continue; Connection conn(*it, *jt); if (!nearest || conn.delta < delta) { nearest = *jt; delta = conn.delta; } } if (nearest) list.Append(Connection(*it, nearest)); } break; } case CMB_MODE_CHAIN: { options.radius = 0; options.maxConnections = 0; const auto first = objects.Begin(); for (auto it=objects.Begin(); it != objects.End(); ++it) { Bool isLast = (it + 1) == objects.End(); if (isLast && (options.closedChain && *it != *first)) { Connection conn(*it, *first); list.Append(conn); } else if (!isLast) { Connection conn(*it, *(it + 1)); list.Append(conn); } } break; } default: GeDebugOut(String(__FUNCTION__) + ": Invalid connectMode"); return false; } // Sort the list by distance. list.SortByDelta(); // This map contains the number of connections each // object already has to make sure no object exceeds the // maximum number if connections. maxon::Bool created = false; maxon::HashMap<C4DAtom*, Int32> map; // Iterate over all connections and establish them. const auto end = list.End(); for (auto it=list.Begin(); it != end; ++it) { if (options.radius > 0.000001 && it->delta > options.radius) continue; // Find and eventually initialize the entries in the map. auto entry1 = map.FindOrCreateEntry(it->obj1, created); if (created) entry1->GetValue() = 0; auto entry2 = map.FindOrCreateEntry(it->obj2, created); if (created) entry2->GetValue() = 0; // Determine if the maximum number of connections is reached. const Int32 nConn1 = entry1->GetValue(); const Int32 nConn2 = entry2->GetValue(); if (options.maxConnections > 0 && (nConn1 >= options.maxConnections || nConn2 >= options.maxConnections)) continue; // Create the force object. BaseObject* force = BaseObject::Alloc(options.forcePluginId); if (!force) { success = false; break; } // Update the parameters. force->SetParameter(FORCE_TYPE, options.forceType, DESCFLAGS_SET_0); force->SetParameter(FORCE_OBJECT_A, it->obj1, DESCFLAGS_SET_0); force->SetParameter(FORCE_OBJECT_B, it->obj2, DESCFLAGS_SET_0); force->SetBit(BIT_ACTIVE); force->SetName(prefix + it->obj1->GetName() + " - " + it->obj2->GetName()); ++entry1->GetValue(); ++entry2->GetValue(); options.output.Append(force); // Position the force object in between the two objects. Matrix mg; mg.off = (it->obj1->GetMg().off + it->obj2->GetMg().off) * 0.5; force->SetMl(mg); } return true; }
bool RhsListener::ExecuteRhsCommand(AgentSML* pAgentSML, smlRhsEventId eventID, std::string const& functionName, std::string const& arguments, std::string* pResultStr) { bool result = false ; // Get the list of connections (clients) who have registered to implement this right hand side (RHS) function. ConnectionList* pList = GetRhsListeners(functionName.c_str()) ; // If nobody is listening we're done (not a bug as we register for all rhs functions and only forward specific ones that the client has registered) if (!pList || pList->size() == 0) return result ; ConnectionListIter connectionIter = pList->begin() ; // We need the first connection for when we're building the message. Perhaps this is a sign that // we shouldn't have rolled these methods into Connection. Connection* pConnection = *connectionIter ; // Convert eventID to a string char const* event = m_pKernelSML->ConvertEventToString(eventID) ; // Build the SML message we're doing to send. // Pass the agent in the "name" parameter not the "agent" parameter as this is a kernel // level event, not an agent level one (because you need to register with the kernel to get "agent created"). soarxml::ElementXML* pMsg = pConnection->CreateSMLCommand(sml_Names::kCommand_Event) ; if (pAgentSML) pConnection->AddParameterToSMLCommand(pMsg, sml_Names::kParamName, pAgentSML->GetName()) ; pConnection->AddParameterToSMLCommand(pMsg, sml_Names::kParamEventID, event) ; pConnection->AddParameterToSMLCommand(pMsg, sml_Names::kParamFunction, functionName.c_str()) ; pConnection->AddParameterToSMLCommand(pMsg, sml_Names::kParamValue, arguments.c_str()) ; #ifdef _DEBUG // Generate a text form of the XML so we can look at it in the debugger. char* pStr = pMsg->GenerateXMLString(true) ; #endif AnalyzeXML response ; // We want to call embedded connections first, so that we get the best performance // for these functions. I don't want to sort the list or otherwise change it so // instead we'll just use a rather clumsy outer loop to do this. for (int phase = 0 ; phase < 2 && !result ; phase++) { // Only call to embedded connections bool embeddedPhase = (phase == 0) ; // Reset the iterator to the beginning of the list connectionIter = pList->begin(); // Keep looping until we get a result while (connectionIter != pList->end() && !result) { pConnection = *connectionIter ; // We call all embedded connections (same process) first before // trying any remote methods. This ensures that if multiple folks register // for the same function we execute the fastest one (w/o going over a socket for the result). if (pConnection->IsRemoteConnection() && embeddedPhase) { connectionIter++ ; continue ; } // It would be faster to just send a message here without waiting for a response // but that could produce incorrect behavior if the client expects to act *during* // the event that we're notifying them about (e.g. notification that we're in the input phase). bool ok = pConnection->SendMessageGetResponse(&response, pMsg) ; if (ok) { char const* pResult = response.GetResultString() ; if (pResult != NULL) { (*pResultStr) = pResult ; result = true ; } } connectionIter++ ; } } #ifdef _DEBUG // Release the string form we generated for the debugger pMsg->DeleteString(pStr) ; #endif // Clean up delete pMsg ; return result ; }
bool RhsListener::HandleFilterEvent(smlRhsEventId eventID, AgentSML* pAgent, char const* pArgument, std::string &pReturnValue) { // Currently only supporting one event here, but that could change in time. assert(eventID == smlEVENT_FILTER) ; // Filters are handled as a RHS function call internally, using a special reserved name. char const* pFunctionName = sml_Names::kFilterName ; // Get the list of connections (clients) who have registered to implement this right hand side (RHS) function. ConnectionList* pList = GetRhsListeners(pFunctionName) ; bool result = false ; // If nobody is listening we're done (not a bug as we register for all rhs functions and only forward specific ones that the client has registered) if (!pList || pList->size() == 0) return result ; ConnectionListIter connectionIter = pList->begin() ; // We need the first connection for when we're building the message. Perhaps this is a sign that // we shouldn't have rolled these methods into Connection. Connection* pConnection = *connectionIter ; // Convert eventID to a string char const* event = m_pKernelSML->ConvertEventToString(eventID) ; // Copy the initial command line into the return buffer and send that over. // This will be sequentially replaced by each filter in turn and whatever // is left in here at the end is the result of the filtering. // This allows multiple filters to act on the data, each modifying it as it goes. // A side effect of this is that the order the filters work on the data is significant. // Anyone in the chain can set the string to be the empty string, which brings the // whole process to a halt (they have eaten the command line at that point). pReturnValue.reserve(strlen(pArgument) + 1); //adding 1 because strlen does not count the terminating null character pReturnValue.assign(pArgument); bool stop = false ; while (connectionIter != pList->end() && !stop) { // Build the SML message we're doing to send. // Pass the agent in the "name" parameter not the "agent" parameter as this is a kernel // level event, not an agent level one (because you need to register with the kernel to get "agent created"). soarxml::ElementXML* pMsg = pConnection->CreateSMLCommand(sml_Names::kCommand_Event) ; pConnection->AddParameterToSMLCommand(pMsg, sml_Names::kParamName, pAgent ? pAgent->GetName() : "") ; pConnection->AddParameterToSMLCommand(pMsg, sml_Names::kParamEventID, event) ; pConnection->AddParameterToSMLCommand(pMsg, sml_Names::kParamFunction, sml_Names::kFilterName) ; pConnection->AddParameterToSMLCommand(pMsg, sml_Names::kParamValue, pReturnValue.c_str()) ; // We send the current command line over #ifdef _DEBUG // Generate a text form of the XML so we can look at it in the debugger. char* pStr = pMsg->GenerateXMLString(true) ; #endif AnalyzeXML response ; pConnection = *connectionIter ; bool ok = pConnection->SendMessageGetResponse(&response, pMsg) ; if (ok) { char const* pResult = response.GetResultString() ; if (pResult != NULL) { // If the listener returns a result then take that // value and return it in "pReturnValue" to the caller. // If the client returns a longer string than the caller, pReturnValue is resized to fit it. pReturnValue.reserve(strlen(pResult) + 1); //adding 1 because strlen does not count the terminating null character pReturnValue.assign(pResult); result = true ; } else { // If one of the filters returns an empty string, stop the process at that point // because the command has been "eaten". Make the result the empty string. pReturnValue[0] = 0 ; result = true ; stop = true ; } } connectionIter++ ; #ifdef _DEBUG // Release the string form we generated for the debugger pMsg->DeleteString(pStr) ; #endif // Clean up delete pMsg ; } return result ; }
ConnectionList CNullNetworkManager::GetConnections() { ConnectionList list; list.push_back(CConnectionPtr(new CNullConnection())); return list; }