Sneed-Group/Poodletooth-iLand
1
0
Fork 0
mirror of https://github.com/Sneed-Group/Poodletooth-iLand synced 2024-12-25 12:42:41 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions
Poodletooth-iLand/panda/pandac/input/libp3pipeline.in

2817 lines
139 KiB
Text
Raw Normal View History

Initial commit
2015-03-03 16:10:12 -06:00
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
Reference in a new issue Copy permalink