int main(void) { opentest(OUTFILE); fs= func( (fd/a) , func(2,0x0082c90f) ); fprintf(outfile,"fs:%ld\n",fs); fs=_func( (fd/a) , _func(2,0x0082c90f) ); fprintf(outfile,"fs:%ld\n",fs); closetest(THISFILE); }
void CallbackTimer::callbackAndDeleteLater() { if (_func) _func(); // The timer will be gone. this->deleteLater(); }
void flush() const { if (_enabled) { _func(_stream.str()); } }
void ProcessUnitList::pushUnit(boost::shared_ptr<org::esb::hive::job::ProcessUnit> unit) { //_unit_list.insert(unit); std::string uuid=org::esb::util::PUUID(); _unit_map[unit->_sequence]=uuid; org::esb::io::File file(_user_data_path+"/"+uuid); org::esb::io::FileOutputStream fos(&file); org::esb::io::ObjectOutputStream ous(&fos); ous.writeObject(unit); ous.close(); while(_unit_map.size()&&(*_unit_map.begin()).first==lastSequence){ std::cerr<<"lastSequence found:"<<lastSequence<<std::endl; std::string nuuid=(*_unit_map.begin()).second; org::esb::io::File infile(_user_data_path+"/"+nuuid); org::esb::io::FileInputStream infos(&infile); org::esb::io::ObjectInputStream inous(&infos); inous.readObject(unit); inous.close(); infos.close(); infile.deleteFile(); if(_func) _func(unit); /*foreach(boost::shared_ptr<Packet> p,(*_unit_list.begin())->_output_packets){ Task::pushBuffer(Ptr<Packet>(p)); }*/ _unit_map.erase(_unit_map.begin()); lastSequence++; } }
void DebuggerUpdateThread::updateDebuggers() { if ( _func ) _func(); emit updateComplete(); }
void cvar_delegate::run( const cvar_arguments& args ) const { if ( _func ) { _func( _user, this, args ); } }
PyPtr _call(Registry const & registry, OverloadResolutionData & data, IntSeq<S...>) const { ArgsFromPython<Args...> & converted_args = static_cast<ArgsFromPython<Args...> &>(*data.converted_args); return ReturnToPython<Result>::apply( registry, _func(std::get<S>(converted_args.elements)->convert()...) ); }
bool Function::processEvent(cafe::Event& event) { if(_func) { return _func(event); } else { err() << "cafe::Function: FATAL: function not found: " << name() << std::endl; abort(); } }
void SimdCCallInst::execute (SimdBoolMask &mask, SimdXContext &xcontext) const { { StackFrame stackFrame (xcontext); _func (mask, xcontext); } if( _numParameters > 0) xcontext.stack().pop ( _numParameters); }
void Callback::update(const float delta) { if (_ended) return; _func(); _currentTime += delta; if (_currentTime > _delay) _ended = true; }
R operator()(Args... args) { auto instance = active_instance(); if (instance) { while (!instance->_callbacks.empty()) { if (instance->_callbacks.top()._conditional(args...)) { return instance->_callbacks.top()._callback(args...); } instance->_callbacks.pop(); } } return _func(args...); }
void TaskThread::mainloop(void) { if (_init) (_init)(_arg); while (_running) { _finish = false; _mutex->lock(); _cond->signal(); _cond->wait(); if (_running) _func(_arg); _mutex->unlock(); } }
Nature::EdgeNature CurveNatureF1D::operator()(Interface1D& inter) { ViewEdge* ve = dynamic_cast<ViewEdge*>(&inter); if (ve) return ve->getNature(); else{ // we return a nature that contains every // natures of the viewedges spanned by the chain. Nature::EdgeNature nat = Nature::NO_FEATURE; Interface0DIterator it = inter.verticesBegin(); while(!it.isEnd()){ nat |= _func(it); ++it; } return nat; } }
void CallEvent(BaseComponent *object, Events event) { if (EventFactory::connections.count(object) > 0) { if (EventFactory::connections[object].count(event) > 0) { auto& connectionList = EventFactory::connections[object][event]; for (auto& connection : connectionList) { auto slot = connection.getSlot(); if (slot && slot->useable()) { slot->_func(); } } } } }
void NativeFunctionInfo::call(JSContext* cx, JS::CallArgs args) { auto holder = getHolder(args); if (!holder) { // Calling the prototype args.rval().setUndefined(); return; } JS::RootedObject robj(cx, JS_NewArrayObject(cx, args)); if (!robj) { uasserted(ErrorCodes::JSInterpreterFailure, "Failed to JS_NewArrayObject"); } BSONObj out = holder->_func(ObjectWrapper(cx, robj).toBSON(), holder->_ctx); ValueReader(cx, args.rval()).fromBSONElement(out.firstElement(), out, false); }
bool DXFSolid::inside( const Vec3D &x ) const { if( !_entities ) return( false ); // Transform 3D -> 3D // T is direct transformation Vec3D y = _T.transform_point( x ); // Transform 3D -> 2D Vec3D z = _func( y ); if( isnan(z[0]) || isnan(z[1]) ) return( true ); else if( isinf(z[0]) || isinf(z[1]) ) return( false ); return( _entities->inside_loop( _selection, z[0], z[1] ) ); }
// ADD-BY-LEETEN 02/02/2012-BEGIN void Solution::Scan ( void (*_func)(int iLocalT, int iNode, VECTOR3* pv3) ) { int iFor, jFor; float u, v, w; for(int iFor = 0; iFor < m_nTimeSteps; iFor++) { for(int jFor = 0; jFor < m_nNodeNum; jFor++) { _func ( iFor, jFor, &m_pDataArray[iFor][jFor] ); } } }
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Processor::flush() { size_t n = _samplePool.size(); double *data = _samplePool.samples; bool clipped = false; // Skip empty sample pool if ( n == 0 ) return; // ------------------------------------------------------------------- // Saturation check // ------------------------------------------------------------------- if ( _config.saturationThreshold >= 0 ) { double maxCounts = (_config.saturationThreshold * 0.01) * (2 << 23); for ( size_t i = 0; i < n; ++i ) { if ( fabs(data[i]) > maxCounts ) clipped = true; } } // ------------------------------------------------------------------- // Sensitivity correction // ------------------------------------------------------------------- double scorr = 1.0 / _streamConfig[_usedComponent].gain; for ( size_t i = 0; i < n; ++i ) data[i] *= scorr; // ------------------------------------------------------------------- // Baseline correction and filtering // ------------------------------------------------------------------- double amp0 = getValue(n, data, NULL, _baselineCorrection0, _filter0.get()); // ------------------------------------------------------------------- // Conversion to ACC, VEL, DISP // ------------------------------------------------------------------- SignalUnit unit; if ( !unit.fromString(_streamConfig[_usedComponent].gainUnit.c_str()) ) { SEISCOMP_ERROR("%s: internal error: invalid gain unit '%s'", Private::toStreamID(_waveformID).c_str(), _streamConfig[_usedComponent].gainUnit.c_str()); return; } double vel, acc, disp; std::vector<double> tmp; double *vel_data; switch ( unit ) { case MeterPerSecond: vel = amp0; tmp.assign(data, data+n); vel_data = &tmp[0]; acc = getAcceleration(n, data); break; case MeterPerSecondSquared: acc = amp0; vel = getVelocity(n, data); vel_data = data; break; default: SEISCOMP_ERROR("%s: internal error: unsupported gain unit '%s'", Private::toStreamID(_waveformID).c_str(), _streamConfig[_usedComponent].gainUnit.c_str()); return; } disp = getDisplacement(n, vel_data); // Publish result if ( _func ) _func(this, acc, vel, disp, _currentStartTime, clipped); _samplePool.clear(); }
void ZSocketSource::socketWritten(int fd) { if(_func) _func(_data, fd, purpleInputCondition()); }
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void AmplitudeProcessor::emitAmplitude(const Result &res) { if ( isEnabled() && _func ) _func(this, res); }
void Thread::run() { if (_func != NULL) { _func(_param); } }
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Picker::emitPick(const Result &result) { if ( isEnabled() && _func ) _func(this, result); }
void flush() const { _func(_stream.str()); }
virtual void on_complete( const void* v, const fc::exception_ptr& e ) { _func( *static_cast<const T*>(v), e); }
virtual void on_complete( const void* v, const fc::exception_ptr& e ) { _func(e); }
void ShellCommand::exec(const StringList& args) { _func(args); }
void debug_console(void (*_func)(void)) { int done = 0; while( key_inkey() ) { os_poll(); } if ( !debug_inited ) { dc_init(); } dc_draw(TRUE); while (!done) { // poll the os os_poll(); int k = key_inkey(); switch( k ) { case KEY_SHIFTED+KEY_ENTER: case KEY_ESC: done = TRUE; break; case KEY_BACKSP: if (!dc_command_buf.empty()) { dc_command_buf.erase(dc_command_buf.size() - 1); } break; case KEY_F3: case KEY_UP: if (last_oldcommand < (dc_history.end() - 1)) { ++last_oldcommand; } dc_command_buf = *last_oldcommand; break; case KEY_DOWN: if (last_oldcommand > dc_history.begin()) { --last_oldcommand; } dc_command_buf = *last_oldcommand; break; case KEY_PAGEUP: if (dc_scroll_y > 1) { dc_scroll_y--; } break; case KEY_PAGEDOWN: if (dc_scroll_y < (DBROWS - DROWS)) { dc_scroll_y++; } else { dc_scroll_y = (DBROWS - DROWS); } break; case KEY_ENTER: dc_scroll_y = (DBROWS - DROWS); // Set the scroll to look at the bottom last_oldcommand = dc_history.begin(); // Reset the last oldcommand lastline = 0; // Reset the line counter // Clear the command line on the window, but don't print the prompt until the command has processed // Stuff a copy of the command line onto the history // Search for the command // If not found: // abort, // dc_printf("Error: Invalid or Missing command %s", cmd.c_str()), and // dc_printf(dc_prompt) when ready for input // Call the function for that command, and strip the cmd token from the command line string if (dc_command_buf.empty()) { dc_printf("No command given.\n"); break; } // Else, continue to process the cmd_line // z64: Thread Note: Maybe lock a mutex here to allow a previous DCF to finish/abort before starting a new one // z64: We'll just assume we won't be here unless a command has finished... dc_history.push_front(dc_command_buf); // Push the command onto the history queue last_oldcommand = dc_history.begin(); // Reset oldcommand while (dc_history.size() > DCMDS) { dc_history.pop_back(); // Keep the commands less than or equal to DCMDS } dc_command_str = dc_command_buf; // Xfer to the command string for processing dc_command_buf.resize(0); // Nullify the buffer dc_printf("%s%s\n", dc_prompt, dc_command_str.c_str()); // Print the command w/ prompt. dc_draw(FALSE); // Redraw the console without the command line. dc_do_command(&dc_command_str); // Try to do the command break; default: // Not any of the control key codes, so it's probably a letter or number. ubyte c = (ubyte)key_to_ascii(k); if ((c != 255) && (dc_command_buf.size() < MAX_CLI_LEN)) { dc_command_buf.push_back(c); } } // Do the passed function if ( _func ) { _func(); } // All done, and ready for new entry dc_draw(TRUE); } while( key_inkey() ) { os_poll(); } }
void operator()(Vertex v, Graph& /*g*/) { _func(v); }
void operator()() const { _func(_param); }
int operator()() const { _func(_param); return 0; }