C++ QThreadStorage类代码示例

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

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

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

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

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

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

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

static inline Cache *cache()
{
    Cache *rv = statCache.localData();
    if (!rv) {
        rv = new Cache;
        statCache.setLocalData(rv);
    }
    return rv;
}