.. _program_listing_file_include_cmb_process.h:

Program Listing for File cmb_process.h
======================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_cmb_process.h>` (``include/cmb_process.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: c

   
   /*
    * Copyright (c) Asbjørn M. Bonvik 2025-26.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *   http://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
    */
   #ifndef CIMBA_CMB_PROCESS_H
   #define CIMBA_CMB_PROCESS_H
   
   #include "cmb_assert.h"
   #include "cmb_event.h"
   
   #include "cmi_coroutine.h"
   #include "cmi_slist.h"
   
   #define CMB_PROCESS_NAMEBUF_SZ 32
   
   #define CMB_PROCESS_SUCCESS INT64_C(0)
   
   #define CMB_PROCESS_PREEMPTED INT64_C(-1)
   
   #define CMB_PROCESS_INTERRUPTED INT64_C(-2)
   
   #define CMB_PROCESS_STOPPED INT64_C(-3)
   
   #define CMB_PROCESS_CANCELLED INT64_C(-4)
   
   #define CMB_PROCESS_TIMEOUT INT64_C(-5)
   
   enum cmb_process_state {
       CMB_PROCESS_CREATED = 0,
       CMB_PROCESS_RUNNING,
       CMB_PROCESS_FINISHED
   };
   
   struct cmb_process {
       struct cmi_coroutine core;              
       int64_t priority;                       
       struct cmi_slist_head awaits;           
       struct cmi_slist_head resources;        
       struct cmi_slist_head waiters;          
       char name[CMB_PROCESS_NAMEBUF_SZ];      
   };
   
   typedef void *(cmb_process_func)(struct cmb_process *cp, void *context);
   
   extern struct cmb_process *cmb_process_create(void);
   
   extern void cmb_process_initialize(struct cmb_process *pp,
                                      const char *name,
                                      cmb_process_func procfunc,
                                      void *context,
                                      int64_t priority);
   
   extern void cmb_process_terminate(struct cmb_process *pp);
   
   extern void cmb_process_destroy(struct cmb_process *pp);
   
   extern void cmb_process_start(struct cmb_process *pp);
   
   [[maybe_unused]]
   static inline struct cmb_process *cmb_process_current(void)
   {
       const struct cmi_coroutine *cp = cmi_coroutine_current();
       const struct cmi_coroutine *mp = cmi_coroutine_main();
   
       return (cp == mp) ? NULL : (struct cmb_process *)cp;
   }
   
   [[maybe_unused]]
   static inline int64_t cmb_process_yield(void)
   {
       const struct cmb_process *pp = (struct cmb_process *)cmi_coroutine_current();
       cmb_assert_release(pp != (struct cmb_process *)cmi_coroutine_main());
   
       const int64_t sig = (int64_t)cmi_coroutine_yield(NULL);
   
       return sig;
   }
   
   extern void cmb_process_resume(struct cmb_process *pp, int64_t sig);
   
   extern void cmb_process_timers_clear(struct cmb_process *pp);
   
   extern uint64_t cmb_process_timer_add(struct cmb_process *pp, double dur, int64_t sig);
   
   [[maybe_unused]]
   static inline uint64_t cmb_process_timer_set(struct cmb_process *pp, const double dur, const int64_t sig)
   {
       cmb_assert_release(pp != NULL);
       cmb_assert_release(dur >= 0.0);
   
       cmb_process_timers_clear(pp);
       const uint64_t handle = cmb_process_timer_add(pp, dur, sig);
   
       return handle;
   }
   
   extern bool cmb_process_timer_cancel(struct cmb_process *pp, uint64_t handle);
   
   extern int64_t cmb_process_hold(double dur);
   
   extern int64_t cmb_process_wait_process(struct cmb_process *awaited);
   
   extern int64_t cmb_process_wait_event(uint64_t ev_handle);
   
   extern void cmb_process_exit(void *retval);
   
   extern void cmb_process_interrupt(struct cmb_process *pp,
                                     int64_t sig,
                                     int64_t pri);
   
   extern int64_t cmb_process_stop(struct cmb_process *tgt, void *retval);
   
   [[maybe_unused]]
   static inline int64_t cmb_process_kill(struct cmb_process *tgt, void *retval)
   {
       return cmb_process_stop(tgt, retval);
   }
   
   [[maybe_unused]]
   static inline const char *cmb_process_name(const struct cmb_process *pp)
   {
       cmb_assert_release(pp != NULL);
   
       return pp->name;
   }
   
   extern void cmb_process_name_set(struct cmb_process *pp,
                                    const char *name);
   
   [[maybe_unused]]
   static inline void *cmb_process_context(const struct cmb_process *pp)
   {
       cmb_assert_release(pp != NULL);
   
       return cmi_coroutine_context((struct cmi_coroutine *)pp);
   }
   
   [[maybe_unused]]
   static inline int64_t cmb_process_priority(const struct cmb_process *pp)
   {
       cmb_assert_release(pp != NULL);
   
       return pp->priority;
   }
   
   extern void cmb_process_priority_set(struct cmb_process *pp, int64_t pri);
   
   [[maybe_unused]]
   static inline enum cmb_process_state cmb_process_status(const struct cmb_process *pp)
   {
       cmb_assert_release(pp != NULL);
   
       const struct cmi_coroutine *cp = (struct cmi_coroutine *)pp;
   
       return (enum cmb_process_state)(cp->status);
   }
   
   extern void *cmb_process_exit_value(const struct cmb_process *pp);
   
   #endif /* CIMBA_CMB_PROCESS_H */