polar-sync-table-node.c

/* Internal API: sync table node type for polar-objc.
   Copyright (C) 2022-2025 Michael Malicoat <[email protected]>
 
   This file is part of polar-objc.
 
   polar-objc is free software; you can redistribute it and/or modify it under the terms of the GNU General Public
   License as published by the Free Software Foundation; either version 3, or (at your option) any later version.
 
   polar-objc is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
   details.
 
   You should have received a copy of the GNU General Public License along with this program; see the file LICENSE.  If
   not, see <http://www.gnu.org/licenses/>.
*/
 
// polar_sync_table_node ***********************************************************************************************
// Private =============================================================================================================
 
// This variable is initialized in polar_sync_table_node_get_type()
static polar_sync_table_node_class class_polar_sync_table_node;
 
// This variable is initialized in _polar_sync_table_node_class_init()
static polar_runtime_object_class *superclass_polar_sync_table_node = NULL;
 
// ---------------------------------------------------------------------------------------------------------------------
 
POLAR_FUNCTION_INTERNAL polar_runtime_object *
_polar_sync_table_node_finalize( polar_sync_table_node *self )
{
  polar_list_node_iterator iter_waiting_requests;
  polar_thread_message *request_current;
  polar_thread_message_queue *request_sender;
 
  /* Release any threads waiting on the target object with an error code, so they don't block forever.  The error code
     was already set as the default return value by polar_runtime_thread_sync_begin() or
     polar_runtime_thread_sync_end(), so we don't need to modify the content of the message.
  */
  if( self->request_waiting_first != NULL )
  {
    polar_runtime_object_preallocated_init( &iter_waiting_requests, POLAR_TYPE_LIST_NODE_ITERATOR, YES );
    polar_list_node_iterator_set_target( &iter_waiting_requests, (polar_list_node *)(self->request_waiting_first) );
 
    while( polar_iterator_get_next((polar_iterator *)(&iter_waiting_requests), (void **)(&request_current)) )
    {
      // Return to sender
      request_sender = request_current->sender_message;
      request_current->sender_message = request_current->recipient_message;
      request_current->recipient_message = NULL;
 
      polar_thread_message_send(request_current, request_sender);
    }
 
    polar_runtime_object_preallocated_finalize( &iter_waiting_requests );
 
    self->request_waiting_first = NULL;
    self->request_waiting_last = NULL;
  }
 
  // Chain up
  return POLAR_RUNTIME_OBJECT_CLASS(superclass_polar_sync_table_node)->finalize( (polar_runtime_object *)self );
}
 
POLAR_FUNCTION_INTERNAL void
_polar_sync_table_node_class_init( polar_sync_table_node_class *self )
{
  // Acquire our superclass
  superclass_polar_sync_table_node = POLAR_RUNTIME_OBJECT_CLASS(self)->class_superclass;
 
  // Establish our virtual methods
  ( (polar_runtime_object_class *)self )->finalize =
    (polar_func_runtime_object_lifecycle)_polar_sync_table_node_finalize;
}
 
static struct polar_internal_type_info pti_polar_sync_table_node =
{
  .name_type          = "polar_sync_table_node",
  .size_type_instance = sizeof(polar_sync_table_node),
  .size_type_class    = sizeof(polar_sync_table_node_class),
  .type_class_init    = (polar_func_runtime_object_class_lifecycle)_polar_sync_table_node_class_init
};
 
// Public ==============================================================================================================
 
POLAR_FUNCTION_INTERNAL OBJC_FUNCTION_CONSTANT polar_internal_type
polar_sync_table_node_get_type( void )
{
  static polar_internal_type pt_polar_sync_table_node = POLAR_INTERNAL_TYPE_INVALID;
 
  if( pt_polar_sync_table_node != POLAR_INTERNAL_TYPE_INVALID )
    return pt_polar_sync_table_node;
 
  pt_polar_sync_table_node = polar_internal_type_init( POLAR_TYPE_HASH_TABLE_NODE_POINTER_KEY,
                                                       &class_polar_sync_table_node,
                                                       &pti_polar_sync_table_node );
 
  return pt_polar_sync_table_node;
}
 
POLAR_FUNCTION_INTERNAL void
polar_sync_table_node_push_request_last( polar_sync_table_node *self, polar_thread_message *service_request )
{
  assert( POLAR_IS_SYNC_TABLE_NODE(self) );
  assert( POLAR_IS_THREAD_MESSAGE(service_request) );
 
  if( self->request_waiting_last != NULL )
    ( (polar_list_node *)self->request_waiting_last )->node_next = (polar_list_node *)service_request;
 
  self->request_waiting_last = service_request;
 
  if( self->request_waiting_first != NULL )
    ;
 
  else
    self->request_waiting_first = service_request;
}
 
POLAR_FUNCTION_INTERNAL polar_thread_message *
polar_sync_table_node_pop_request_first( polar_sync_table_node *self )
{
  polar_thread_message *result;
 
  assert( POLAR_IS_SYNC_TABLE_NODE(self) );
 
  result = (polar_thread_message *)
    polar_list_node_list_pop_first( (polar_list_node **)(&self->request_waiting_first) );
 
  if( self->request_waiting_first != NULL )
    ;
 
  else
    self->request_waiting_last = NULL;
 
  return result;
}