ACE/ace/Handle_Set.inl

   1 // -*- C++ -*-
   2 #include "ace/Log_Category.h"
   3
   4 #if defined (ACE_HAS_STRINGS)
   5 #  include "ace/os_include/os_strings.h"
   6 #endif /* ACE_HAS_STRINGS */
   7
   8 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   9
  10 /// Initialize the bitmask to all 0s and reset the associated fields.
  11 ACE_INLINE void
  12 ACE_Handle_Set::reset ()
  13 {
  14   ACE_TRACE ("ACE_Handle_Set::reset");
  15   this->max_handle_ = ACE_INVALID_HANDLE;
  16 #if defined (ACE_HAS_BIG_FD_SET)
  17   this->min_handle_ = NUM_WORDS * WORDSIZE;
  18 #endif /* ACE_HAS_BIG_FD_SET */
  19   this->size_ = 0;
  20   // #if !defined (ACE_HAS_BIG_FD_SET)      Why is this here?  -Steve Huston
  21   FD_ZERO (&this->mask_);
  22   // #endif /* ACE_HAS_BIG_FD_SET */
  23 }
  24
  25 #if defined (ACE_HAS_BIG_FD_SET)
  26 ACE_INLINE ACE_Handle_Set &
  27 ACE_Handle_Set::operator = (const ACE_Handle_Set &rhs)
  28 {
  29   ACE_TRACE ("ACE_Handle_Set::operator =");
  30
  31   if (rhs.size_ > 0)
  32     {
  33       this->size_ = rhs.size_;
  34       this->max_handle_ = rhs.max_handle_;
  35       this->min_handle_ = rhs.min_handle_;
  36       this->mask_ = rhs.mask_;
  37     }
  38   else
  39     {
  40       this->reset ();
  41     }
  42
  43   return *this;
  44 }
  45
  46 ACE_INLINE
  47 ACE_Handle_Set::ACE_Handle_Set (const ACE_Handle_Set &rhs)
  48 {
  49   ACE_TRACE ("ACE_Handle_Set::ACE_Handle_Set");
  50
  51   if (rhs.size_ > 0)
  52     {
  53       this->size_ = rhs.size_;
  54       this->max_handle_ = rhs.max_handle_;
  55       this->min_handle_ = rhs.min_handle_;
  56       this->mask_ = rhs.mask_;
  57     }
  58   else
  59     {
  60       this->reset ();
  61     }
  62 }
  63 #endif /* ACE_HAS_BIG_FD_SET */
  64
  65 /// Returns the number of the large bit.
  66 ACE_INLINE ACE_HANDLE
  67 ACE_Handle_Set::max_set () const
  68 {
  69   ACE_TRACE ("ACE_Handle_Set::max_set");
  70   return this->max_handle_;
  71 }
  72
  73 /// Checks whether handle is enabled.
  74 ACE_INLINE int
  75 ACE_Handle_Set::is_set (ACE_HANDLE handle) const
  76 {
  77   ACE_TRACE ("ACE_Handle_Set::is_set");
  78
  79   fd_set *set = const_cast<fd_set*> (&this->mask_);
  80   int ret = FD_ISSET (handle, set);
  81
  82 #if defined (ACE_HAS_BIG_FD_SET)
  83   ret = ret && this->size_ > 0;
  84 #elif defined (ACE_VXWORKS) && ACE_VXWORKS >= 0x690
  85   ret = ret != 0;
  86 #endif
  87   return ret;
  88 }
  89
  90 /// Enables the handle.
  91 ACE_INLINE void
  92 ACE_Handle_Set::set_bit (ACE_HANDLE handle)
  93 {
  94   ACE_TRACE ("ACE_Handle_Set::set_bit");
  95   if ((handle != ACE_INVALID_HANDLE)
  96       && (!this->is_set (handle)))
  97     {
  98 #if defined (ACE_HANDLE_SET_USES_FD_ARRAY)
  99       FD_SET ((SOCKET) handle,
 100               &this->mask_);
 101       ++this->size_;
 102 #else /* ACE_HANDLE_SET_USES_FD_ARRAY */
 103 #if defined (ACE_HAS_BIG_FD_SET)
 104       if (this->size_ == 0)
 105         FD_ZERO (&this->mask_);
 106
 107       if (handle < this->min_handle_)
 108         this->min_handle_ = handle;
 109 #endif /* ACE_HAS_BIG_FD_SET */
 110
 111       FD_SET (handle,
 112               &this->mask_);
 113       ++this->size_;
 114
 115       if (handle > this->max_handle_)
 116         this->max_handle_ = handle;
 117 #endif /* ACE_HANDLE_SET_USES_FD_ARRAY */
 118     }
 119 }
 120
 121 /// Disables the handle.
 122 ACE_INLINE void
 123 ACE_Handle_Set::clr_bit (ACE_HANDLE handle)
 124 {
 125   ACE_TRACE ("ACE_Handle_Set::clr_bit");
 126
 127   if ((handle != ACE_INVALID_HANDLE) &&
 128       (this->is_set (handle)))
 129     {
 130       FD_CLR ((ACE_SOCKET) handle,
 131               &this->mask_);
 132       --this->size_;
 133
 134 #if !defined (ACE_HANDLE_SET_USES_FD_ARRAY)
 135       if (handle == this->max_handle_)
 136         this->set_max (this->max_handle_);
 137 #endif /* !ACE_HANDLE_SET_USES_FD_ARRAY */
 138     }
 139 }
 140
 141 /// Returns a count of the number of enabled bits.
 142 ACE_INLINE int
 143 ACE_Handle_Set::num_set () const
 144 {
 145   ACE_TRACE ("ACE_Handle_Set::num_set");
 146 #if defined (ACE_HANDLE_SET_USES_FD_ARRAY)
 147   return this->mask_.fd_count;
 148 #else /* !ACE_HANDLE_SET_USES_FD_ARRAY */
 149   return this->size_;
 150 #endif /* ACE_HANDLE_SET_USES_FD_ARRAY */
 151 }
 152
 153 /// Returns a pointer to the underlying fd_set.
 154 ACE_INLINE
 155 ACE_Handle_Set::operator fd_set *()
 156 {
 157   ACE_TRACE ("ACE_Handle_Set::operator fd_set *");
 158
 159   if (this->size_ > 0)
 160     return (fd_set *) &this->mask_;
 161   else
 162     return nullptr;
 163 }
 164
 165 /// Returns a pointer to the underlying fd_set.
 166 ACE_INLINE fd_set *
 167 ACE_Handle_Set::fdset ()
 168 {
 169   ACE_TRACE ("ACE_Handle_Set::fdset");
 170
 171   if (this->size_ > 0)
 172     return (fd_set *) &this->mask_;
 173   else
 174     return nullptr;
 175 }
 176
 177 ACE_END_VERSIONED_NAMESPACE_DECL