polar-thread-message.c

/* Internal API: inter-thread message 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_thread_message ************************************************************************************************
// Private =============================================================================================================
 
// This variable is initialized in polar_thread_message_get_type()
static polar_thread_message_class class_polar_thread_message;
 
// This variable is initialized in _polar_thread_message_class_init()
static polar_runtime_object_class *superclass_polar_thread_message = NULL;
 
// ---------------------------------------------------------------------------------------------------------------------
 
POLAR_FUNCTION_INTERNAL polar_thread_message *
_polar_thread_message_init( polar_thread_message *self )
{
  // Chain up first
  self = (polar_thread_message *)
    POLAR_RUNTIME_OBJECT_CLASS(superclass_polar_thread_message)->init( (polar_runtime_object *)self );
 
  if( self != NULL )
  {
    self->count_references = 1;
  }
 
  return self;
}
 
POLAR_FUNCTION_INTERNAL polar_runtime_object *
_polar_thread_message_finalize( polar_thread_message *self )
{
  if( objc_atomic_decrement_intptr(&self->count_references) != 0 )
    return (polar_runtime_object *)self;
 
  // Chain up
  return POLAR_RUNTIME_OBJECT_CLASS(superclass_polar_thread_message)->finalize( (polar_runtime_object *)self );
}
 
POLAR_FUNCTION_INTERNAL void
_polar_thread_message_deallocate( polar_thread_message *self )
{
  size_t size_message_total;
 
  if( objc_atomic_compare_exchange_intptr(&self->count_references, 0, -1) == NO )
    return;
 
  size_message_total = polar_runtime_object_get_size( (polar_runtime_object *)self );
  if( self->size_message_data > OBJC_SIZEOF_POINTER )
    size_message_total += self->size_message_data;
 
  polar_memory_free(self, size_message_total);
}
 
POLAR_FUNCTION_INTERNAL void
_polar_thread_message_class_init( polar_thread_message_class *self )
{
  // Acquire our superclass
  superclass_polar_thread_message = POLAR_RUNTIME_OBJECT_CLASS(self)->class_superclass;
 
  // Establish our virtual methods
  ( (polar_runtime_object_class *)self )->init = (polar_func_runtime_object_lifecycle)_polar_thread_message_init;
 
  ( (polar_runtime_object_class *)self )->finalize =
    (polar_func_runtime_object_lifecycle)_polar_thread_message_finalize;
 
  ( (polar_runtime_object_class *)self )->deallocate =
    (polar_func_runtime_object_deallocate)_polar_thread_message_deallocate;
}
 
static struct polar_internal_type_info pti_polar_thread_message =
{
  .name_type          = "polar_thread_message",
  .size_type_instance = sizeof(polar_thread_message),
  .size_type_class    = sizeof(polar_thread_message_class),
  .type_class_init    = (polar_func_runtime_object_class_lifecycle)_polar_thread_message_class_init
};
 
// Public ==============================================================================================================
 
POLAR_FUNCTION_INTERNAL OBJC_FUNCTION_CONSTANT polar_internal_type
polar_thread_message_get_type( void )
{
  static polar_internal_type pt_polar_thread_message = POLAR_INTERNAL_TYPE_INVALID;
 
  if( pt_polar_thread_message != POLAR_INTERNAL_TYPE_INVALID )
    return pt_polar_thread_message;
 
  pt_polar_thread_message = polar_internal_type_init( POLAR_TYPE_LIST_NODE, &class_polar_thread_message,
                                                      &pti_polar_thread_message );
 
  return pt_polar_thread_message;
}
 
POLAR_FUNCTION_INTERNAL polar_thread_message *
polar_thread_message_new( uintptr_t message_subject, size_t size_message_data, void *message_data )
{
  polar_thread_message *result;
  size_t size_message_total;
 
  size_message_total = sizeof(*result);
  if( size_message_data > OBJC_SIZEOF_POINTER )
    size_message_total += size_message_data;
 
  result = (polar_thread_message *)polar_memory_allocate(size_message_total);
  result = (polar_thread_message *)polar_runtime_object_preallocated_init(result, POLAR_TYPE_THREAD_MESSAGE, NO);
 
  result->subject_message = message_subject;
  result->size_message_data = size_message_data;
 
  if( size_message_data > OBJC_SIZEOF_POINTER )
  {
    result->message_data = &result[1];
    objc_memcpy(result->message_data, message_data, size_message_data);
  }
 
  else
    result->message_data = message_data;
 
  return result;
}
 
POLAR_FUNCTION_INTERNAL polar_thread_message *
polar_thread_message_preallocated_init( void *p_message, size_t size_message, uintptr_t message_subject,
                                        size_t size_message_data, void *message_data )
{
  polar_thread_message *result;
 
  assert( p_message != NULL );
  assert( size_message >= sizeof(*result) );
 
  result = (polar_thread_message *)polar_runtime_object_preallocated_init(p_message, POLAR_TYPE_THREAD_MESSAGE, YES);
 
  result->subject_message = message_subject;
  result->count_references = -( MAXINT >> 1 );
  result->size_message_data = size_message_data;
  result->message_data = message_data;
 
  return result;
}