1412101763
2 2
13 libp3pipeline 4 kd_i 12 panda3d.core 
116
114 29 upcast_to_TypedReferenceCount 0 12 230 44 AsyncTaskBase::upcast_to_TypedReferenceCount 0 1 2 48
upcast from AsyncTaskBase to TypedReferenceCount
72
TypedReferenceCount *AsyncTaskBase::upcast_to_TypedReferenceCount(void);

115 25 downcast_to_AsyncTaskBase 0 12 231 46 TypedReferenceCount::downcast_to_AsyncTaskBase 0 1 3 50
downcast from TypedReferenceCount to AsyncTaskBase
68
AsyncTaskBase *TypedReferenceCount::downcast_to_AsyncTaskBase(void);

116 17 upcast_to_Namable 0 12 230 32 AsyncTaskBase::upcast_to_Namable 0 1 4 36
upcast from AsyncTaskBase to Namable
48
Namable *AsyncTaskBase::upcast_to_Namable(void);

117 25 downcast_to_AsyncTaskBase 0 12 232 34 Namable::downcast_to_AsyncTaskBase 0 1 5 38
downcast from Namable to AsyncTaskBase
56
AsyncTaskBase *Namable::downcast_to_AsyncTaskBase(void);

118 14 ~AsyncTaskBase 0 6 230 29 AsyncTaskBase::~AsyncTaskBase 0 0 233
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskBase::Destructor
//       Access: Published, Virtual
//  Description:
////////////////////////////////////////////////////////////////////
44
virtual AsyncTaskBase::~AsyncTaskBase(void);

119 14 get_class_type 0 4 230 29 AsyncTaskBase::get_class_type 0 1 1 0
54
static TypeHandle AsyncTaskBase::get_class_type(void);

120 29 upcast_to_TypedReferenceCount 0 12 234 37 Thread::upcast_to_TypedReferenceCount 0 1 36 41
upcast from Thread to TypedReferenceCount
65
TypedReferenceCount *Thread::upcast_to_TypedReferenceCount(void);

121 18 downcast_to_Thread 0 12 231 39 TypedReferenceCount::downcast_to_Thread 0 1 37 43
downcast from TypedReferenceCount to Thread
54
Thread *TypedReferenceCount::downcast_to_Thread(void);

122 17 upcast_to_Namable 0 12 234 25 Thread::upcast_to_Namable 0 1 38 29
upcast from Thread to Namable
41
Namable *Thread::upcast_to_Namable(void);

123 18 downcast_to_Thread 0 12 232 27 Namable::downcast_to_Thread 0 1 39 31
downcast from Namable to Thread
42
Thread *Namable::downcast_to_Thread(void);

124 7 ~Thread 0 6 234 15 Thread::~Thread 0 0 226
////////////////////////////////////////////////////////////////////
//     Function: Thread::Destructor
//       Access: Published, Virtual
//  Description:
////////////////////////////////////////////////////////////////////
30
virtual Thread::~Thread(void);

125 11 bind_thread 0 4 234 19 Thread::bind_thread 0 1 6 1438
////////////////////////////////////////////////////////////////////
//     Function: Thread::bind_thread
//       Access: Published, Static
//  Description: Returns a new Panda Thread object associated with the
//               current thread (which has been created externally).
//               This can be used to bind a unique Panda Thread object
//               with an external thread, such as a new Python thread.
//
//               It is particularly useful to bind a Panda Thread
//               object to an external thread for the purposes of
//               PStats monitoring.  Without this call, each external
//               thread will be assigned the same global
//               ExternalThread object, which means they will all
//               appear in the same PStats graph.
//
//               It is the caller's responsibility to save the
//               returned Thread pointer for the lifetime of the
//               external thread.  It is an error for the Thread
//               pointer to destruct while the external thread is
//               still in the system.
//
//               It is also an error to call this method from the main
//               thread, or twice within a given thread, unless it is
//               given the same name each time (in which case the same
//               pointer will be returned each time).
////////////////////////////////////////////////////////////////////
120
static PointerTo< Thread > Thread::bind_thread(basic_string< char > const &name, basic_string< char > const &sync_name);

126 13 get_sync_name 0 4 234 21 Thread::get_sync_name 0 1 7 565
////////////////////////////////////////////////////////////////////
//     Function: Thread::get_sync_name
//       Access: Published
//  Description: Returns the sync name of the thread.  This name
//               collects threads into "sync groups", which are
//               expected to run synchronously.  This is mainly used
//               for the benefit of PStats; threads with the same sync
//               name can be ticked all at once via the thread_tick()
//               call.
////////////////////////////////////////////////////////////////////
69
inline basic_string< char > const &Thread::get_sync_name(void) const;

127 16 get_pstats_index 0 4 234 24 Thread::get_pstats_index 0 1 8 476
////////////////////////////////////////////////////////////////////
//     Function: Thread::get_pstats_index
//       Access: Published
//  Description: Returns the PStats index associated with this thread,
//               or -1 if no index has yet been associated with this
//               thread.  This is used internally by the PStatClient;
//               you should not need to call this directly.
////////////////////////////////////////////////////////////////////
48
inline int Thread::get_pstats_index(void) const;

128 13 get_unique_id 0 4 234 21 Thread::get_unique_id 0 1 9 402
////////////////////////////////////////////////////////////////////
//     Function: Thread::get_unique_id
//       Access: Published
//  Description: Returns a string that is guaranteed to be unique to
//               this thread, across all processes on the machine,
//               during at least the lifetime of this process.
////////////////////////////////////////////////////////////////////
62
inline basic_string< char > Thread::get_unique_id(void) const;

129 18 get_pipeline_stage 0 4 234 26 Thread::get_pipeline_stage 0 1 10 409
////////////////////////////////////////////////////////////////////
//     Function: Thread::get_pipeline_stage
//       Access: Published
//  Description: Returns the Pipeline stage number associated with
//               this thread.  The default stage is 0 if no stage is
//               specified otherwise.  See set_pipeline_stage().
////////////////////////////////////////////////////////////////////
50
inline int Thread::get_pipeline_stage(void) const;

130 18 set_pipeline_stage 0 4 234 26 Thread::set_pipeline_stage 0 1 11 831
////////////////////////////////////////////////////////////////////
//     Function: Thread::set_pipeline_stage
//       Access: Published
//  Description: Specifies the Pipeline stage number associated with
//               this thread.  The default stage is 0 if no stage is
//               specified otherwise.
//
//               This must be a value in the range [0
//               .. pipeline->get_num_stages() - 1].  It specifies the
//               values that this thread observes for all pipelined
//               data.  Typically, an application thread will leave
//               this at 0, but a render thread may set it to 1 or 2
//               (to operate on the previous frame's data, or the
//               second previous frame's data).
////////////////////////////////////////////////////////////////////
52
void Thread::set_pipeline_stage(int pipeline_stage);

131 22 set_min_pipeline_stage 0 4 234 30 Thread::set_min_pipeline_stage 0 1 12 392
////////////////////////////////////////////////////////////////////
//     Function: Thread::set_min_pipeline_stage
//       Access: Published
//  Description: Sets this thread's pipeline stage number to at least
//               the indicated value, unless it is already larger.
//               See set_pipeline_stage().
////////////////////////////////////////////////////////////////////
67
inline void Thread::set_min_pipeline_stage(int min_pipeline_stage);

132 15 get_main_thread 0 4 234 23 Thread::get_main_thread 0 1 13 345
////////////////////////////////////////////////////////////////////
//     Function: Thread::get_main_thread
//       Access: Published, Static
//  Description: Returns a pointer to the "main" Thread object--this
//               is the Thread that started the whole process.
////////////////////////////////////////////////////////////////////
52
static inline Thread *Thread::get_main_thread(void);

133 19 get_external_thread 0 4 234 27 Thread::get_external_thread 0 1 14 531
////////////////////////////////////////////////////////////////////
//     Function: Thread::get_external_thread
//       Access: Published, Static
//  Description: Returns a pointer to the "external" Thread
//               object--this is a special Thread object that
//               corresponds to any thread spawned outside of Panda's
//               threading interface.  Note that multiple different
//               threads may share this same pointer.
////////////////////////////////////////////////////////////////////
56
static inline Thread *Thread::get_external_thread(void);

134 18 get_current_thread 0 4 234 26 Thread::get_current_thread 0 1 15 738
////////////////////////////////////////////////////////////////////
//     Function: Thread::get_current_thread
//       Access: Published, Static
//  Description: Returns a pointer to the currently-executing Thread
//               object.  If this is called from the main thread, this
//               will return the same value as get_main_thread().
//
//               This will always return some valid Thread pointer.
//               It will never return NULL, even if the current thread
//               was spawned outside of Panda's threading system,
//               although all non-Panda threads will return the exact
//               same Thread pointer.
////////////////////////////////////////////////////////////////////
55
static inline Thread *Thread::get_current_thread(void);

135 26 get_current_pipeline_stage 0 4 234 34 Thread::get_current_pipeline_stage 0 1 16 485
////////////////////////////////////////////////////////////////////
//     Function: Thread::get_current_pipeline_stage
//       Access: Published, Static
//  Description: Returns the integer pipeline stage associated with
//               the current thread.  This is the same thing as
//               get_current_thread()->get_pipeline_stage(), but it
//               may be faster to retrieve in some contexts.
////////////////////////////////////////////////////////////////////
59
static inline int Thread::get_current_pipeline_stage(void);

136 22 is_threading_supported 0 4 234 30 Thread::is_threading_supported 0 1 17 417
////////////////////////////////////////////////////////////////////
//     Function: Thread::is_threading_supported
//       Access: Published, Static
//  Description: Returns true if threading support has been compiled
//               in and enabled, or false if no threading is available
//               (and Thread::start() will always fail).
////////////////////////////////////////////////////////////////////
56
static inline bool Thread::is_threading_supported(void);

137 15 is_true_threads 0 4 234 23 Thread::is_true_threads 0 1 18 461
////////////////////////////////////////////////////////////////////
//     Function: Thread::is_true_threads
//       Access: Published, Static
//  Description: Returns true if a real threading library is available
//               that supports actual OS-implemented threads, or false
//               if the only threading we can provide is simulated
//               user-space threading.
////////////////////////////////////////////////////////////////////
49
static inline bool Thread::is_true_threads(void);

138 17 is_simple_threads 0 4 234 25 Thread::is_simple_threads 0 1 19 722
////////////////////////////////////////////////////////////////////
//     Function: Thread::is_simple_threads
//       Access: Published, Static
//  Description: Returns true if Panda is currently compiled for
//               "simple threads", which is to say, cooperative
//               context switching only, reducing the need for quite
//               so many critical section protections.  This is not
//               necessarily the opposite of "true threads", since one
//               possible implementation of simple threads is via true
//               threads with mutex protection to ensure only one runs
//               at a time.
////////////////////////////////////////////////////////////////////
51
static inline bool Thread::is_simple_threads(void);

139 5 sleep 0 4 234 13 Thread::sleep 0 1 20 360
////////////////////////////////////////////////////////////////////
//     Function: Thread::sleep
//       Access: Published, Static
//  Description: Suspends the current thread for at least the
//               indicated amount of time.  It might be suspended for
//               longer.
////////////////////////////////////////////////////////////////////
49
static inline void Thread::sleep(double seconds);

140 11 force_yield 0 4 234 19 Thread::force_yield 0 1 21 306
////////////////////////////////////////////////////////////////////
//     Function: Thread::field_yield
//       Access: Published, Static
//  Description: Suspends the current thread for the rest of the
//               current epoch.
////////////////////////////////////////////////////////////////////
45
static inline void Thread::force_yield(void);

141 14 consider_yield 0 4 234 22 Thread::consider_yield 0 1 22 520
////////////////////////////////////////////////////////////////////
//     Function: Thread::consider_yield
//       Access: Published, Static
//  Description: Possibly suspends the current thread for the rest of
//               the current epoch, if it has run for enough this
//               epoch.  This is especially important for the simple
//               thread implementation, which relies on cooperative
//               yields like this.
////////////////////////////////////////////////////////////////////
48
static inline void Thread::consider_yield(void);

142 6 output 0 6 234 14 Thread::output 0 1 23 222
////////////////////////////////////////////////////////////////////
//     Function: Thread::output
//       Access: Published, Virtual
//  Description:
////////////////////////////////////////////////////////////////////
48
virtual void Thread::output(ostream &out) const;

143 14 output_blocker 0 4 234 22 Thread::output_blocker 0 1 24 440
////////////////////////////////////////////////////////////////////
//     Function: Thread::output_blocker
//       Access: Published
//  Description: Writes a description of the mutex or condition
//               variable that this thread is blocked on.  Writes
//               nothing if there is no blocker, or if we are not in
//               DEBUG_THREADS mode.
////////////////////////////////////////////////////////////////////
48
void Thread::output_blocker(ostream &out) const;

144 12 write_status 0 4 234 20 Thread::write_status 0 1 25 227
////////////////////////////////////////////////////////////////////
//     Function: Thread::write_status
//       Access: Published, Static
//  Description:
////////////////////////////////////////////////////////////////////
47
static void Thread::write_status(ostream &out);

145 10 is_started 0 4 234 18 Thread::is_started 0 1 26 338
////////////////////////////////////////////////////////////////////
//     Function: Thread::is_started
//       Access: Published
//  Description: Returns true if the thread has been started, false if
//               it has not, or if join() has already been called.
////////////////////////////////////////////////////////////////////
43
inline bool Thread::is_started(void) const;

146 11 is_joinable 0 4 234 19 Thread::is_joinable 0 1 27 302
////////////////////////////////////////////////////////////////////
//     Function: Thread::is_joinable
//       Access: Published
//  Description: Returns the value of joinable that was passed to the
//               start() call.
////////////////////////////////////////////////////////////////////
44
inline bool Thread::is_joinable(void) const;

147 5 start 0 4 234 13 Thread::start 0 1 28 1333
////////////////////////////////////////////////////////////////////
//     Function: Thread::start
//       Access: Public
//  Description: Starts the thread executing.  It is only valid to
//               call this once.
//
//               The thread will begin executing its thread_main()
//               function, and will terminate when thread_main()
//               returns.
//
//               priority is intended as a hint to the relative
//               importance of this thread.  This may be ignored by
//               the thread implementation.
//
//               joinable should be set true if you intend to call
//               join() to wait for the thread to terminate, or false
//               if you don't care and you will never call join().
//               Note that the reference count on the Thread object is
//               incremented while the thread itself is running, so if
//               you just want to fire and forget a thread, you may
//               pass joinable = false, and never store the Thread
//               object.  It will automatically destruct itself when
//               it finishes.
//
//               The return value is true if the thread is
//               successfully started, false otherwise.
////////////////////////////////////////////////////////////////////
59
bool Thread::start(ThreadPriority priority, bool joinable);

148 4 join 0 4 234 12 Thread::join 0 1 29 366
////////////////////////////////////////////////////////////////////
//     Function: Thread::join
//       Access: Published
//  Description: Blocks the calling process until the thread
//               terminates.  If the thread has already terminated,
//               this returns immediately.
////////////////////////////////////////////////////////////////////
31
inline void Thread::join(void);

149 7 preempt 0 4 234 15 Thread::preempt 0 1 30 432
////////////////////////////////////////////////////////////////////
//     Function: Thread::preempt
//       Access: Published
//  Description: Indicates that this thread should run as soon as
//               possible, preemptying any other threads that may be
//               scheduled to run.  This may not be implemented on
//               every platform.
////////////////////////////////////////////////////////////////////
34
inline void Thread::preempt(void);

150 15 set_python_data 0 4 234 23 Thread::set_python_data 0 1 31 543
////////////////////////////////////////////////////////////////////
//     Function: Thread::set_python_data
//       Access: Published
//  Description: Sets an arbitrary Python object that may be
//               associated with this thread object.  This is just for
//               the purposes of associated arbitrary Python data with
//               the C++ object; other than managing the reference
//               count, the C++ code does nothing with this object.
////////////////////////////////////////////////////////////////////
52
void Thread::set_python_data(PyObject *python_data);

151 15 get_python_data 0 4 234 23 Thread::get_python_data 0 1 32 302
////////////////////////////////////////////////////////////////////
//     Function: Thread::get_python_data
//       Access: Published
//  Description: Returns the Python object that was set with
//               set_python_data().
////////////////////////////////////////////////////////////////////
46
PyObject *Thread::get_python_data(void) const;

152 16 get_current_task 0 4 234 24 Thread::get_current_task 0 1 33 402
////////////////////////////////////////////////////////////////////
//     Function: Thread::get_current_task
//       Access: Published
//  Description: Returns the task currently executing on this thread
//               (via the AsyncTaskManager), if any, or NULL if the
//               thread is not currently servicing a task.
////////////////////////////////////////////////////////////////////
59
inline AsyncTaskBase *Thread::get_current_task(void) const;

153 16 prepare_for_exit 0 4 234 24 Thread::prepare_for_exit 0 1 34 387
////////////////////////////////////////////////////////////////////
//     Function: Thread::prepare_for_exit
//       Access: Published
//  Description: Should be called by the main thread just before
//               exiting the program, this blocks until any remaining
//               thread cleanup has finished.
////////////////////////////////////////////////////////////////////
50
static inline void Thread::prepare_for_exit(void);

154 14 get_class_type 0 4 234 22 Thread::get_class_type 0 1 35 0
47
static TypeHandle Thread::get_class_type(void);

155 7 acquire 0 4 235 20 MutexDirect::acquire 0 1 40 735
////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::acquire
//       Access: Published
//  Description: Grabs the mutex if it is available.  If it is not
//               available, blocks until it becomes available, then
//               grabs it.  In either case, the function does not
//               return until the mutex is held; you should then call
//               unlock().
//
//               This method is considered const so that you can lock
//               and unlock const mutexes, mainly to allow thread-safe
//               access to otherwise const data.
//
//               Also see MutexHolder.
////////////////////////////////////////////////////////////////////
45
inline void MutexDirect::acquire(void) const;

156 11 try_acquire 0 4 235 24 MutexDirect::try_acquire 0 1 41 369
////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::try_acquire
//       Access: Published
//  Description: Returns immediately, with a true value indicating the
//               mutex has been acquired, and false indicating it has
//               not.
////////////////////////////////////////////////////////////////////
49
inline bool MutexDirect::try_acquire(void) const;

157 7 release 0 4 235 20 MutexDirect::release 0 1 42 515
////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::release
//       Access: Published
//  Description: Releases the mutex.  It is an error to call this if
//               the mutex was not already locked.
//
//               This method is considered const so that you can lock
//               and unlock const mutexes, mainly to allow thread-safe
//               access to otherwise const data.
////////////////////////////////////////////////////////////////////
45
inline void MutexDirect::release(void) const;

158 15 debug_is_locked 0 4 235 28 MutexDirect::debug_is_locked 0 1 43 572
////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::debug_is_locked
//       Access: Published
//  Description: Returns true if the current thread has locked the
//               Mutex, false otherwise.  This method is only intended
//               for use in debugging, hence the method name; in the
//               MutexDirect case, it always returns true, since
//               there's not a reliable way to determine this
//               otherwise.
////////////////////////////////////////////////////////////////////
53
inline bool MutexDirect::debug_is_locked(void) const;

159 8 set_name 0 4 235 21 MutexDirect::set_name 0 1 44 303
////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::set_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
////////////////////////////////////////////////////////////////////
68
inline void MutexDirect::set_name(basic_string< char > const &name);

160 10 clear_name 0 4 235 23 MutexDirect::clear_name 0 1 45 305
////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::clear_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
////////////////////////////////////////////////////////////////////
42
inline void MutexDirect::clear_name(void);

161 8 has_name 0 4 235 21 MutexDirect::has_name 0 1 46 303
////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::has_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
////////////////////////////////////////////////////////////////////
46
inline bool MutexDirect::has_name(void) const;

162 8 get_name 0 4 235 21 MutexDirect::get_name 0 1 47 303
////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::get_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
////////////////////////////////////////////////////////////////////
62
inline basic_string< char > MutexDirect::get_name(void) const;

163 6 output 0 4 235 19 MutexDirect::output 0 1 48 311
////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::output
//       Access: Public
//  Description: This method is declared virtual in MutexDebug, but
//               non-virtual in MutexDirect.
////////////////////////////////////////////////////////////////////
45
void MutexDirect::output(ostream &out) const;

164 5 Mutex 0 4 236 12 Mutex::Mutex 0 2 49 50 1388
// Filename: pmutex.I
// Created by:  drose (08Aug02)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: Mutex::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: Mutex::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: Mutex::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: Mutex::Copy Constructor
//       Access: Private
//  Description: Do not attempt to copy mutexes.
////////////////////////////////////////////////////////////////////
81
inline Mutex::Mutex(void);
inline Mutex::Mutex(basic_string< char > const &name);

165 6 ~Mutex 0 4 236 13 Mutex::~Mutex 0 0 216
////////////////////////////////////////////////////////////////////
//     Function: Mutex::Destructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
27
inline Mutex::~Mutex(void);

166 19 ~ConditionVarDirect 0 4 237 39 ConditionVarDirect::~ConditionVarDirect 0 0 226
////////////////////////////////////////////////////////////////////
//     Function: ConditionVarDirect::Destructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
53
inline ConditionVarDirect::~ConditionVarDirect(void);

167 9 get_mutex 0 4 237 29 ConditionVarDirect::get_mutex 0 1 51 301
////////////////////////////////////////////////////////////////////
//     Function: ConditionVarDirect::get_mutex
//       Access: Public
//  Description: Returns the mutex associated with this condition
//               variable.
////////////////////////////////////////////////////////////////////
62
inline MutexDirect &ConditionVarDirect::get_mutex(void) const;

168 4 wait 0 4 237 24 ConditionVarDirect::wait 0 2 52 53 1945
////////////////////////////////////////////////////////////////////
//     Function: ConditionVarDirect::wait
//       Access: Public
//  Description: Waits on the condition.  The caller must already be
//               holding the lock associated with the condition
//               variable before calling this function.
//
//               wait() will release the lock, then go to sleep until
//               some other thread calls notify() on this condition
//               variable.  At that time at least one thread waiting
//               on the same ConditionVarDirect will grab the lock again,
//               and then return from wait().
//
//               It is possible that wait() will return even if no one
//               has called notify().  It is the responsibility of the
//               calling process to verify the condition on return
//               from wait, and possibly loop back to wait again if
//               necessary.
//
//               Note the semantics of a condition variable: the mutex
//               must be held before wait() is called, and it will
//               still be held when wait() returns.  However, it will
//               be temporarily released during the wait() call
//               itself.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ConditionVarDirect::wait
//       Access: Published
//  Description: Waits on the condition, with a timeout.  The function
//               will return when the condition variable is notified,
//               or the timeout occurs.  There is no way to directly
//               tell which happened, and it is possible that neither
//               in fact happened (spurious wakeups are possible).
//
//               See wait() with no parameters for more.
////////////////////////////////////////////////////////////////////
97
inline void ConditionVarDirect::wait(void);
inline void ConditionVarDirect::wait(double timeout);

169 6 notify 0 4 237 26 ConditionVarDirect::notify 0 1 54 903
////////////////////////////////////////////////////////////////////
//     Function: ConditionVarDirect::notify
//       Access: Public
//  Description: Informs one of the other threads who are currently
//               blocked on wait() that the relevant condition has
//               changed.  If multiple threads are currently waiting,
//               at least one of them will be woken up, although there
//               is no way to predict which one.  It is possible that
//               more than one thread will be woken up.
//
//               The caller must be holding the mutex associated with
//               the condition variable before making this call, which
//               will not release the mutex.
//
//               If no threads are waiting, this is a no-op: the
//               notify event is lost.
////////////////////////////////////////////////////////////////////
45
inline void ConditionVarDirect::notify(void);

170 6 output 0 4 237 26 ConditionVarDirect::output 0 1 55 332
////////////////////////////////////////////////////////////////////
//     Function: ConditionVarDirect::output
//       Access: Public
//  Description: This method is declared virtual in ConditionVarDebug,
//               but non-virtual in ConditionVarDirect.
////////////////////////////////////////////////////////////////////
52
void ConditionVarDirect::output(ostream &out) const;

171 12 ConditionVar 0 4 238 26 ConditionVar::ConditionVar 0 1 56 1329
// Filename: conditionVar.I
// Created by:  drose (09Aug02)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: ConditionVar::Constructor
//       Access: Published
//  Description: You must pass in a Mutex to the condition variable
//               constructor.  This mutex may be shared by other
//               condition variables, if desired.  It is the caller's
//               responsibility to ensure the Mutex object does not
//               destruct during the lifetime of the condition
//               variable.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ConditionVar::Copy Constructor
//       Access: Private
//  Description: Do not attempt to copy condition variables.
////////////////////////////////////////////////////////////////////
48
inline ConditionVar::ConditionVar(Mutex &mutex);

172 13 ~ConditionVar 0 4 238 27 ConditionVar::~ConditionVar 0 0 223
////////////////////////////////////////////////////////////////////
//     Function: ConditionVar::Destructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
41
inline ConditionVar::~ConditionVar(void);

173 9 get_mutex 0 4 238 23 ConditionVar::get_mutex 0 1 57 298
////////////////////////////////////////////////////////////////////
//     Function: ConditionVar::get_mutex
//       Access: Published
//  Description: Returns the mutex associated with this condition
//               variable.
////////////////////////////////////////////////////////////////////
50
inline Mutex &ConditionVar::get_mutex(void) const;

174 23 ~ConditionVarFullDirect 0 4 239 47 ConditionVarFullDirect::~ConditionVarFullDirect 0 0 230
////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFullDirect::Destructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
61
inline ConditionVarFullDirect::~ConditionVarFullDirect(void);

175 9 get_mutex 0 4 239 33 ConditionVarFullDirect::get_mutex 0 1 58 308
////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFullDirect::get_mutex
//       Access: Published
//  Description: Returns the mutex associated with this condition
//               variable.
////////////////////////////////////////////////////////////////////
66
inline MutexDirect &ConditionVarFullDirect::get_mutex(void) const;

176 4 wait 0 4 239 28 ConditionVarFullDirect::wait 0 2 59 60 1960
////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFullDirect::wait
//       Access: Published
//  Description: Waits on the condition.  The caller must already be
//               holding the lock associated with the condition
//               variable before calling this function.
//
//               wait() will release the lock, then go to sleep until
//               some other thread calls notify() on this condition
//               variable.  At that time at least one thread waiting
//               on the same ConditionVarFullDirect will grab the lock again,
//               and then return from wait().
//
//               It is possible that wait() will return even if no one
//               has called notify().  It is the responsibility of the
//               calling process to verify the condition on return
//               from wait, and possibly loop back to wait again if
//               necessary.
//
//               Note the semantics of a condition variable: the mutex
//               must be held before wait() is called, and it will
//               still be held when wait() returns.  However, it will
//               be temporarily released during the wait() call
//               itself.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFullDirect::wait
//       Access: Published
//  Description: Waits on the condition, with a timeout.  The function
//               will return when the condition variable is notified,
//               or the timeout occurs.  There is no way to directly
//               tell which happened, and it is possible that neither
//               in fact happened (spurious wakeups are possible).
//
//               See wait() with no parameters for more.
////////////////////////////////////////////////////////////////////
105
inline void ConditionVarFullDirect::wait(void);
inline void ConditionVarFullDirect::wait(double timeout);

177 6 notify 0 4 239 30 ConditionVarFullDirect::notify 0 1 61 904
////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFullDirect::notify
//       Access: Published
//  Description: Informs one of the other threads who are currently
//               blocked on wait() that the relevant condition has
//               changed.  If multiple threads are currently waiting,
//               at least one of them will be woken up, although there
//               is no way to predict which one.  It is possible that
//               more than one thread will be woken up.
//
//               The caller must be holding the mutex associated with
//               the condition variable before making this call, which
//               will not release the mutex.
//
//               If no threads are waiting, this is a no-op: the
//               notify is lost.
////////////////////////////////////////////////////////////////////
49
inline void ConditionVarFullDirect::notify(void);

178 10 notify_all 0 4 239 34 ConditionVarFullDirect::notify_all 0 1 62 673
////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFullDirect::notify_all
//       Access: Published
//  Description: Informs all of the other threads who are currently
//               blocked on wait() that the relevant condition has
//               changed.
//
//               The caller must be holding the mutex associated with
//               the condition variable before making this call, which
//               will not release the mutex.
//
//               If no threads are waiting, this is a no-op: the
//               notify event is lost.
////////////////////////////////////////////////////////////////////
53
inline void ConditionVarFullDirect::notify_all(void);

179 6 output 0 4 239 30 ConditionVarFullDirect::output 0 1 63 344
////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFullDirect::output
//       Access: Public
//  Description: This method is declared virtual in ConditionVarFullDebug,
//               but non-virtual in ConditionVarFullDirect.
////////////////////////////////////////////////////////////////////
56
void ConditionVarFullDirect::output(ostream &out) const;

180 16 ConditionVarFull 0 4 240 34 ConditionVarFull::ConditionVarFull 0 1 64 1341
// Filename: conditionVarFull.I
// Created by:  drose (28Aug06)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFull::Constructor
//       Access: Published
//  Description: You must pass in a Mutex to the condition variable
//               constructor.  This mutex may be shared by other
//               condition variables, if desired.  It is the caller's
//               responsibility to ensure the Mutex object does not
//               destruct during the lifetime of the condition
//               variable.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFull::Copy Constructor
//       Access: Private
//  Description: Do not attempt to copy condition variables.
////////////////////////////////////////////////////////////////////
56
inline ConditionVarFull::ConditionVarFull(Mutex &mutex);

181 17 ~ConditionVarFull 0 4 240 35 ConditionVarFull::~ConditionVarFull 0 0 227
////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFull::Destructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
49
inline ConditionVarFull::~ConditionVarFull(void);

182 9 get_mutex 0 4 240 27 ConditionVarFull::get_mutex 0 1 65 302
////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFull::get_mutex
//       Access: Published
//  Description: Returns the mutex associated with this condition
//               variable.
////////////////////////////////////////////////////////////////////
54
inline Mutex &ConditionVarFull::get_mutex(void) const;

183 7 acquire 0 4 241 22 ReMutexDirect::acquire 0 2 66 67 1115
////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::acquire
//       Access: Published
//  Description: Grabs the reMutex if it is available.  If it is not
//               available, blocks until it becomes available, then
//               grabs it.  In either case, the function does not
//               return until the reMutex is held; you should then call
//               unlock().
//
//               This method is considered const so that you can lock
//               and unlock const reMutexes, mainly to allow thread-safe
//               access to otherwise const data.
//
//               Also see ReMutexHolder.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::acquire
//       Access: Published
//  Description: This variant on acquire() accepts the current thread as
//               a parameter, if it is already known, as an
//               optimization.
////////////////////////////////////////////////////////////////////
113
inline void ReMutexDirect::acquire(void) const;
inline void ReMutexDirect::acquire(Thread *current_thread) const;

184 11 try_acquire 0 4 241 26 ReMutexDirect::try_acquire 0 2 68 69 744
////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::try_acquire
//       Access: Published
//  Description: Returns immediately, with a true value indicating the
//               mutex has been acquired, and false indicating it has
//               not.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::try_acquire
//       Access: Published
//  Description: Returns immediately, with a true value indicating the
//               mutex has been acquired, and false indicating it has
//               not.
////////////////////////////////////////////////////////////////////
121
inline bool ReMutexDirect::try_acquire(void) const;
inline bool ReMutexDirect::try_acquire(Thread *current_thread) const;

185 12 elevate_lock 0 4 241 27 ReMutexDirect::elevate_lock 0 1 70 819
////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::elevate_lock
//       Access: Published
//  Description: This method increments the lock count, assuming the
//               calling thread already holds the lock.  After this
//               call, release() will need to be called one additional
//               time to release the lock.
//
//               This method really performs the same function as
//               acquire(), but it offers a potential (slight)
//               performance benefit when the calling thread knows
//               that it already holds the lock.  It is an error to
//               call this when the calling thread does not hold the
//               lock.
////////////////////////////////////////////////////////////////////
52
inline void ReMutexDirect::elevate_lock(void) const;

186 7 release 0 4 241 22 ReMutexDirect::release 0 1 71 523
////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::release
//       Access: Published
//  Description: Releases the reMutex.  It is an error to call this if
//               the reMutex was not already locked.
//
//               This method is considered const so that you can lock
//               and unlock const reMutexes, mainly to allow thread-safe
//               access to otherwise const data.
////////////////////////////////////////////////////////////////////
47
inline void ReMutexDirect::release(void) const;

187 15 debug_is_locked 0 4 241 30 ReMutexDirect::debug_is_locked 0 1 72 578
////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::debug_is_locked
//       Access: Published
//  Description: Returns true if the current thread has locked the
//               ReMutex, false otherwise.  This method is only intended
//               for use in debugging, hence the method name; in the
//               ReMutexDirect case, it always returns true, since
//               there's not a reliable way to determine this
//               otherwise.
////////////////////////////////////////////////////////////////////
55
inline bool ReMutexDirect::debug_is_locked(void) const;

188 8 set_name 0 4 241 23 ReMutexDirect::set_name 0 1 73 305
////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::set_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
////////////////////////////////////////////////////////////////////
70
inline void ReMutexDirect::set_name(basic_string< char > const &name);

189 10 clear_name 0 4 241 25 ReMutexDirect::clear_name 0 1 74 307
////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::clear_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
////////////////////////////////////////////////////////////////////
44
inline void ReMutexDirect::clear_name(void);

190 8 has_name 0 4 241 23 ReMutexDirect::has_name 0 1 75 305
////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::has_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
////////////////////////////////////////////////////////////////////
48
inline bool ReMutexDirect::has_name(void) const;

191 8 get_name 0 4 241 23 ReMutexDirect::get_name 0 1 76 305
////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::get_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
////////////////////////////////////////////////////////////////////
64
inline basic_string< char > ReMutexDirect::get_name(void) const;

192 6 output 0 4 241 21 ReMutexDirect::output 0 1 77 318
////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::output
//       Access: Published
//  Description: This method is declared virtual in MutexDebug, but
//               non-virtual in ReMutexDirect.
////////////////////////////////////////////////////////////////////
47
void ReMutexDirect::output(ostream &out) const;

193 7 ReMutex 0 4 242 16 ReMutex::ReMutex 0 2 78 79 1135
// Filename: reMutex.I
// Created by:  drose (15Jan06)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: ReMutex::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ReMutex::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ReMutex::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
89
inline ReMutex::ReMutex(void);
inline ReMutex::ReMutex(basic_string< char > const &name);

194 8 ~ReMutex 0 4 242 17 ReMutex::~ReMutex 0 0 215
////////////////////////////////////////////////////////////////////
//     Function: ReMutex::Destructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
31
inline ReMutex::~ReMutex(void);

195 14 get_class_type 0 4 243 30 ExternalThread::get_class_type 0 1 80 0
55
static TypeHandle ExternalThread::get_class_type(void);

196 15 ~ExternalThread 0 4 243 31 ExternalThread::~ExternalThread 0 0 0
38
ExternalThread::~ExternalThread(void);

197 7 acquire 0 4 244 25 LightMutexDirect::acquire 0 1 81 760
////////////////////////////////////////////////////////////////////
//     Function: LightMutexDirect::acquire
//       Access: Published
//  Description: Grabs the lightMutex if it is available.  If it is not
//               available, blocks until it becomes available, then
//               grabs it.  In either case, the function does not
//               return until the lightMutex is held; you should then call
//               unlock().
//
//               This method is considered const so that you can lock
//               and unlock const lightMutexes, mainly to allow thread-safe
//               access to otherwise const data.
//
//               Also see LightMutexHolder.
////////////////////////////////////////////////////////////////////
50
inline void LightMutexDirect::acquire(void) const;

198 7 release 0 4 244 25 LightMutexDirect::release 0 1 82 535
////////////////////////////////////////////////////////////////////
//     Function: LightMutexDirect::release
//       Access: Published
//  Description: Releases the lightMutex.  It is an error to call this if
//               the lightMutex was not already locked.
//
//               This method is considered const so that you can lock
//               and unlock const lightMutexes, mainly to allow thread-safe
//               access to otherwise const data.
////////////////////////////////////////////////////////////////////
50
inline void LightMutexDirect::release(void) const;

199 15 debug_is_locked 0 4 244 33 LightMutexDirect::debug_is_locked 0 1 83 587
////////////////////////////////////////////////////////////////////
//     Function: LightMutexDirect::debug_is_locked
//       Access: Published
//  Description: Returns true if the current thread has locked the
//               LightMutex, false otherwise.  This method is only intended
//               for use in debugging, hence the method name; in the
//               LightMutexDirect case, it always returns true, since
//               there's not a reliable way to determine this
//               otherwise.
////////////////////////////////////////////////////////////////////
58
inline bool LightMutexDirect::debug_is_locked(void) const;

200 8 set_name 0 4 244 26 LightMutexDirect::set_name 0 1 84 313
////////////////////////////////////////////////////////////////////
//     Function: LightMutexDirect::set_name
//       Access: Public
//  Description: The lightMutex name is only defined when compiling in
//               DEBUG_THREADS mode.
////////////////////////////////////////////////////////////////////
73
inline void LightMutexDirect::set_name(basic_string< char > const &name);

201 10 clear_name 0 4 244 28 LightMutexDirect::clear_name 0 1 85 315
////////////////////////////////////////////////////////////////////
//     Function: LightMutexDirect::clear_name
//       Access: Public
//  Description: The lightMutex name is only defined when compiling in
//               DEBUG_THREADS mode.
////////////////////////////////////////////////////////////////////
47
inline void LightMutexDirect::clear_name(void);

202 8 has_name 0 4 244 26 LightMutexDirect::has_name 0 1 86 313
////////////////////////////////////////////////////////////////////
//     Function: LightMutexDirect::has_name
//       Access: Public
//  Description: The lightMutex name is only defined when compiling in
//               DEBUG_THREADS mode.
////////////////////////////////////////////////////////////////////
51
inline bool LightMutexDirect::has_name(void) const;

203 8 get_name 0 4 244 26 LightMutexDirect::get_name 0 1 87 313
////////////////////////////////////////////////////////////////////
//     Function: LightMutexDirect::get_name
//       Access: Public
//  Description: The lightMutex name is only defined when compiling in
//               DEBUG_THREADS mode.
////////////////////////////////////////////////////////////////////
67
inline basic_string< char > LightMutexDirect::get_name(void) const;

204 6 output 0 4 244 24 LightMutexDirect::output 0 1 88 326
////////////////////////////////////////////////////////////////////
//     Function: LightMutexDirect::output
//       Access: Public
//  Description: This method is declared virtual in LightMutexDebug, but
//               non-virtual in LightMutexDirect.
////////////////////////////////////////////////////////////////////
50
void LightMutexDirect::output(ostream &out) const;

205 10 LightMutex 0 4 245 22 LightMutex::LightMutex 0 2 89 90 1417
// Filename: lightMutex.I
// Created by:  drose (08Oct08)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: LightMutex::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: LightMutex::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: LightMutex::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: LightMutex::Copy Constructor
//       Access: Private
//  Description: Do not attempt to copy lightMutexes.
////////////////////////////////////////////////////////////////////
101
inline LightMutex::LightMutex(void);
inline LightMutex::LightMutex(basic_string< char > const &name);

206 11 ~LightMutex 0 4 245 23 LightMutex::~LightMutex 0 0 221
////////////////////////////////////////////////////////////////////
//     Function: LightMutex::Destructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
37
inline LightMutex::~LightMutex(void);

207 7 acquire 0 4 246 27 LightReMutexDirect::acquire 0 2 91 92 1145
////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::acquire
//       Access: Published
//  Description: Grabs the lightReMutex if it is available.  If it is not
//               available, blocks until it becomes available, then
//               grabs it.  In either case, the function does not
//               return until the lightReMutex is held; you should then call
//               unlock().
//
//               This method is considered const so that you can lock
//               and unlock const lightReMutexes, mainly to allow thread-safe
//               access to otherwise const data.
//
//               Also see LightReMutexHolder.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::acquire
//       Access: Published
//  Description: This variant on acquire() accepts the current thread as
//               a parameter, if it is already known, as an
//               optimization.
////////////////////////////////////////////////////////////////////
123
inline void LightReMutexDirect::acquire(void) const;
inline void LightReMutexDirect::acquire(Thread *current_thread) const;

208 12 elevate_lock 0 4 246 32 LightReMutexDirect::elevate_lock 0 1 93 824
////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::elevate_lock
//       Access: Published
//  Description: This method increments the lock count, assuming the
//               calling thread already holds the lock.  After this
//               call, release() will need to be called one additional
//               time to release the lock.
//
//               This method really performs the same function as
//               acquire(), but it offers a potential (slight)
//               performance benefit when the calling thread knows
//               that it already holds the lock.  It is an error to
//               call this when the calling thread does not hold the
//               lock.
////////////////////////////////////////////////////////////////////
57
inline void LightReMutexDirect::elevate_lock(void) const;

209 7 release 0 4 246 27 LightReMutexDirect::release 0 1 94 543
////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::release
//       Access: Published
//  Description: Releases the lightReMutex.  It is an error to call this if
//               the lightReMutex was not already locked.
//
//               This method is considered const so that you can lock
//               and unlock const lightReMutexes, mainly to allow thread-safe
//               access to otherwise const data.
////////////////////////////////////////////////////////////////////
52
inline void LightReMutexDirect::release(void) const;

210 15 debug_is_locked 0 4 246 35 LightReMutexDirect::debug_is_locked 0 1 95 593
////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::debug_is_locked
//       Access: Published
//  Description: Returns true if the current thread has locked the
//               LightReMutex, false otherwise.  This method is only intended
//               for use in debugging, hence the method name; in the
//               LightReMutexDirect case, it always returns true, since
//               there's not a reliable way to determine this
//               otherwise.
////////////////////////////////////////////////////////////////////
60
inline bool LightReMutexDirect::debug_is_locked(void) const;

211 8 set_name 0 4 246 28 LightReMutexDirect::set_name 0 1 96 310
////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::set_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
////////////////////////////////////////////////////////////////////
75
inline void LightReMutexDirect::set_name(basic_string< char > const &name);

212 10 clear_name 0 4 246 30 LightReMutexDirect::clear_name 0 1 97 312
////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::clear_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
////////////////////////////////////////////////////////////////////
49
inline void LightReMutexDirect::clear_name(void);

213 8 has_name 0 4 246 28 LightReMutexDirect::has_name 0 1 98 310
////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::has_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
////////////////////////////////////////////////////////////////////
53
inline bool LightReMutexDirect::has_name(void) const;

214 8 get_name 0 4 246 28 LightReMutexDirect::get_name 0 1 99 310
////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::get_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
////////////////////////////////////////////////////////////////////
69
inline basic_string< char > LightReMutexDirect::get_name(void) const;

215 6 output 0 4 246 26 LightReMutexDirect::output 0 1 100 328
////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::output
//       Access: Published
//  Description: This method is declared virtual in MutexDebug, but
//               non-virtual in LightReMutexDirect.
////////////////////////////////////////////////////////////////////
52
void LightReMutexDirect::output(ostream &out) const;

216 12 LightReMutex 0 4 247 26 LightReMutex::LightReMutex 0 2 101 102 1155
// Filename: lightReMutex.I
// Created by:  drose (08Oct08)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: LightReMutex::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: LightReMutex::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: LightReMutex::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
109
inline LightReMutex::LightReMutex(void);
inline LightReMutex::LightReMutex(basic_string< char > const &name);

217 13 ~LightReMutex 0 4 247 27 LightReMutex::~LightReMutex 0 0 220
////////////////////////////////////////////////////////////////////
//     Function: LightReMutex::Destructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
41
inline LightReMutex::~LightReMutex(void);

218 14 get_class_type 0 4 248 26 MainThread::get_class_type 0 1 103 0
51
static TypeHandle MainThread::get_class_type(void);

219 11 ~MainThread 0 4 248 23 MainThread::~MainThread 0 0 0
30
MainThread::~MainThread(void);

220 12 PythonThread 0 4 249 26 PythonThread::PythonThread 0 1 104 224
////////////////////////////////////////////////////////////////////
//     Function: PythonThread::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
136
PythonThread::PythonThread(PyObject *function, PyObject *args, basic_string< char > const &name, basic_string< char > const &sync_name);

221 4 join 0 4 249 18 PythonThread::join 0 1 105 506
////////////////////////////////////////////////////////////////////
//     Function: PythonThread::join
//       Access: Published
//  Description: Blocks the calling process until the thread
//               terminates.  If the thread has already terminated,
//               this returns immediately.
//
//               The PythonThread flavor of this function returns the
//               same value returned by the thread function.
////////////////////////////////////////////////////////////////////
35
PyObject *PythonThread::join(void);

222 14 get_class_type 0 4 249 28 PythonThread::get_class_type 0 1 106 0
53
static TypeHandle PythonThread::get_class_type(void);

223 9 Semaphore 0 4 250 20 Semaphore::Semaphore 0 2 107 108 969
// Filename: psemaphore.I
// Created by:  drose (13Oct08)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: Semaphore::Constructor
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: Semaphore::Copy Constructor
//       Access: Private
//  Description: Do not attempt to copy semaphores.
////////////////////////////////////////////////////////////////////
53
inline Semaphore::Semaphore(int initial_count = (1));

224 10 ~Semaphore 0 4 250 21 Semaphore::~Semaphore 0 0 221
////////////////////////////////////////////////////////////////////
//     Function: Semaphore::Destructor
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
35
inline Semaphore::~Semaphore(void);

225 7 acquire 0 4 250 18 Semaphore::acquire 0 1 109 372
////////////////////////////////////////////////////////////////////
//     Function: Semaphore::acquire
//       Access: Published
//  Description: Decrements the internal count.  If the count was
//               already at zero, blocks until the count is nonzero,
//               then decrements it.
////////////////////////////////////////////////////////////////////
37
inline void Semaphore::acquire(void);

226 11 try_acquire 0 4 250 22 Semaphore::try_acquire 0 1 110 342
////////////////////////////////////////////////////////////////////
//     Function: Semaphore::try_acquire
//       Access: Published
//  Description: If the semaphore can be acquired without blocking,
//               does so and returns true.  Otherwise, returns false.
////////////////////////////////////////////////////////////////////
41
inline bool Semaphore::try_acquire(void);

227 7 release 0 4 250 18 Semaphore::release 0 1 111 401
////////////////////////////////////////////////////////////////////
//     Function: Semaphore::release
//       Access: Published
//  Description: Increments the semaphore's internal count.  This may
//               wake up another thread blocked on acquire().
//
//               Returns the count of the semaphore upon release.
////////////////////////////////////////////////////////////////////
36
inline int Semaphore::release(void);

228 9 get_count 0 4 250 20 Semaphore::get_count 0 1 112 366
////////////////////////////////////////////////////////////////////
//     Function: Semaphore::get_count
//       Access: Published
//  Description: Returns the current semaphore count.  Note that this
//               call is not thread-safe (the count may change at any
//               time).
////////////////////////////////////////////////////////////////////
44
inline int Semaphore::get_count(void) const;

229 6 output 0 4 250 17 Semaphore::output 0 1 113 217
////////////////////////////////////////////////////////////////////
//     Function: Semaphore::output
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
43
void Semaphore::output(ostream &out) const;

113
1 14 Dtool_kd_idS4g 0 7 9 252 0 14 Dtool_kd_idS4g 0 0 
2 14 Dtool_kd_ikBIS 0 7 3 254 0 14 Dtool_kd_ikBIS 0 1 4 this 3 253  
3 14 Dtool_kd_i_Yr4 0 7 4 253 118 14 Dtool_kd_i_Yr4 0 1 4 this 3 254  
4 14 Dtool_kd_iqPoC 0 6 6 255 0 14 Dtool_kd_iqPoC 0 1 4 this 3 253  
5 14 Dtool_kd_iUoYV 0 7 7 253 118 14 Dtool_kd_iUoYV 0 1 4 this 3 255  
6 14 Dtool_kd_iRc6P 0 7 17 257 124 14 Dtool_kd_iRc6P 1438 ////////////////////////////////////////////////////////////////////
//     Function: Thread::bind_thread
//       Access: Published, Static
//  Description: Returns a new Panda Thread object associated with the
//               current thread (which has been created externally).
//               This can be used to bind a unique Panda Thread object
//               with an external thread, such as a new Python thread.
//
//               It is particularly useful to bind a Panda Thread
//               object to an external thread for the purposes of
//               PStats monitoring.  Without this call, each external
//               thread will be assigned the same global
//               ExternalThread object, which means they will all
//               appear in the same PStats graph.
//
//               It is the caller's responsibility to save the
//               returned Thread pointer for the lifetime of the
//               external thread.  It is an error for the Thread
//               pointer to destruct while the external thread is
//               still in the system.
//
//               It is also an error to call this method from the main
//               thread, or twice within a given thread, unless it is
//               given the same name each time (in which case the same
//               pointer will be returned each time).
//////////////////////////////////////////////////////////////////// 2 4 name 1 256  9 sync_name 1 256  
7 14 Dtool_kd_ijq87 0 6 18 256 0 14 Dtool_kd_ijq87 565 ////////////////////////////////////////////////////////////////////
//     Function: Thread::get_sync_name
//       Access: Published
//  Description: Returns the sync name of the thread.  This name
//               collects threads into "sync groups", which are
//               expected to run synchronously.  This is mainly used
//               for the benefit of PStats; threads with the same sync
//               name can be ticked all at once via the thread_tick()
//               call.
//////////////////////////////////////////////////////////////////// 1 4 this 3 258  
8 14 Dtool_kd_iH7ri 0 6 19 260 0 14 Dtool_kd_iH7ri 476 ////////////////////////////////////////////////////////////////////
//     Function: Thread::get_pstats_index
//       Access: Published
//  Description: Returns the PStats index associated with this thread,
//               or -1 if no index has yet been associated with this
//               thread.  This is used internally by the PStatClient;
//               you should not need to call this directly.
//////////////////////////////////////////////////////////////////// 1 4 this 3 258  
9 14 Dtool_kd_igw2i 0 6 20 256 0 14 Dtool_kd_igw2i 402 ////////////////////////////////////////////////////////////////////
//     Function: Thread::get_unique_id
//       Access: Published
//  Description: Returns a string that is guaranteed to be unique to
//               this thread, across all processes on the machine,
//               during at least the lifetime of this process.
//////////////////////////////////////////////////////////////////// 1 4 this 3 258  
10 14 Dtool_kd_imKhn 0 6 21 260 0 14 Dtool_kd_imKhn 409 ////////////////////////////////////////////////////////////////////
//     Function: Thread::get_pipeline_stage
//       Access: Published
//  Description: Returns the Pipeline stage number associated with
//               this thread.  The default stage is 0 if no stage is
//               specified otherwise.  See set_pipeline_stage().
//////////////////////////////////////////////////////////////////// 1 4 this 3 258  
11 14 Dtool_kd_iiVSW 0 4 22 261 0 14 Dtool_kd_iiVSW 831 ////////////////////////////////////////////////////////////////////
//     Function: Thread::set_pipeline_stage
//       Access: Published
//  Description: Specifies the Pipeline stage number associated with
//               this thread.  The default stage is 0 if no stage is
//               specified otherwise.
//
//               This must be a value in the range [0
//               .. pipeline->get_num_stages() - 1].  It specifies the
//               values that this thread observes for all pipelined
//               data.  Typically, an application thread will leave
//               this at 0, but a render thread may set it to 1 or 2
//               (to operate on the previous frame's data, or the
//               second previous frame's data).
//////////////////////////////////////////////////////////////////// 2 4 this 3 257  14 pipeline_stage 1 260  
12 14 Dtool_kd_iOmlk 0 4 23 261 0 14 Dtool_kd_iOmlk 392 ////////////////////////////////////////////////////////////////////
//     Function: Thread::set_min_pipeline_stage
//       Access: Published
//  Description: Sets this thread's pipeline stage number to at least
//               the indicated value, unless it is already larger.
//               See set_pipeline_stage().
//////////////////////////////////////////////////////////////////// 2 4 this 3 257  18 min_pipeline_stage 1 260  
13 14 Dtool_kd_iY2Dw 0 7 24 257 124 14 Dtool_kd_iY2Dw 345 ////////////////////////////////////////////////////////////////////
//     Function: Thread::get_main_thread
//       Access: Published, Static
//  Description: Returns a pointer to the "main" Thread object--this
//               is the Thread that started the whole process.
//////////////////////////////////////////////////////////////////// 0 
14 14 Dtool_kd_iD1UC 0 7 25 257 124 14 Dtool_kd_iD1UC 531 ////////////////////////////////////////////////////////////////////
//     Function: Thread::get_external_thread
//       Access: Published, Static
//  Description: Returns a pointer to the "external" Thread
//               object--this is a special Thread object that
//               corresponds to any thread spawned outside of Panda's
//               threading interface.  Note that multiple different
//               threads may share this same pointer.
//////////////////////////////////////////////////////////////////// 0 
15 14 Dtool_kd_i3TiV 0 7 26 257 124 14 Dtool_kd_i3TiV 738 ////////////////////////////////////////////////////////////////////
//     Function: Thread::get_current_thread
//       Access: Published, Static
//  Description: Returns a pointer to the currently-executing Thread
//               object.  If this is called from the main thread, this
//               will return the same value as get_main_thread().
//
//               This will always return some valid Thread pointer.
//               It will never return NULL, even if the current thread
//               was spawned outside of Panda's threading system,
//               although all non-Panda threads will return the exact
//               same Thread pointer.
//////////////////////////////////////////////////////////////////// 0 
16 14 Dtool_kd_iqF2R 0 6 27 260 0 14 Dtool_kd_iqF2R 485 ////////////////////////////////////////////////////////////////////
//     Function: Thread::get_current_pipeline_stage
//       Access: Published, Static
//  Description: Returns the integer pipeline stage associated with
//               the current thread.  This is the same thing as
//               get_current_thread()->get_pipeline_stage(), but it
//               may be faster to retrieve in some contexts.
//////////////////////////////////////////////////////////////////// 0 
17 14 Dtool_kd_i5vLQ 0 6 28 262 0 14 Dtool_kd_i5vLQ 417 ////////////////////////////////////////////////////////////////////
//     Function: Thread::is_threading_supported
//       Access: Published, Static
//  Description: Returns true if threading support has been compiled
//               in and enabled, or false if no threading is available
//               (and Thread::start() will always fail).
//////////////////////////////////////////////////////////////////// 0 
18 14 Dtool_kd_iyg5j 0 6 29 262 0 14 Dtool_kd_iyg5j 461 ////////////////////////////////////////////////////////////////////
//     Function: Thread::is_true_threads
//       Access: Published, Static
//  Description: Returns true if a real threading library is available
//               that supports actual OS-implemented threads, or false
//               if the only threading we can provide is simulated
//               user-space threading.
//////////////////////////////////////////////////////////////////// 0 
19 14 Dtool_kd_iQd5Y 0 6 30 262 0 14 Dtool_kd_iQd5Y 722 ////////////////////////////////////////////////////////////////////
//     Function: Thread::is_simple_threads
//       Access: Published, Static
//  Description: Returns true if Panda is currently compiled for
//               "simple threads", which is to say, cooperative
//               context switching only, reducing the need for quite
//               so many critical section protections.  This is not
//               necessarily the opposite of "true threads", since one
//               possible implementation of simple threads is via true
//               threads with mutex protection to ensure only one runs
//               at a time.
//////////////////////////////////////////////////////////////////// 0 
20 14 Dtool_kd_iEK72 0 4 31 261 0 14 Dtool_kd_iEK72 360 ////////////////////////////////////////////////////////////////////
//     Function: Thread::sleep
//       Access: Published, Static
//  Description: Suspends the current thread for at least the
//               indicated amount of time.  It might be suspended for
//               longer.
//////////////////////////////////////////////////////////////////// 1 7 seconds 1 263  
21 14 Dtool_kd_iA_Rs 0 4 32 261 0 14 Dtool_kd_iA_Rs 306 ////////////////////////////////////////////////////////////////////
//     Function: Thread::field_yield
//       Access: Published, Static
//  Description: Suspends the current thread for the rest of the
//               current epoch.
//////////////////////////////////////////////////////////////////// 0 
22 14 Dtool_kd_iMrcC 0 4 33 261 0 14 Dtool_kd_iMrcC 520 ////////////////////////////////////////////////////////////////////
//     Function: Thread::consider_yield
//       Access: Published, Static
//  Description: Possibly suspends the current thread for the rest of
//               the current epoch, if it has run for enough this
//               epoch.  This is especially important for the simple
//               thread implementation, which relies on cooperative
//               yields like this.
//////////////////////////////////////////////////////////////////// 0 
23 14 Dtool_kd_iffd4 0 4 34 261 0 14 Dtool_kd_iffd4 222 ////////////////////////////////////////////////////////////////////
//     Function: Thread::output
//       Access: Published, Virtual
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 258  3 out 1 264  
24 14 Dtool_kd_iIMot 0 4 35 261 0 14 Dtool_kd_iIMot 440 ////////////////////////////////////////////////////////////////////
//     Function: Thread::output_blocker
//       Access: Published
//  Description: Writes a description of the mutex or condition
//               variable that this thread is blocked on.  Writes
//               nothing if there is no blocker, or if we are not in
//               DEBUG_THREADS mode.
//////////////////////////////////////////////////////////////////// 2 4 this 3 258  3 out 1 264  
25 14 Dtool_kd_iTfGZ 0 4 36 261 0 14 Dtool_kd_iTfGZ 227 ////////////////////////////////////////////////////////////////////
//     Function: Thread::write_status
//       Access: Published, Static
//  Description:
//////////////////////////////////////////////////////////////////// 1 3 out 1 264  
26 14 Dtool_kd_i9pHH 0 6 37 262 0 14 Dtool_kd_i9pHH 338 ////////////////////////////////////////////////////////////////////
//     Function: Thread::is_started
//       Access: Published
//  Description: Returns true if the thread has been started, false if
//               it has not, or if join() has already been called.
//////////////////////////////////////////////////////////////////// 1 4 this 3 258  
27 14 Dtool_kd_ifYmX 0 6 38 262 0 14 Dtool_kd_ifYmX 302 ////////////////////////////////////////////////////////////////////
//     Function: Thread::is_joinable
//       Access: Published
//  Description: Returns the value of joinable that was passed to the
//               start() call.
//////////////////////////////////////////////////////////////////// 1 4 this 3 258  
28 14 Dtool_kd_i6vf2 0 6 39 262 0 14 Dtool_kd_i6vf2 1333 ////////////////////////////////////////////////////////////////////
//     Function: Thread::start
//       Access: Public
//  Description: Starts the thread executing.  It is only valid to
//               call this once.
//
//               The thread will begin executing its thread_main()
//               function, and will terminate when thread_main()
//               returns.
//
//               priority is intended as a hint to the relative
//               importance of this thread.  This may be ignored by
//               the thread implementation.
//
//               joinable should be set true if you intend to call
//               join() to wait for the thread to terminate, or false
//               if you don't care and you will never call join().
//               Note that the reference count on the Thread object is
//               incremented while the thread itself is running, so if
//               you just want to fire and forget a thread, you may
//               pass joinable = false, and never store the Thread
//               object.  It will automatically destruct itself when
//               it finishes.
//
//               The return value is true if the thread is
//               successfully started, false otherwise.
//////////////////////////////////////////////////////////////////// 3 4 this 3 257  8 priority 1 233  8 joinable 1 262  
29 14 Dtool_kd_iz6lV 0 4 40 261 0 14 Dtool_kd_iz6lV 366 ////////////////////////////////////////////////////////////////////
//     Function: Thread::join
//       Access: Published
//  Description: Blocks the calling process until the thread
//               terminates.  If the thread has already terminated,
//               this returns immediately.
//////////////////////////////////////////////////////////////////// 1 4 this 3 257  
30 14 Dtool_kd_iEmqG 0 4 41 261 0 14 Dtool_kd_iEmqG 432 ////////////////////////////////////////////////////////////////////
//     Function: Thread::preempt
//       Access: Published
//  Description: Indicates that this thread should run as soon as
//               possible, preemptying any other threads that may be
//               scheduled to run.  This may not be implemented on
//               every platform.
//////////////////////////////////////////////////////////////////// 1 4 this 3 257  
31 14 Dtool_kd_iBnhA 0 4 42 261 0 14 Dtool_kd_iBnhA 543 ////////////////////////////////////////////////////////////////////
//     Function: Thread::set_python_data
//       Access: Published
//  Description: Sets an arbitrary Python object that may be
//               associated with this thread object.  This is just for
//               the purposes of associated arbitrary Python data with
//               the C++ object; other than managing the reference
//               count, the C++ code does nothing with this object.
//////////////////////////////////////////////////////////////////// 2 4 this 3 257  11 python_data 1 266  
32 14 Dtool_kd_i3PGe 0 6 43 266 0 14 Dtool_kd_i3PGe 302 ////////////////////////////////////////////////////////////////////
//     Function: Thread::get_python_data
//       Access: Published
//  Description: Returns the Python object that was set with
//               set_python_data().
//////////////////////////////////////////////////////////////////// 1 4 this 3 258  
33 14 Dtool_kd_iHhFW 0 7 44 253 118 14 Dtool_kd_iHhFW 402 ////////////////////////////////////////////////////////////////////
//     Function: Thread::get_current_task
//       Access: Published
//  Description: Returns the task currently executing on this thread
//               (via the AsyncTaskManager), if any, or NULL if the
//               thread is not currently servicing a task.
//////////////////////////////////////////////////////////////////// 1 4 this 3 258  
34 14 Dtool_kd_iwYwm 0 4 45 261 0 14 Dtool_kd_iwYwm 387 ////////////////////////////////////////////////////////////////////
//     Function: Thread::prepare_for_exit
//       Access: Published
//  Description: Should be called by the main thread just before
//               exiting the program, this blocks until any remaining
//               thread cleanup has finished.
//////////////////////////////////////////////////////////////////// 0 
35 14 Dtool_kd_i_lqM 0 7 46 252 0 14 Dtool_kd_i_lqM 0 0 
36 14 Dtool_kd_im7Dx 0 7 12 254 0 14 Dtool_kd_im7Dx 0 1 4 this 3 257  
37 14 Dtool_kd_iiO2P 0 7 13 257 124 14 Dtool_kd_iiO2P 0 1 4 this 3 254  
38 14 Dtool_kd_ilnUX 0 6 14 255 0 14 Dtool_kd_ilnUX 0 1 4 this 3 257  
39 14 Dtool_kd_iFtoz 0 7 15 257 124 14 Dtool_kd_iFtoz 0 1 4 this 3 255  
40 14 Dtool_kd_iOui6 0 4 48 261 0 14 Dtool_kd_iOui6 735 ////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::acquire
//       Access: Published
//  Description: Grabs the mutex if it is available.  If it is not
//               available, blocks until it becomes available, then
//               grabs it.  In either case, the function does not
//               return until the mutex is held; you should then call
//               unlock().
//
//               This method is considered const so that you can lock
//               and unlock const mutexes, mainly to allow thread-safe
//               access to otherwise const data.
//
//               Also see MutexHolder.
//////////////////////////////////////////////////////////////////// 1 4 this 3 268  
41 14 Dtool_kd_ia7c4 0 6 49 262 0 14 Dtool_kd_ia7c4 369 ////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::try_acquire
//       Access: Published
//  Description: Returns immediately, with a true value indicating the
//               mutex has been acquired, and false indicating it has
//               not.
//////////////////////////////////////////////////////////////////// 1 4 this 3 268  
42 14 Dtool_kd_ippbs 0 4 50 261 0 14 Dtool_kd_ippbs 515 ////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::release
//       Access: Published
//  Description: Releases the mutex.  It is an error to call this if
//               the mutex was not already locked.
//
//               This method is considered const so that you can lock
//               and unlock const mutexes, mainly to allow thread-safe
//               access to otherwise const data.
//////////////////////////////////////////////////////////////////// 1 4 this 3 268  
43 14 Dtool_kd_iHTyM 0 6 51 262 0 14 Dtool_kd_iHTyM 572 ////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::debug_is_locked
//       Access: Published
//  Description: Returns true if the current thread has locked the
//               Mutex, false otherwise.  This method is only intended
//               for use in debugging, hence the method name; in the
//               MutexDirect case, it always returns true, since
//               there's not a reliable way to determine this
//               otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 268  
44 14 Dtool_kd_i9_B4 0 4 52 261 0 14 Dtool_kd_i9_B4 303 ////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::set_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
//////////////////////////////////////////////////////////////////// 2 4 this 3 270  4 name 1 256  
45 14 Dtool_kd_iJnDd 0 4 53 261 0 14 Dtool_kd_iJnDd 305 ////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::clear_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
//////////////////////////////////////////////////////////////////// 1 4 this 3 270  
46 14 Dtool_kd_iqC3W 0 6 54 262 0 14 Dtool_kd_iqC3W 303 ////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::has_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
//////////////////////////////////////////////////////////////////// 1 4 this 3 268  
47 14 Dtool_kd_iAGiT 0 6 55 256 0 14 Dtool_kd_iAGiT 303 ////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::get_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
//////////////////////////////////////////////////////////////////// 1 4 this 3 268  
48 14 Dtool_kd_iyEWt 0 4 56 261 0 14 Dtool_kd_iyEWt 311 ////////////////////////////////////////////////////////////////////
//     Function: MutexDirect::output
//       Access: Public
//  Description: This method is declared virtual in MutexDebug, but
//               non-virtual in MutexDirect.
//////////////////////////////////////////////////////////////////// 2 4 this 3 268  3 out 1 264  
49 14 Dtool_kd_iNvQQ 0 7 58 271 165 14 Dtool_kd_iNvQQ 699 // Filename: pmutex.I
// Created by:  drose (08Aug02)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: Mutex::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
50 14 Dtool_kd_idp7X 0 7 58 271 165 14 Dtool_kd_idp7X 217 ////////////////////////////////////////////////////////////////////
//     Function: Mutex::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 name 1 256  
51 14 Dtool_kd_iD016 0 6 62 270 0 14 Dtool_kd_iD016 301 ////////////////////////////////////////////////////////////////////
//     Function: ConditionVarDirect::get_mutex
//       Access: Public
//  Description: Returns the mutex associated with this condition
//               variable.
//////////////////////////////////////////////////////////////////// 1 4 this 3 272  
52 14 Dtool_kd_iG44v 0 4 63 261 0 14 Dtool_kd_iG44v 1330 ////////////////////////////////////////////////////////////////////
//     Function: ConditionVarDirect::wait
//       Access: Public
//  Description: Waits on the condition.  The caller must already be
//               holding the lock associated with the condition
//               variable before calling this function.
//
//               wait() will release the lock, then go to sleep until
//               some other thread calls notify() on this condition
//               variable.  At that time at least one thread waiting
//               on the same ConditionVarDirect will grab the lock again,
//               and then return from wait().
//
//               It is possible that wait() will return even if no one
//               has called notify().  It is the responsibility of the
//               calling process to verify the condition on return
//               from wait, and possibly loop back to wait again if
//               necessary.
//
//               Note the semantics of a condition variable: the mutex
//               must be held before wait() is called, and it will
//               still be held when wait() returns.  However, it will
//               be temporarily released during the wait() call
//               itself.
//////////////////////////////////////////////////////////////////// 1 4 this 3 274  
53 14 Dtool_kd_i2oja 0 4 63 261 0 14 Dtool_kd_i2oja 613 ////////////////////////////////////////////////////////////////////
//     Function: ConditionVarDirect::wait
//       Access: Published
//  Description: Waits on the condition, with a timeout.  The function
//               will return when the condition variable is notified,
//               or the timeout occurs.  There is no way to directly
//               tell which happened, and it is possible that neither
//               in fact happened (spurious wakeups are possible).
//
//               See wait() with no parameters for more.
//////////////////////////////////////////////////////////////////// 2 4 this 3 274  7 timeout 1 263  
54 14 Dtool_kd_ilhob 0 4 64 261 0 14 Dtool_kd_ilhob 903 ////////////////////////////////////////////////////////////////////
//     Function: ConditionVarDirect::notify
//       Access: Public
//  Description: Informs one of the other threads who are currently
//               blocked on wait() that the relevant condition has
//               changed.  If multiple threads are currently waiting,
//               at least one of them will be woken up, although there
//               is no way to predict which one.  It is possible that
//               more than one thread will be woken up.
//
//               The caller must be holding the mutex associated with
//               the condition variable before making this call, which
//               will not release the mutex.
//
//               If no threads are waiting, this is a no-op: the
//               notify event is lost.
//////////////////////////////////////////////////////////////////// 1 4 this 3 274  
55 14 Dtool_kd_i_ndm 0 4 65 261 0 14 Dtool_kd_i_ndm 332 ////////////////////////////////////////////////////////////////////
//     Function: ConditionVarDirect::output
//       Access: Public
//  Description: This method is declared virtual in ConditionVarDebug,
//               but non-virtual in ConditionVarDirect.
//////////////////////////////////////////////////////////////////// 2 4 this 3 272  3 out 1 264  
56 14 Dtool_kd_iYPq5 0 7 67 275 172 14 Dtool_kd_iYPq5 1056 // Filename: conditionVar.I
// Created by:  drose (09Aug02)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: ConditionVar::Constructor
//       Access: Published
//  Description: You must pass in a Mutex to the condition variable
//               constructor.  This mutex may be shared by other
//               condition variables, if desired.  It is the caller's
//               responsibility to ensure the Mutex object does not
//               destruct during the lifetime of the condition
//               variable.
//////////////////////////////////////////////////////////////////// 1 5 mutex 1 271  
57 14 Dtool_kd_iVf1V 0 6 69 271 0 14 Dtool_kd_iVf1V 298 ////////////////////////////////////////////////////////////////////
//     Function: ConditionVar::get_mutex
//       Access: Published
//  Description: Returns the mutex associated with this condition
//               variable.
//////////////////////////////////////////////////////////////////// 1 4 this 3 276  
58 14 Dtool_kd_ij3dq 0 6 72 270 0 14 Dtool_kd_ij3dq 308 ////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFullDirect::get_mutex
//       Access: Published
//  Description: Returns the mutex associated with this condition
//               variable.
//////////////////////////////////////////////////////////////////// 1 4 this 3 278  
59 14 Dtool_kd_iqoyJ 0 4 73 261 0 14 Dtool_kd_iqoyJ 1341 ////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFullDirect::wait
//       Access: Published
//  Description: Waits on the condition.  The caller must already be
//               holding the lock associated with the condition
//               variable before calling this function.
//
//               wait() will release the lock, then go to sleep until
//               some other thread calls notify() on this condition
//               variable.  At that time at least one thread waiting
//               on the same ConditionVarFullDirect will grab the lock again,
//               and then return from wait().
//
//               It is possible that wait() will return even if no one
//               has called notify().  It is the responsibility of the
//               calling process to verify the condition on return
//               from wait, and possibly loop back to wait again if
//               necessary.
//
//               Note the semantics of a condition variable: the mutex
//               must be held before wait() is called, and it will
//               still be held when wait() returns.  However, it will
//               be temporarily released during the wait() call
//               itself.
//////////////////////////////////////////////////////////////////// 1 4 this 3 280  
60 14 Dtool_kd_i20dk 0 4 73 261 0 14 Dtool_kd_i20dk 617 ////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFullDirect::wait
//       Access: Published
//  Description: Waits on the condition, with a timeout.  The function
//               will return when the condition variable is notified,
//               or the timeout occurs.  There is no way to directly
//               tell which happened, and it is possible that neither
//               in fact happened (spurious wakeups are possible).
//
//               See wait() with no parameters for more.
//////////////////////////////////////////////////////////////////// 2 4 this 3 280  7 timeout 1 263  
61 14 Dtool_kd_iqZiM 0 4 74 261 0 14 Dtool_kd_iqZiM 904 ////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFullDirect::notify
//       Access: Published
//  Description: Informs one of the other threads who are currently
//               blocked on wait() that the relevant condition has
//               changed.  If multiple threads are currently waiting,
//               at least one of them will be woken up, although there
//               is no way to predict which one.  It is possible that
//               more than one thread will be woken up.
//
//               The caller must be holding the mutex associated with
//               the condition variable before making this call, which
//               will not release the mutex.
//
//               If no threads are waiting, this is a no-op: the
//               notify is lost.
//////////////////////////////////////////////////////////////////// 1 4 this 3 280  
62 14 Dtool_kd_iDEGf 0 4 75 261 0 14 Dtool_kd_iDEGf 673 ////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFullDirect::notify_all
//       Access: Published
//  Description: Informs all of the other threads who are currently
//               blocked on wait() that the relevant condition has
//               changed.
//
//               The caller must be holding the mutex associated with
//               the condition variable before making this call, which
//               will not release the mutex.
//
//               If no threads are waiting, this is a no-op: the
//               notify event is lost.
//////////////////////////////////////////////////////////////////// 1 4 this 3 280  
63 14 Dtool_kd_ipZKZ 0 4 76 261 0 14 Dtool_kd_ipZKZ 344 ////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFullDirect::output
//       Access: Public
//  Description: This method is declared virtual in ConditionVarFullDebug,
//               but non-virtual in ConditionVarFullDirect.
//////////////////////////////////////////////////////////////////// 2 4 this 3 278  3 out 1 264  
64 14 Dtool_kd_i7JQC 0 7 78 281 181 14 Dtool_kd_i7JQC 1064 // Filename: conditionVarFull.I
// Created by:  drose (28Aug06)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFull::Constructor
//       Access: Published
//  Description: You must pass in a Mutex to the condition variable
//               constructor.  This mutex may be shared by other
//               condition variables, if desired.  It is the caller's
//               responsibility to ensure the Mutex object does not
//               destruct during the lifetime of the condition
//               variable.
//////////////////////////////////////////////////////////////////// 1 5 mutex 1 271  
65 14 Dtool_kd_iHhKo 0 6 80 271 0 14 Dtool_kd_iHhKo 302 ////////////////////////////////////////////////////////////////////
//     Function: ConditionVarFull::get_mutex
//       Access: Published
//  Description: Returns the mutex associated with this condition
//               variable.
//////////////////////////////////////////////////////////////////// 1 4 this 3 282  
66 14 Dtool_kd_it6SB 0 4 82 261 0 14 Dtool_kd_it6SB 745 ////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::acquire
//       Access: Published
//  Description: Grabs the reMutex if it is available.  If it is not
//               available, blocks until it becomes available, then
//               grabs it.  In either case, the function does not
//               return until the reMutex is held; you should then call
//               unlock().
//
//               This method is considered const so that you can lock
//               and unlock const reMutexes, mainly to allow thread-safe
//               access to otherwise const data.
//
//               Also see ReMutexHolder.
//////////////////////////////////////////////////////////////////// 1 4 this 3 284  
67 14 Dtool_kd_iUbPW 0 4 82 261 0 14 Dtool_kd_iUbPW 368 ////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::acquire
//       Access: Published
//  Description: This variant on acquire() accepts the current thread as
//               a parameter, if it is already known, as an
//               optimization.
//////////////////////////////////////////////////////////////////// 2 4 this 3 284  14 current_thread 1 257  
68 14 Dtool_kd_irrov 0 6 83 262 0 14 Dtool_kd_irrov 371 ////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::try_acquire
//       Access: Published
//  Description: Returns immediately, with a true value indicating the
//               mutex has been acquired, and false indicating it has
//               not.
//////////////////////////////////////////////////////////////////// 1 4 this 3 284  
69 14 Dtool_kd_iOL6E 0 6 83 262 0 14 Dtool_kd_iOL6E 371 ////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::try_acquire
//       Access: Published
//  Description: Returns immediately, with a true value indicating the
//               mutex has been acquired, and false indicating it has
//               not.
//////////////////////////////////////////////////////////////////// 2 4 this 3 284  14 current_thread 1 257  
70 14 Dtool_kd_ipqNB 0 4 84 261 0 14 Dtool_kd_ipqNB 819 ////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::elevate_lock
//       Access: Published
//  Description: This method increments the lock count, assuming the
//               calling thread already holds the lock.  After this
//               call, release() will need to be called one additional
//               time to release the lock.
//
//               This method really performs the same function as
//               acquire(), but it offers a potential (slight)
//               performance benefit when the calling thread knows
//               that it already holds the lock.  It is an error to
//               call this when the calling thread does not hold the
//               lock.
//////////////////////////////////////////////////////////////////// 1 4 this 3 284  
71 14 Dtool_kd_iKHzQ 0 4 85 261 0 14 Dtool_kd_iKHzQ 523 ////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::release
//       Access: Published
//  Description: Releases the reMutex.  It is an error to call this if
//               the reMutex was not already locked.
//
//               This method is considered const so that you can lock
//               and unlock const reMutexes, mainly to allow thread-safe
//               access to otherwise const data.
//////////////////////////////////////////////////////////////////// 1 4 this 3 284  
72 14 Dtool_kd_i7UUZ 0 6 86 262 0 14 Dtool_kd_i7UUZ 578 ////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::debug_is_locked
//       Access: Published
//  Description: Returns true if the current thread has locked the
//               ReMutex, false otherwise.  This method is only intended
//               for use in debugging, hence the method name; in the
//               ReMutexDirect case, it always returns true, since
//               there's not a reliable way to determine this
//               otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 284  
73 14 Dtool_kd_i_Nyn 0 4 87 261 0 14 Dtool_kd_i_Nyn 305 ////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::set_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
//////////////////////////////////////////////////////////////////// 2 4 this 3 286  4 name 1 256  
74 14 Dtool_kd_ibDp3 0 4 88 261 0 14 Dtool_kd_ibDp3 307 ////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::clear_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
//////////////////////////////////////////////////////////////////// 1 4 this 3 286  
75 14 Dtool_kd_iMADE 0 6 89 262 0 14 Dtool_kd_iMADE 305 ////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::has_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
//////////////////////////////////////////////////////////////////// 1 4 this 3 284  
76 14 Dtool_kd_iCBpz 0 6 90 256 0 14 Dtool_kd_iCBpz 305 ////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::get_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
//////////////////////////////////////////////////////////////////// 1 4 this 3 284  
77 14 Dtool_kd_iywef 0 4 91 261 0 14 Dtool_kd_iywef 318 ////////////////////////////////////////////////////////////////////
//     Function: ReMutexDirect::output
//       Access: Published
//  Description: This method is declared virtual in MutexDebug, but
//               non-virtual in ReMutexDirect.
//////////////////////////////////////////////////////////////////// 2 4 this 3 284  3 out 1 264  
78 14 Dtool_kd_iyZ9B 0 7 93 287 194 14 Dtool_kd_iyZ9B 699 // Filename: reMutex.I
// Created by:  drose (15Jan06)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: ReMutex::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 0 
79 14 Dtool_kd_irzYG 0 7 93 287 194 14 Dtool_kd_irzYG 216 ////////////////////////////////////////////////////////////////////
//     Function: ReMutex::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 name 1 256  
80 14 Dtool_kd_iSmL_ 0 7 96 252 0 14 Dtool_kd_iSmL_ 0 0 
81 14 Dtool_kd_igIId 0 4 99 261 0 14 Dtool_kd_igIId 760 ////////////////////////////////////////////////////////////////////
//     Function: LightMutexDirect::acquire
//       Access: Published
//  Description: Grabs the lightMutex if it is available.  If it is not
//               available, blocks until it becomes available, then
//               grabs it.  In either case, the function does not
//               return until the lightMutex is held; you should then call
//               unlock().
//
//               This method is considered const so that you can lock
//               and unlock const lightMutexes, mainly to allow thread-safe
//               access to otherwise const data.
//
//               Also see LightMutexHolder.
//////////////////////////////////////////////////////////////////// 1 4 this 3 288  
82 14 Dtool_kd_iv86A 0 4 100 261 0 14 Dtool_kd_iv86A 535 ////////////////////////////////////////////////////////////////////
//     Function: LightMutexDirect::release
//       Access: Published
//  Description: Releases the lightMutex.  It is an error to call this if
//               the lightMutex was not already locked.
//
//               This method is considered const so that you can lock
//               and unlock const lightMutexes, mainly to allow thread-safe
//               access to otherwise const data.
//////////////////////////////////////////////////////////////////// 1 4 this 3 288  
83 14 Dtool_kd_isRoB 0 6 101 262 0 14 Dtool_kd_isRoB 587 ////////////////////////////////////////////////////////////////////
//     Function: LightMutexDirect::debug_is_locked
//       Access: Published
//  Description: Returns true if the current thread has locked the
//               LightMutex, false otherwise.  This method is only intended
//               for use in debugging, hence the method name; in the
//               LightMutexDirect case, it always returns true, since
//               there's not a reliable way to determine this
//               otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 288  
84 14 Dtool_kd_iMAKY 0 4 102 261 0 14 Dtool_kd_iMAKY 313 ////////////////////////////////////////////////////////////////////
//     Function: LightMutexDirect::set_name
//       Access: Public
//  Description: The lightMutex name is only defined when compiling in
//               DEBUG_THREADS mode.
//////////////////////////////////////////////////////////////////// 2 4 this 3 290  4 name 1 256  
85 14 Dtool_kd_i39Ii 0 4 103 261 0 14 Dtool_kd_i39Ii 315 ////////////////////////////////////////////////////////////////////
//     Function: LightMutexDirect::clear_name
//       Access: Public
//  Description: The lightMutex name is only defined when compiling in
//               DEBUG_THREADS mode.
//////////////////////////////////////////////////////////////////// 1 4 this 3 290  
86 14 Dtool_kd_ifUxV 0 6 104 262 0 14 Dtool_kd_ifUxV 313 ////////////////////////////////////////////////////////////////////
//     Function: LightMutexDirect::has_name
//       Access: Public
//  Description: The lightMutex name is only defined when compiling in
//               DEBUG_THREADS mode.
//////////////////////////////////////////////////////////////////// 1 4 this 3 288  
87 14 Dtool_kd_iPdHP 0 6 105 256 0 14 Dtool_kd_iPdHP 313 ////////////////////////////////////////////////////////////////////
//     Function: LightMutexDirect::get_name
//       Access: Public
//  Description: The lightMutex name is only defined when compiling in
//               DEBUG_THREADS mode.
//////////////////////////////////////////////////////////////////// 1 4 this 3 288  
88 14 Dtool_kd_i5WyC 0 4 106 261 0 14 Dtool_kd_i5WyC 326 ////////////////////////////////////////////////////////////////////
//     Function: LightMutexDirect::output
//       Access: Public
//  Description: This method is declared virtual in LightMutexDebug, but
//               non-virtual in LightMutexDirect.
//////////////////////////////////////////////////////////////////// 2 4 this 3 288  3 out 1 264  
89 14 Dtool_kd_iwke4 0 7 108 291 206 14 Dtool_kd_iwke4 708 // Filename: lightMutex.I
// Created by:  drose (08Oct08)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: LightMutex::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
90 14 Dtool_kd_iMnVX 0 7 108 291 206 14 Dtool_kd_iMnVX 222 ////////////////////////////////////////////////////////////////////
//     Function: LightMutex::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 name 1 256  
91 14 Dtool_kd_ipFmq 0 4 111 261 0 14 Dtool_kd_ipFmq 770 ////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::acquire
//       Access: Published
//  Description: Grabs the lightReMutex if it is available.  If it is not
//               available, blocks until it becomes available, then
//               grabs it.  In either case, the function does not
//               return until the lightReMutex is held; you should then call
//               unlock().
//
//               This method is considered const so that you can lock
//               and unlock const lightReMutexes, mainly to allow thread-safe
//               access to otherwise const data.
//
//               Also see LightReMutexHolder.
//////////////////////////////////////////////////////////////////// 1 4 this 3 292  
92 14 Dtool_kd_iq5jU 0 4 111 261 0 14 Dtool_kd_iq5jU 373 ////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::acquire
//       Access: Published
//  Description: This variant on acquire() accepts the current thread as
//               a parameter, if it is already known, as an
//               optimization.
//////////////////////////////////////////////////////////////////// 2 4 this 3 292  14 current_thread 1 257  
93 14 Dtool_kd_iN2dq 0 4 112 261 0 14 Dtool_kd_iN2dq 824 ////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::elevate_lock
//       Access: Published
//  Description: This method increments the lock count, assuming the
//               calling thread already holds the lock.  After this
//               call, release() will need to be called one additional
//               time to release the lock.
//
//               This method really performs the same function as
//               acquire(), but it offers a potential (slight)
//               performance benefit when the calling thread knows
//               that it already holds the lock.  It is an error to
//               call this when the calling thread does not hold the
//               lock.
//////////////////////////////////////////////////////////////////// 1 4 this 3 292  
94 14 Dtool_kd_iqsmJ 0 4 113 261 0 14 Dtool_kd_iqsmJ 543 ////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::release
//       Access: Published
//  Description: Releases the lightReMutex.  It is an error to call this if
//               the lightReMutex was not already locked.
//
//               This method is considered const so that you can lock
//               and unlock const lightReMutexes, mainly to allow thread-safe
//               access to otherwise const data.
//////////////////////////////////////////////////////////////////// 1 4 this 3 292  
95 14 Dtool_kd_i9mua 0 6 114 262 0 14 Dtool_kd_i9mua 593 ////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::debug_is_locked
//       Access: Published
//  Description: Returns true if the current thread has locked the
//               LightReMutex, false otherwise.  This method is only intended
//               for use in debugging, hence the method name; in the
//               LightReMutexDirect case, it always returns true, since
//               there's not a reliable way to determine this
//               otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 292  
96 14 Dtool_kd_iVMm3 0 4 115 261 0 14 Dtool_kd_iVMm3 310 ////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::set_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
//////////////////////////////////////////////////////////////////// 2 4 this 3 294  4 name 1 256  
97 14 Dtool_kd_iSRSX 0 4 116 261 0 14 Dtool_kd_iSRSX 312 ////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::clear_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
//////////////////////////////////////////////////////////////////// 1 4 this 3 294  
98 14 Dtool_kd_iO1Hw 0 6 117 262 0 14 Dtool_kd_iO1Hw 310 ////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::has_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
//////////////////////////////////////////////////////////////////// 1 4 this 3 292  
99 14 Dtool_kd_iE3TP 0 6 118 256 0 14 Dtool_kd_iE3TP 310 ////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::get_name
//       Access: Public
//  Description: The mutex name is only defined when compiling in
//               DEBUG_THREADS mode.
//////////////////////////////////////////////////////////////////// 1 4 this 3 292  
100 14 Dtool_kd_iYWCn 0 4 119 261 0 14 Dtool_kd_iYWCn 328 ////////////////////////////////////////////////////////////////////
//     Function: LightReMutexDirect::output
//       Access: Published
//  Description: This method is declared virtual in MutexDebug, but
//               non-virtual in LightReMutexDirect.
//////////////////////////////////////////////////////////////////// 2 4 this 3 292  3 out 1 264  
101 14 Dtool_kd_idgTl 0 7 121 295 217 14 Dtool_kd_idgTl 709 // Filename: lightReMutex.I
// Created by:  drose (08Oct08)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: LightReMutex::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 0 
102 14 Dtool_kd_id1K3 0 7 121 295 217 14 Dtool_kd_id1K3 221 ////////////////////////////////////////////////////////////////////
//     Function: LightReMutex::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 name 1 256  
103 14 Dtool_kd_iLWAo 0 7 124 252 0 14 Dtool_kd_iLWAo 0 0 
104 14 Dtool_kd_iwMgt 0 7 127 296 124 14 Dtool_kd_iwMgt 224 ////////////////////////////////////////////////////////////////////
//     Function: PythonThread::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 4 8 function 1 266  4 args 1 266  4 name 1 256  9 sync_name 1 256  
105 14 Dtool_kd_iSXFP 0 6 128 266 0 14 Dtool_kd_iSXFP 506 ////////////////////////////////////////////////////////////////////
//     Function: PythonThread::join
//       Access: Published
//  Description: Blocks the calling process until the thread
//               terminates.  If the thread has already terminated,
//               this returns immediately.
//
//               The PythonThread flavor of this function returns the
//               same value returned by the thread function.
//////////////////////////////////////////////////////////////////// 1 4 this 3 296  
106 14 Dtool_kd_iKwfX 0 7 129 252 0 14 Dtool_kd_iKwfX 0 0 
107 14 Dtool_kd_iCIsB 0 7 131 297 224 14 Dtool_kd_iCIsB 708 // Filename: psemaphore.I
// Created by:  drose (13Oct08)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: Semaphore::Constructor
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 1 13 initial_count 1 260  
108 14 Dtool_kd_idG23 0 7 131 297 224 14 Dtool_kd_idG23 708 // Filename: psemaphore.I
// Created by:  drose (13Oct08)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: Semaphore::Constructor
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 0 
109 14 Dtool_kd_iu2W_ 0 4 133 261 0 14 Dtool_kd_iu2W_ 372 ////////////////////////////////////////////////////////////////////
//     Function: Semaphore::acquire
//       Access: Published
//  Description: Decrements the internal count.  If the count was
//               already at zero, blocks until the count is nonzero,
//               then decrements it.
//////////////////////////////////////////////////////////////////// 1 4 this 3 297  
110 14 Dtool_kd_ifUgs 0 6 134 262 0 14 Dtool_kd_ifUgs 342 ////////////////////////////////////////////////////////////////////
//     Function: Semaphore::try_acquire
//       Access: Published
//  Description: If the semaphore can be acquired without blocking,
//               does so and returns true.  Otherwise, returns false.
//////////////////////////////////////////////////////////////////// 1 4 this 3 297  
111 14 Dtool_kd_iyIK2 0 6 135 260 0 14 Dtool_kd_iyIK2 401 ////////////////////////////////////////////////////////////////////
//     Function: Semaphore::release
//       Access: Published
//  Description: Increments the semaphore's internal count.  This may
//               wake up another thread blocked on acquire().
//
//               Returns the count of the semaphore upon release.
//////////////////////////////////////////////////////////////////// 1 4 this 3 297  
112 14 Dtool_kd_i_IPX 0 6 136 260 0 14 Dtool_kd_i_IPX 366 ////////////////////////////////////////////////////////////////////
//     Function: Semaphore::get_count
//       Access: Published
//  Description: Returns the current semaphore count.  Note that this
//               call is not thread-safe (the count may change at any
//               time).
//////////////////////////////////////////////////////////////////// 1 4 this 3 298  
113 14 Dtool_kd_iMF_3 0 4 137 261 0 14 Dtool_kd_iMF_3 217 ////////////////////////////////////////////////////////////////////
//     Function: Semaphore::output
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 298  3 out 1 264  
70
230 13 AsyncTaskBase 0 26625 13 AsyncTaskBase 13 AsyncTaskBase 0 0 0 0 118 0 1 119 0 0 2 3 231 114 115 3 232 116 117 0 0 346
////////////////////////////////////////////////////////////////////
//       Class : AsyncTaskBase
// Description : The abstract base class for AsyncTask.  This is
//               defined here only so we can store a pointer to the
//               current task on the Thread.
////////////////////////////////////////////////////////////////////

231 19 TypedReferenceCount 0 2049 19 TypedReferenceCount 19 TypedReferenceCount 0 0 0 0 0 0 0 0 0 0 0 0 710
////////////////////////////////////////////////////////////////////
//       Class : TypedReferenceCount
// Description : A base class for things which need to inherit from
//               both TypedObject and from ReferenceCount.  It's
//               convenient to define this intermediate base class
//               instead of multiply inheriting from the two classes
//               each time they are needed, so that we can sensibly
//               pass around pointers to things which are both
//               TypedObjects and ReferenceCounters.
//               
//               See also TypedObject for detailed instructions.
////////////////////////////////////////////////////////////////////

232 7 Namable 0 2049 7 Namable 7 Namable 0 0 0 0 0 0 0 0 0 0 0 0 324
////////////////////////////////////////////////////////////////////
//       Class : Namable
// Description : A base class for all things which can have a name.
//               The name is either empty or nonempty, but it is never
//               NULL.
////////////////////////////////////////////////////////////////////

233 14 ThreadPriority 0 532481 14 ThreadPriority 14 ThreadPriority 0 0 0 0 0 0 0 0 0 0 4 6 TP_low 6 TP_low 0 9 TP_normal 9 TP_normal 1 7 TP_high 7 TP_high 2 9 TP_urgent 9 TP_urgent 3 0 243
////////////////////////////////////////////////////////////////////
// An enumerated type used by Thread to specify a suggested relative
// priority for a particular thread.
////////////////////////////////////////////////////////////////////

234 6 Thread 0 26625 6 Thread 6 Thread 0 0 0 0 124 0 30 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 0 0 2 3 231 120 121 3 232 122 123 0 0 668
////////////////////////////////////////////////////////////////////
//       Class : Thread
// Description : A thread; that is, a lightweight process.  This is an
//               abstract base class; to use it, you must subclass
//               from it and redefine thread_main().
//
//               The thread itself will keep a reference count on the
//               Thread object while it is running; when the thread
//               returns from its root function, the Thread object
//               will automatically be destructed if no other pointers
//               are referencing it.
////////////////////////////////////////////////////////////////////

235 11 MutexDirect 0 43009 11 MutexDirect 11 MutexDirect 0 0 0 0 0 0 9 155 156 157 158 159 160 161 162 163 0 0 0 0 0 364
////////////////////////////////////////////////////////////////////
//       Class : MutexDirect
// Description : This class implements a standard mutex by making
//               direct calls to the underlying implementation layer.
//               It doesn't perform any debugging operations.
////////////////////////////////////////////////////////////////////

236 5 Mutex 0 26625 5 Mutex 5 Mutex 0 0 0 1 164 165 0 0 0 0 1 0 235 0 0 0 0 0

237 18 ConditionVarDirect 0 26625 18 ConditionVarDirect 18 ConditionVarDirect 0 0 0 0 166 0 4 167 168 169 170 0 0 0 0 0 661
////////////////////////////////////////////////////////////////////
//       Class : ConditionVarDirect
// Description : A condition variable, usually used to communicate
//               information about changing state to a thread that is
//               waiting for something to happen.  A condition
//               variable can be used to "wake up" a thread when some
//               arbitrary condition has changed.
//
//               A condition variable is associated with a single
//               mutex, and several condition variables may share the
//               same mutex.
////////////////////////////////////////////////////////////////////

238 12 ConditionVar 0 26625 12 ConditionVar 12 ConditionVar 0 0 0 1 171 172 0 1 173 0 0 1 0 237 0 0 0 0 0

239 22 ConditionVarFullDirect 0 26625 22 ConditionVarFullDirect 22 ConditionVarFullDirect 0 0 0 0 174 0 5 175 176 177 178 179 0 0 0 0 0 665
////////////////////////////////////////////////////////////////////
//       Class : ConditionVarFullDirect
// Description : A condition variable, usually used to communicate
//               information about changing state to a thread that is
//               waiting for something to happen.  A condition
//               variable can be used to "wake up" a thread when some
//               arbitrary condition has changed.
//
//               A condition variable is associated with a single
//               mutex, and several condition variables may share the
//               same mutex.
////////////////////////////////////////////////////////////////////

240 16 ConditionVarFull 0 26625 16 ConditionVarFull 16 ConditionVarFull 0 0 0 1 180 181 0 1 182 0 0 1 0 239 0 0 0 0 0

241 13 ReMutexDirect 0 43009 13 ReMutexDirect 13 ReMutexDirect 0 0 0 0 0 0 10 183 184 185 186 187 188 189 190 191 192 0 0 0 0 0 368
////////////////////////////////////////////////////////////////////
//       Class : ReMutexDirect
// Description : This class implements a standard reMutex by making
//               direct calls to the underlying implementation layer.
//               It doesn't perform any debugging operations.
////////////////////////////////////////////////////////////////////

242 7 ReMutex 0 26625 7 ReMutex 7 ReMutex 0 0 0 1 193 194 0 0 0 0 1 0 241 0 0 0 0 0

243 14 ExternalThread 0 141313 14 ExternalThread 14 ExternalThread 0 0 0 0 196 0 1 195 0 0 1 0 234 0 0 0 0 356
////////////////////////////////////////////////////////////////////
//       Class : ExternalThread
// Description : The special "external thread" class.  There is one
//               instance of these in the world, and it is returned by
//               Thread::get_external_thread().
////////////////////////////////////////////////////////////////////

244 16 LightMutexDirect 0 43009 16 LightMutexDirect 16 LightMutexDirect 0 0 0 0 0 0 8 197 198 199 200 201 202 203 204 0 0 0 0 0 372
////////////////////////////////////////////////////////////////////
//       Class : LightMutexDirect
// Description : This class implements a lightweight Mutex by making
//               direct calls to the underlying implementation layer.
//               It doesn't perform any debugging operations.
////////////////////////////////////////////////////////////////////

245 10 LightMutex 0 26625 10 LightMutex 10 LightMutex 0 0 0 1 205 206 0 0 0 0 1 0 244 0 0 0 0 0

246 18 LightReMutexDirect 0 43009 18 LightReMutexDirect 18 LightReMutexDirect 0 0 0 0 0 0 9 207 208 209 210 211 212 213 214 215 0 0 0 0 0 378
////////////////////////////////////////////////////////////////////
//       Class : LightReMutexDirect
// Description : This class implements a standard lightReMutex by making
//               direct calls to the underlying implementation layer.
//               It doesn't perform any debugging operations.
////////////////////////////////////////////////////////////////////

247 12 LightReMutex 0 26625 12 LightReMutex 12 LightReMutex 0 0 0 1 216 217 0 0 0 0 1 0 246 0 0 0 0 0

248 10 MainThread 0 141313 10 MainThread 10 MainThread 0 0 0 0 219 0 1 218 0 0 1 0 234 0 0 0 0 344
////////////////////////////////////////////////////////////////////
//       Class : MainThread
// Description : The special "main thread" class.  There is one
//               instance of these in the world, and it is returned by
//               Thread::get_main_thread().
////////////////////////////////////////////////////////////////////

249 12 PythonThread 0 75777 12 PythonThread 12 PythonThread 0 0 0 1 220 124 0 2 221 222 0 0 1 0 234 0 0 0 0 376
////////////////////////////////////////////////////////////////////
//       Class : PythonThread
// Description : This class is exposed to Python to allow creation of
//               a Panda thread from the Python level.  It will spawn
//               a thread that executes an arbitrary Python functor.
////////////////////////////////////////////////////////////////////

250 9 Semaphore 0 26625 9 Semaphore 9 Semaphore 0 0 0 1 223 224 0 5 225 226 227 228 229 0 0 0 0 0 594
////////////////////////////////////////////////////////////////////
//       Class : Semaphore
// Description : A classic semaphore synchronization primitive.  
//
//               A semaphore manages an internal counter which is
//               decremented by each acquire() call and incremented by
//               each release() call. The counter can never go below
//               zero; when acquire() finds that it is zero, it
//               blocks, waiting until some other thread calls
//               release().
////////////////////////////////////////////////////////////////////

251 10 TypeHandle 0 2048 10 TypeHandle 10 TypeHandle 0 0 0 0 0 0 0 0 0 0 0 0 1098
////////////////////////////////////////////////////////////////////
//       Class : TypeHandle
// Description : TypeHandle is the identifier used to differentiate
//               C++ class types.  Any C++ classes that inherit from
//               some base class, and must be differentiated at run
//               time, should store a static TypeHandle object that
//               can be queried through a static member function
//               named get_class_type().  Most of the time, it is also
//               desirable to inherit from TypedObject, which provides
//               some virtual functions to return the TypeHandle for a
//               particular instance.
//
//               At its essence, a TypeHandle is simply a unique
//               identifier that is assigned by the TypeRegistry.  The
//               TypeRegistry stores a tree of TypeHandles, so that
//               ancestry of a particular type may be queried, and the
//               type name may be retrieved for run-time display.
////////////////////////////////////////////////////////////////////

252 12 TypeHandle * 0 8576 12 TypeHandle * 12 TypeHandle * 0 0 251 0 0 0 0 0 0 0 0 0 0

253 15 AsyncTaskBase * 0 8576 15 AsyncTaskBase * 15 AsyncTaskBase * 0 0 230 0 0 0 0 0 0 0 0 0 0

254 21 TypedReferenceCount * 0 8576 21 TypedReferenceCount * 21 TypedReferenceCount * 0 0 231 0 0 0 0 0 0 0 0 0 0

255 9 Namable * 0 8576 9 Namable * 9 Namable * 0 0 232 0 0 0 0 0 0 0 0 0 0

256 13 atomic string 0 2 13 atomic string 13 atomic string 0 7 0 0 0 0 0 0 0 0 0 0 0

257 8 Thread * 0 8576 8 Thread * 8 Thread * 0 0 234 0 0 0 0 0 0 0 0 0 0

258 14 Thread const * 0 8576 14 Thread const * 14 Thread const * 0 0 259 0 0 0 0 0 0 0 0 0 0

259 12 Thread const 0 8832 12 Thread const 12 Thread const 0 0 234 0 0 0 0 0 0 0 0 0 0

260 3 int 0 8194 3 int 3 int 0 1 0 0 0 0 0 0 0 0 0 0 0

261 4 void 0 8194 4 void 4 void 0 6 0 0 0 0 0 0 0 0 0 0 0

262 4 bool 0 8194 4 bool 4 bool 0 4 0 0 0 0 0 0 0 0 0 0 0

263 6 double 0 8194 6 double 6 double 0 3 0 0 0 0 0 0 0 0 0 0 0

264 9 ostream * 0 8576 9 ostream * 9 ostream * 0 0 265 0 0 0 0 0 0 0 0 0 0

265 7 ostream 0 2048 7 ostream 7 ostream 0 0 0 0 0 0 0 0 0 0 0 0 0

266 10 PyObject * 0 8576 10 PyObject * 10 PyObject * 0 0 267 0 0 0 0 0 0 0 0 0 0

267 8 PyObject 0 2048 8 PyObject 8 PyObject 0 0 0 0 0 0 0 0 0 0 0 0 0

268 19 MutexDirect const * 0 8576 19 MutexDirect const * 19 MutexDirect const * 0 0 269 0 0 0 0 0 0 0 0 0 0

269 17 MutexDirect const 0 8832 17 MutexDirect const 17 MutexDirect const 0 0 235 0 0 0 0 0 0 0 0 0 0

270 13 MutexDirect * 0 8576 13 MutexDirect * 13 MutexDirect * 0 0 235 0 0 0 0 0 0 0 0 0 0

271 7 Mutex * 0 8576 7 Mutex * 7 Mutex * 0 0 236 0 0 0 0 0 0 0 0 0 0

272 26 ConditionVarDirect const * 0 8576 26 ConditionVarDirect const * 26 ConditionVarDirect const * 0 0 273 0 0 0 0 0 0 0 0 0 0

273 24 ConditionVarDirect const 0 8832 24 ConditionVarDirect const 24 ConditionVarDirect const 0 0 237 0 0 0 0 0 0 0 0 0 0

274 20 ConditionVarDirect * 0 8576 20 ConditionVarDirect * 20 ConditionVarDirect * 0 0 237 0 0 0 0 0 0 0 0 0 0

275 14 ConditionVar * 0 8576 14 ConditionVar * 14 ConditionVar * 0 0 238 0 0 0 0 0 0 0 0 0 0

276 20 ConditionVar const * 0 8576 20 ConditionVar const * 20 ConditionVar const * 0 0 277 0 0 0 0 0 0 0 0 0 0

277 18 ConditionVar const 0 8832 18 ConditionVar const 18 ConditionVar const 0 0 238 0 0 0 0 0 0 0 0 0 0

278 30 ConditionVarFullDirect const * 0 8576 30 ConditionVarFullDirect const * 30 ConditionVarFullDirect const * 0 0 279 0 0 0 0 0 0 0 0 0 0

279 28 ConditionVarFullDirect const 0 8832 28 ConditionVarFullDirect const 28 ConditionVarFullDirect const 0 0 239 0 0 0 0 0 0 0 0 0 0

280 24 ConditionVarFullDirect * 0 8576 24 ConditionVarFullDirect * 24 ConditionVarFullDirect * 0 0 239 0 0 0 0 0 0 0 0 0 0

281 18 ConditionVarFull * 0 8576 18 ConditionVarFull * 18 ConditionVarFull * 0 0 240 0 0 0 0 0 0 0 0 0 0

282 24 ConditionVarFull const * 0 8576 24 ConditionVarFull const * 24 ConditionVarFull const * 0 0 283 0 0 0 0 0 0 0 0 0 0

283 22 ConditionVarFull const 0 8832 22 ConditionVarFull const 22 ConditionVarFull const 0 0 240 0 0 0 0 0 0 0 0 0 0

284 21 ReMutexDirect const * 0 8576 21 ReMutexDirect const * 21 ReMutexDirect const * 0 0 285 0 0 0 0 0 0 0 0 0 0

285 19 ReMutexDirect const 0 8832 19 ReMutexDirect const 19 ReMutexDirect const 0 0 241 0 0 0 0 0 0 0 0 0 0

286 15 ReMutexDirect * 0 8576 15 ReMutexDirect * 15 ReMutexDirect * 0 0 241 0 0 0 0 0 0 0 0 0 0

287 9 ReMutex * 0 8576 9 ReMutex * 9 ReMutex * 0 0 242 0 0 0 0 0 0 0 0 0 0

288 24 LightMutexDirect const * 0 8576 24 LightMutexDirect const * 24 LightMutexDirect const * 0 0 289 0 0 0 0 0 0 0 0 0 0

289 22 LightMutexDirect const 0 8832 22 LightMutexDirect const 22 LightMutexDirect const 0 0 244 0 0 0 0 0 0 0 0 0 0

290 18 LightMutexDirect * 0 8576 18 LightMutexDirect * 18 LightMutexDirect * 0 0 244 0 0 0 0 0 0 0 0 0 0

291 12 LightMutex * 0 8576 12 LightMutex * 12 LightMutex * 0 0 245 0 0 0 0 0 0 0 0 0 0

292 26 LightReMutexDirect const * 0 8576 26 LightReMutexDirect const * 26 LightReMutexDirect const * 0 0 293 0 0 0 0 0 0 0 0 0 0

293 24 LightReMutexDirect const 0 8832 24 LightReMutexDirect const 24 LightReMutexDirect const 0 0 246 0 0 0 0 0 0 0 0 0 0

294 20 LightReMutexDirect * 0 8576 20 LightReMutexDirect * 20 LightReMutexDirect * 0 0 246 0 0 0 0 0 0 0 0 0 0

295 14 LightReMutex * 0 8576 14 LightReMutex * 14 LightReMutex * 0 0 247 0 0 0 0 0 0 0 0 0 0

296 14 PythonThread * 0 8576 14 PythonThread * 14 PythonThread * 0 0 249 0 0 0 0 0 0 0 0 0 0

297 11 Semaphore * 0 8576 11 Semaphore * 11 Semaphore * 0 0 250 0 0 0 0 0 0 0 0 0 0

298 17 Semaphore const * 0 8576 17 Semaphore const * 17 Semaphore const * 0 0 299 0 0 0 0 0 0 0 0 0 0

299 15 Semaphore const 0 8832 15 Semaphore const 15 Semaphore const 0 0 250 0 0 0 0 0 0 0 0 0 0

0
0
0
