ACE/ace/SV_Semaphore_Simple.inl

   1 // -*- C++ -*-
   2 #include "ace/Global_Macros.h"
   3 #include "ace/OS_NS_Thread.h"
   4
   5 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   6
   7 #if defined (ACE_HAS_WCHAR)
   8 // Semaphores don't offer wide-char names, so convert the name and forward
   9 // to the narrow-char open().
  10 ACE_INLINE int
  11 ACE_SV_Semaphore_Simple::open (const wchar_t *name,
  12                                short flags,
  13                                int initial_value,
  14                                u_short nsems,
  15                                mode_t perms)
  16 {
  17   ACE_TRACE ("ACE_SV_Semaphore_Simple::open (wchar_t)");
  18   return this->open (ACE_Wide_To_Ascii (name).char_rep (),
  19                      flags,
  20                      initial_value,
  21                      nsems,
  22                      perms);
  23 }
  24 #endif /* ACE_HAS_WCHAR */
  25
  26 ACE_INLINE int
  27 ACE_SV_Semaphore_Simple::control (int cmd,
  28                                   semun arg,
  29                                   u_short n) const
  30 {
  31   ACE_TRACE ("ACE_SV_Semaphore_Simple::control");
  32   return this->internal_id_ == -1 ?
  33     -1 : ACE_OS::semctl (this->internal_id_, n, cmd, arg);
  34 }
  35
  36 // Close a ACE_SV_Semaphore, marking it as invalid for subsequent
  37 // operations...
  38
  39 ACE_INLINE int
  40 ACE_SV_Semaphore_Simple::close (void)
  41 {
  42   ACE_TRACE ("ACE_SV_Semaphore_Simple::close");
  43 #ifdef ACE_HAS_SYSV_IPC
  44   return this->init ();
  45 #else
  46   ACE_NOTSUP_RETURN (-1);
  47 #endif
  48 }
  49
  50 // General ACE_SV_Semaphore operation on an array of SV_Semaphores.
  51
  52 ACE_INLINE int
  53 ACE_SV_Semaphore_Simple::op (sembuf op_vec[], u_short n) const
  54 {
  55   ACE_TRACE ("ACE_SV_Semaphore_Simple::op");
  56   return this->internal_id_ == -1
  57     ? -1 : ACE_OS::semop (this->internal_id_, op_vec, n);
  58 }
  59
  60 // Wait until a ACE_SV_Semaphore's value is greater than 0, the
  61 // decrement it by 1 and return. Dijkstra's P operation, Tannenbaums
  62 // DOWN operation.
  63
  64 ACE_INLINE int
  65 ACE_SV_Semaphore_Simple::acquire (u_short n, short flags) const
  66 {
  67   ACE_TRACE ("ACE_SV_Semaphore_Simple::acquire");
  68   return this->op (-1, n, flags);
  69 }
  70
  71 ACE_INLINE int
  72 ACE_SV_Semaphore_Simple::acquire_read (u_short n, short flags) const
  73 {
  74   ACE_TRACE ("ACE_SV_Semaphore_Simple::acquire_read");
  75   return this->acquire (n, flags);
  76 }
  77
  78 ACE_INLINE int
  79 ACE_SV_Semaphore_Simple::acquire_write (u_short n, short flags) const
  80 {
  81   ACE_TRACE ("ACE_SV_Semaphore_Simple::acquire_write");
  82   return this->acquire (n, flags);
  83 }
  84
  85 // Non-blocking version of acquire().
  86
  87 ACE_INLINE int
  88 ACE_SV_Semaphore_Simple::tryacquire (u_short n, short flags) const
  89 {
  90   ACE_TRACE ("ACE_SV_Semaphore_Simple::tryacquire");
  91   return this->op (-1, n, flags | IPC_NOWAIT);
  92 }
  93
  94 // Non-blocking version of acquire().
  95
  96 ACE_INLINE int
  97 ACE_SV_Semaphore_Simple::tryacquire_read (u_short n, short flags) const
  98 {
  99   ACE_TRACE ("ACE_SV_Semaphore_Simple::tryacquire_read");
 100   return this->tryacquire (n, flags);
 101 }
 102
 103 // Non-blocking version of acquire().
 104
 105 ACE_INLINE int
 106 ACE_SV_Semaphore_Simple::tryacquire_write (u_short n, short flags) const
 107 {
 108   ACE_TRACE ("ACE_SV_Semaphore_Simple::tryacquire_write");
 109   return this->tryacquire (n, flags);
 110 }
 111
 112 // Increment ACE_SV_Semaphore by one. Dijkstra's V operation,
 113 // Tannenbaums UP operation.
 114
 115 ACE_INLINE int
 116 ACE_SV_Semaphore_Simple::release (u_short n, short flags) const
 117 {
 118   ACE_TRACE ("ACE_SV_Semaphore_Simple::release");
 119   return this->op (1, n, flags);
 120 }
 121
 122 ACE_INLINE int
 123 ACE_SV_Semaphore_Simple::get_id (void) const
 124 {
 125   ACE_TRACE ("ACE_SV_Semaphore_Simple::get_id");
 126   return this->internal_id_;
 127 }
 128
 129 ACE_END_VERSIONED_NAMESPACE_DECL