dart::bin::DescriptorInfoMultipleMixin< DI > Class Template Reference

#include <eventhandler.h>

Inheritance diagram for dart::bin::DescriptorInfoMultipleMixin< DI >:

Public Member Functions
	DescriptorInfoMultipleMixin (intptr_t fd, bool disable_tokens)
virtual	~DescriptorInfoMultipleMixin ()
virtual bool	IsListeningSocket () const
virtual void	SetPortAndMask (Dart_Port port, intptr_t mask)
virtual void	RemovePort (Dart_Port port)
virtual void	RemoveAllPorts ()
virtual Dart_Port	NextNotifyDartPort (intptr_t events_ready)
virtual void	NotifyAllDartPorts (uintptr_t events)
virtual void	ReturnTokens (Dart_Port port, int count)
virtual intptr_t	Mask ()
virtual void	Close ()

Detailed Description

template<typename DI>
class dart::bin::DescriptorInfoMultipleMixin< DI >

Definition at line 357 of file eventhandler.h.

Constructor & Destructor Documentation

DescriptorInfoMultipleMixin()

template<typename DI >

dart::bin::DescriptorInfoMultipleMixin< DI >::DescriptorInfoMultipleMixin ( intptr_t  fd, bool  disable_tokens  )

inline

Definition at line 392 of file eventhandler.h.

      : DI(fd),
        tokens_map_(&SamePortValue, kTokenCount),
        disable_tokens_(disable_tokens) {}

~DescriptorInfoMultipleMixin()

template<typename DI >

virtual dart::bin::DescriptorInfoMultipleMixin< DI >::~DescriptorInfoMultipleMixin ( )

inlinevirtual

Definition at line 397 of file eventhandler.h.

{ RemoveAllPorts(); }

Member Function Documentation

Close()

template<typename DI >

virtual void dart::bin::DescriptorInfoMultipleMixin< DI >::Close ( )

inlinevirtual

Definition at line 562 of file eventhandler.h.

{ DI::Close(); }

IsListeningSocket()

template<typename DI >

virtual bool dart::bin::DescriptorInfoMultipleMixin< DI >::IsListeningSocket ( ) const

inlinevirtual

Definition at line 399 of file eventhandler.h.

{ return true; }

Mask()

template<typename DI >

virtual intptr_t dart::bin::DescriptorInfoMultipleMixin< DI >::Mask ( )

inlinevirtual

Definition at line 555 of file eventhandler.h.

                          {
    if (active_readers_.HasHead()) {
      return 1 << kInEvent;
    }
    return 0;
  }

NextNotifyDartPort()

template<typename DI >

virtual Dart_Port dart::bin::DescriptorInfoMultipleMixin< DI >::NextNotifyDartPort ( intptr_t  events_ready )

inlinevirtual

Definition at line 491 of file eventhandler.h.

                                                              {
    // We're only sending `kInEvents` if there are multiple listeners (which is
    // listening socktes).
    ASSERT(IS_EVENT(events_ready, kInEvent) ||
           IS_EVENT(events_ready, kDestroyedEvent));
 
    if (active_readers_.HasHead()) {
      PortEntry* pentry = reinterpret_cast<PortEntry*>(active_readers_.head());
 
      // Update token count.
      if (!disable_tokens_) {
        pentry->token_count--;
      }
      if (pentry->token_count <= 0) {
        active_readers_.RemoveHead();
      } else {
        active_readers_.Rotate();
      }
 
      return pentry->dart_port;
    }
    return 0;
  }

NotifyAllDartPorts()

template<typename DI >

virtual void dart::bin::DescriptorInfoMultipleMixin< DI >::NotifyAllDartPorts ( uintptr_t  events )

inlinevirtual

Definition at line 515 of file eventhandler.h.

                                                    {
    // Unexpected close, asynchronous destroy or error events are the only
    // ones we broadcast to all listeners.
    ASSERT(IS_EVENT(events, kCloseEvent) || IS_EVENT(events, kErrorEvent) ||
           IS_EVENT(events, kDestroyedEvent));
 
    for (SimpleHashMap::Entry* entry = tokens_map_.Start(); entry != nullptr;
         entry = tokens_map_.Next(entry)) {
      PortEntry* pentry = reinterpret_cast<PortEntry*>(entry->value);
      DartUtils::PostInt32(pentry->dart_port, events);
 
      // Update token count.
      bool was_ready = pentry->IsReady();
      if (!disable_tokens_) {
        pentry->token_count--;
      }
 
      if (was_ready && (pentry->token_count <= 0)) {
        active_readers_.Remove(pentry);
      }
    }
  }

RemoveAllPorts()

template<typename DI >

virtual void dart::bin::DescriptorInfoMultipleMixin< DI >::RemoveAllPorts ( )

inlinevirtual

Definition at line 479 of file eventhandler.h.

                                {
    for (SimpleHashMap::Entry* entry = tokens_map_.Start(); entry != nullptr;
         entry = tokens_map_.Next(entry)) {
      PortEntry* pentry = reinterpret_cast<PortEntry*>(entry->value);
      entry->value = nullptr;
      active_readers_.Remove(pentry);
      delete pentry;
    }
    tokens_map_.Clear();
    active_readers_.RemoveAll(DeletePortEntry);
  }

RemovePort()

template<typename DI >

virtual void dart::bin::DescriptorInfoMultipleMixin< DI >::RemovePort ( Dart_Port  port )

inlinevirtual

Definition at line 455 of file eventhandler.h.

                                          {
    SimpleHashMap::Entry* entry = tokens_map_.Lookup(
        GetHashmapKeyFromPort(port), GetHashmapHashFromPort(port), false);
    if (entry != nullptr) {
      PortEntry* pentry = reinterpret_cast<PortEntry*>(entry->value);
      if (pentry->IsReady()) {
        active_readers_.Remove(pentry);
      }
      tokens_map_.Remove(GetHashmapKeyFromPort(port),
                         GetHashmapHashFromPort(port));
      delete pentry;
    } else {
      // NOTE: This is a listening socket which has been immediately closed.
      //
      // If a listening socket is not listened on, the event handler does not
      // know about it beforehand. So the first time the event handler knows
      // about it, is when it is supposed to be closed. We therefore do nothing
      // here.
      //
      // But whether to close it, depends on whether other isolates have it open
      // as well or not.
    }
  }

ReturnTokens()

template<typename DI >

virtual void dart::bin::DescriptorInfoMultipleMixin< DI >::ReturnTokens ( Dart_Port  port, int  count  )

inlinevirtual

Definition at line 538 of file eventhandler.h.

                                                       {
    SimpleHashMap::Entry* entry = tokens_map_.Lookup(
        GetHashmapKeyFromPort(port), GetHashmapHashFromPort(port), false);
    ASSERT(entry != nullptr);
 
    PortEntry* pentry = reinterpret_cast<PortEntry*>(entry->value);
    bool was_ready = pentry->IsReady();
    if (!disable_tokens_) {
      pentry->token_count += count;
    }
    ASSERT(pentry->token_count <= kTokenCount);
    bool is_ready = pentry->IsReady();
    if (!was_ready && is_ready) {
      active_readers_.Add(pentry);
    }
  }

SetPortAndMask()

template<typename DI >

virtual void dart::bin::DescriptorInfoMultipleMixin< DI >::SetPortAndMask ( Dart_Port  port, intptr_t  mask  )

inlinevirtual

Definition at line 401 of file eventhandler.h.

                                                             {
    SimpleHashMap::Entry* entry = tokens_map_.Lookup(
        GetHashmapKeyFromPort(port), GetHashmapHashFromPort(port), true);
    PortEntry* pentry;
    if (entry->value == nullptr) {
      pentry = new PortEntry();
      pentry->dart_port = port;
      pentry->token_count = kTokenCount;
      pentry->is_reading = IsReadingMask(mask);
      entry->value = reinterpret_cast<void*>(pentry);
 
      if (pentry->IsReady()) {
        active_readers_.Add(pentry);
      }
    } else {
      pentry = reinterpret_cast<PortEntry*>(entry->value);
      bool was_ready = pentry->IsReady();
      pentry->is_reading = IsReadingMask(mask);
      bool is_ready = pentry->IsReady();
 
      if (was_ready && !is_ready) {
        active_readers_.Remove(pentry);
      } else if (!was_ready && is_ready) {
        active_readers_.Add(pentry);
      }
    }
 
#ifdef DEBUG
    // To ensure that all readers are ready.
    int ready_count = 0;
 
    if (active_readers_.HasHead()) {
      PortEntry* root = reinterpret_cast<PortEntry*>(active_readers_.head());
      PortEntry* current = root;
      do {
        ASSERT(current->IsReady());
        ready_count++;
        active_readers_.Rotate();
        current = active_readers_.head();
      } while (current != root);
    }
 
    for (SimpleHashMap::Entry* entry = tokens_map_.Start(); entry != nullptr;
         entry = tokens_map_.Next(entry)) {
      PortEntry* pentry = reinterpret_cast<PortEntry*>(entry->value);
      if (pentry->IsReady()) {
        ready_count--;
      }
    }
    // Ensure all ready items are in `active_readers_`.
    ASSERT(ready_count == 0);
#endif
  }

---

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

• third_party/dart-lang/sdk/runtime/bin/eventhandler.h