QBlkSocket.h

Go to the documentation of this file.

/********************************************************************************
*                                                                               *
*                          Network socket i/o device                            *
*                                                                               *
*********************************************************************************
*        Copyright (C) 2003-2006 by Niall Douglas.   All Rights Reserved.       *
*       NOTE THAT I DO NOT PERMIT ANY OF MY CODE TO BE PROMOTED TO THE GPL      *
*********************************************************************************
* This code is free software; you can redistribute it and/or modify it under    *
* the terms of the GNU Library General Public License v2.1 as published by the  *
* Free Software Foundation EXCEPT that clause 3 does not apply ie; you may not  *
* "upgrade" this code to the GPL without my prior written permission.           *
* Please consult the file "License_Addendum2.txt" accompanying this file.       *
*                                                                               *
* This code is distributed in the hope that it will be useful,                  *
* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                          *
*********************************************************************************
* $Id:                                                                          *
********************************************************************************/


#ifndef QBLKSOCKET_H
#define QBLKSOCKET_H
#include "QIODeviceS.h"
#include "QHostAddress.h"

namespace FX {

class FXString;

struct QBlkSocketPrivate;
class FXAPIR QBlkSocket : public QIODeviceS
{
    QBlkSocketPrivate *p;
    QBlkSocket &operator=(const QBlkSocket &);
    FXDLLLOCAL void fillInAddrs(bool incPeer);
    FXDLLLOCAL void zeroAddrs();
    FXDLLLOCAL void setupSocket();
    QBlkSocket(const QBlkSocket &o, int h);
    virtual FXDLLLOCAL void *int_getOSHandle() const;
public:
    enum Type
    {
        Stream=0,   
        Datagram    
    };
    QBlkSocket(Type type=Stream, FXushort port=0);
    QBlkSocket(const QHostAddress &addr, FXushort port, Type type=Stream);
    QBlkSocket(const FXString &addr, FXushort port, Type type=Stream);
#ifndef HAVE_CPP0XRVALUEREFS
#ifdef HAVE_CONSTTEMPORARIES
    QBlkSocket(const QBlkSocket &o);
#else
    QBlkSocket(QBlkSocket &o);
#endif
#else
private:
    QBlkSocket(const QBlkSocket &); // disable copy constructor
public:
    QBlkSocket(QBlkSocket &&o);
#endif
    ~QBlkSocket();

    Type type() const;
    void setType(Type type);
    const QHostAddress &address() const;
    FXushort port() const;
    QHostAddress peerAddress() const;
    FXushort peerPort() const;
    const QHostAddress &requestedAddress() const;
    FXushort requestedPort() const;
    void setRequestedAddressAndPort(const QHostAddress &reqAddr, FXushort port);
    bool isUnique() const;
    void setUnique(bool a);
    FXuval receiveBufferSize() const;
    void setReceiveBufferSize(FXuval newsize);
    FXuval sendBufferSize() const;
    void setSendBufferSize(FXuval newsize);
    FXuval maxDatagramSize() const;
    FXint maxPending() const;
    void setMaxPending(FXint newp);
    bool listen(int newp) { setMaxPending(newp); return true; }
    bool addressReusable() const;
    void setAddressReusable(bool newar);
    bool keepAlive() const;
    void setKeepAlive(bool newar);
    FXint lingerPeriod() const;
    void setLingerPeriod(FXint period);
    bool usingNagles() const;
    void setUsingNagles(bool newar);
    bool connected() const;

    bool create(FXuint mode=IO_ReadWrite);
    bool open(FXuint mode=IO_ReadWrite);
    void close();
    void flush();
    bool reset();

    FXfval size() const;
    FXDEPRECATEDEXT FXfval bytesAvailable() const { return size(); }
    virtual const FXACL &permissions() const;

    FXuval readBlock(char *data, FXuval maxlen);
    FXuval writeBlock(const char *data, FXuval maxlen);
    FXuval writeBlock(const char *data, FXuval maxlen, const QHostAddress &addr, FXushort port);
    int ungetch(int);
    QBlkSocket *waitForConnection(FXuint waitfor=FXINFINITE);

public:
    FXDEPRECATEDEXT bool blocking() const { return true; }
    FXDEPRECATEDEXT void setBlocking(bool) { }
    FXDEPRECATEDEXT FXuval waitForMore(int msecs, bool *timeout=0);
};

} // namespace

#endif

---

(C) 2002-2009 Niall Douglas. Some parts (C) to assorted authors.