From 252a2ec8b0f0f9cf20c947737087b24a8185b588 Mon Sep 17 00:00:00 2001 From: Michele Calgaro Date: Wed, 10 Jul 2024 18:56:16 +0900 Subject: Rename IO and network class nt* related files to equivalent tq* Signed-off-by: Michele Calgaro --- doc/html/tqnetworkprotocol.html | 532 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 532 insertions(+) create mode 100644 doc/html/tqnetworkprotocol.html (limited to 'doc/html/tqnetworkprotocol.html') diff --git a/doc/html/tqnetworkprotocol.html b/doc/html/tqnetworkprotocol.html new file mode 100644 index 000000000..72341bef3 --- /dev/null +++ b/doc/html/tqnetworkprotocol.html @@ -0,0 +1,532 @@ + + + + + +TQNetworkProtocol Class + + + + + + + +

TQNetworkProtocol Class Reference
[network module]

+ +

The TQNetworkProtocol class provides a common API for network protocols. +More... +

#include <tqnetworkprotocol.h> +

Inherits TQObject. +

Inherited by TQFtp, TQHttp, and TQLocalFs. +

List of all member functions. +

Public Members

enum State { StWaiting = 0, StInProgress, StDone, StFailed, StStopped }
enum Operation { OpListChildren = 1, OpMkDir = 2, OpMkdir = OpMkDir, OpRemove = 4, OpRename = 8, OpGet = 32, OpPut = 64 }
enum ConnectionState { ConHostFound, ConConnected, ConClosed }
enum Error { NoError = 0, ErrValid, ErrUnknownProtocol, ErrUnsupported, ErrParse, ErrLoginIncorrect, ErrHostNotFound, ErrListChildren, ErrListChlidren = ErrListChildren, ErrMkDir, ErrMkdir = ErrMkDir, ErrRemove, ErrRename, ErrGet, ErrPut, ErrFileNotExisting, ErrPermissionDenied }
TQNetworkProtocol ()
virtual ~TQNetworkProtocol ()
virtual void setUrl ( TQUrlOperator * u )
virtual void setAutoDelete ( bool b, int i = 10000 )
bool autoDelete () const
virtual int supportedOperations () const
virtual void addOperation ( TQNetworkOperation * op )
TQUrlOperator * url () const
TQNetworkOperation * operationInProgress () const
virtual void clearOperationQueue ()
virtual void stop ()

Signals

void data ( const TQByteArray & data, TQNetworkOperation * op )
void connectionStateChanged ( int state, const TQString & data )
void finished ( TQNetworkOperation * op )
void start ( TQNetworkOperation * op )
void newChildren ( const TQValueList<TQUrlInfo> & i, TQNetworkOperation * op )
void newChild ( const TQUrlInfo & i, TQNetworkOperation * op )
void createdDirectory ( const TQUrlInfo & i, TQNetworkOperation * op )
void removed ( TQNetworkOperation * op )
void itemChanged ( TQNetworkOperation * op )
void dataTransferProgress ( int bytesDone, int bytesTotal, TQNetworkOperation * op )

Static Public Members

void registerNetworkProtocol ( const TQString & protocol, TQNetworkProtocolFactoryBase * protocolFactory )
TQNetworkProtocol * getNetworkProtocol ( const TQString & protocol )
bool hasOnlyLocalFileSystem ()

Protected Members

virtual void operationListChildren ( TQNetworkOperation * op )
virtual void operationMkDir ( TQNetworkOperation * op )
virtual void operationRemove ( TQNetworkOperation * op )
virtual void operationRename ( TQNetworkOperation * op )
virtual void operationGet ( TQNetworkOperation * op )
virtual void operationPut ( TQNetworkOperation * op )
virtual bool checkConnection ( TQNetworkOperation * op )

Detailed Description

+ + +The TQNetworkProtocol class provides a common API for network protocols. + +

+ + + +

This is a base class which should be used for network protocols +implementations that can then be used in TQt (e.g. in the file +dialog) together with the TQUrlOperator. +

The easiest way to implement a new network protocol is to +reimplement the operation*() methods, e.g. operationGet(), etc. +Only the supported operations should be reimplemented. To specify +which operations are supported, also reimplement +supportedOperations() and return an int that is OR'd together +using the supported operations from the TQNetworkProtocol::Operation enum. +

When you implement a network protocol this way, it is important to +emit the correct signals. Also, always emit the finished() signal +when an operation is done (on success and on failure). TQt +relies on correctly emitted finished() signals. +

For a detailed description of the TQt Network Architecture and how +to implement and use network protocols in TQt, see the TQt Network Documentation. +

See also Input/Output and Networking. + +

Member Type Documentation

TQNetworkProtocol::ConnectionState

+ +

When the connection state of a network protocol changes it emits +the signal connectionStateChanged(). The first argument is one of +the following values: +

TQNetworkProtocol::ConHostFound - Host has been found. +
TQNetworkProtocol::ConConnected - Connection to the host has been established. +
TQNetworkProtocol::ConClosed - Connection has been closed. +

TQNetworkProtocol::Error

+ +

When an operation fails (finishes unsuccessfully), the +TQNetworkOperation of the operation returns an error code which has +one of the following values: +

TQNetworkProtocol::NoError - No error occurred. +
TQNetworkProtocol::ErrValid - The URL you are operating on is not valid. +
TQNetworkProtocol::ErrUnknownProtocol - There is no protocol implementation +available for the protocol of the URL you are operating on (e.g. +if the protocol is http and no http implementation has been +registered). +
TQNetworkProtocol::ErrUnsupported - The operation is not supported by the +protocol. +
TQNetworkProtocol::ErrParse - The URL could not be parsed correctly. +
TQNetworkProtocol::ErrLoginIncorrect - You needed to login but the username +or password is wrong. +
TQNetworkProtocol::ErrHostNotFound - The specified host (in the URL) couldn't +be found. +
TQNetworkProtocol::ErrListChildren - An error occurred while listing the +children (files). +
TQNetworkProtocol::ErrMkDir - An error occurred when creating a directory. +
TQNetworkProtocol::ErrRemove - An error occurred when removing a child (file). +
TQNetworkProtocol::ErrRename - An error occurred when renaming a child (file). +
TQNetworkProtocol::ErrGet - An error occurred while getting (retrieving) data. +
TQNetworkProtocol::ErrPut - An error occurred while putting (uploading) data. +
TQNetworkProtocol::ErrFileNotExisting - A file which is needed by the operation +doesn't exist. +
TQNetworkProtocol::ErrPermissionDenied - Permission for doing the operation has +been denied. +

You should also use these error codes when implementing custom +network protocols. If this is not possible, you can define your own +error codes by using integer values that don't conflict with any +of these values. + +

TQNetworkProtocol::Operation

+ +

This enum lists the possible operations that a network protocol +can support. supportedOperations() returns an int of these that is +OR'd together. Also, the type() of a TQNetworkOperation is always +one of these values. +

TQNetworkProtocol::OpListChildren - List the children of a URL, e.g. of a directory. +
TQNetworkProtocol::OpMkDir - Create a directory. +
TQNetworkProtocol::OpRemove - Remove a child (e.g. a file). +
TQNetworkProtocol::OpRename - Rename a child (e.g. a file). +
TQNetworkProtocol::OpGet - Get data from a location. +
TQNetworkProtocol::OpPut - Put data to a location. +

TQNetworkProtocol::State

+ +

This enum contains the state that a TQNetworkOperation can have. +

TQNetworkProtocol::StWaiting - The operation is in the TQNetworkProtocol's queue +waiting to be prcessed. +
TQNetworkProtocol::StInProgress - The operation is being processed. +
TQNetworkProtocol::StDone - The operation has been processed succesfully. +
TQNetworkProtocol::StFailed - The operation has been processed but an error occurred. +
TQNetworkProtocol::StStopped - The operation has been processed but has been +stopped before it finished, and is waiting to be processed. +

Member Function Documentation

TQNetworkProtocol::TQNetworkProtocol () +

+Constructor of the network protocol base class. Does some +initialization and connecting of signals and slots. + +

TQNetworkProtocol::~TQNetworkProtocol () `[virtual]` +

+Destructor. + +

void TQNetworkProtocol::addOperation ( TQNetworkOperation * op ) `[virtual]` +

+Adds the operation op to the operation queue. The operation +will be processed as soon as possible. This method returns +immediately. + +

bool TQNetworkProtocol::autoDelete () const +

+Returns TRUE if auto-deleting is enabled; otherwise returns FALSE. +

See also TQNetworkProtocol::setAutoDelete(). + +

bool TQNetworkProtocol::checkConnection ( TQNetworkOperation * op ) `[virtual protected]` +

+For processing operations the network protocol base class calls +this method quite often. This should be reimplemented by new +network protocols. It should return TRUE if the connection is OK +(open); otherwise it should return FALSE. If the connection is not +open the protocol should open it. +

If the connection can't be opened (e.g. because you already tried +but the host couldn't be found), set the state of op to +TQNetworkProtocol::StFailed and emit the finished() signal with +this TQNetworkOperation as argument. +

op is the operation that needs an open connection. + +

Example: network/networkprotocol/nntp.cpp. +

void TQNetworkProtocol::clearOperationQueue () `[virtual]` +

+Clears the operation queue. + +

void TQNetworkProtocol::connectionStateChanged ( int state, const TQString & data ) `[signal]` +

+ +

This signal is emitted whenever the state of the connection of the +network protocol is changed. state describes the new state, +which is one of, ConHostFound, ConConnected or ConClosed. +data is a message text. + +

void TQNetworkProtocol::createdDirectory ( const TQUrlInfo & i, TQNetworkOperation * op ) `[signal]` +

+ +

This signal is emitted when mkdir() has been succesful and the +directory has been created. i holds the information about the +new directory. op is the pointer to the operation object which +contains all the information about the operation, including the +state, etc. Using op->arg( 0 ), you can get the file name of the +new directory. +

When a protocol emits this signal, TQNetworkProtocol is smart +enough to let the TQUrlOperator, which is used by the network +protocol, emit its corresponding signal. + +

void TQNetworkProtocol::data ( const TQByteArray & data, TQNetworkOperation * op ) `[signal]` +

+ +

This signal is emitted when new data has been received after +calling get() or put(). op holds the name of the file from +which data is retrieved or uploaded in its first argument, and the +(raw) data in its second argument. You can get them with +op->arg( 0 ) and op->rawArg( 1 ). op is the pointer to the +operation object, which contains all the information about the +operation, including the state, etc. +

When a protocol emits this signal, TQNetworkProtocol is smart +enough to let the TQUrlOperator (which is used by the network +protocol) emit its corresponding signal. + +

void TQNetworkProtocol::dataTransferProgress ( int bytesDone, int bytesTotal, TQNetworkOperation * op ) `[signal]` +

+ +

This signal is emitted during the transfer of data (using put() or +get()). bytesDone is how many bytes of bytesTotal have been +transferred. bytesTotal may be -1, which means that the total +number of bytes is not known. op is the pointer to the +operation object which contains all the information about the +operation, including the state, etc. +

When a protocol emits this signal, TQNetworkProtocol is smart +enough to let the TQUrlOperator, which is used by the network +protocol, emit its corresponding signal. + +

void TQNetworkProtocol::finished ( TQNetworkOperation * op ) `[signal]` +

+ +

This signal is emitted when an operation finishes. This signal is +always emitted, for both success and failure. op is the pointer +to the operation object which contains all the information about +the operation, including the state, etc. Check the state and error +code of the operation object to determine whether or not the +operation was successful. +

When a protocol emits this signal, TQNetworkProtocol is smart +enough to let the TQUrlOperator, which is used by the network +protocol, emit its corresponding signal. + +

TQNetworkProtocol * TQNetworkProtocol::getNetworkProtocol ( const TQString & protocol ) `[static]` +

+Static method to get a new instance of the network protocol protocol. For example, if you need to do some FTP operations, do +the following: +

+    TQFtp *ftp = TQNetworkProtocol::getNetworkProtocol( "ftp" );
+

+ +This returns a pointer to a new instance of an ftp implementation +or null if no protocol for ftp was registered. The ownership of +the pointer is transferred to you, so you must delete it if you +don't need it anymore. +

Normally you should not work directly with network protocols, so +you will not need to call this method yourself. Instead, use +TQUrlOperator, which makes working with network protocols much more +convenient. +

bool TQNetworkProtocol::hasOnlyLocalFileSystem () `[static]` +

+Returns TRUE if the only protocol registered is for working on the +local filesystem; returns FALSE if other network protocols are +also registered. + +

void TQNetworkProtocol::itemChanged ( TQNetworkOperation * op ) `[signal]` +

+ +

This signal is emitted whenever a file which is a child of this +URL has been changed, e.g. by successfully calling rename(). op +holds the original and the new file names in the first and second +arguments, accessible with op->arg( 0 ) and op->arg( 1 ) +respectively. op is the pointer to the operation object which +contains all the information about the operation, including the +state, etc. +

When a protocol emits this signal, TQNetworkProtocol is smart +enough to let the TQUrlOperator, which is used by the network +protocol, emit its corresponding signal. + +

void TQNetworkProtocol::newChild ( const TQUrlInfo & i, TQNetworkOperation * op ) `[signal]` +

+ +

This signal is emitted if a new child (file) has been read. +TQNetworkProtocol automatically connects it to a slot which creates +a list of TQUrlInfo objects (with just one TQUrlInfo i) and emits +the newChildren() signal with this list. op is the pointer to +the operation object which contains all the information about the +operation that has finished, including the state, etc. +

This is just a convenience signal useful for implementing your own +network protocol. In all other cases connect to the newChildren() +signal with its list of TQUrlInfo objects. + +

void TQNetworkProtocol::newChildren ( const TQValueList<TQUrlInfo> & i, TQNetworkOperation * op ) `[signal]` +

+ +

This signal is emitted after listChildren() was called and new +children (files) have been read from the list of files. i holds +the information about the new children. op is the pointer to +the operation object which contains all the information about the +operation, including the state, etc. +

When a protocol emits this signal, TQNetworkProtocol is smart +enough to let the TQUrlOperator, which is used by the network +protocol, emit its corresponding signal. +

When implementing your own network protocol and reading children, +you usually don't read one child at once, but rather a list of +them. That's why this signal takes a list of TQUrlInfo objects. If +you prefer to read just one child at a time you can use the +convenience signal newChild(), which takes a single TQUrlInfo +object. + +

void TQNetworkProtocol::operationGet ( TQNetworkOperation * op ) `[virtual protected]` +

+When implementing a new network protocol, this method should be +reimplemented if the protocol supports getting data; this method +should then process the TQNetworkOperation. +

When you reimplement this method it's very important that you emit +the correct signals at the correct time (especially the finished() +signal after processing an operation). Take a look at the TQt Network Documentation which describes in +detail how to reimplement this method. You may also want to look +at the example implementation in +examples/network/networkprotocol/nntp.cpp. +