/* * listener_spawn is responsible for creating a Listener class * and launching the listener. It is provided as a means for * the C thread subsystem to launch the listener C++ object. */ void listener_spawn( thread_Settings *thread ) { Listener *theListener = NULL; // start up a listener theListener = new Listener( thread ); #ifndef WIN32 // handling of daemon mode in non-win32 builds if ( isDaemon( thread ) ) { theListener->runAsDaemon("iperf",LOG_DAEMON); } #endif // Start listening theListener->Run(); DELETE_PTR( theListener ); }
void Entity::updateView(View &view , Listener &listener , RenderWindow &window) { Vector2u sizeWindow = window.getSize(); //sizeWindow.x /= 1.f;//SCALE_VIEW //sizeWindow.y /= 1.f;// TODO : increase zoom for camera, reason: small image view.setSize(Vector2f(sizeWindow)); float tempX = getXPos(); float tempY = getYPos(); listener.setPosition(tempX, tempY, 0); float x = getXPos(); float y = getYPos(); int leftBorder = sizeWindow.x / 2; int rightBorder = SIZE_BLOCK * (WIDTH_MAP - BORDER1) - sizeWindow.x / 2; int topBorder = sizeWindow.y / 2; int lowBorder = SIZE_BLOCK * LONG_MAP - sizeWindow.y / 2; if (int(x) < leftBorder) tempX = float(leftBorder); else if (int(x) > rightBorder) tempX = float(rightBorder); if (int(y) < topBorder) tempY = float(topBorder); else if (int(y) > lowBorder) tempY = float(lowBorder); view.setCenter(tempX, tempY); }
/** * @param prop SFXLP_ORIENTATION (yaw, pitch) in degrees. */ void DS_SFX_Listenerv(int prop, float* values) { switch(prop) { case SFXLP_POSITION: listener.position.set(values); //DSFMOD_TRACE("Pos:" << values[0] << "," << values[1] << "," << values[2]); break; case SFXLP_ORIENTATION: // Convert the angles to front and up vectors. listener.setOrientation(float(values[0]/180*M_PI), float(values[1]/180*M_PI)); break; case SFXLP_VELOCITY: listener.velocity.set(values); break; case SFXLP_REVERB: updateListenerEnvironmentSettings(values); break; case SFXLP_PRIMARY_FORMAT: DSFMOD_TRACE("SFX_Listenerv: Ignoring SFXLP_PRIMARY_FORMAT."); return; default: return; } }
RowType* ForexConnectWrapper::getTableRow(O2GTable table, std::string key, bool (*finderFunc)(RowType *, std::string), ReaderType* (*readerCreateFunc)(IO2GResponseReaderFactory* , IO2GResponse *)) { IO2GResponse *response; if( !loginRules->isTableLoadedByDefault(table) ) { IO2GRequest *request = mRequestFactory->createRefreshTableRequestByAccount(Trades, sAccountID.c_str()); Listener *ll = new Listener(session); response = ll->sendRequest(request); request->release(); ll->release(); if (!response) { log("No response to manual table refresh request"); throw "No response to manual table refresh request"; } } else { response = loginRules->getTableRefreshResponse(table); if (!response) { log("No response to automatic table refresh request"); throw "No response to automatic table refresh request"; } } ReaderType *reader = readerCreateFunc(mResponseReaderFactory, response); response->release(); RowType *row = NULL; for ( int i = 0; i < reader->size(); ++i ) { row = reader->getRow(i); if ( finderFunc(row, key) ) { break; } row->release(); row = NULL; } reader->release(); if (row == NULL) { std::stringstream ss; ss << "Could not find row for key " << key; log(ss.str()); throw ss.str().c_str(); } return row; }
int main() { model = new Wrapper(new SimpleModel()); Simulator<External*>* sim = new Simulator<External*>(model); Listener* l = new Listener(); sim->addEventListener(l); // First input/output series. Internal event test. l->setExpected(1.0,FAST,1); Event<External*> e; e.model = model; e.value = new External(FAST,1); Bag<Event<External*> > x; x.insert(e); sim->computeNextState(x,0.0); assert(sim->nextEventTime() == 1.0); sim->execNextEvent(); assert(output_happened); output_happened = false; // Second input/output series. External event test. l->setExpected(3.5,SLOW,1); x.clear(); e.value = new External(SLOW,1); x.insert(e); sim->computeNextState(x,1.5); assert(!output_happened); assert(sim->nextEventTime() == 3.5); sim->execNextEvent(); assert(output_happened); output_happened = false; // Third input/output series. Confluent event test l->setExpected(5.5,SLOW,2); x.clear(); e.value = new External(STOP,1); x.insert(e); assert(sim->nextEventTime() == 5.5); sim->computeNextState(x,sim->nextEventTime()); assert(output_happened); assert(sim->nextEventTime() == DBL_MAX); // Done. Try to clean up. assert(External::num_existing == 3); delete model; delete l; delete sim; assert(Internal::num_existing == 0); return 0; }
void ForexConnectWrapper::openMarket(const std::string symbol, const std::string direction, int amount) { if (direction != O2G2::Sell && direction != O2G2::Buy) { log("Direction must be 'B' or 'S'"); throw "Direction must be 'B' or 'S'"; } std::string sOfferID = getOfferID(symbol); IO2GValueMap *valuemap = mRequestFactory->createValueMap(); valuemap->setString(Command, O2G2::Commands::CreateOrder); valuemap->setString(OrderType, O2G2::Orders::TrueMarketOpen); valuemap->setString(AccountID, sAccountID.c_str()); valuemap->setString(OfferID, sOfferID.c_str()); valuemap->setString(BuySell, direction.c_str()); valuemap->setInt(Amount, amount); valuemap->setString(TimeInForce, O2G2::TIF::IOC); IO2GRequest *orderRequest = mRequestFactory->createOrderRequest(valuemap); valuemap->release(); TableListener *tableListener = new TableListener(); tableListener->setRequestID(orderRequest->getRequestID()); IO2GTableManager *tableManager = getLoadedTableManager(); subscribeTableListener(tableManager, tableListener); Listener *ll = new Listener(session); IO2GResponse *response = ll->sendRequest(orderRequest); orderRequest->release(); ll->release(); if (!response) { std::stringstream ss; ss << "Failed to send openMarket request " << symbol << " " << direction << " " << amount; log(ss.str()); throw ss.str().c_str(); } tableListener->waitForTableUpdate(); response->release(); unsubscribeTableListener(tableManager, tableListener); tableListener->release(); tableManager->release(); }
void XmlSceneParser::Parse (const ParseNode& decl, Listener& node, Node& parent, SceneContext& context) { try { //настройка узла node.SetGain (get<float> (decl, "gain", node.Gain ())); //разбор родительских параметров Parse (decl, static_cast<Entity&> (node), parent, context); } catch (xtl::exception& e) { e.touch ("scene_graph::XmlSceneParser::Parse(const ParseNode&,Listener&,Node&,SceneContext&)"); throw; } }
LRESULT onCreate(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { // Add the window to the clipboard viewer chain. RegisterHotKey(hWnd, 1, MOD_CONTROL | MOD_ALT, VK_RETURN); RegisterHotKey(hWnd, 2, MOD_CONTROL | MOD_ALT, VK_UP); if (listener.prepare()) listener.start(); hwndNextViewer = SetClipboardViewer(hWnd); hList = CreateWindowW(L"ListBox", L"Listbox", WS_CHILD | LBS_NOTIFY, CW_USEDEFAULT, 0, 600, 600, hWnd, (HMENU)ID_LIST, hInst, NULL); //SendMessage(hList, LB_ADDSTRING, 0, (LPARAM)L"Text"); //DefProc = (TDefProc)SetWindowLongPtr(hList, GWLP_WNDPROC, (LONG)&WndProc); ShowWindow(hList, SW_HIDE); //ShowWindow(hWnd, SW_HIDE); return 0; }
void Entity::publish() { assert(!isPublished); isPublished = true; // Try find which listeners (systems) correspond with this entity's set of components for(std::vector<System*>::iterator sysIter = world->systems.begin(); sysIter != world->systems.end(); ++ sysIter) { System* sys = *sysIter; // Iterate over that system's requirements, check that each one is fulfilled bool haveAllRequirements = true; const std::vector<ComponentID>& requirements = sys->getRequiredComponents(); for(std::vector<ComponentID>::const_iterator reqIter = requirements.begin(); reqIter != requirements.end(); ++ reqIter) { const ComponentID& reqId = *reqIter; // Check if we fulfill this requirements bool haveRequirement = false; for(std::vector<Component*>::iterator compIter = components.begin(); compIter != components.end(); ++ compIter) { Component* myComponent = *compIter; if(myComponent->getID() == reqId) { haveRequirement = true; break; } } // If we are missing a single requirement, then we do not have all of them if(!haveRequirement) { haveAllRequirements = false; break; } } // Entity has all requirements, therefore add it to our listener list if(haveAllRequirements) { listeners.push_back(sys); } } // Tell every listener that we exist for(std::vector<Listener*>::iterator listIter = listeners.begin(); listIter != listeners.end(); ++ listIter) { Listener* listener = *listIter; listener->onEntityExists(this); } }
void ForexConnectWrapper::setSubscriptionStatus(std::string instrument, std::string status) { IO2GTableManager *tableManager = getLoadedTableManager(); IO2GOffersTable *offersTable = (IO2GOffersTable *)tableManager->getTable(::Offers); tableManager->release(); IO2GOfferTableRow *offerRow = NULL; IO2GTableIterator tableIterator; bool instrumentFound = false; while (offersTable->getNextRow(tableIterator, offerRow)) { if ( instrument == offerRow->getInstrument() ) { instrumentFound = true; IO2GRequestFactory *factory = session->getRequestFactory(); IO2GValueMap *valueMap = factory->createValueMap(); valueMap->setString(::Command, O2G2::Commands::SetSubscriptionStatus); valueMap->setString(::SubscriptionStatus, status.c_str()); valueMap->setString(::OfferID, offerRow->getOfferID()); IO2GRequest *request = factory->createOrderRequest(valueMap); valueMap->release(); Listener *ll = new Listener(session); IO2GResponse *response = ll->sendRequest(request); response->release(); request->release(); ll->release(); factory->release(); break; } } offerRow->release(); offersTable->release(); if (!instrumentFound) { std::stringstream ss; ss << "Could not find offer row for instrument " << instrument; log(ss.str()); throw ss.str().c_str(); } }
void Transport::Send(Serializer& _ser, const Peer& _peer, netU32 _type) { Listener *listener = GetListener(_type); if(listener) { _ser.ResetCursor(); SerializerLess serless(_ser); listener->Push(serless, _peer); } else { // unavailable transport assert(false); } // update stats struct Activity* activity = GetActivity(_peer); activity->m_lastSend = Time::GetMsTime(); activity->m_nbSend++; }
const TypedEventHandler* EventListenerManager::GetTypedEventHandler(nsIAtom* aEventName, const nsAString& aTypeString) { uint32_t eventType = nsContentUtils::GetEventId(aEventName); Listener* listener = FindEventHandler(eventType, aEventName, aTypeString); if (!listener) { return nullptr; } JSEventHandler* jsEventHandler = listener->GetJSEventHandler(); if (listener->mHandlerIsString) { CompileEventHandlerInternal(listener, nullptr, nullptr); } const TypedEventHandler& typedHandler = jsEventHandler->GetTypedEventHandler(); return typedHandler.HasEventHandler() ? &typedHandler : nullptr; }
netBool Transport::Pull(SerializerLess &_ser, Peer& _peer) { netBool isFound = false; for(listeners_t::iterator it=m_listeners.begin(); it != m_listeners.end(); ++it) { Listener *listener = (*it); if(listener->Pull(_ser, _peer)) { isFound = true; // update stats struct Activity* activity = GetActivity(_peer); activity->m_lastRecv = Time::GetMsTime(); activity->m_nbRecv++; break; } } return isFound; }
bool chainEvents(Listener& someListener, const LLSD& event) { // Make this call so we can watch for side effects for test purposes. someListener.call(event); // This function represents a recursive event chain -- or some other // scenario in which an event handler raises additional events. int value = event.asInteger(); if (value) { LLEventPumps::instance().obtain("login").post(value - 1); } return false; }
// // Run motion detection on a saved file, provide debug images in matrix mode over HTTP // int main( int argc, const char *argv[] ) { debugInitialise( "example6", "", 5 ); Info( "Starting" ); avInit(); Application app; NetworkAVInput input( "input", "/tmp/movie.mp4" ); app.addThread( &input ); MotionDetector motionDetector( "modect" ); motionDetector.registerProvider( input ); //EventRecorder eventRecorder( "/transfer/ozx" ); app.addThread( &motionDetector ); MatrixVideo matrixVideo( "matrix", PIX_FMT_YUV420P, 640, 480, FrameRate( 1, 10 ), 2, 2 ); matrixVideo.registerProvider( *motionDetector.refImageSlave() ); matrixVideo.registerProvider( *motionDetector.compImageSlave() ); matrixVideo.registerProvider( *motionDetector.deltaImageSlave() ); matrixVideo.registerProvider( *motionDetector.varImageSlave() ); app.addThread( &matrixVideo ); Listener listener; app.addThread( &listener ); HttpController httpController( "p8080", 8080 ); listener.addController( &httpController ); httpController.addStream( "file", input ); httpController.addStream( "debug", SlaveVideo::cClass() ); httpController.addStream( "debug", matrixVideo ); httpController.addStream( "debug", motionDetector ); app.run(); }
void ParticleL::update(const Listener& list, const ci::Vec2f pos){ mAge++; if (mAge > mLifespan) mIsDead = true; float ageMap = 1.0f - (mAge / (float)mLifespan); mRadius = constrain(list.getVolume() * 2.f, .5f, 2.f ); Vec2f expander = mAnchorPosition; expander.rotate(mAge/20.f); expander *= mRadius; addPosition( expander ); }
virtual void SetUp() { Listener listener; // The Matrix::LookAt function is hardcoded to be left handed listener = Listener(&state_1_); listener.SetOrientation(mathfu::Vector<float, 3>(0.0f, 0.0f, 0.0f), mathfu::Vector<float, 3>(0.0f, 1.0f, 0.0f), -mathfu::kAxisZ3f); listener = Listener(&state_2_); listener.SetOrientation(mathfu::Vector<float, 3>(12.0f, 34.0f, 56.0f), mathfu::Vector<float, 3>(0.0f, 0.0f, 78.0f), -mathfu::kAxisX3f); listener = Listener(&state_3_); listener.SetOrientation(mathfu::Vector<float, 3>(10.0f, 10.0f, 10.0f), mathfu::Vector<float, 3>(20.0f, 0.0f, 0.0f), -mathfu::kAxisY3f); listener_list_1_.InsertAfter(&state_1_); listener_list_2_.InsertAfter(&state_2_); listener_list_3_.InsertAfter(&state_3_); }
// Starting a new listener, initialize it and LISTEN ULONG RequestQueue::StartListener(USHORT p_port,URL* p_url,USHORT p_timeout) { AutoCritSec lock(&m_lock); Listeners::iterator it = m_listeners.find(p_port); if(it == m_listeners.end()) { Listener* listener = new Listener(this,p_port,p_url,p_timeout); m_listeners.insert(std::make_pair(p_port,listener)); if(listener->Initialize(p_port) == NoError) { listener->StartListener(); return NO_ERROR; } else { // Log the error return ERROR_BAD_COMMAND; } } return ERROR_ALREADY_EXISTS; }
Listener* NetFactory::listen(const string& ip, int port, INetReactor &netReactor) { if (0 == port) { LOG_SYSTEM_ERR << "listen at <" << ip << ": " << port << "> failed, port = 0!"; return NULL; } // ´´½¨Ò»¸öÍøÂç¼àÌýÆ÷£¬¸ÃÍøÂç¼àÌýÆ÷½«±»×¢²áµ½ÍøÂçÖÐ Listener* listener = new Listener(nextNet(), &netReactor, this); if (NULL == listener) { LOG_SYSTEM_ERR << "listen at <" << ip << ": " << port << "> failed, not enough memory"; return NULL; } if (!listener->open(ip, port)) { LOG_ERROR << "listen at <" << ip << ": " << port << "> failed"; delete listener; return NULL; } m_listeners.push_back(listener); return listener; }
MyApp() : scene(BLOCK_SIZE) { speakerLayout = new SpeakerLayout(); if (onLaptop) { cout << "Using 2 speaker layout" << endl; speakerLayout->addSpeaker(Speaker(0, 45, 0, 1.0, 1.0)); speakerLayout->addSpeaker(Speaker(1, -45, 0, 1.0, 1.0)); } else { cout << "Using 3 speaker layout" << endl; speakerLayout->addSpeaker(Speaker(0, 0, 0, 100.0, 1.0)); speakerLayout->addSpeaker(Speaker(1, 120, 0, 100.0, 1.0)); speakerLayout->addSpeaker(Speaker(2,-120, 0, 100.0, 1.0)); //speakerLayout->addSpeaker(Speaker(3, 0, 0, 0.0, 0.5)); } panner = new Vbap(*speakerLayout); panner->setIs3D(false); // no 3d! listener = scene.createListener(panner); listener->compile(); for (int i = 0; i < 10; i++) { source[i].dopplerType(DOPPLER_NONE); // XXX doppler kills when moving fast! source[i].law(ATTEN_LINEAR); scene.addSource(source[i]); } panner->print(); scene.usePerSampleProcessing(false); AudioDevice::printAll(); audioIO().print(); fflush(stdout); if (onLaptop) { cout << "we're on a laptop, so use normal, default audio hardware" << endl; initAudio(44100, BLOCK_SIZE); } else { cout << "we're on the mini, so we will try the TASCAM" << endl; // audioIO().device(AudioDevice("TASCAM")); audioIO().device(AudioDevice(29)); initAudio(44100, BLOCK_SIZE, 4, 0); } cout << "GOT HERE" << endl; audioIO().print(); fflush(stdout); }
ParticleI::ParticleI(const Vec2f& position, const Listener& list){ addPosition(Vec2f::zero()); addPosition(Vec2f::zero()); mAnchorPosition = position; mRadius = list.getVolume() * 25; mRadiusAnchor = mRadius; mOverlayColor = Color::white(); mDrag = .8f; mFillGaps = false; mVelThreshold = 5.f; mVel = randVec2f() * 40.f; mColor = ColorA(1.f, .4f, 0.6f, 1.f); }
/** * @brief This function walks a tree calling methods of the given listener. * * @param listener This argument specifies the listener which this function * uses to convert the tree to a key set. * @param root This variable stores the root of the tree this function * visits. */ void walk (Listener & listener, node const & node) { ELEKTRA_LOG_DEBUG ("Parse tree: %s", toString (node).c_str ()); // If the document contains only one a single value we call `exitValue` // for that function. We need to handle that special case to not add // value multiple times for maps (once for `c_l_block_map_implicit_value` // and `c_l_block_seq_entry`) and once for the child of // `c_l_block_map_implicit_value`). if (node.is_root () && !node.children.empty () && ends_with (node.children.back ()->name (), "node")) { listener.exitValue (node.children.back ()->content ()); return; } executeListenerMethods (listener, node); }
Executer::Executer(Environment* environment) { // create and initialize listeners Listener* compressor = new CompressorListener(); compressor->init(environment); Listener* shooter = new ShooterListener(); shooter->init(environment); Listener* intake = new IntakeListener(); intake->init(environment); Listener* movement = new MovementListener(); movement->init(environment); AutonomousListener* auton = new AutonomousListener(); auton->init(environment); listeners.push_back(compressor); listeners.push_back(auton); listeners.push_back(shooter); listeners.push_back(intake); listeners.push_back(movement); }
MyApp () : audioScene(BLOCK_SIZE), spatializer(speakerLayout) { initWindow(); addSphere(graphics().mesh()); graphics().mesh().generateNormals(); for (int i = 0; i < 50; ++i) { source[i].freq(150 + random.uniform(-1, 1)); audioScene.addSource(source[i]); } for (int i = 0; i < 50; ++i) { source[i + 50].freq(700 + random.uniform(-2, 2)); audioScene.addSource(source[i + 50]); } for (int i = 0; i < 50; ++i) { source[i + 50].freq(1800 + random.uniform(-3, 3)); audioScene.addSource(source[i + 100]); } gam::sampleRate(44100); audioIO().device(0); initAudio(44100, BLOCK_SIZE); listener = audioScene.createListener(&spatializer); listener->compile(); for (int i = 0; i < 150; ++i) { double ft1 = data[i * 4]; double ft2 = data[(i * 4)+ 1]; double ft3 = data[(i * 4)+ 2]; double ft4 = data[(i * 4)+ 3]; double x = mapRange(ft1, 4.3, 7.9, -10.0, 10.0); double y = mapRange(ft2, 2.0, 4.4, -10.0, 10.0); double z = mapRange(ft3, 1.0, 6.9, -10.0, 10.0); // double size = mapRange(ft4, 0.1, 2.5, 0.25, 0.5); source[i].pos(x, y, z); source[i].farClip(2); } audioScene.usePerSampleProcessing(false); }
void ParticleFactory::perform(const double elapsedSeconds, const Vec2f origin, const Listener& list, ParticleSystem & ps) { double offsetSeconds = elapsedSeconds + d_adjustSeconds - d_offsetTime; if (offsetSeconds < 0) ci::app::console() << "waiting for song to start..." << std::endl; if (offsetSeconds >= 30 && offsetSeconds < 45) { while (ps.mParticles.size() < 3) { Particle* particle = new ParticleG(origin, list); ps.addParticle(particle); } } if (offsetSeconds >= 45 && offsetSeconds < 75) { Particle* particle = new ParticleC(origin, list); ps.addParticle(particle); } if (offsetSeconds >= 75 && offsetSeconds < 105) { Particle* particle = new ParticleB(origin, list); ps.addParticle(particle); } if (offsetSeconds >= 105 && offsetSeconds < 135) { Particle* particle = new ParticleL(origin, list); ps.addParticle(particle); } if (offsetSeconds >= 135 && offsetSeconds < 150) { Particle* particle = new ParticleI(origin, list); ps.addParticle(particle); } if (offsetSeconds >= 135 && offsetSeconds < 165) { for (int i = 0; i < (int)(list.getVolume()*10.f); ++i) { Particle* particle = new ParticleD(origin, list); ps.addParticle(particle); } for (int i = 0; i < 3; ++i) { Particle* particle = new ParticleA(origin, list); particle->mOrientation = ps.mOrientation; ps.addParticle(particle); } } if (offsetSeconds >= 165 && offsetSeconds < 195) { for (int i = 0; i < 4; ++i) { Particle* particle = new ParticleH(origin, list); ps.addParticle(particle); } } if (offsetSeconds >= 195 && offsetSeconds < 210) { for (int i = 0; i < 4; ++i) { Particle* particle = new ParticleF(origin, list); particle->mOrientation = ps.mOrientation; ps.addParticle(particle); } Particle* particle = new ParticleE(origin, list); particle->mOrientation = ps.mOrientation; ps.addParticle(particle); } if (offsetSeconds >= 210 && offsetSeconds < 225) { Particle* particle = new ParticleJ(origin, list); ps.addParticle(particle); } if (offsetSeconds >= 225 && offsetSeconds < 255) { Particle* particle = new ParticleN(origin, list); ps.addParticle(particle); } if (offsetSeconds >= 255 ) { Particle* particle = new ParticleK(origin, list); ps.addParticle(particle); } }
void ParticleFactory::create(const double elapsedSeconds, const Vec2f origin, const Listener& list, ParticleSystem & ps) { ps.mUnderlays = 3; switch (d_particleToCreate) { case PARTICLE_A:{ for (int i = 0; i < 3; ++i) { Particle* particle = new ParticleA(origin, list); particle->mOrientation = ps.mOrientation; ps.addParticle(particle); } }break; case PARTICLE_B:{ Particle* particle = new ParticleB(origin, list); ps.addParticle(particle); }break; case PARTICLE_C:{ Particle* particle = new ParticleC(origin, list); ps.addParticle(particle); }break; case PARTICLE_D:{ for (int i = 0; i < (int)(list.getVolume()*20.f); ++i) { Particle* particle = new ParticleD(origin, list); ps.addParticle(particle); } }break; case PARTICLE_E:{ Particle* particle = new ParticleE(origin, list); particle->mOrientation = ps.mOrientation; ps.addParticle(particle); }break; case PARTICLE_F:{ for (int i = 0; i < 4; ++i) { Particle* particle = new ParticleF(origin, list); particle->mOrientation = ps.mOrientation; ps.addParticle(particle); } }break; case PARTICLE_G:{ while (ps.mParticles.size() < 3) { Particle* particle = new ParticleG(origin, list); ps.addParticle(particle); } }break; case PARTICLE_H:{ for (int i = 0; i < 4; ++i) { Particle* particle = new ParticleH(origin, list); ps.addParticle(particle); } }break; case PARTICLE_I:{ Particle* particle = new ParticleI(origin, list); ps.addParticle(particle); }break; case PARTICLE_J:{ Particle* particle = new ParticleJ(origin, list); ps.addParticle(particle); }break; case PARTICLE_K:{ Particle* particle = new ParticleK(origin, list); ps.addParticle(particle); }break; case PARTICLE_L:{ Particle* particle = new ParticleL(origin, list); ps.addParticle(particle); }break; case PARTICLE_M:{ Particle* particle = new ParticleM(origin, list); particle->mOrientation = ps.mOrientation; ps.addParticle(particle); ps.mUnderlays = 1; }break; case PARTICLE_N:{ Particle* particle = new ParticleN(origin, list); ps.addParticle(particle); }break; default: ci::app::console() << "UNKNOWN PARTICLE: " << d_particleToCreate; break; } }
size_t Communication::Read (void *dst, size_t dst_len, uint32_t timeout_usec, ConnectionStatus &status, Error *error_ptr) { lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION, "%p Communication::Read (dst = %p, dst_len = %" PRIu64 ", timeout = %u usec) connection = %p", this, dst, (uint64_t)dst_len, timeout_usec, m_connection_sp.get()); if (m_read_thread_enabled) { // We have a dedicated read thread that is getting data for us size_t cached_bytes = GetCachedBytes (dst, dst_len); if (cached_bytes > 0 || timeout_usec == 0) { status = eConnectionStatusSuccess; return cached_bytes; } if (m_connection_sp.get() == NULL) { if (error_ptr) error_ptr->SetErrorString("Invalid connection."); status = eConnectionStatusNoConnection; return 0; } // Set the timeout appropriately TimeValue timeout_time; if (timeout_usec != UINT32_MAX) { timeout_time = TimeValue::Now(); timeout_time.OffsetWithMicroSeconds (timeout_usec); } Listener listener ("Communication::Read"); listener.StartListeningForEvents (this, eBroadcastBitReadThreadGotBytes | eBroadcastBitReadThreadDidExit); EventSP event_sp; while (listener.WaitForEvent (timeout_time.IsValid() ? &timeout_time : NULL, event_sp)) { const uint32_t event_type = event_sp->GetType(); if (event_type & eBroadcastBitReadThreadGotBytes) { return GetCachedBytes (dst, dst_len); } if (event_type & eBroadcastBitReadThreadDidExit) { Disconnect (NULL); break; } } return 0; } // We aren't using a read thread, just read the data synchronously in this // thread. lldb::ConnectionSP connection_sp (m_connection_sp); if (connection_sp.get()) { return connection_sp->Read (dst, dst_len, timeout_usec, status, error_ptr); } if (error_ptr) error_ptr->SetErrorString("Invalid connection."); status = eConnectionStatusNoConnection; return 0; }
void * ProcessKDP::AsyncThread (void *arg) { ProcessKDP *process = (ProcessKDP*) arg; const lldb::pid_t pid = process->GetID(); Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet (KDP_LOG_PROCESS)); if (log) log->Printf ("ProcessKDP::AsyncThread (arg = %p, pid = %" PRIu64 ") thread starting...", arg, pid); Listener listener ("ProcessKDP::AsyncThread"); EventSP event_sp; const uint32_t desired_event_mask = eBroadcastBitAsyncContinue | eBroadcastBitAsyncThreadShouldExit; if (listener.StartListeningForEvents (&process->m_async_broadcaster, desired_event_mask) == desired_event_mask) { bool done = false; while (!done) { if (log) log->Printf ("ProcessKDP::AsyncThread (pid = %" PRIu64 ") listener.WaitForEvent (NULL, event_sp)...", pid); if (listener.WaitForEvent (NULL, event_sp)) { uint32_t event_type = event_sp->GetType(); if (log) log->Printf ("ProcessKDP::AsyncThread (pid = %" PRIu64 ") Got an event of type: %d...", pid, event_type); // When we are running, poll for 1 second to try and get an exception // to indicate the process has stopped. If we don't get one, check to // make sure no one asked us to exit bool is_running = false; DataExtractor exc_reply_packet; do { switch (event_type) { case eBroadcastBitAsyncContinue: { is_running = true; if (process->m_comm.WaitForPacketWithTimeoutMicroSeconds (exc_reply_packet, 1 * USEC_PER_SEC)) { ThreadSP thread_sp (process->GetKernelThread()); if (thread_sp) { lldb::RegisterContextSP reg_ctx_sp (thread_sp->GetRegisterContext()); if (reg_ctx_sp) reg_ctx_sp->InvalidateAllRegisters(); static_cast<ThreadKDP *>(thread_sp.get())->SetStopInfoFrom_KDP_EXCEPTION (exc_reply_packet); } // TODO: parse the stop reply packet is_running = false; process->SetPrivateState(eStateStopped); } else { // Check to see if we are supposed to exit. There is no way to // interrupt a running kernel, so all we can do is wait for an // exception or detach... if (listener.GetNextEvent(event_sp)) { // We got an event, go through the loop again event_type = event_sp->GetType(); } } } break; case eBroadcastBitAsyncThreadShouldExit: if (log) log->Printf ("ProcessKDP::AsyncThread (pid = %" PRIu64 ") got eBroadcastBitAsyncThreadShouldExit...", pid); done = true; is_running = false; break; default: if (log) log->Printf ("ProcessKDP::AsyncThread (pid = %" PRIu64 ") got unknown event 0x%8.8x", pid, event_type); done = true; is_running = false; break; } } while (is_running); } else { if (log) log->Printf ("ProcessKDP::AsyncThread (pid = %" PRIu64 ") listener.WaitForEvent (NULL, event_sp) => false", pid); done = true; } } } if (log) log->Printf ("ProcessKDP::AsyncThread (arg = %p, pid = %" PRIu64 ") thread exiting...", arg, pid); process->m_async_thread.Reset(); return NULL; }
void * listener_thread(void *data) { Listener *listener = (Listener*) data; listener->main(); return NULL; }
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ // Tests for Listener class #include "catch.hpp" #include "lib/listener.h" #include "protocol/protocolfactory.h" TEST_CASE("Listener: Unable to listen", "[server]") { SECTION("Bad protocolFactory") { ProtocolFactory protocolFactory(ProtocolType::None); std::shared_ptr<CommonHeaders> commonHeaders(new CommonHeaders()); std::shared_ptr<ContentManagerCustomizer> contentManagerCustomizer(new ContentManagerCustomizer(100, 100000)); std::shared_ptr<ContentManagerFactory> contentManagerFactory(new ContentManagerFactory(ContentManagerType::None, commonHeaders, contentManagerCustomizer)); Listener listener(1, Host::ALL_INTERFACES4, protocolFactory, contentManagerFactory); std::this_thread::sleep_for(std::chrono::milliseconds(100)); REQUIRE(listener.inErrorState()); } SECTION("Compare to Host") { Host googleDNS("google-public-dns-a.google.com", 80, Host::ProtocolPreference::IPV4); ProtocolFactory protocolFactory(ProtocolType::None); std::shared_ptr<CommonHeaders> commonHeaders(new CommonHeaders()); std::shared_ptr<ContentManagerCustomizer> contentManagerCustomizer(new ContentManagerCustomizer(100, 100000)); std::shared_ptr<ContentManagerFactory> contentManagerFactory(new ContentManagerFactory(ContentManagerType::None, commonHeaders, contentManagerCustomizer)); Listener listener(1, Host::ALL_INTERFACES4, protocolFactory, contentManagerFactory); std::this_thread::sleep_for(std::chrono::milliseconds(100)); REQUIRE(listener == 1); REQUIRE(listener.getHost() == Host::ALL_INTERFACES4); REQUIRE_FALSE(listener == 2);