void operator()(boost::system::error_code ec, std::size_t bytes_transfered) { pt::ptree jsonobj; std::istream jsondata( m_buffer.get() ); /** * Here, we got a json object like this: * {"retcode":0,"result":{"uiuin":"","account":615050000,"uin":954663841}} * */ //处理! try { pt::json_parser::read_json( jsondata, jsonobj ); //TODO, group members if( jsonobj.get<int>( "retcode" ) == 0 ) { m_this_group->qqnum = jsonobj.get<std::string>( "result.account" ); BOOST_LOG_TRIVIAL(debug) << "qq number of group " << utf8_to_local_encode(m_this_group->name) << " is " << m_this_group->qqnum; m_webqq->siggroupnumber(m_this_group); m_handler(boost::system::error_code()); return ; }else{ BOOST_LOG_TRIVIAL(error) << literal_to_localstr("获取群的QQ号码失败"); pt::json_parser::write_json(std::cerr, jsonobj); } } catch( const pt::ptree_error & jserr ) { } // 返回错误 m_handler(error::make_error_code(error::failed_to_fetch_group_qqnumber)); }
void operator()( const boost::system::error_code& ec, std::size_t bytes_transfered) { std::string msg; pt::ptree json; std::istream response( buf.get() ); if (!ec){ // 登录步骤. //处理! try { js::read_json( response, json ); js::write_json( std::cout, json ); if( json.get<std::string>( "retcode" ) == "0" ) { m_webqq->m_psessionid = json.get_child( "result" ).get<std::string>( "psessionid" ); m_webqq->m_vfwebqq = json.get_child( "result" ).get<std::string>( "vfwebqq" ); m_webqq->m_status = LWQQ_STATUS_ONLINE; m_handler(boost::system::error_code()); return; } } catch( const pt::json_parser_error & jserr ) { BOOST_LOG_TRIVIAL(error) << __FILE__ << " : " <<__LINE__ << " :" << "parse json error :" << jserr.what(); } catch( const pt::ptree_bad_path & jserr ) { BOOST_LOG_TRIVIAL(error) << __FILE__ << " : " <<__LINE__ << " :" << "parse bad path error : " << jserr.what(); } } m_handler(boost::system::errc::make_error_code(boost::system::errc::protocol_error)); }
void operator()(boost::system::error_code ec, std::size_t bytes_transfered) { pt::ptree jsonobj; std::istream jsondata( m_buffer.get() ); /** * Here, we got a json object like this: * {"retcode":0,"result":{"uiuin":"","account":615050000,"uin":954663841}} * */ //处理! try { pt::json_parser::read_json( jsondata, jsonobj ); //TODO, group members if( jsonobj.get<int>( "retcode" ) == 0 ) { m_this_group->qqnum = jsonobj.get<std::string>( "result.account" ); BOOST_LOG_TRIVIAL(debug) << "qq number of group " << console_out_str(m_this_group->name) << " is " << m_this_group->qqnum; // 写缓存 pt::json_parser::write_json(std::string("cache/group_qqnumber") + m_this_group->gid, jsonobj); //start polling messages, 2 connections! BOOST_LOG_TRIVIAL(info) << "start polling messages"; m_webqq->siggroupnumber(m_this_group); m_handler(boost::system::error_code()); return ; }else{ BOOST_LOG_TRIVIAL(error) << console_out_str("获取群的QQ号码失败"); pt::json_parser::write_json(std::cerr, jsonobj); } } catch( const pt::ptree_error & jserr ) { } try{ // 读取缓存 pt::json_parser::read_json(std::string("cache/group_qqnumber") + m_this_group->gid, jsonobj); m_this_group->qqnum = jsonobj.get<std::string>( "result.account" ); BOOST_LOG_TRIVIAL(debug) << "(cached) qq number of group" << console_out_str(m_this_group->name) << "is" << m_this_group->qqnum << std::endl; // 向用户报告一个 group 出来了. m_webqq->siggroupnumber(m_this_group); m_handler(boost::system::error_code()); return; }catch (const pt::ptree_error & jserr){ boost::delayedcallsec( m_webqq->get_ioservice() , 500 + boost::rand48()() % 100 , boost::bind( &make_update_group_qqnumber_op, m_webqq, m_this_group, m_handler) ); } }
/** * Thread of the receiver socket. It handles all incoming data * and forwards it to the main event loop. */ void receiverThread() { // hold a reference count of the context auto context = m_context; zmq::socket_t receiver(*context, zmq::socket_type::sub); receiver.connect(m_addr.makeReceiverAddress()); receiver.setsockopt(ZMQ_SUBSCRIBE, "", 0); int timeout = 200; receiver.setsockopt(ZMQ_RCVTIMEO, &timeout, sizeof(timeout)); bool cancel = false; auto last_connect = std::chrono::system_clock::now(); while (!cancel) { zmq::message_t zmq_msg; bool again = !receiver.recv(&zmq_msg); if (again) { if (m_cancel) { return; } capnqml::Message msg; msg.setType(capnqml::Message::Type::Connect); push(msg); auto now = std::chrono::system_clock::now(); if (now - last_connect > std::chrono::milliseconds(m_timeout) && m_state == Channel::State::Connected) { // timeout m_state = Channel::State::Disconnected; m_loop.invoke([this]() { if (m_disconnect) { m_disconnect(); } }); } continue; } auto message = _::unpack(zmq_msg); if (message.type() == Message::Type::Connect) { last_connect = std::chrono::system_clock::now(); if (m_state == Channel::State::Disconnected && m_connect) { m_state = Channel::State::Connected; m_loop.invoke([this]() { m_connect(); }); } m_state = Channel::State::Connected; } auto fun = [this, msg = std::move(message)] { if (m_handler) { m_handler(msg); } }; m_loop.invoke(std::move(fun)); if (message.type() == Message::Type::Disconnect) { m_state = Channel::State::Disconnected; m_loop.invoke([this]() { if (m_disconnect) { m_disconnect(); } }); } } }
void operator()( const boost::system::error_code& ec, std::size_t bytes_transfered) { std::string msg; pt::ptree json; std::istream response( buf.get() ); if (!ec){ // 登录步骤. //处理! try { js::read_json( response, json ); if( json.get<std::string>( "retcode" ) == "0" ) { m_webqq->m_psessionid = json.get<std::string>( "result.psessionid" ); m_webqq->m_vfwebqq = json.get<std::string>( "result.vfwebqq" ); m_webqq->m_myself_uin = json.get<std::string>("result.uin"); m_webqq->m_cookie_mgr.save_cookie("psession.qq.com", "/", "vfwebqq", m_webqq->m_vfwebqq, "session"); m_webqq->m_cookie_mgr.save_cookie("psession.qq.com", "/", "psessionid", m_webqq->m_psessionid, "session"); m_webqq->m_cookie_mgr.save_cookie("psession.qq.com", "/", "uin", m_webqq->m_myself_uin, "session"); m_webqq->m_status = LWQQ_STATUS_ONLINE; m_webqq->get_ioservice().post( boost::asio::detail::bind_handler(m_handler,boost::system::error_code()) ); return; } } catch( const pt::ptree_error & jserr ) { BOOST_LOG_TRIVIAL(error) << __FILE__ << " : " <<__LINE__ << " :" << "parse bad path error : " << jserr.what(); } } m_handler(error::make_error_code(error::failed_to_change_status)); }
void http_connection::on_assign_bandwidth(asio::error_code const& e) { if ((e == asio::error::operation_aborted && m_limiter_timer_active) || !m_sock.is_open()) { if (!m_bottled || !m_called) m_handler(e, m_parser, 0, 0); return; } m_limiter_timer_active = false; if (e) return; if (m_download_quota > 0) return; m_download_quota = m_rate_limit / 4; int amount_to_read = m_recvbuffer.size() - m_read_pos; if (amount_to_read > m_download_quota) amount_to_read = m_download_quota; m_sock.async_read_some(asio::buffer(&m_recvbuffer[0] + m_read_pos , amount_to_read) , bind(&http_connection::on_read , shared_from_this(), _1, _2)); m_limiter_timer_active = true; m_limiter_timer.expires_from_now(milliseconds(250)); m_limiter_timer.async_wait(bind(&http_connection::on_assign_bandwidth , shared_from_this(), _1)); }
void http_connection::on_write(asio::error_code const& e) { if (e) { close(); if (m_bottled && m_called) return; m_called = true; m_handler(e, m_parser, 0, 0); return; } std::string().swap(sendbuffer); m_recvbuffer.resize(4096); int amount_to_read = m_recvbuffer.size() - m_read_pos; if (m_rate_limit > 0 && amount_to_read > m_download_quota) { amount_to_read = m_download_quota; if (m_download_quota == 0) { if (!m_limiter_timer_active) on_assign_bandwidth(asio::error_code()); return; } } m_sock.async_read_some(asio::buffer(&m_recvbuffer[0] + m_read_pos , amount_to_read) , bind(&http_connection::on_read , shared_from_this(), _1, _2)); }
void http_connection::on_connect(asio::error_code const& e /*, tcp::resolver::iterator i*/) { if (!e) { m_last_receive = time_now(); asio::async_write(m_sock, asio::buffer(sendbuffer) , bind(&http_connection::on_write, shared_from_this(), _1)); } /* else if (i != tcp::resolver::iterator()) { // The connection failed. Try the next endpoint in the list. m_sock.close(); m_cc.enqueue(bind(&http_connection::connect, shared_from_this(), _1, *i) , bind(&http_connection::on_connect_timeout, shared_from_this()) , m_timeout); } */ else { close(); if (m_bottled && m_called) return; m_called = true; m_handler(e, m_parser, 0, 0); } }
void CPackMgr::PullData(uint32 linkid , uint8*pdata , uint32 datalen) { std::map<uint32,std::vector<uint8>*>::iterator iter = m_streams.find(linkid); if(iter != m_streams.end()) { std::vector<uint8>*p = iter->second; for (uint32 k = 0 ; k < datalen ; k ++) p->insert(p->end(),pdata, pdata + datalen ); uint32 ll = sizeof(uint32); while ((uint32)p->size() > ll) { uint32 packlen = 0; uint8* packdata = &p->operator [](0); uint32 packdatalen = (uint32)p->size(); if( !UnPackLen(packdata,packdatalen,packlen) ) break; if((uint32)p->size() - ll >= packlen) { if(m_handler) m_handler(linkid,&p->operator [](ll),packlen); std::vector<uint8>::iterator bit = p->begin(); std::vector<uint8>::iterator eit = bit + ll + packlen; p->erase(bit,eit); } } } }
void COverlappedOperation::HandleCompletion() { if (!m_completionHandled) { m_completionHandled = true; m_handler(this); } }
void http_connection::on_connect_timeout() { if (m_connection_ticket > -1) m_cc.done(m_connection_ticket); m_connection_ticket = -1; if (m_bottled && m_called) return; m_called = true; m_handler(asio::error::timed_out, m_parser, 0, 0); close(); }
void operator()(boost::system::error_code ec, size_t bytes_transfered) { if ((coro=(!coro))) { boost::asio::async_write(m_stream, m_streambuf.data(), *this); } else { m_handler(ec, bytes_transfered); } }
void Receiver::handle_receive_from(const boost::system::error_code& err, size_t bytes_recvd) { // Send the raw data to the handler if (!err && bytes_recvd > 0) { m_handler(m_data); } // Start new accept start_receive(); }
void Comm::process_wire() { byte val = wire_get(); if (val != m_addr) { wire_drain(); return; } byte num = wire_get(); m_handler(num); wire_drain(); }
void Notifier::onEvent(IOLoop* loop, int events) { NotifierPtr_t notifier = shared_from_this(); eventfd_t value; if(eventfd_read(m_fd, &value) < 0) { LOG_ERROR("eventfd read error"); return; } m_handler(notifier); }
void operator()(boost::system::error_code ec, std::size_t bytes_transfered) { m_webqq->m_cookie_mgr.save_cookie(*m_stream); std::string vcimg; vcimg.resize(bytes_transfered); m_buffer->sgetn(&vcimg[0], bytes_transfered); if (ec) ec = error::fetch_verifycode_failed; m_handler(ec, vcimg); }
~ScopeWatcher() { if (m_handler) { try { m_handler(); } catch (...) { } } }
void generic_bus< PBus >::platform_handler(bus_channel ch, bus_event type, size_t total) { // Transfer complete accross all channels bool last_event = (ch == bus_channel::meta && type == bus_event::tc); if (type == bus_event::err) { m_state |= xfer_error; } if (last_event) { // Spurious events are not allowed ecl_assert(!(m_state & xfer_served)); m_state |= xfer_served; } if (m_state & async_mode) { m_handler(ch, type, total); // Bus unlocked, it is time to check if bus cleaned. if (last_event && !(m_state & bus_locked)) { // It is possible that bus_handler() is executed in thread context // rather in ISR context. This means that context switch can occur // right after unlock flag is set inside unlock() but before // cleanup will occur. Atomic test_and_set will protect important // call with lock-free critical section. // In case if handler is executed in ISR context, this check // is almost meaningless, besides that setting a flag is required // to inform rest of the system that cleanup already done. if (!m_cleaned.test_and_set()) { cleanup(); } } } else { // In blocking mode a bus is responcible for bytes counting if (ch == bus_channel::tx) { m_sent = total; } else if (ch == bus_channel::rx) { m_received = total; } // Don't do anything for 'meta' channel } if (last_event) { // Inform rest of the bus about event handling m_complete.signal(); } }
void LogMessage::Log ( LogMessage::Severity sev, ///< Message severity const char *file, ///< Filename where log occurs int lineNum ///< Line number where log occurs ) { if ( m_handler != NULL ) { std::string str = m_stream.str(); m_handler( sev, str.c_str(), file, lineNum ); } } // Log
void http_connection::on_resolve(asio::error_code const& e , tcp::resolver::iterator i) { if (e) { close(); if (m_bottled && m_called) return; m_called = true; m_handler(e, m_parser, 0, 0); return; } assert(i != tcp::resolver::iterator()); m_cc.enqueue(bind(&http_connection::connect, shared_from_this(), _1, *i) , bind(&http_connection::on_connect_timeout, shared_from_this()) , m_timeout); }
void title_presence_change_subscription::on_event_received( _In_ const web::json::value& data ) { if (m_handler && !data.is_null()) { std::error_code errc; auto titlePresenceValue = utils::extract_json_as_string(data, errc); title_presence_state titlePresenceState = title_presence_state::unknown; if (!errc) { if (utils::str_icmp(titlePresenceValue, _T("started")) == 0) { titlePresenceState = title_presence_state::started; } else if (utils::str_icmp(titlePresenceValue, _T("ended")) == 0) { titlePresenceState = title_presence_state::ended; } } else { if(m_subscriptionErrorHandler != nullptr) { m_subscriptionErrorHandler( xbox::services::real_time_activity::real_time_activity_subscription_error_event_args( *this, xbox_live_error_code::json_error, "JSON deserialization failure" ) ); } return; } auto presenceEventArgs = title_presence_change_event_args( m_xboxUserId, m_titleId, std::move(titlePresenceState) ); m_handler(presenceEventArgs); } }
void LogMessage::PrintStr ( LogMessage::Severity sev, ///< Message severity const char *str ///< String to print ) { if ( m_handler == NULL ) { return; } static char line[ 512 ] = { 0 }; char *endLine = &line[ sizeof( line ) - 1]; const char *src = str; do { int lineLen = strlen( line ); char *dst = &line[ lineLen ]; while (( *src != '\0' ) && ( *src != '\n' ) && ( dst < endLine )) { *dst++ = *src++; } *dst = '\0'; if (( *src == '\n' ) || ( dst >= endLine )) { // Don't use the LOG macro, since it may cause memory allocation // to occur, and this routine is often called as part of the // process of dumping memory leaks m_handler( sev, line, __FILE__, __LINE__ ); line[ 0 ] = '\0'; if ( *src == '\n' ) { src++; } } } while ( *src != '\0' ); } // Printf
void Log::CloseLog( BOOL result, char* message ) { char buffer[40]; char* result_s = ConvertResult( result ); if(message) { hal_snprintf( buffer, sizeof(buffer), "%12s, %4s", message, result_s ); } else { hal_snprintf( buffer, sizeof(buffer), "%12s, %4s", m_logBuffer, result_s ); } m_handler( buffer, NULL ); }
/** * Process events in the queue. */ bool process() { decltype(m_buffer) local_buffer; decltype(m_invokes) local_invoke_buffer; { std::lock_guard<std::mutex> lock(m_data_lock); if (m_state == State::Cancelling) { return false; } m_state = State::Processing; for (auto &msg : m_buffer) { local_buffer.push_back(std::move(msg)); } for (auto &fun : m_invokes) { local_invoke_buffer.push_back(std::move(fun)); } m_buffer.clear(); m_invokes.clear(); } if (m_handler) { for (auto &msg : local_buffer) { m_handler(std::move(msg)); } } for (auto &fun : local_invoke_buffer) { if(fun) { fun(); } } { std::lock_guard<std::mutex> lock(m_data_lock); if (m_state == State::Cancelling) { return false; } m_state = State::Idle; } return true; }
void Comm::process_serial() { if (! Serial.available()) { return; } byte addr = serial_get(); byte pkt = serial_get(); byte num = serial_get(); bool okay = false; if (!addr) { // handle by master if (m_handler) { okay = m_handler(num); serial_drain(); } else { okay = drain(num); } } else { // send to slave okay = transmit(addr,num); serial_drain(); } if (okay) { Serial.print("OK"); } else { Serial.print("NO"); } Serial.print(pkt); Serial.print(addr); Serial.print(num); Serial.print('\0'); }
void handle(const RouteMatch& m) const { m_handler(m); }
ScopeExit::~ScopeExit() { if (!m_cancelled) { m_handler(); } }
void xw::WaylandSurfaceListener::SurfaceCreated(xw::Surface &surface) { if (!m_handler.empty()) m_handler(surface); }
static void invoke(channel ch, event e, size_t total) { m_handler(ch, e, total); }
void Button::update() { if(m_sprite.getGlobalBounds().contains(m_app.inputmanager.getMousePos()) && m_app.inputmanager.isButtonHit(sf::Mouse::Left)) m_handler(); }