C++ ConnectionReader::isValid方法代码示例

bool yarp::os::Node::Helper::read(ConnectionReader& reader)
{
    if (!reader.isValid()) {
        return false;
    }
    NodeArgs na;
    na.request.read(reader);
    //printf("NODE API for %s received %s\n",
    //name.c_str(),
    //na.request.toString().c_str());
    std::string key = na.request.get(0).asString();
    na.args = na.request.tail().tail();
    if (key=="getBusStats") {
        getBusStats(na);
    } else if (key=="getBusInfo") {
        getBusInfo(na);
    } else if (key=="getMasterUri") {
        getMasterUri(na);
    } else if (key=="shutdown") {
        shutdown(na);
    } else if (key=="getPid") {
        getPid(na);
    } else if (key=="getSubscriptions") {
        getSubscriptions(na);
    } else if (key=="getPublications") {
        getPublications(na);
    } else if (key=="paramUpdate") {
        paramUpdate(na);
    } else if (key=="publisherUpdate") {
        publisherUpdate(na);
    } else if (key=="requestTopic") {
        requestTopic(na);
    } else {
        na.error("I have no idea what you are talking about");
    }
    if (na.should_drop) {
        reader.requestDrop(); // ROS likes to close down.
    }
    if (reader.getWriter()) {
        Bottle full;
        full.addInt32(na.code);
        full.addString(na.msg);
        full.add(na.reply);
        //printf("NODE %s <<< %s\n",
        //name.c_str(),
        //full.toString().c_str());
        full.write(*reader.getWriter());
    }
    return true;
}

 bool read(ConnectionReader& reader) override {
     if (!reader.isValid()) {
         return false;
     }
     receives++;
     BottleImpl bot;
     bot.read(reader);
     if (expectation==std::string("")) {
         report(1,"got unexpected input");
         return false;
     }
     checkEqual(bot.toString(),expectation,"received bottle");
     return true;
 }

    virtual bool read(ConnectionReader& reader) {
        // called by comms code
        readBlock.wait();

        if (!reader.isValid()) {
            // termination
            stateMutex.wait();
            if (readDelegate!=NULL) {
                readResult = readDelegate->read(reader);
            }
            stateMutex.post();
            produce.post();
            readBlock.post();
            return false;
        }

        // wait for happy consumer - don't want to miss a packet
        if (!readBackground) {
            consume.wait();
        }

        if (closed) {
            YARP_DEBUG(Logger::get(),"Port::read shutting down");
            readBlock.post();
            return false;
        }

        stateMutex.wait();
        readResult = false;
        if (readDelegate!=NULL) {
            readResult = readDelegate->read(reader);
        } else {
            // read and ignore
            YARP_DEBUG(Logger::get(),"data received in Port, no reader for it");
            Bottle b;
            b.read(reader);
        }
        if (!readBackground) {
            readDelegate = NULL;
            writeDelegate = NULL;
        }
        bool result = readResult;
        stateMutex.post();
        if (!readBackground) {
            produce.post();
        }
        if (result&&willReply) {
            consume.wait();
            if (closed) {
                YARP_DEBUG(Logger::get(),"Port::read shutting down");
                readBlock.post();
                return false;
            }
            if (writeDelegate!=NULL) {
                stateMutex.wait();
                ConnectionWriter *writer = reader.getWriter();
                if (writer!=NULL) {
                    result = readResult = writeDelegate->write(*writer);
                }
                stateMutex.post();
            }
            if (dropDue) {
                reader.requestDrop();
            }
            produce.post();
        }
        readBlock.post();
        return result;
    }

bool PortReaderBufferBase::read(ConnectionReader& connection)
{
    if (connection.getReference()!=nullptr) {
        //printf("REF %ld %d\n", (long int)connection.getReference(),
        //     connection.isValid());
        return acceptObjectBase(connection.getReference(), nullptr);
    }

    if (mPriv->replier != nullptr) {
        if (connection.getWriter()) {
            return mPriv->replier->read(connection);
        }
    }
    PortReaderPacket *reader = nullptr;
    while (reader==nullptr) {
        mPriv->stateSema.wait();
        reader = mPriv->get();
        if (reader && reader->getReader() == nullptr) {
            PortReader *next = create();
            yAssert(next != nullptr);
            reader->setReader(next);
        }

        mPriv->stateSema.post();
        if (reader==nullptr) {
            mPriv->consumeSema.wait();
        }
    }
    bool ok = false;
    if (connection.isValid()) {
        yAssert(reader->getReader()!=nullptr);
        ok = reader->getReader()->read(connection);
        reader->setEnvelope(connection.readEnvelope());
    } else {
        // this is a disconnection
        // don't talk to this port ever again
        mPriv->port = nullptr;
    }
    if (ok) {
        mPriv->stateSema.wait();
        bool pruned = false;
        if (mPriv->ct>0 && mPriv->prune) {
            PortReaderPacket *readerPacket =
                mPriv->dropContent();
            pruned = (readerPacket!=nullptr);
        }
        //mPriv->configure(reader, false, true);
        mPriv->pool.addActivePacket(reader);
        mPriv->ct++;
        mPriv->stateSema.post();
        if (!pruned) {
            mPriv->contentSema.post();
        }
        //YARP_ERROR(Logger::get(), ">>>>>>>>>>>>>>>>> adding data");
    } else {
        mPriv->stateSema.wait();
        mPriv->pool.addInactivePacket(reader);
        mPriv->stateSema.post();
        //YARP_ERROR(Logger::get(), ">>>>>>>>>>>>>>>>> skipping data");

        // important to give reader a shot anyway, allowing proper closing
        YARP_DEBUG(Logger::get(), "giving PortReaderBuffer chance to close");
        mPriv->contentSema.post();
    }
    return ok;
}