C++ QThreadStorage::hasLocalData方法代码示例

			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;
			}

void tst_QThreadStorage::hasLocalData()
{
    QThreadStorage<Pointer *> pointers;
    QVERIFY(!pointers.hasLocalData());
    pointers.setLocalData(new Pointer);
    QVERIFY(pointers.hasLocalData());
    pointers.setLocalData(0);
    QVERIFY(!pointers.hasLocalData());
}

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());
}

OAuthNetworkAccessManager* OAuthNetworkAccessManager::getInstance() {
    if (!oauthNetworkAccessManagers.hasLocalData()) {
        oauthNetworkAccessManagers.setLocalData(new OAuthNetworkAccessManager());
    }
    
    return oauthNetworkAccessManagers.localData();
}

IconvProcessor & ucs4ToUtf8()
{
	static QThreadStorage<IconvProcessor *> processor;
	if (!processor.hasLocalData())
		processor.setLocalData(new IconvProcessor("UTF-8", ucs4_codeset));
	return *processor.localData();
}

			RDFServicePtr trackerRelease()
			{
				if(!tracker_persistent_tls.hasLocalData())
					return RDFServicePtr();
				RDFServicePtr ret = *tracker_persistent_tls.localData();
				tracker_persistent_tls.setLocalData(0);
				return ret;
			}

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);
}

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
}

/** 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 testAdoptedThreadStorageWin(void *p)
{
    QThreadStorage<Pointer *>  *pointers = reinterpret_cast<QThreadStorage<Pointer *> *>(p);
    if (pointers->hasLocalData()) {
        threadStorageOk = false;
        return;
    }

    Pointer *pointer = new Pointer();
    pointers->setLocalData(pointer);

    if (pointers->hasLocalData() == false) {
        threadStorageOk = false;
        return;
    }

    if (pointers->localData() != pointer) {
        threadStorageOk = false;
        return;
    }
    QObject::connect(QThread::currentThread(), SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
}

/** 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 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);
}