IconvProcessor & ucs4ToUtf8()
{
static QThreadStorage<IconvProcessor *> processor;
if (!processor.hasLocalData())
processor.setLocalData(new IconvProcessor("UTF-8", ucs4_codeset));
return *processor.localData();
}
~Class()
{
// trigger creation of a new QThreadStorage, after the previous QThreadStorage from main() was destructed
static QThreadStorage<int *> threadstorage;
threadstorage.setLocalData(new int);
threadstorage.setLocalData(new int);
}
IconvProcessor & utf8ToUcs4()
{
static QThreadStorage<IconvProcessor *> processor;
if (!processor.hasLocalData())
processor.setLocalData(new IconvProcessor(ucs4_codeset, "UTF-8"));
return *processor.localData();
}
ImagePtr PixelStreamUpdater::getTileImage(const uint tileIndex,
const deflect::View view) const
{
// guard against frame swap during asynchronous readings
const QReadLocker frameLock(&_frameMutex);
try
{
if (!_frameLeftOrMono)
throw std::runtime_error("No frames yet");
if (tileIndex >= _perTileLock->size())
throw std::runtime_error("Tile index is invalid");
// prevent double-decoding of a tile that could occur unexpectedly when
// resizing the stream window
std::lock_guard<std::mutex> lock{_perTileLock->at(tileIndex)};
const bool rightEye = view == deflect::View::right_eye;
const bool rightFrame = rightEye && !_frameRight->tiles.empty();
const auto& processor = rightFrame ? _processRight : _processorLeft;
// turbojpeg handles need to be per thread, and this function may be
// called from multiple threads
static QThreadStorage<deflect::server::TileDecoder> tileDecoders;
return processor->getTileImage(tileIndex, tileDecoders.localData());
}
catch (const std::runtime_error& e)
{
print_log(LOG_ERROR, LOG_STREAM, "Error decoding stream tile: '%s'",
e.what());
std::rethrow_exception(std::current_exception());
}
}
OAuthNetworkAccessManager* OAuthNetworkAccessManager::getInstance() {
if (!oauthNetworkAccessManagers.hasLocalData()) {
oauthNetworkAccessManagers.setLocalData(new OAuthNetworkAccessManager());
}
return oauthNetworkAccessManagers.localData();
}
QSharedPointer<RDFGraphCache> TrackerService::getRDFGraphCache(bool persistent)
{
QSharedPointer<RDFGraphCache> ret;
if(!tracker_tls.hasLocalData()
// check if the weak pointer in local data is valid and store it to ret
|| !(ret = *tracker_tls.localData()))
{
static bool initialized = false;
if(!initialized)
{
QMutexLocker lock(&tracker_global_lock_g);
if(!initialized)
initialized = initializeTrackerEnvironment();
}
QSharedPointer<TrackerService> tracker
= QSharedCreator<TrackerService>::create();
tracker->setParent( tracker.toWeakRef() );
ret = QSharedCreator<RDFGraphCache>::create(tracker);
tracker_tls.setLocalData(new QWeakPointer<RDFGraphCache>(ret));
}
if(persistent && !tracker_persistent_tls.hasLocalData())
tracker_persistent_tls.setLocalData
(new TLSDestroyer<QSharedPointer<RDFGraphCache> >(ret));
return ret;
}
RDFServicePtr trackerRelease()
{
if(!tracker_persistent_tls.hasLocalData())
return RDFServicePtr();
RDFServicePtr ret = *tracker_persistent_tls.localData();
tracker_persistent_tls.setLocalData(0);
return ret;
}
vector<unsigned short>
ucs4_to_utf16(char_type const * s, size_t ls)
{
static QThreadStorage<IconvProcessor *> processor;
if (!processor.hasLocalData())
processor.setLocalData(new IconvProcessor(utf16_codeset, ucs4_codeset));
return iconv_convert<unsigned short>(*processor.localData(), s, ls);
}
void removeFromCache(const QString &key)
//! [8] //! [9]
{
if (!caches.hasLocalData())
return;
caches.localData().remove(key);
}
void cacheObject(const QString &key, SomeClass *object)
//! [7] //! [8]
{
if (!caches.hasLocalData())
caches.setLocalData(new QCache<QString, SomeClass>);
caches.localData()->insert(key, object);
}
int main()
{
// instantiate the class that will use QThreadStorage from its destructor, it's destructor will be run last
static Class instance;
// instantiate QThreadStorage, it's destructor (and the global destructors for QThreadStorages internals) will run first
static QThreadStorage<int *> threadstorage;
threadstorage.setLocalData(new int);
threadstorage.setLocalData(new int);
}
static inline Cache *cache()
{
Cache *rv = statCache.localData();
if (!rv) {
rv = new Cache;
statCache.setLocalData(rv);
}
return rv;
}
void defer(const VoidFunc & function)
{
// create a helper in this thread if not yet created
if( ! deferHelpers.hasLocalData()) {
deferHelpers.setLocalData( new DeferHelper);
}
// queue up the function execution in this same thread
// (because the object was created in this same thread)
deferHelpers.localData()-> queue( function);
}
bool Utils::String::naturalCompareCaseInsensitive(const QString &left, const QString &right)
{
// provide a single `NaturalCompare` instance for easy use
// https://doc.qt.io/qt-5/threads-reentrancy.html
#ifdef Q_OS_MAC // workaround for Apple xcode: https://stackoverflow.com/a/29929949
static QThreadStorage<NaturalCompare> nCmp;
if (!nCmp.hasLocalData()) nCmp.setLocalData(NaturalCompare(false));
return (nCmp.localData())(left, right);
#else
thread_local NaturalCompare nCmp(false);
return nCmp(left, right);
#endif
}
QctThreadLocalData *
QctThreadLocalData::instance()
{
static QThreadStorage<QctThreadLocalData *> storage;
QctThreadLocalData *data = storage.localData();
if (0 == data) {
data = new QctThreadLocalData;
storage.setLocalData(data);
}
return data;
}
/** Return the string used to identify a particular thread */
QString SIREERROR_EXPORT getThreadString()
{
QThreadStorage<QString*> *store = pidStrings();
if (store->hasLocalData())
{
return *(store->localData());
}
else
{
return QString::null;
}
}
vector<char_type>
eightbit_to_ucs4(char const * s, size_t ls, string const & encoding)
{
static QThreadStorage<map<string, IconvProcessor> *> static_processors;
if (!static_processors.hasLocalData())
static_processors.setLocalData(new map<string, IconvProcessor>);
map<string, IconvProcessor> & processors = *static_processors.localData();
if (processors.find(encoding) == processors.end()) {
IconvProcessor processor(ucs4_codeset, encoding.c_str());
processors.insert(make_pair(encoding, processor));
}
return iconv_convert<char_type>(processors[encoding], s, ls);
}
void QPlatformGLContextPrivate::setCurrentContext(QPlatformGLContext *context)
{
QPlatformGLThreadContext *threadContext = qplatformgl_context_storage.localData();
if (!threadContext) {
if (!QThread::currentThread()) {
qWarning("No QTLS available. currentContext wont work");
return;
}
threadContext = new QPlatformGLThreadContext;
qplatformgl_context_storage.setLocalData(threadContext);
}
threadContext->context = context;
}
void RpcConnection::connIdMsgHandler(QtMsgType /*type*/, const char* msg)
{
if (connId.hasLocalData()) {
QString newMsg(*connId.localData());
newMsg.append(msg);
newMsg.replace(QChar('\n'), QString("\n").append(*connId.localData()));
fprintf(stderr, "%s\n", qPrintable(newMsg));
fflush(stderr);
return;
}
fprintf(stderr, "%s\n", msg);
fflush(stderr);
}
/** Return the string used by SireError to identify a particular
thread within a process */
QString SIREERROR_EXPORT getPIDString()
{
QThreadStorage<QString*> *store = pidStrings();
if (store->hasLocalData())
{
return QString("%1:%2").arg( getProcessString(),
*(store->localData()) );
}
else
{
return getProcessString();
}
}
void Coroutine::yieldHelper(Status stopStatus)
{
Coroutine *stoppingCoroutine = *qt_currentCoroutine.localData();
Q_ASSERT(stoppingCoroutine);
Q_ASSERT(stoppingCoroutine->_status == Running);
stoppingCoroutine->_status = stopStatus;
Coroutine *continuingCoroutine = stoppingCoroutine->_caller;
Q_ASSERT(continuingCoroutine);
stoppingCoroutine->_caller = 0;
*qt_currentCoroutine.localData() = continuingCoroutine;
switchStack(continuingCoroutine->_stackPointer, &stoppingCoroutine->_stackPointer);
}
QDBusConnection trackerBus(bool is_thread_private)
{
if(!is_thread_private)
return QDBusConnection::sessionBus();
// Create a separate D-Bus connection for each thread. Use ClosingDBusConnection so
// that the bus gets disconnected when the thread storage is deleted.
if (!dbus_tls.hasLocalData()) {
QString id = QString::number(counter.fetchAndAddRelaxed(1))
.prepend("libqttracker-dbus-");
dbus_tls.setLocalData(new ClosingDBusConnection
(QDBusConnection::connectToBus(QDBusConnection::SessionBus, id)));
}
return *dbus_tls.localData();
}
/*!
Passes control to the coroutine.
The coroutine will run until it terminates or is stopped by a call to yield().
Returns whether it can be continued again.
Calling this function is only valid if in the NotStarted or Stopped state.
\sa yield()
*/
bool Coroutine::cont()
{
Q_ASSERT(_status == NotStarted || _status == Stopped);
Q_ASSERT(!_caller);
if (!_stackPointer)
createStack();
_status = Running;
_caller = *qt_currentCoroutine.localData();
*qt_currentCoroutine.localData() = this;
switchStack(_stackPointer, &_caller->_stackPointer);
return _status != Terminated;
}
void RpcConnection::start()
{
QString id = QString("[%1:%2] ");
clientSock = new QTcpSocket;
if (!clientSock->setSocketDescriptor(socketDescriptor)) {
qWarning("Unable to initialize TCP socket for incoming connection");
return;
}
qDebug("clientSock Thread = %p", clientSock->thread());
connId.setLocalData(new QString(id.arg(clientSock->peerAddress().toString())
.arg(clientSock->peerPort())));
qDebug("accepting new connection from %s: %d",
clientSock->peerAddress().toString().toAscii().constData(),
clientSock->peerPort());
inStream = new google::protobuf::io::CopyingInputStreamAdaptor(
new PbQtInputStream(clientSock));
inStream->SetOwnsCopyingStream(true);
outStream = new google::protobuf::io::CopyingOutputStreamAdaptor(
new PbQtOutputStream(clientSock));
outStream->SetOwnsCopyingStream(true);
connect(clientSock, SIGNAL(readyRead()),
this, SLOT(on_clientSock_dataAvail()));
connect(clientSock, SIGNAL(disconnected()),
this, SLOT(on_clientSock_disconnected()));
connect(clientSock, SIGNAL(error(QAbstractSocket::SocketError)),
this, SLOT(on_clientSock_error(QAbstractSocket::SocketError)));
}
void tst_QThreadStorage::init()
{
dummy[1].setLocalData(new int(5));
dummy[2].setLocalData(new int(4));
dummy[3].setLocalData(new int(3));
tls1.setLocalData(new QString());
}
void tst_QThreadStorage::autoDelete()
{
QThreadStorage<Pointer *> pointers;
QVERIFY(!pointers.hasLocalData());
Thread thread(pointers);
int c = Pointer::count;
{
QMutexLocker locker(&thread.mutex);
thread.start();
thread.cond.wait(&thread.mutex);
// QCOMPARE(Pointer::count, c + 1);
thread.cond.wakeOne();
}
thread.wait();
QCOMPARE(Pointer::count, c);
}
/*!
Returns the currently running Coroutine for the active thread.
This function will return a unique Coroutine instance that is in the
Running state for the initial 'coroutine' of a thread.
*/
Coroutine *Coroutine::currentCoroutine()
{
// establish a context for the starting coroutine
if (!qt_currentCoroutine.hasLocalData()) {
// set qt_currentCoroutine before actually constructing the root
// coroutine to avoid recursing through the constructor call below
Coroutine **currentPtr = new Coroutine*;
qt_currentCoroutine.setLocalData(currentPtr);
*currentPtr = new Coroutine;
qt_threadRootCoroutine.setLocalData(*currentPtr);
(*currentPtr)->_status = Running;
return *currentPtr;
}
return *qt_currentCoroutine.localData();
}
/*!
Returns the last context which called makeCurrent. This function is thread aware.
*/
const QPlatformGLContext* QPlatformGLContext::currentContext()
{
QPlatformGLThreadContext *threadContext = qplatformgl_context_storage.localData();
if(threadContext) {
return threadContext->context;
}
return 0;
}
CGHost :: CGHost( CConfig *CFG, QString configFile )
: d_ptr(new CGHostPrivate()),
m_ConfigFile(configFile)
{
currentGHost.setLocalData( this );
foreach( QObject *plugin, QPluginLoader::staticInstances() )
{
LoadPlugin( plugin, CFG );
}
void tst_QThreadStorage::localData()
{
QThreadStorage<Pointer*> pointers;
Pointer *p = new Pointer;
QVERIFY(!pointers.hasLocalData());
pointers.setLocalData(p);
QVERIFY(pointers.hasLocalData());
QCOMPARE(pointers.localData(), p);
pointers.setLocalData(0);
QCOMPARE(pointers.localData(), (Pointer *)0);
QVERIFY(!pointers.hasLocalData());
}
