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