338b8dc301
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@14574 a95241bf-73f2-0310-859d-f6bbb57e9c96
191 lines
3.8 KiB
C++
191 lines
3.8 KiB
C++
/*
|
|
* Copyright 2001-2005, Haiku.
|
|
* Distributed under the terms of the MIT License.
|
|
*
|
|
* Authors:
|
|
* DarkWyrm <bpmagic@columbus.rr.com>
|
|
* Pahtz <pahtz@yahoo.com.au>
|
|
* Axel Dörfler, axeld@pinc-software.de
|
|
*/
|
|
#ifndef _PORTLINK_H
|
|
#define _PORTLINK_H
|
|
|
|
#include <OS.h>
|
|
#include <LinkMsgReader.h>
|
|
#include <LinkMsgSender.h>
|
|
|
|
/*
|
|
Error checking rules: (for if you don't want to check every return code)
|
|
|
|
Calling EndMessage() is optional, implied by Flush() or StartMessage().
|
|
|
|
If you are sending just one message you only need to test Flush() == B_OK
|
|
|
|
If you are buffering multiple messages without calling Flush() you must
|
|
check EndMessage() == B_OK, or the last Attach() for each message. Check
|
|
Flush() at the end.
|
|
|
|
If you are reading, check the last Read() or ReadString() you perform.
|
|
|
|
*/
|
|
|
|
namespace BPrivate {
|
|
|
|
class ServerLink {
|
|
public:
|
|
ServerLink();
|
|
virtual ~ServerLink();
|
|
|
|
// send methods
|
|
|
|
void SetSenderPort(port_id port);
|
|
port_id SenderPort();
|
|
|
|
status_t StartMessage(int32 code, size_t minSize = 0);
|
|
void CancelMessage();
|
|
status_t EndMessage();
|
|
|
|
status_t Flush(bigtime_t timeout = B_INFINITE_TIMEOUT, bool needsReply = false);
|
|
status_t Attach(const void *data, ssize_t size);
|
|
status_t AttachString(const char *string, int32 length = -1);
|
|
status_t AttachRegion(const BRegion ®ion);
|
|
status_t AttachShape(BShape &shape);
|
|
template <class Type> status_t Attach(const Type& data);
|
|
|
|
// receive methods
|
|
|
|
void SetReceiverPort(port_id port);
|
|
port_id ReceiverPort();
|
|
|
|
status_t GetNextMessage(int32 &code, bigtime_t timeout = B_INFINITE_TIMEOUT);
|
|
bool NeedsReply() const;
|
|
status_t Read(void *data, ssize_t size);
|
|
status_t ReadString(char **string);
|
|
status_t ReadRegion(BRegion *region);
|
|
status_t ReadShape(BShape *shape);
|
|
template <class Type> status_t Read(Type *data);
|
|
|
|
// convenience methods
|
|
|
|
status_t FlushWithReply(int32 &code);
|
|
LinkSender &Sender() { return *fSender; }
|
|
LinkReceiver &Receiver() { return *fReceiver; }
|
|
|
|
protected:
|
|
LinkSender *fSender;
|
|
LinkReceiver *fReceiver;
|
|
};
|
|
|
|
class PortLink : public ServerLink {
|
|
public:
|
|
PortLink(port_id sender = -1, port_id receiver = -1);
|
|
virtual ~PortLink();
|
|
|
|
void SetTo(port_id sender, port_id receiver);
|
|
};
|
|
|
|
|
|
// sender inline functions
|
|
|
|
inline void
|
|
ServerLink::SetSenderPort(port_id port)
|
|
{
|
|
fSender->SetPort(port);
|
|
}
|
|
|
|
inline port_id
|
|
ServerLink::SenderPort()
|
|
{
|
|
return fSender->Port();
|
|
}
|
|
|
|
inline status_t
|
|
ServerLink::StartMessage(int32 code, size_t minSize)
|
|
{
|
|
return fSender->StartMessage(code, minSize);
|
|
}
|
|
|
|
inline status_t
|
|
ServerLink::EndMessage()
|
|
{
|
|
return fSender->EndMessage();
|
|
}
|
|
|
|
inline void
|
|
ServerLink::CancelMessage()
|
|
{
|
|
fSender->CancelMessage();
|
|
}
|
|
|
|
inline status_t
|
|
ServerLink::Flush(bigtime_t timeout, bool needsReply)
|
|
{
|
|
return fSender->Flush(timeout, needsReply);
|
|
}
|
|
|
|
inline status_t
|
|
ServerLink::Attach(const void *data, ssize_t size)
|
|
{
|
|
return fSender->Attach(data, size);
|
|
}
|
|
|
|
inline status_t
|
|
ServerLink::AttachString(const char *string, int32 length)
|
|
{
|
|
return fSender->AttachString(string, length);
|
|
}
|
|
|
|
template<class Type> status_t
|
|
ServerLink::Attach(const Type &data)
|
|
{
|
|
return Attach(&data, sizeof(Type));
|
|
}
|
|
|
|
// #pragma mark - receiver inline functions
|
|
|
|
inline void
|
|
ServerLink::SetReceiverPort(port_id port)
|
|
{
|
|
fReceiver->SetPort(port);
|
|
}
|
|
|
|
inline port_id
|
|
ServerLink::ReceiverPort()
|
|
{
|
|
return fReceiver->Port();
|
|
}
|
|
|
|
inline status_t
|
|
ServerLink::GetNextMessage(int32 &code, bigtime_t timeout)
|
|
{
|
|
return fReceiver->GetNextMessage(code, timeout);
|
|
}
|
|
|
|
inline bool
|
|
ServerLink::NeedsReply() const
|
|
{
|
|
return fReceiver->NeedsReply();
|
|
}
|
|
|
|
inline status_t
|
|
ServerLink::Read(void *data, ssize_t size)
|
|
{
|
|
return fReceiver->Read(data, size);
|
|
}
|
|
|
|
inline status_t
|
|
ServerLink::ReadString(char **string)
|
|
{
|
|
return fReceiver->ReadString(string);
|
|
}
|
|
|
|
template <class Type> status_t
|
|
ServerLink::Read(Type *data)
|
|
{
|
|
return Read(data, sizeof(Type));
|
|
}
|
|
|
|
} // namespace BPrivate
|
|
|
|
#endif /* _PORTLINK_H */
|