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 */ 247