C++ dataAvailable函数代码示例

ConnectionError ConnectionTCPServer::recv( int timeout )
{
    m_recvMutex.lock();

    if( m_cancel || m_socket < 0 || !m_connectionHandler )
    {
        m_recvMutex.unlock();
        return ConnNotConnected;
    }

    if( !dataAvailable( timeout ) )
    {
        m_recvMutex.unlock();
        return ConnNoError;
    }

    struct sockaddr_in they;
    int sin_size = sizeof( struct sockaddr_in );
#ifdef WIN32
    int newfd = accept( m_socket, (struct sockaddr*)&they, &sin_size );
#else
    int newfd = accept( m_socket, (struct sockaddr*)&they, (socklen_t*)&sin_size );
#endif

    m_recvMutex.unlock();

    ConnectionTCPClient* conn = new ConnectionTCPClient( m_logInstance, inet_ntoa( they.sin_addr ),
            ntohs( they.sin_port ) );
    conn->setSocket( newfd );
    m_connectionHandler->handleIncomingConnection( conn );

    return ConnNoError;
}

ctkDICOMHostMainLogic::ctkDICOMHostMainLogic(ctkHostedAppPlaceholderWidget* placeHolder, ctkDICOMAppWidget* dicomAppWidget, 
                                             QWidget* placeHolderForControls) : 
  QObject(placeHolder), 
  PlaceHolderForHostedApp(placeHolder),
  DicomAppWidget(dicomAppWidget),
  PlaceHolderForControls(placeHolderForControls),
  ValidSelection(false),
  SendData(false)
{
  this->Host = new ctkExampleDicomHost(PlaceHolderForHostedApp);
  this->HostControls = new ctkExampleHostControlWidget(Host, PlaceHolderForControls);

  Data = new ctkDicomAppHosting::AvailableData;

  disconnect(this->Host,SIGNAL(startProgress()),this->Host,SLOT(onStartProgress()));
  connect(this->Host,SIGNAL(appReady()),this,SLOT(onAppReady()), Qt::QueuedConnection);
  connect(this->Host,SIGNAL(startProgress()),this,SLOT(publishSelectedData()), Qt::QueuedConnection);
  connect(this->PlaceHolderForHostedApp,SIGNAL(resized()),this,SLOT(placeHolderResized()));

  QTreeView * treeview = dicomAppWidget->findChild<QTreeView*>("TreeView");
  QItemSelectionModel* selectionmodel = treeview->selectionModel();
  connect(selectionmodel, SIGNAL(selectionChanged ( const QItemSelection &, const QItemSelection & )),
    this, SLOT(onTreeSelectionChanged(const QItemSelection &, const QItemSelection &)));

  connect(this->Host, SIGNAL(dataAvailable()), this, SLOT(onDataAvailable()));

  connect( qApp, SIGNAL(aboutToQuit()), this, SLOT(aboutToQuit()) );
}

bool LH_MonitoringSource_Fraps::doUpdate()
{
#ifndef Q_OS_WIN
    return false;
#else
    HMODULE frapsDLL;
    FRAPS_SHARED_DATA *fsd;
#ifdef Q_PROCESSOR_X86_32
    frapsDLL = GetModuleHandleA("FRAPS32.DLL");
#else
    frapsDLL = GetModuleHandleA("FRAPS64.DLL");
#endif
    bool resultVal = false;

    setDataAvailable(frapsDLL != NULL);
    if(!dataAvailable()) // Not running
        pingFraps();
    else {
        FrapsSharedData = (FRAPS_SHARED_DATA *(WINAPI *)()) GetProcAddress(frapsDLL, "FrapsSharedData");

        if (!FrapsSharedData)
        {
            qWarning() << "This version of Fraps is incompatible with LCDHost: Fraps 1.9C or later is required!";
        } else {
            fsd = FrapsSharedData();
            updateValue("Current FPS","","",(int)fsd->currentFPS, fps_);
            updateValue("Game Name","","",fsd->gameName);
            //updateValue("Total Frames","","",(int)fsd->totalFrames);
            //updateValue("Time of Last Frame","","",(int)fsd->timeOfLastFrame);
            resultVal = true;
        }
    }
    return resultVal;
#endif
}

TextTraceHandler::TextTraceHandler(QIODevice *device, QObject *parent)
: QObject(parent)
{
    d = new TextTraceHandlerPrivate;
    d->device = device;
    connect(device, SIGNAL(readyRead()), this, SLOT(dataAvailable()));
}

bool SensorfwRotationSensor::doConnect()
{
    Q_ASSERT(m_sensorInterface);
    if (m_bufferSize==1)
       return QObject::connect(m_sensorInterface, SIGNAL(dataAvailable(XYZ)), this, SLOT(slotDataAvailable(XYZ)));
    return QObject::connect(m_sensorInterface, SIGNAL(frameAvailable(QVector<XYZ>)),this, SLOT(slotFrameAvailable(QVector<XYZ>)));
}

void ServerSocket::handleData()
{
    /*  qWarning() << "void ServerSocket::handleSocketData()" << m_bufferedData << m_bufferedData.size();
      int datasize = m_bufferedData.size();
      if((!(datasize % 4)) && datasize < 20)
      {
        if(m_bufferedData.contains(Command::playerlist))
        {
    //       qWarning() << "Playerlist requested; ID: " << m_id;
          emit playerlistRequested(m_id);
        }
        else if(m_bufferedData.contains(Command::ohsocketIdent))
        {
    //       m_ident = true;
          killSocketTimer();
        }
        else if(m_bufferedData.contains(Command::playerReady))
        {
          emit playerReady(m_id);
        }
        else
          emit dataAvailable(m_id);
      }
      else*/
    emit dataAvailable(m_id);
}

void
SmugMug::WebService::_slotHttpRequestFinished (int id, bool error) {

    qDebug () << "Request Finished: " << id;

    if (error) {

        _logHttpError (QString ("Request Finished: %1").arg (id));
    }
    else {

        emit dataAvailable (_dataIn);

        bool err = false;

        QDomDocument doc;
        if (doc.setContent (_dataIn)) {

            QDomElement root = doc.documentElement();

            if (!_isResponseValid (root)) {

                err = true;
                _responseFailed (root);
            }

            _handleResponse (id, root, err);
        }

        emit actionFinished ();
        qDebug () << "actionFinished: " << id;
    }
}

bool LabelToolPlugin::visualizeImgCb(label_tool_msgs::ImagesToLabel::Request &req,
                                     label_tool_msgs::ImagesToLabel::Response &res)
{
  reset();

  // copy data on class structure
  for(auto &img : req.images)
  {
    // convert to opencv mat
    cv_bridge::CvImagePtr cv_ptr;
    try
    {
      cv_ptr = cv_bridge::toCvCopy(img, img.encoding);
    }
    catch (cv_bridge::Exception& e)
    {
      ROS_ERROR("cv_bridge exception: %s", e.what());
      return false;
    }


    std::vector<cv::Point> polygon_edges;

    ImgWithPolygon img_with_poly_class;
    img_with_poly_class.img_ = cv_ptr->image;
    img_with_poly_class.polygon_edges_ = polygon_edges;
    img_with_polygons_.push_back(img_with_poly_class);
  }

  emit dataAvailable();
  return true;
}

void QmlProfilerModelManager::complete()
{
    switch (state()) {
    case QmlProfilerDataState::ProcessingData:
        setState(QmlProfilerDataState::Done);
        emit dataAvailable();
        break;
    case QmlProfilerDataState::AcquiringData:
        // If trace end time was not explicitly set, use the last event
        if (d->traceTime->endTime() == 0)
            d->traceTime->setEndTime(d->model->lastTimeMark());
        setState(QmlProfilerDataState::ProcessingData);
        d->model->complete();
        d->v8Model->complete();
        break;
    case QmlProfilerDataState::Empty:
        setState(QmlProfilerDataState::Done);
        break;
    case QmlProfilerDataState::Done:
        break;
    default:
        emit error(tr("Unexpected complete signal in data model."));
        break;
    }
}

int MG2639_Cell::readWaitForResponses(const char * goodRsp, 
                                      const char * failRsp, unsigned int timeout)
{
	unsigned long timeIn = millis(); // Timestamp coming into function
	unsigned int received = 0; // received keeps track of number of chars read
	
	clearBuffer(); // Clear the class receive buffer (rxBuffer)
	while (timeIn + timeout > millis()) // While we haven't timed out
	{
		if (dataAvailable()) // If data is available on UART RX
		{
			// Increment received count & read byte to buffer
			received += readByteToBuffer();
			if (searchBuffer(goodRsp))
				return received; // If we've received [goodRsp], return received
			if (searchBuffer(failRsp)) // If we've received [failRsp]
				return ERROR_FAIL_RESPONSE; // return FAIL response error code
		}
	}
	
	if (received > 0) // If we received any characters
		return ERROR_UNKNOWN_RESPONSE;	// Return unkown response error code
	else // If we haven't received any characters
		return ERROR_TIMEOUT; // Return the timeout error code
}

bool QBluetoothSocketPrivate::setSocketDescriptor(const QAndroidJniObject &socket, QBluetoothServiceInfo::Protocol socketType_,
                         QBluetoothSocket::SocketState socketState, QBluetoothSocket::OpenMode openMode)
{
    Q_Q(QBluetoothSocket);

    if (q->state() != QBluetoothSocket::UnconnectedState || !socket.isValid())
        return false;

    if (!ensureNativeSocket(socketType_))
        return false;

    socketObject = socket;

    QAndroidJniEnvironment env;
    inputStream = socketObject.callObjectMethod("getInputStream", "()Ljava/io/InputStream;");
    outputStream = socketObject.callObjectMethod("getOutputStream", "()Ljava/io/OutputStream;");

    if (env->ExceptionCheck() || !inputStream.isValid() || !outputStream.isValid()) {
        env->ExceptionDescribe();
        env->ExceptionClear();

        //close socket again
        socketObject.callMethod<void>("close");
        if (env->ExceptionCheck()) {
            env->ExceptionDescribe();
            env->ExceptionClear();
        }

        socketObject = inputStream = outputStream = remoteDevice = QAndroidJniObject();


        errorString = QBluetoothSocket::tr("Obtaining streams for service failed");
        q->setSocketError(QBluetoothSocket::NetworkError);
        q->setSocketState(QBluetoothSocket::UnconnectedState);
        return false;
    }

    remoteDevice = socketObject.callObjectMethod("getRemoteDevice", "()Landroid/bluetooth/BluetoothDevice;");

    if (inputThread) {
        inputThread->deleteLater();
        inputThread = 0;
    }
    inputThread = new InputStreamThread(this);
    QObject::connect(inputThread, SIGNAL(dataAvailable()),
                     q, SIGNAL(readyRead()), Qt::QueuedConnection);
    QObject::connect(inputThread, SIGNAL(error(int)),
                     this, SLOT(inputThreadError(int)), Qt::QueuedConnection);
    inputThread->run();


    q->setSocketState(socketState);
    q->setOpenMode(openMode | QIODevice::Unbuffered);

    if (openMode == QBluetoothSocket::ConnectedState)
        emit q->connected();

    return true;
}

bool SensorfwMagnetometer::doConnect()
{
    Q_ASSERT(m_sensorInterface);
    if (m_bufferSize==1)
        return QObject::connect(m_sensorInterface, SIGNAL(dataAvailable(MagneticField)),
                                this, SLOT(slotDataAvailable(MagneticField)));
     return QObject::connect(m_sensorInterface, SIGNAL(frameAvailable(QVector<MagneticField>)),
                             this, SLOT(slotFrameAvailable(QVector<MagneticField>)));
}

void UDPServer::handleDataRequest(QString data)
{
    qDebug() << "UDPServer::handleDataRequest called with data:" << data;
    QString cmd = data.section(';',1,1).toLower();
    switch (COMMANDS.indexOf(cmd.section(' ',0,0)))
    {
    case 0: // Help command (help)
        qDebug() << "help command called";
        sendHelp();
        break;
    case 1: // List devices command (lsdvs)
        qDebug() << "List devices command called";
        sendDeviceList();
        break;
    case 2: // Select device command (sldvc)
        qDebug() << "Select device command called";
        selectDevice(cmd);
        break;
    case 3: // Deselect device command (dsdvc)
        qDebug() << "Deselect device command called";
        deselectDevice();
        break;
    case 4: // List buttons command (lsbts)
        qDebug() << "List buttons command called";
        listButtons();
        break;
    case 5: // Keymap command (kmap)
        qDebug() << "Keymap command called";
        mapKey(cmd);
        break;
    case 6: // Undo keymap command (umap)
        qDebug() << "Undo keymap command called";
        unmapKey(cmd);
        break;
    case 7: // Supported devices command (supdvs)
        qDebug() << "Supported devices command called";
        supportedDevices(cmd);
        break;
    case 8: // Axis Format Map (afmap)
        qDebug() << "Axis Format Map command called";
        axisFormatMap(cmd);
        break;
    case 9: // Axis Key Map (akmap)
        qDebug() << "Axis Key Map command called";
        axisKeyMap(cmd);
        break;
    default:
        qDebug() << "Command not recognised";
        QString reply = "10;";
        reply += "\'" + cmd.section(' ',0,0) + "\'";
        reply += " is not recognized as a command, use the \'help\' command for more information";
        sendDatagram(reply.toLatin1());
        break;
    }

    emit dataAvailable(data);
}

bool AccelerometerSensorChannelInterface::dataReceivedImpl()
{
    QVector<AccelerationData> values;
    if(!read<AccelerationData>(values))
        return false;
    if(!frameAvailableConnected || values.size() == 1)
    {
        foreach(const AccelerationData& data, values)
            emit dataAvailable(XYZ(data));
    }

void ONBinaryProtocol::Detach(bool keepBuffer)
{
    disconnect(this, SLOT(dataAvailable()));

    _device = nullptr;

    if (! keepBuffer) {
        _buffer.clear();
    }
}