static void qt_ignore_sigpipe()
{
// Set to ignore SIGPIPE once only.
static QBasicAtomic atom = Q_ATOMIC_INIT(0);
if (atom.testAndSet(0, 1)) {
struct sigaction noaction;
memset(&noaction, 0, sizeof(noaction));
noaction.sa_handler = SIG_IGN;
::sigaction(SIGPIPE, &noaction, 0);
}
}
** libraries.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not expressly
** granted herein.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/
#include "qlinkedlist.h"
QLinkedListData QLinkedListData::shared_null = {
&QLinkedListData::shared_null, &QLinkedListData::shared_null, Q_ATOMIC_INIT(1), 0, true
};
/*! \class QLinkedList
\brief The QLinkedList class is a template class that provides linked lists.
\ingroup tools
\ingroup shared
\mainclass
\reentrant
QLinkedList\<T\> is one of Qt's generic \l{container classes}. It
stores a list of values and provides iterator-based access as
well as \l{constant time} insertions and removals.
QList\<T\>, QLinkedList\<T\>, and QVector\<T\> provide similar
#include "qlist.h"
#include "qtools_p.h"
#include <string.h>
/*
QList as an array-list combines the easy-of-use of a random
access interface with fast list operations and the low memory
management overhead of an array. Accessing elements by index,
appending, prepending, and removing elements from both the front
and the back all happen in constant time O(1). Inserting or
removing elements at random index positions \ai happens in linear
time, or more precisly in O(min{i,n-i}) <= O(n/2), with n being
the number of elements in the list.
*/
QListData::Data QListData::shared_null = { Q_ATOMIC_INIT(1), 0, 0, 0, true, { 0 } };
static int grow(int size)
{
// dear compiler: don't optimize me out.
volatile int x = qAllocMore(size * sizeof(void *), QListData::DataHeaderSize) / sizeof(void *);
return x;
}
QListData::Data *QListData::detach()
{
Q_ASSERT(d->ref != 1);
Data *x = static_cast<Data *>(qMalloc(DataHeaderSize + d->alloc * sizeof(void *)));
::memcpy(x, d, DataHeaderSize + d->alloc * sizeof(void *));
x->alloc = d->alloc;
x->ref.init(1);
If you want a blocking lookup, use the QHostInfo::fromName() function:
\code
QHostInfo info = QHostInfo::fromName("www.trolltech.com");
\endcode
QHostInfo supports Internationalized Domain Names (IDNs) through the
IDNA and Punycode standards.
To retrieve the name of the local host, use the static
QHostInfo::localHostName() function.
\sa QAbstractSocket, {http://www.rfc-editor.org/rfc/rfc3492.txt}{RFC 3492}
*/
static QBasicAtomic idCounter = Q_ATOMIC_INIT(1);
/*!
Looks up the IP address(es) associated with host name \a name, and
returns an ID for the lookup. When the result of the lookup is
ready, the slot or signal \a member in \a receiver is called with
a QHostInfo argument. The QHostInfo object can then be inspected
to get the results of the lookup.
The lookup is performed by a single function call, for example:
\code
QHostInfo::lookupHost("www.kde.org",
this, SLOT(lookedUp(QHostInfo)));
\endcode
