Function WaitMessage

mars/comm/messagequeue/message_queue.cc:478–533

}

bool WaitMessage(const MessagePost_t& _message, long _timeoutInMs) {
    bool is_in_mq = Handler2Queue(Post2Handler(_message)) == CurrentThreadMessageQueue();

    ScopedLock lock(sg_messagequeue_map_mutex);
    const MessageQueue_t& id = Handler2Queue(Post2Handler(_message));
    std::map<MessageQueue_t, MessageQueueContent>::iterator pos = sg_messagequeue_map.find(id);
    if (sg_messagequeue_map.end() == pos) return false;
    MessageQueueContent& content = pos->second;

    auto find_it = std::find_if(content.lst_message.begin(), content.lst_message.end(),
                                [&_message](const MessageWrapper * const &_v) {
                                    return _message == _v->postid;
                                });
    
    if (find_it == content.lst_message.end()) {
        auto find_it = std::find_if(content.lst_runloop_info.begin(), content.lst_runloop_info.end(),
                     [&_message](const RunLoopInfo& _v){ return _message == _v.runing_message_id; });
        
        if (find_it != content.lst_runloop_info.end()) {
            if (is_in_mq) return false;
            
            boost::shared_ptr<Condition> runing_cond = find_it->runing_cond;
            if(_timeoutInMs < 0) {
                runing_cond->wait(lock);
            } else {
                int ret = runing_cond->wait(lock, _timeoutInMs);
                return ret==0;
            }
        }
    } else {
        
        if (is_in_mq) {
            lock.unlock();
            RunLoop( [&_message](){
                        MessageQueueContent& content = sg_messagequeue_map[Handler2Queue(Post2Handler(_message))];
                        return content.lst_message.end() == std::find_if(content.lst_message.begin(), content.lst_message.end(),
                                                                [&_message](const MessageWrapper *  const &_v) {
                                                                    return _message == _v->postid;
                                                                });
            }).Run();
            
        } else {
            if (!((*find_it)->wait_end_cond))(*find_it)->wait_end_cond = boost::make_shared<Condition>();

            boost::shared_ptr<Condition> wait_end_cond = (*find_it)->wait_end_cond;
            if(_timeoutInMs < 0) {
                wait_end_cond->wait(lock);
            } else {
                int ret = wait_end_cond->wait(lock, _timeoutInMs);
                return ret==0;
            }
        }
    }

    return true;
}

bool FoundMessage(const MessagePost_t& _message) {