/usr/include/Poco/ThreadLocal.h is in libpoco-dev 1.8.0.1-1ubuntu4.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 | //
// ThreadLocal.h
//
// Library: Foundation
// Package: Threading
// Module: Thread
//
// Definition of the ThreadLocal template and related classes.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_ThreadLocal_INCLUDED
#define Foundation_ThreadLocal_INCLUDED
#include "Poco/Foundation.h"
#include <map>
namespace Poco {
class Foundation_API TLSAbstractSlot
/// This is the base class for all objects
/// that the ThreadLocalStorage class manages.
{
public:
TLSAbstractSlot();
virtual ~TLSAbstractSlot();
};
template <class C>
class TLSSlot: public TLSAbstractSlot
/// The Slot template wraps another class
/// so that it can be stored in a ThreadLocalStorage
/// object. This class is used internally, and you
/// must not create instances of it yourself.
{
public:
TLSSlot():
_value()
{
}
~TLSSlot()
{
}
C& value()
{
return _value;
}
private:
TLSSlot(const TLSSlot&);
TLSSlot& operator = (const TLSSlot&);
C _value;
};
class Foundation_API ThreadLocalStorage
/// This class manages the local storage for each thread.
/// Never use this class directly, always use the
/// ThreadLocal template for managing thread local storage.
{
public:
ThreadLocalStorage();
/// Creates the TLS.
~ThreadLocalStorage();
/// Deletes the TLS.
TLSAbstractSlot*& get(const void* key);
/// Returns the slot for the given key.
static ThreadLocalStorage& current();
/// Returns the TLS object for the current thread
/// (which may also be the main thread).
static void clear();
/// Clears the current thread's TLS object.
/// Does nothing in the main thread.
private:
typedef std::map<const void*, TLSAbstractSlot*> TLSMap;
TLSMap _map;
friend class Thread;
};
template <class C>
class ThreadLocal
/// This template is used to declare type safe thread
/// local variables. It can basically be used like
/// a smart pointer class with the special feature
/// that it references a different object
/// in every thread. The underlying object will
/// be created when it is referenced for the first
/// time.
/// See the NestedDiagnosticContext class for an
/// example how to use this template.
/// Every thread only has access to its own
/// thread local data. There is no way for a thread
/// to access another thread's local data.
{
typedef TLSSlot<C> Slot;
public:
ThreadLocal()
{
}
~ThreadLocal()
{
}
C* operator -> ()
{
return &get();
}
C& operator * ()
/// "Dereferences" the smart pointer and returns a reference
/// to the underlying data object. The reference can be used
/// to modify the object.
{
return get();
}
C& get()
/// Returns a reference to the underlying data object.
/// The reference can be used to modify the object.
{
TLSAbstractSlot*& p = ThreadLocalStorage::current().get(this);
if (!p) p = new Slot;
return static_cast<Slot*>(p)->value();
}
private:
ThreadLocal(const ThreadLocal&);
ThreadLocal& operator = (const ThreadLocal&);
};
} // namespace Poco
#endif // Foundation_ThreadLocal_INCLUDED
|