クラス sc_core::sc_runnable

#include <sc_runnable.h>

すべてのメンバ一覧

Public メソッド

 sc_runnable ()
 ~sc_runnable ()
void init ()
void toggle ()
void remove_method (sc_method_handle)
void remove_thread (sc_thread_handle)
void push_back_method (sc_method_handle)
void push_back_thread (sc_thread_handle)
void push_front_method (sc_method_handle)
void push_front_thread (sc_thread_handle)
bool is_empty () const
sc_method_handle pop_method ()
sc_thread_handle pop_thread ()

Private メソッド

 sc_runnable (const sc_runnable &)
sc_runnableoperator= (const sc_runnable &)

Private 変数

sc_method_handle m_methods_push_head
sc_method_handle m_methods_push_tail
sc_method_handle m_methods_pop
sc_thread_handle m_threads_push_head
sc_thread_handle m_threads_push_tail
sc_thread_handle m_threads_pop


説明

sc_runnable.h66 行で定義されています。


コンストラクタとデストラクタ

sc_core::sc_runnable::sc_runnable (  )  [inline]

sc_runnable_int.h309 行で定義されています。

00310 {
00311     m_methods_pop = 0;
00312     m_methods_push_head = 0;
00313     m_methods_push_tail = 0;
00314     m_threads_pop = 0;
00315     m_threads_push_head = 0;
00316     m_threads_push_tail = 0;
00317 }

sc_core::sc_runnable::~sc_runnable (  )  [inline]

sc_runnable_int.h325 行で定義されています。

00326 {
00327     delete m_methods_push_head;
00328     delete m_threads_push_head;
00329 }

sc_core::sc_runnable::sc_runnable ( const sc_runnable  )  [private]


関数

void sc_core::sc_runnable::init (  )  [inline]

sc_runnable_int.h79 行で定義されています。

00080 {
00081     m_methods_pop = SC_NO_METHODS;
00082     if ( !m_methods_push_head )
00083     {
00084         m_methods_push_head = 
00085             new sc_method_process((const char*)0, true, (SC_ENTRY_FUNC)0, 0, 0);
00086         m_methods_push_head->dont_initialize(true);
00087     }
00088     m_methods_push_tail = m_methods_push_head;
00089         m_methods_push_head->set_next_runnable(SC_NO_METHODS);
00090 
00091     m_threads_pop = SC_NO_THREADS;
00092     if ( !m_threads_push_head )
00093     {
00094         m_threads_push_head = 
00095             new sc_thread_process((const char*)0, true, (SC_ENTRY_FUNC)0, 0, 0);
00096         m_threads_push_head->dont_initialize(true);
00097     }
00098         m_threads_push_head->set_next_runnable(SC_NO_THREADS);
00099     m_threads_push_tail = m_threads_push_head;
00100 }

void sc_core::sc_runnable::toggle (  )  [inline]

sc_runnable_int.h338 行で定義されています。

00339 {
00340     m_methods_pop = m_methods_push_head->next_runnable();
00341     m_methods_push_head->set_next_runnable(SC_NO_METHODS);
00342     m_methods_push_tail = m_methods_push_head;
00343     m_threads_pop = m_threads_push_head->next_runnable();
00344     m_threads_push_head->set_next_runnable(SC_NO_THREADS);
00345     m_threads_push_tail = m_threads_push_head;
00346 }

void sc_core::sc_runnable::remove_method ( sc_method_handle  remove_p  )  [inline]

sc_runnable_int.h251 行で定義されています。

00252 {
00253     sc_method_handle now_p;     // Method now checking.
00254     sc_method_handle prior_p;   // Method prior to now_p.
00255 
00256     prior_p = m_methods_push_head;
00257     for ( now_p = m_methods_push_head; now_p!= SC_NO_METHODS; 
00258             now_p = now_p->next_runnable() )
00259     {
00260         if ( remove_p == now_p )
00261         {
00262             prior_p->set_next_runnable( now_p->next_runnable() );
00263             if (now_p == m_methods_push_tail) {
00264                 m_methods_push_tail = prior_p;
00265             }
00266             now_p->set_next_runnable(0);
00267             break;
00268         }
00269         prior_p = now_p;
00270     }
00271 }

void sc_core::sc_runnable::remove_thread ( sc_thread_handle  remove_p  )  [inline]

sc_runnable_int.h282 行で定義されています。

00283 {
00284     sc_thread_handle now_p;     // Thread now checking.
00285     sc_thread_handle prior_p;   // Thread prior to now_p.
00286 
00287     prior_p = m_threads_push_head;
00288     for ( now_p = m_threads_push_head; now_p != SC_NO_THREADS; 
00289             now_p = now_p->next_runnable() )
00290     {
00291         if ( remove_p == now_p )
00292         {
00293             prior_p->set_next_runnable( now_p->next_runnable() );
00294             if (now_p == m_threads_push_tail) {
00295                 m_threads_push_tail = prior_p;
00296             }
00297             now_p->set_next_runnable(0);
00298             break;
00299         }
00300         prior_p = now_p;
00301     }
00302 }

void sc_core::sc_runnable::push_back_method ( sc_method_handle  method_h  )  [inline]

sc_runnable_int.h122 行で定義されています。

00123 {
00124     // assert( method_h->next_runnable() == 0 ); // Can't queue twice.
00125     method_h->set_next_runnable(SC_NO_METHODS);
00126     m_methods_push_tail->set_next_runnable(method_h);
00127     m_methods_push_tail = method_h;
00128 }

void sc_core::sc_runnable::push_back_thread ( sc_thread_handle  thread_h  )  [inline]

sc_runnable_int.h138 行で定義されています。

00139 {
00140     // assert( thread_h->next_runnable() == 0 ); // Can't queue twice.
00141     thread_h->set_next_runnable(SC_NO_THREADS);
00142     m_threads_push_tail->set_next_runnable(thread_h);
00143     m_threads_push_tail = thread_h;
00144 }

void sc_core::sc_runnable::push_front_method ( sc_method_handle  method_h  )  [inline]

sc_runnable_int.h155 行で定義されています。

00156 {
00157     // assert( method_h->next_runnable() == 0 ); // Can't queue twice.
00158     method_h->set_next_runnable(m_methods_push_head->next_runnable());
00159     if ( m_methods_push_tail == m_methods_push_head ) // Empty queue.
00160     {
00161         m_methods_push_tail->set_next_runnable(method_h);
00162         m_methods_push_tail = method_h;
00163     }
00164     else                                               // Non-empty queue.
00165     {
00166         m_methods_push_head->set_next_runnable(method_h);
00167     }
00168 }

void sc_core::sc_runnable::push_front_thread ( sc_thread_handle  thread_h  )  [inline]

sc_runnable_int.h179 行で定義されています。

00180 {
00181     // assert( thread_h->next_runnable() == 0 ); // Can't queue twice.
00182     thread_h->set_next_runnable(m_threads_push_head->next_runnable());
00183     if ( m_threads_push_tail == m_threads_push_head ) // Empty queue.
00184     {
00185         m_threads_push_tail->set_next_runnable(thread_h);
00186         m_threads_push_tail = thread_h;
00187     }
00188     else                                               // Non-empty queue.
00189     {
00190         m_threads_push_head->set_next_runnable(thread_h);
00191     }
00192 }

bool sc_core::sc_runnable::is_empty (  )  const [inline]

sc_runnable_int.h108 行で定義されています。

00109 {
00110     return m_methods_push_head->next_runnable() == SC_NO_METHODS && 
00111                 m_threads_push_head->next_runnable() == SC_NO_THREADS;
00112 }

sc_method_handle sc_core::sc_runnable::pop_method (  )  [inline]

sc_runnable_int.h201 行で定義されています。

00202 {
00203     sc_method_handle result_p;
00204 
00205     result_p = m_methods_pop;
00206     if ( result_p != SC_NO_METHODS ) 
00207     {
00208         m_methods_pop = result_p->next_runnable();
00209         result_p->set_next_runnable(0);
00210     }
00211         else
00212         {
00213                 result_p = 0;
00214         }
00215     return result_p;
00216 
00217 }

sc_thread_handle sc_core::sc_runnable::pop_thread (  )  [inline]

sc_runnable_int.h225 行で定義されています。

00226 {
00227     sc_thread_handle result_p;
00228 
00229     result_p = m_threads_pop;
00230     if ( result_p != SC_NO_THREADS ) 
00231     {
00232         m_threads_pop = result_p->next_runnable();
00233         result_p->set_next_runnable(0);
00234     }
00235         else
00236         {
00237                 result_p = 0;
00238         }
00239     return result_p;
00240 }

sc_runnable& sc_core::sc_runnable::operator= ( const sc_runnable  )  [private]


変数

sc_runnable.h90 行で定義されています。

sc_runnable.h91 行で定義されています。

sc_runnable.h92 行で定義されています。

sc_runnable.h93 行で定義されています。

sc_runnable.h94 行で定義されています。

sc_runnable.h95 行で定義されています。


このクラスの説明は次のファイルから生成されました:

SystemCに対してFri Jun 6 20:12:02 2008に生成されました。  doxygen 1.5.6