source: rtems/c/src/librtems++/include/rtems++/rtemsMessageQueue.h @ c499856

4.115
Last change on this file since c499856 was c499856, checked in by Chris Johns <chrisj@…>, on Mar 20, 2014 at 9:10:47 PM

Change all references of rtems.com to rtems.org.

  • Property mode set to 100644
File size: 6.3 KB
Line 
1/*
2  ------------------------------------------------------------------------
3
4  COPYRIGHT (c) 1997
5  Objective Design Systems Ltd Pty (ODS)
6  All rights reserved (R) Objective Design Systems Ltd Pty
7
8  The license and distribution terms for this file may be found in the
9  file LICENSE in this distribution or at
10  http://www.rtems.org/license/LICENSE.
11
12  ------------------------------------------------------------------------
13
14  rtemsMessageQueue class.
15
16  This class allows the user to create a RTEMS message queue, or to
17  access and manage an already existing message queue.
18
19  The first constructor with the message queue parameters creates a
20  RTEMS message queue object. The destructor of this object also
21  deletes the message queue object. The last status code should be
22  checked after construction to see if the create completed
23  successfully.
24
25  The second constructor connects to an existing message queue
26  object. The last status code should be checked after construction to
27  see if the message queue existed.
28
29  The third constructor is a copy constructor. Connects to an existing
30  object which is in scope.
31
32  The fourth constructor allows for the message queue to be created
33  after construction, or to connect to a message queue later.
34
35  ------------------------------------------------------------------------ */
36
37#if !defined(_rtemsMessageQueue_h_)
38#define _rtemsMessageQueue_h_
39
40#include <rtems++/rtemsStatusCode.h>
41
42/* ----
43    rtemsMessageQueue
44*/
45
46class rtemsMessageQueue
47  : public rtemsStatusCode
48{
49public:
50  // attribute a message queue can have
51  enum WaitMode { wait_by_fifo = RTEMS_FIFO,
52                  wait_by_priority = RTEMS_PRIORITY };
53  enum Scope { local = RTEMS_LOCAL,
54               global = RTEMS_GLOBAL };
55
56  // only the first 4 characters of the name are taken
57
58  // creates a message queue
59  rtemsMessageQueue(const char* name,
60                    const uint32_t count,
61                    const size_t max_message_size,
62                    const WaitMode wait_mode = wait_by_fifo,
63                    const Scope scope = local);
64
65  // connects to a message queue
66  rtemsMessageQueue(const char *name, const uint32_t node = RTEMS_SEARCH_ALL_NODES);
67
68  // copy and default constructors
69  rtemsMessageQueue(const rtemsMessageQueue& message_queue);
70  rtemsMessageQueue();
71
72  // only the creator's destructor will delete the actual object
73  virtual ~rtemsMessageQueue();
74
75  // create or destroy (delete) the message queue
76  virtual const rtems_status_code create(const char* name,
77                                         const uint32_t count,
78                                         const size_t max_message_size,
79                                         const WaitMode wait_mode = wait_by_fifo,
80                                         const Scope scope = local);
81  virtual const rtems_status_code destroy();
82
83  // connect to an existing message queue object, will not be the owner
84  const rtemsMessageQueue& operator=(const rtemsMessageQueue& message_queue);
85  virtual const rtems_status_code connect(const char *name,
86                                          const uint32_t node = RTEMS_SEARCH_ALL_NODES);
87
88  // send a message of size from the buffer
89  inline const rtems_status_code send(const void *buffer,
90                                      const size_t size);
91  inline const rtems_status_code urgent(const void *buffer,
92                                        const size_t size);
93  inline const rtems_status_code broadcast(const void *buffer,
94                                           const size_t size,
95                                           uint32_t& count);
96
97  // receive a message of size, the timeout is in micro-secs
98  inline const rtems_status_code receive(const void *buffer,
99                                         size_t& size,
100                                         rtems_interval micro_secs = RTEMS_NO_TIMEOUT,
101                                         bool wait = true);
102
103  // flush a message queue, returning the number of messages dropped
104  inline const rtems_status_code flush(uint32_t& size);
105
106  // object id, and name
107  const rtems_id id_is() const { return id; }
108  const rtems_name name_is() const { return name; }
109  const char *name_string() const { return name_str; }
110
111private:
112
113  // make this object reference an invalid RTEMS object
114  void make_invalid();
115
116  // message queue name
117  rtems_name name;
118  char name_str[5];
119
120  // owner, true if this object owns the message queue
121  // will delete the message queue when it destructs
122  bool owner;
123
124  // the rtems id, object handle
125  rtems_id id;
126};
127
128const rtems_status_code rtemsMessageQueue::send(const void *buffer,
129                                                const size_t size)
130{
131  return set_status_code(rtems_message_queue_send(id, (void*) buffer, size));
132}
133
134const rtems_status_code rtemsMessageQueue::urgent(const void *buffer,
135                                                  const size_t size)
136{
137  return set_status_code(rtems_message_queue_urgent(id, (void*) buffer, size));
138}
139
140const rtems_status_code rtemsMessageQueue::broadcast(const void *buffer,
141                                                     const size_t size,
142                                                     uint32_t& count)
143{
144  return set_status_code(rtems_message_queue_broadcast(id,
145                                                       (void*) buffer,
146                                                       size,
147                                                       &count));
148}
149
150const rtems_status_code rtemsMessageQueue::receive(const void *buffer,
151                                                   size_t& size,
152                                                   rtems_interval micro_secs,
153                                                   bool wait)
154{
155  rtems_interval usecs = micro_secs &&
156    (micro_secs < rtems_configuration_get_microseconds_per_tick()) ?
157    rtems_configuration_get_microseconds_per_tick() : micro_secs;
158  return set_status_code(rtems_message_queue_receive(id,
159                                                     (void*) buffer,
160                                                     &size,
161                                                     wait ? RTEMS_WAIT : RTEMS_NO_WAIT,
162                                                     RTEMS_MICROSECONDS_TO_TICKS(usecs)));
163}
164
165const rtems_status_code rtemsMessageQueue::flush(uint32_t& count)
166{
167  return set_status_code(rtems_message_queue_flush(id, &count));
168}
169
170#endif  // _rtemsMessageQueue_h_
Note: See TracBrowser for help on using the repository browser.