dart::MessageQueue Class Reference

#include <message.h>

Classes
class	Iterator

Public Member Functions
	MessageQueue ()
	~MessageQueue ()
void	Enqueue (std::unique_ptr< Message > msg, bool before_events)
std::unique_ptr< Message >	Dequeue ()
bool	IsEmpty ()
void	Clear ()
intptr_t	Length () const
Message *	FindMessageById (intptr_t id)
void	PrintJSON (JSONStream *stream)

Detailed Description

Definition at line 159 of file message.h.

Constructor & Destructor Documentation

MessageQueue()

dart::MessageQueue::MessageQueue

(

)

Definition at line 87 of file message.cc.

                           {
  head_ = nullptr;
  tail_ = nullptr;
}

~MessageQueue()

dart::MessageQueue::~MessageQueue

(

)

Definition at line 92 of file message.cc.

                            {
  // Ensure that all pending messages have been released.
  Clear();
  ASSERT(head_ == nullptr);
}

Member Function Documentation

Clear()

void dart::MessageQueue::Clear

(

)

Definition at line 158 of file message.cc.

                         {
  std::unique_ptr<Message> cur(head_);
  head_ = nullptr;
  tail_ = nullptr;
  while (cur != nullptr) {
    std::unique_ptr<Message> next(cur->next_);
    cur = std::move(next);
  }
}

Dequeue()

std::unique_ptr< Message > dart::MessageQueue::Dequeue

(

)

Definition at line 142 of file message.cc.

                                             {
  Message* result = head_;
  if (result != nullptr) {
    head_ = result->next_;
    // The following update to tail_ is not strictly needed.
    if (head_ == nullptr) {
      tail_ = nullptr;
    }
#if defined(DEBUG)
    result->next_ = result;  // Make sure to trigger ASSERT in Enqueue.
#endif                       // DEBUG
    return std::unique_ptr<Message>(result);
  }
  return nullptr;
}

Enqueue()

void dart::MessageQueue::Enqueue	(	std::unique_ptr< Message >	msg,
		bool	before_events
	)

Definition at line 98 of file message.cc.

                                                                          {
  // TODO(mdempsky): Use unique_ptr internally?
  Message* msg = msg0.release();
 
  // Make sure messages are not reused.
  ASSERT(msg->next_ == nullptr);
  if (head_ == nullptr) {
    // Only element in the queue.
    ASSERT(tail_ == nullptr);
    head_ = msg;
    tail_ = msg;
  } else {
    ASSERT(tail_ != nullptr);
    if (!before_events) {
      // Append at the tail.
      tail_->next_ = msg;
      tail_ = msg;
    } else {
      ASSERT(msg->dest_port() == Message::kIllegalPort);
      if (head_->dest_port() != Message::kIllegalPort) {
        msg->next_ = head_;
        head_ = msg;
      } else {
        Message* cur = head_;
        while (cur->next_ != nullptr) {
          if (cur->next_->dest_port() != Message::kIllegalPort) {
            // Splice in the new message at the break.
            msg->next_ = cur->next_;
            cur->next_ = msg;
            return;
          }
          cur = cur->next_;
        }
        // All pending messages are isolate library control messages. Append at
        // the tail.
        ASSERT(tail_ == cur);
        ASSERT(tail_->dest_port() == Message::kIllegalPort);
        tail_->next_ = msg;
        tail_ = msg;
      }
    }
  }
}

FindMessageById()

Message * dart::MessageQueue::FindMessageById

(

intptr_t

id

)

Definition at line 201 of file message.cc.

                                                  {
  MessageQueue::Iterator it(this);
  while (it.HasNext()) {
    Message* current = it.Next();
    ASSERT(current != nullptr);
    if (current->Id() == id) {
      return current;
    }
  }
  return nullptr;
}

IsEmpty()

bool dart::MessageQueue::IsEmpty ( )

inline

Definition at line 170 of file message.h.

{ return head_ == nullptr; }

Length()

intptr_t dart::MessageQueue::Length

(

)

const

Definition at line 191 of file message.cc.

                                    {
  MessageQueue::Iterator it(this);
  intptr_t length = 0;
  while (it.HasNext()) {
    it.Next();
    length++;
  }
  return length;
}

PrintJSON()

void dart::MessageQueue::PrintJSON

(

JSONStream *

stream

)

Definition at line 213 of file message.cc.

                                               {
#ifndef PRODUCT
  JSONArray messages(stream);
 
  Object& msg_handler = Object::Handle();
 
  MessageQueue::Iterator it(this);
  intptr_t depth = 0;
  while (it.HasNext()) {
    Message* current = it.Next();
    JSONObject message(&messages);
    message.AddProperty("type", "Message");
    message.AddPropertyF("name", "Isolate Message (%" Px ")", current->Id());
    message.AddPropertyF("messageObjectId", "messages/%" Px "", current->Id());
    message.AddProperty("size", current->Size());
    message.AddProperty("index", depth++);
    message.AddPropertyF("_destinationPort", "%" Pd64 "",
                         static_cast<int64_t>(current->dest_port()));
    message.AddProperty("_priority",
                        Message::PriorityAsString(current->priority()));
    // TODO(johnmccutchan): Move port -> handler map out of Dart and into the
    // VM, that way we can lookup the handler without invoking Dart code.
    msg_handler = DartLibraryCalls::LookupHandler(current->dest_port());
    if (msg_handler.IsClosure()) {
      // Grab function from closure.
      msg_handler = Closure::Cast(msg_handler).function();
    }
    if (msg_handler.IsFunction()) {
      const Function& function = Function::Cast(msg_handler);
      message.AddProperty("handler", function);
 
      const Script& script = Script::Handle(function.script());
      if (!script.IsNull()) {
        message.AddLocation(script, function.token_pos(),
                            function.end_token_pos());
      }
    }
  }
#endif  // !PRODUCT
}

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/vm/message.h
• third_party/dart-lang/sdk/runtime/vm/message.cc