1/*
  2 * Copyright 2001-2007, Haiku.
  3 * Distributed under the terms of the MIT License.
  4 *
  5 * Authors:
  6 *		DarkWyrm <bpmagic@columbus.rr.com>
  7 *		Pahtz <pahtz@yahoo.com.au>
  8 *		Axel Dörfler, axeld@pinc-software.de
  9 */
 10#ifndef _SERVER_LINK_H
 11#define _SERVER_LINK_H
 12
 13
 14#include <OS.h>
 15#include <LinkReceiver.h>
 16#include <LinkSender.h>
 17
 18class BShape;
 19class BString;
 20class BGradient;
 21
 22/*
 23 * Error checking rules: (for if you don't want to check every return code)
 24 * - Calling EndMessage() is optional, implied by Flush() or StartMessage().
 25 * - If you are sending just one message you only need to test Flush() == B_OK
 26 * - If you are buffering multiple messages without calling Flush() you must
 27 *   check EndMessage() == B_OK, or the last Attach() for each message.
 28 *   Check Flush() at the end.
 29 * - If you are reading, check the last Read() or ReadString() you perform.
 30 */
 31
 32namespace BPrivate {
 33
 34class ServerLink {
 35public:
 36								ServerLink();
 37	virtual						~ServerLink();
 38
 39			void				SetTo(port_id sender, port_id receiver);
 40
 41	// send methods
 42
 43			void				SetSenderPort(port_id port);
 44			port_id				SenderPort();
 45
 46			void				SetTargetTeam(team_id team);
 47			team_id				TargetTeam();
 48
 49			status_t			StartMessage(int32 code, size_t minSize = 0);
 50			void				CancelMessage();
 51			status_t			EndMessage();
 52
 53			status_t			Flush(bigtime_t timeout = B_INFINITE_TIMEOUT,
 54									bool needsReply = false);
 55			status_t			Attach(const void* data, ssize_t size);
 56			status_t			AttachString(const char* string,
 57									int32 length = -1);
 58			status_t			AttachRegion(const BRegion& region);
 59			status_t			AttachShape(BShape& shape);
 60			status_t			AttachGradient(const BGradient& gradient);
 61
 62			template <class Type>
 63			status_t			Attach(const Type& data);
 64
 65	// receive methods
 66
 67			void				SetReceiverPort(port_id port);
 68			port_id				ReceiverPort();
 69
 70			status_t			GetNextMessage(int32& code,
 71									bigtime_t timeout = B_INFINITE_TIMEOUT);
 72			bool				NeedsReply() const;
 73			status_t			Read(void* data, ssize_t size);
 74			status_t			ReadString(char* buffer, size_t bufferSize);
 75			status_t			ReadString(BString& string,
 76									size_t* _length = NULL);
 77			status_t			ReadString(char** _string,
 78									size_t* _length = NULL);
 79			status_t			ReadRegion(BRegion* region);
 80			status_t			ReadShape(BShape* shape);
 81			status_t			ReadGradient(BGradient** _gradient);
 82			
 83			template <class Type>
 84			status_t			Read(Type* data);
 85
 86	// convenience methods
 87
 88			status_t			FlushWithReply(int32& code);
 89			LinkSender&			Sender() { return *fSender; }
 90			LinkReceiver&		Receiver() { return *fReceiver; }
 91
 92protected:
 93			LinkSender*			fSender;
 94			LinkReceiver*		fReceiver;
 95};
 96
 97
 98// #pragma mark - sender inline functions
 99
100
101inline void
102ServerLink::SetSenderPort(port_id port)
103{
104	fSender->SetPort(port);
105}
106
107
108inline port_id
109ServerLink::SenderPort()
110{
111	return fSender->Port();
112}
113
114
115inline void
116ServerLink::SetTargetTeam(team_id team)
117{
118	fSender->SetTargetTeam(team);
119}
120
121
122inline team_id
123ServerLink::TargetTeam()
124{
125	return fSender->TargetTeam();
126}
127
128
129inline status_t
130ServerLink::StartMessage(int32 code, size_t minSize)
131{
132	return fSender->StartMessage(code, minSize);
133}
134
135
136inline status_t
137ServerLink::EndMessage()
138{
139	return fSender->EndMessage();
140}
141
142
143inline void
144ServerLink::CancelMessage()
145{
146	fSender->CancelMessage();
147}
148
149
150inline status_t
151ServerLink::Flush(bigtime_t timeout, bool needsReply)
152{
153	return fSender->Flush(timeout, needsReply);
154}
155
156
157inline status_t
158ServerLink::Attach(const void* data, ssize_t size)
159{
160	return fSender->Attach(data, size);
161}
162
163
164inline status_t
165ServerLink::AttachString(const char* string, int32 length)
166{
167	return fSender->AttachString(string, length);
168}
169
170
171template<class Type> status_t
172ServerLink::Attach(const Type& data)
173{
174	return Attach(&data, sizeof(Type));
175}
176
177
178// #pragma mark - receiver inline functions
179
180
181inline void
182ServerLink::SetReceiverPort(port_id port)
183{
184	fReceiver->SetPort(port);
185}
186
187
188inline port_id
189ServerLink::ReceiverPort()
190{
191	return fReceiver->Port();
192}
193
194
195inline status_t
196ServerLink::GetNextMessage(int32& code, bigtime_t timeout)
197{
198	return fReceiver->GetNextMessage(code, timeout);
199}
200
201
202inline bool
203ServerLink::NeedsReply() const
204{
205	return fReceiver->NeedsReply();
206}
207
208
209inline status_t
210ServerLink::Read(void* data, ssize_t size)
211{
212	return fReceiver->Read(data, size);
213}
214
215
216inline status_t
217ServerLink::ReadString(char* buffer, size_t bufferSize)
218{
219	return fReceiver->ReadString(buffer, bufferSize);
220}
221
222
223inline status_t
224ServerLink::ReadString(BString& string, size_t* _length)
225{
226	return fReceiver->ReadString(string, _length);
227}
228
229
230inline status_t
231ServerLink::ReadString(char** _string, size_t* _length)
232{
233	return fReceiver->ReadString(_string, _length);
234}
235
236
237template <class Type> status_t
238ServerLink::Read(Type* data)
239{
240	return Read(data, sizeof(Type));
241}
242
243
244}	// namespace BPrivate
245
246#endif	/* _SERVER_LINK_H */