Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

no changes, just reformat/indent consistently

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@57797 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2009-01-02 21:58:09 +00:00
parent df21920b80
commit f26d81383f
2 changed files with 192 additions and 194 deletions
Download Patch File Download Diff File Expand all files Collapse all files

382
include/wx/socket.h
View File

@@ -101,178 +101,177 @@ enum wxSocketType
class WXDLLIMPEXP_NET wxSocketBase : public wxObject class WXDLLIMPEXP_NET wxSocketBase : public wxObject
{ {
public: public:
// Public interface
// ----------------
// Public interface // ctors and dtors
// ---------------- wxSocketBase();
wxSocketBase(wxSocketFlags flags, wxSocketType type);
virtual ~wxSocketBase();
void Init();
bool Destroy();
// ctors and dtors // state
wxSocketBase(); bool Ok() const { return IsOk(); }
wxSocketBase(wxSocketFlags flags, wxSocketType type); bool IsOk() const { return m_impl != NULL; }
virtual ~wxSocketBase(); bool Error() const { return LastError() != wxSOCKET_NOERROR; }
void Init(); bool IsClosed() const { return m_closed; }
bool Destroy(); bool IsConnected() const { return m_connected; }
bool IsData() { return WaitForRead(0, 0); }
bool IsDisconnected() const { return !IsConnected(); }
wxUint32 LastCount() const { return m_lcount; }
wxSocketError LastError() const;
void SaveState();
void RestoreState();
// state // addresses
bool Ok() const { return IsOk(); } virtual bool GetLocal(wxSockAddress& addr_man) const;
bool IsOk() const { return m_impl != NULL; } virtual bool GetPeer(wxSockAddress& addr_man) const;
bool Error() const { return LastError() != wxSOCKET_NOERROR; } virtual bool SetLocal(const wxIPV4address& local);
bool IsClosed() const { return m_closed; }
bool IsConnected() const { return m_connected; }
bool IsData() { return WaitForRead(0, 0); }
bool IsDisconnected() const { return !IsConnected(); }
wxUint32 LastCount() const { return m_lcount; }
wxSocketError LastError() const;
void SaveState();
void RestoreState();
// addresses // base IO
virtual bool GetLocal(wxSockAddress& addr_man) const; virtual bool Close();
virtual bool GetPeer(wxSockAddress& addr_man) const; void ShutdownOutput();
virtual bool SetLocal(const wxIPV4address& local); wxSocketBase& Discard();
wxSocketBase& Peek(void* buffer, wxUint32 nbytes);
wxSocketBase& Read(void* buffer, wxUint32 nbytes);
wxSocketBase& ReadMsg(void *buffer, wxUint32 nbytes);
wxSocketBase& Unread(const void *buffer, wxUint32 nbytes);
wxSocketBase& Write(const void *buffer, wxUint32 nbytes);
wxSocketBase& WriteMsg(const void *buffer, wxUint32 nbytes);
// base IO // all Wait() functions wait until their condition is satisfied or the
virtual bool Close(); // timeout expires; if seconds == -1 (default) then m_timeout value is used
void ShutdownOutput(); //
wxSocketBase& Discard(); // it is also possible to call InterruptWait() to cancel any current Wait()
wxSocketBase& Peek(void* buffer, wxUint32 nbytes);
wxSocketBase& Read(void* buffer, wxUint32 nbytes);
wxSocketBase& ReadMsg(void *buffer, wxUint32 nbytes);
wxSocketBase& Unread(const void *buffer, wxUint32 nbytes);
wxSocketBase& Write(const void *buffer, wxUint32 nbytes);
wxSocketBase& WriteMsg(const void *buffer, wxUint32 nbytes);
// all Wait() functions wait until their condition is satisfied or the // wait for anything at all to happen with this socket
// timeout expires; if seconds == -1 (default) then m_timeout value is used bool Wait(long seconds = -1, long milliseconds = 0);
//
// it is also possible to call InterruptWait() to cancel any current Wait()
// wait for anything at all to happen with this socket // wait until we can read from or write to the socket without blocking
bool Wait(long seconds = -1, long milliseconds = 0); // (notice that this does not mean that the operation will succeed but only
// that it will return immediately)
bool WaitForRead(long seconds = -1, long milliseconds = 0);
bool WaitForWrite(long seconds = -1, long milliseconds = 0);
// wait until we can read from or write to the socket without blocking // wait until the connection is terminated
// (notice that this does not mean that the operation will succeed but only bool WaitForLost(long seconds = -1, long milliseconds = 0);
// that it will return immediately)
bool WaitForRead(long seconds = -1, long milliseconds = 0);
bool WaitForWrite(long seconds = -1, long milliseconds = 0);
// wait until the connection is terminated void InterruptWait() { m_interrupt = true; }
bool WaitForLost(long seconds = -1, long milliseconds = 0);
void InterruptWait() { m_interrupt = true; }
wxSocketFlags GetFlags() const { return m_flags; } wxSocketFlags GetFlags() const { return m_flags; }
void SetFlags(wxSocketFlags flags); void SetFlags(wxSocketFlags flags);
void SetTimeout(long seconds); void SetTimeout(long seconds);
long GetTimeout() const { return m_timeout; } long GetTimeout() const { return m_timeout; }
bool GetOption(int level, int optname, void *optval, int *optlen); bool GetOption(int level, int optname, void *optval, int *optlen);
bool SetOption(int level, int optname, const void *optval, int optlen); bool SetOption(int level, int optname, const void *optval, int optlen);
wxUint32 GetLastIOSize() const { return m_lcount; } wxUint32 GetLastIOSize() const { return m_lcount; }
// event handling // event handling
void *GetClientData() const { return m_clientData; } void *GetClientData() const { return m_clientData; }
void SetClientData(void *data) { m_clientData = data; } void SetClientData(void *data) { m_clientData = data; }
void SetEventHandler(wxEvtHandler& handler, int id = wxID_ANY); void SetEventHandler(wxEvtHandler& handler, int id = wxID_ANY);
void SetNotify(wxSocketEventFlags flags); void SetNotify(wxSocketEventFlags flags);
void Notify(bool notify); void Notify(bool notify);
// initialize/shutdown the sockets (usually called automatically) // initialize/shutdown the sockets (usually called automatically)
static bool IsInitialized(); static bool IsInitialized();
static bool Initialize(); static bool Initialize();
static void Shutdown(); static void Shutdown();
// Implementation from now on // Implementation from now on
// -------------------------- // --------------------------
// do not use, should be private (called from wxSocketImpl only) // do not use, should be private (called from wxSocketImpl only)
void OnRequest(wxSocketNotify notify); void OnRequest(wxSocketNotify notify);
// do not use, not documented nor supported // do not use, not documented nor supported
bool IsNoWait() const { return ((m_flags & wxSOCKET_NOWAIT) != 0); } bool IsNoWait() const { return ((m_flags & wxSOCKET_NOWAIT) != 0); }
wxSocketType GetType() const { return m_type; } wxSocketType GetType() const { return m_type; }
private: private:
friend class wxSocketClient; friend class wxSocketClient;
friend class wxSocketServer; friend class wxSocketServer;
friend class wxDatagramSocket; friend class wxDatagramSocket;
// low level IO // low level IO
wxUint32 DoRead(void* buffer, wxUint32 nbytes); wxUint32 DoRead(void* buffer, wxUint32 nbytes);
wxUint32 DoWrite(const void *buffer, wxUint32 nbytes); wxUint32 DoWrite(const void *buffer, wxUint32 nbytes);
// wait until the given flags are set for this socket or the given timeout // wait until the given flags are set for this socket or the given timeout
// (or m_timeout) expires // (or m_timeout) expires
// //
// notice that wxSOCKET_LOST_FLAG is always taken into account but the return // notice that wxSOCKET_LOST_FLAG is always taken into account but the
// value depends on whether it is included in flags or not: if it is, and the // return value depends on whether it is included in flags or not: if it
// connection is indeed lost, true is returned, but if it isn't then the // is, and the connection is indeed lost, true is returned, but if it isn't
// function returns false in this case // then the function returns false in this case
// //
// false is always returned if we returned because of the timeout expiration // false is always returned if we returned because of the timeout expiration
bool DoWait(long timeout, wxSocketEventFlags flags); bool DoWait(long timeout, wxSocketEventFlags flags);
// a helper calling DoWait() using the same convention as the public // a helper calling DoWait() using the same convention as the public
// WaitForXXX() functions use, i.e. use our timeout if seconds == -1 or the // WaitForXXX() functions use, i.e. use our timeout if seconds == -1 or the
// specified timeout otherwise // specified timeout otherwise
bool DoWait(long seconds, long milliseconds, wxSocketEventFlags flags); bool DoWait(long seconds, long milliseconds, wxSocketEventFlags flags);
// another helper calling DoWait() using our m_timeout // another helper calling DoWait() using our m_timeout
bool DoWaitWithTimeout(wxSocketEventFlags flags) bool DoWaitWithTimeout(wxSocketEventFlags flags)
{ {
return DoWait(m_timeout*1000, flags); return DoWait(m_timeout*1000, flags);
} }
// pushback buffer // pushback buffer
void Pushback(const void *buffer, wxUint32 size); void Pushback(const void *buffer, wxUint32 size);
wxUint32 GetPushback(void *buffer, wxUint32 size, bool peek); wxUint32 GetPushback(void *buffer, wxUint32 size, bool peek);
// store the given error as the LastError() // store the given error as the LastError()
void SetError(wxSocketError error); void SetError(wxSocketError error);
private: private:
// socket // socket
wxSocketImpl *m_impl; // port-specific implementation wxSocketImpl *m_impl; // port-specific implementation
wxSocketType m_type; // wxSocket type wxSocketType m_type; // wxSocket type
// state // state
wxSocketFlags m_flags; // wxSocket flags wxSocketFlags m_flags; // wxSocket flags
bool m_connected; // connected? bool m_connected; // connected?
bool m_establishing; // establishing connection? bool m_establishing; // establishing connection?
bool m_reading; // busy reading? bool m_reading; // busy reading?
bool m_writing; // busy writing? bool m_writing; // busy writing?
bool m_closed; // was the other end closed? bool m_closed; // was the other end closed?
wxUint32 m_lcount; // last IO transaction size wxUint32 m_lcount; // last IO transaction size
unsigned long m_timeout; // IO timeout value in seconds unsigned long m_timeout; // IO timeout value in seconds
// (TODO: remove, wxSocketImpl has it too) // (TODO: remove, wxSocketImpl has it too)
wxList m_states; // stack of states (TODO: remove!) wxList m_states; // stack of states (TODO: remove!)
bool m_interrupt; // interrupt ongoing wait operations? bool m_interrupt; // interrupt ongoing wait operations?
bool m_beingDeleted; // marked for delayed deletion? bool m_beingDeleted; // marked for delayed deletion?
wxIPV4address m_localAddress; // bind to local address? wxIPV4address m_localAddress; // bind to local address?
// pushback buffer // pushback buffer
void *m_unread; // pushback buffer void *m_unread; // pushback buffer
wxUint32 m_unrd_size; // pushback buffer size wxUint32 m_unrd_size; // pushback buffer size
wxUint32 m_unrd_cur; // pushback pointer (index into buffer) wxUint32 m_unrd_cur; // pushback pointer (index into buffer)
// events // events
int m_id; // socket id int m_id; // socket id
wxEvtHandler *m_handler; // event handler wxEvtHandler *m_handler; // event handler
void *m_clientData; // client data for events void *m_clientData; // client data for events
bool m_notify; // notify events to users? bool m_notify; // notify events to users?
wxSocketEventFlags m_eventmask; // which events to notify? wxSocketEventFlags m_eventmask; // which events to notify?
wxSocketEventFlags m_eventsgot; // collects events received in OnRequest() wxSocketEventFlags m_eventsgot; // collects events received in OnRequest()
// the initialization count, wxSocket is initialized if > 0 // the initialization count, wxSocket is initialized if > 0
static size_t m_countInit; static size_t m_countInit;
friend class wxSocketReadGuard; friend class wxSocketReadGuard;
friend class wxSocketWriteGuard; friend class wxSocketWriteGuard;
DECLARE_NO_COPY_CLASS(wxSocketBase) DECLARE_NO_COPY_CLASS(wxSocketBase)
DECLARE_CLASS(wxSocketBase) DECLARE_CLASS(wxSocketBase)
}; };
@@ -282,17 +281,17 @@ private:
class WXDLLIMPEXP_NET wxSocketServer : public wxSocketBase class WXDLLIMPEXP_NET wxSocketServer : public wxSocketBase
{ {
DECLARE_CLASS(wxSocketServer)
public: public:
wxSocketServer(const wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE); wxSocketServer(const wxSockAddress& addr,
wxSocketFlags flags = wxSOCKET_NONE);
wxSocketBase* Accept(bool wait = true); wxSocketBase* Accept(bool wait = true);
bool AcceptWith(wxSocketBase& socket, bool wait = true); bool AcceptWith(wxSocketBase& socket, bool wait = true);
bool WaitForAccept(long seconds = -1, long milliseconds = 0); bool WaitForAccept(long seconds = -1, long milliseconds = 0);
DECLARE_NO_COPY_CLASS(wxSocketServer) DECLARE_NO_COPY_CLASS(wxSocketServer)
DECLARE_CLASS(wxSocketServer)
}; };
@@ -302,36 +301,36 @@ public:
class WXDLLIMPEXP_NET wxSocketClient : public wxSocketBase class WXDLLIMPEXP_NET wxSocketClient : public wxSocketBase
{ {
DECLARE_CLASS(wxSocketClient)
public: public:
wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE); wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE);
virtual ~wxSocketClient();
virtual bool Connect(const wxSockAddress& addr, bool wait = true); virtual bool Connect(const wxSockAddress& addr, bool wait = true);
bool Connect(const wxSockAddress& addr, const wxSockAddress& local, bool Connect(const wxSockAddress& addr,
bool wait = true); const wxSockAddress& local,
bool wait = true);
bool WaitOnConnect(long seconds = -1, long milliseconds = 0); bool WaitOnConnect(long seconds = -1, long milliseconds = 0);
// Sets initial socket buffer sizes using the SO_SNDBUF and SO_RCVBUF options // Sets initial socket buffer sizes using the SO_SNDBUF and SO_RCVBUF
// before calling connect (either one can be -1 to leave it unchanged) // options before calling connect (either one can be -1 to leave it
void SetInitialSocketBuffers(int recv, int send) // unchanged)
{ void SetInitialSocketBuffers(int recv, int send)
m_initialRecvBufferSize = recv; {
m_initialSendBufferSize = send; m_initialRecvBufferSize = recv;
} m_initialSendBufferSize = send;
}
private: private:
virtual bool DoConnect(const wxSockAddress& addr, virtual bool DoConnect(const wxSockAddress& addr,
const wxSockAddress* local, const wxSockAddress* local,
bool wait = true); bool wait = true);
// buffer sizes, -1 if unset and defaults should be used // buffer sizes, -1 if unset and defaults should be used
int m_initialRecvBufferSize; int m_initialRecvBufferSize;
int m_initialSendBufferSize; int m_initialSendBufferSize;
DECLARE_NO_COPY_CLASS(wxSocketClient) DECLARE_NO_COPY_CLASS(wxSocketClient)
DECLARE_CLASS(wxSocketClient)
}; };
@@ -343,22 +342,24 @@ private:
class WXDLLIMPEXP_NET wxDatagramSocket : public wxSocketBase class WXDLLIMPEXP_NET wxDatagramSocket : public wxSocketBase
{ {
DECLARE_CLASS(wxDatagramSocket)
public: public:
wxDatagramSocket(const wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE); wxDatagramSocket(const wxSockAddress& addr,
wxSocketFlags flags = wxSOCKET_NONE);
wxDatagramSocket& RecvFrom( wxSockAddress& addr, wxDatagramSocket& RecvFrom(wxSockAddress& addr,
void* buf, void *buf,
wxUint32 nBytes ); wxUint32 nBytes);
wxDatagramSocket& SendTo( const wxSockAddress& addr, wxDatagramSocket& SendTo(const wxSockAddress& addr,
const void* buf, const void* buf,
wxUint32 nBytes ); wxUint32 nBytes);
/* TODO: /* TODO:
bool Connect(wxSockAddress& addr); bool Connect(wxSockAddress& addr);
*/ */
DECLARE_NO_COPY_CLASS(wxDatagramSocket)
private:
DECLARE_NO_COPY_CLASS(wxDatagramSocket)
DECLARE_CLASS(wxDatagramSocket)
}; };
@@ -369,22 +370,23 @@ public:
class WXDLLIMPEXP_NET wxSocketEvent : public wxEvent class WXDLLIMPEXP_NET wxSocketEvent : public wxEvent
{ {
public: public:
wxSocketEvent(int id = 0) wxSocketEvent(int id = 0)
: wxEvent(id, wxEVT_SOCKET) : wxEvent(id, wxEVT_SOCKET)
{ {
} }
wxSocketNotify GetSocketEvent() const { return m_event; } wxSocketNotify GetSocketEvent() const { return m_event; }
wxSocketBase *GetSocket() const { return (wxSocketBase *) GetEventObject(); } wxSocketBase *GetSocket() const
void *GetClientData() const { return m_clientData; } { return (wxSocketBase *) GetEventObject(); }
void *GetClientData() const { return m_clientData; }
virtual wxEvent *Clone() const { return new wxSocketEvent(*this); } virtual wxEvent *Clone() const { return new wxSocketEvent(*this); }
public: public:
wxSocketNotify m_event; wxSocketNotify m_event;
void *m_clientData; void *m_clientData;
DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSocketEvent) DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSocketEvent)
}; };

4
src/common/socket.cpp
View File

@@ -1804,10 +1804,6 @@ wxSocketClient::wxSocketClient(wxSocketFlags flags)
m_initialSendBufferSize = -1; m_initialSendBufferSize = -1;
} }
wxSocketClient::~wxSocketClient()
{
}
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Connect // Connect
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------