summaryrefslogtreecommitdiff
path: root/ACE/ace/Handle_Set.h
diff options
context:
space:
mode:
Diffstat (limited to 'ACE/ace/Handle_Set.h')
-rw-r--r--ACE/ace/Handle_Set.h247
1 files changed, 247 insertions, 0 deletions
diff --git a/ACE/ace/Handle_Set.h b/ACE/ace/Handle_Set.h
new file mode 100644
index 00000000000..023db731e57
--- /dev/null
+++ b/ACE/ace/Handle_Set.h
@@ -0,0 +1,247 @@
+/* -*- C++ -*- */
+
+//=============================================================================
+/**
+ * @file Handle_Set.h
+ *
+ * $Id$
+ *
+ * @author Douglas C. Schmidt <schmidt@cs.wustl.edu>
+ */
+//=============================================================================
+
+#ifndef ACE_HANDLE_SET_H
+#define ACE_HANDLE_SET_H
+#include /**/ "ace/pre.h"
+
+#include "ace/ACE_export.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/os_include/sys/os_select.h"
+#include "ace/os_include/os_limits.h"
+
+#if defined (__QNX__)
+ typedef long fd_mask;
+#endif /* __QNX__ */
+
+// Default size of the ACE Reactor.
+#if defined (FD_SETSIZE)
+ int const ACE_FD_SETSIZE = FD_SETSIZE;
+#else /* !FD_SETSIZE */
+# define ACE_FD_SETSIZE FD_SETSIZE
+#endif /* ACE_FD_SETSIZE */
+
+#if !defined (ACE_DEFAULT_SELECT_REACTOR_SIZE)
+# define ACE_DEFAULT_SELECT_REACTOR_SIZE ACE_FD_SETSIZE
+#endif /* ACE_DEFAULT_SELECT_REACTOR_SIZE */
+
+ACE_BEGIN_VERSIONED_NAMESPACE_DECL
+
+/**
+ * @class ACE_Handle_Set
+ *
+ * @brief C++ wrapper facade for the socket <fd_set> abstraction.
+ *
+ * This abstraction is a very efficient wrapper facade over
+ * <fd_set>. In particular, no range checking is performed, so
+ * it's important not to set or clear bits that are outside the
+ * <ACE_DEFAULT_SELECT_REACTOR_SIZE>.
+ */
+class ACE_Export ACE_Handle_Set
+{
+public:
+ friend class ACE_Handle_Set_Iterator;
+
+ // = Initialization and termination.
+
+ enum
+ {
+ MAXSIZE = ACE_DEFAULT_SELECT_REACTOR_SIZE
+ };
+
+ // = Initialization methods.
+ /// Constructor, initializes the bitmask to all 0s.
+ ACE_Handle_Set (void);
+
+ /**
+ * Constructor, initializes the handle set from a given mask.
+ * <ACE_FD_SET_TYPE> is a <typedef> based on the platform's native
+ * type used for masks passed to <select>.
+ */
+ ACE_Handle_Set (const ACE_FD_SET_TYPE &mask);
+
+ // = Methods for manipulating bitsets.
+ /// Initialize the bitmask to all 0s and reset the associated fields.
+ void reset (void);
+
+ /**
+ * Checks whether <handle> is enabled. No range checking is
+ * performed so <handle> must be less than
+ * <ACE_DEFAULT_SELECT_REACTOR_SIZE>.
+ */
+ int is_set (ACE_HANDLE handle) const;
+
+ /// Enables the <handle>. No range checking is performed so <handle>
+ /// must be less than <ACE_DEFAULT_SELECT_REACTOR_SIZE>.
+ void set_bit (ACE_HANDLE handle);
+
+ /// Disables the <handle>. No range checking is performed so
+ /// <handle> must be less than <ACE_DEFAULT_SELECT_REACTOR_SIZE>.
+ void clr_bit (ACE_HANDLE handle);
+
+ /// Returns a count of the number of enabled bits.
+ int num_set (void) const;
+
+ /// Returns the number of the large bit.
+ ACE_HANDLE max_set (void) const;
+
+ /**
+ * Rescan the underlying <fd_set> up to handle <max> to find the new
+ * <max_handle> (highest bit set) and <size> (how many bits set) values.
+ * This is useful for evaluating the changes after the handle set has
+ * been manipulated in some way other than member functions; for example,
+ * after <select> modifies the <fd_set>.
+ */
+ void sync (ACE_HANDLE max);
+
+ /// Returns a pointer to the underlying <fd_set>. Returns 0 if
+ /// there are no handle bits set (<size_> == 0).
+ operator fd_set *();
+
+ /// Returns a pointer to the underlying <fd_set>. Returns 0 if
+ /// there are no handle bits set (<size_> == 0).
+ fd_set *fdset (void);
+
+#if defined (ACE_HAS_BIG_FD_SET)
+ /// Assignment operator optimizes for cases where <size_> == 0.
+ ACE_Handle_Set & operator= (const ACE_Handle_Set &);
+#endif /* ACE_HAS_BIG_FD_SET */
+
+ /// Dump the state of an object.
+ void dump (void) const;
+
+ /// Declare the dynamic allocation hooks.
+ ACE_ALLOC_HOOK_DECLARE;
+
+private:
+ /// Size of the set, i.e., a count of the number of enabled bits.
+ int size_;
+
+ /// Current max handle.
+ ACE_HANDLE max_handle_;
+
+#if defined (ACE_HAS_BIG_FD_SET)
+ /// Current min handle.
+ ACE_HANDLE min_handle_;
+#endif /* ACE_HAS_BIG_FD_SET */
+
+ /// Bitmask.
+ fd_set mask_;
+
+ enum
+ {
+ WORDSIZE = NFDBITS,
+#if !defined (ACE_WIN32)
+ NUM_WORDS = howmany (MAXSIZE, NFDBITS),
+#endif /* ACE_WIN32 */
+ NBITS = 256
+ };
+
+ /// Counts the number of bits enabled in N. Uses a table lookup to
+ /// speed up the count.
+ static int count_bits (u_long n);
+
+#if defined (ACE_HAS_BIG_FD_SET)
+ /// Find the position of the bit counting from right to left.
+ static int bitpos (u_long bit);
+#endif /* ACE_HAS_BIG_FD_SET */
+
+ /// Resets the <max_handle_> after a clear of the original
+ /// <max_handle_>.
+ void set_max (ACE_HANDLE max);
+
+ /// Table that maps bytes to counts of the enabled bits in each value
+ /// from 0 to 255.
+ static const char nbits_[NBITS];
+};
+
+/**
+ * @class ACE_Handle_Set_Iterator
+ *
+ * @brief Iterator for the ACE_Handle_Set abstraction.
+ */
+class ACE_Export ACE_Handle_Set_Iterator
+{
+public:
+ /// Constructor.
+ ACE_Handle_Set_Iterator (const ACE_Handle_Set &hs);
+
+ /// Default dtor.
+ ~ACE_Handle_Set_Iterator (void);
+
+ /// Reset the state of the iterator by reinitializing the state
+ /// that we maintain.
+ void reset_state (void);
+
+ /**
+ * "Next" operator. Returns the next unseen ACE_HANDLE in the
+ * <Handle_Set> up to <handle_set_.max_handle_>). When all the
+ * handles have been seen returns <ACE_INVALID_HANDLE>. Advances
+ * the iterator automatically, so you need not call <operator++>
+ * (which is now obsolete).
+ */
+ ACE_HANDLE operator () (void);
+
+ /// This is a no-op and no longer does anything. It's only here for
+ /// backwards compatibility.
+ /// @deprecated
+ void operator++ (void);
+
+ /// Dump the state of an object.
+ void dump (void) const;
+
+ /// Declare the dynamic allocation hooks.
+ ACE_ALLOC_HOOK_DECLARE;
+
+private:
+ /// The <Handle_Set> we are iterating through.
+ const ACE_Handle_Set &handles_;
+
+ /// Index of the bit we're examining in the current <word_num_> word.
+#if defined (ACE_WIN32)
+ u_int handle_index_;
+#elif !defined (ACE_HAS_BIG_FD_SET)
+ int handle_index_;
+#elif defined (ACE_HAS_BIG_FD_SET)
+ int handle_index_;
+ u_long oldlsb_;
+#endif /* ACE_WIN32 */
+
+ /// Number of the word we're iterating over (typically between 0..7).
+ int word_num_;
+
+#if defined (ACE_HAS_BIG_FD_SET)
+ /// Number max of the words with a possible bit on.
+ int word_max_;
+#endif /* ACE_HAS_BIG_FD_SET */
+
+#if !defined (ACE_WIN32) && !defined (ACE_HAS_BIG_FD_SET)
+ /// Value of the bits in the word we're iterating on.
+ fd_mask word_val_;
+#elif !defined (ACE_WIN32) && defined (ACE_HAS_BIG_FD_SET)
+ /// Value of the bits in the word we're iterating on.
+ u_long word_val_;
+#endif /* !ACE_WIN32 && !ACE_HAS_BIG_FD_SET */
+};
+
+ACE_END_VERSIONED_NAMESPACE_DECL
+
+#if defined (__ACE_INLINE__)
+#include "ace/Handle_Set.inl"
+#endif /* __ACE_INLINE__ */
+
+#include /**/ "ace/post.h"
+#endif /* ACE_HANDLE_SET */