chainimpl.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-2-Clause */
 
/*
 *  Copyright (c) 2010 embedded brains GmbH & Co. KG
 *
 *  COPYRIGHT (c) 1989-2014.
 *  On-Line Applications Research Corporation (OAR).
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef _RTEMS_SCORE_CHAINIMPL_H
#define _RTEMS_SCORE_CHAINIMPL_H
 
#include <rtems/score/chain.h>
#include <rtems/score/assert.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define CHAIN_INITIALIZER_EMPTY(name) \
  { { { &(name).Tail.Node, NULL }, &(name).Head.Node } }
 
#define CHAIN_INITIALIZER_ONE_NODE( node ) \
  { { { (node), NULL }, (node) } }
 
#define CHAIN_NODE_INITIALIZER_ONE_NODE_CHAIN( chain ) \
  { &(chain)->Tail.Node, &(chain)->Head.Node }
 
#define CHAIN_DEFINE_EMPTY(name) \
  Chain_Control name = CHAIN_INITIALIZER_EMPTY(name)
 
void _Chain_Initialize(
  Chain_Control *the_chain,
  void          *starting_address,
  size_t         number_nodes,
  size_t         node_size
);
 
size_t _Chain_Node_count_unprotected( const Chain_Control *chain );
 
static inline void _Chain_Set_off_chain(
  Chain_Node *node
)
{
  node->next = NULL;
#if defined(RTEMS_DEBUG)
  node->previous = NULL;
#endif
}
 
static inline void _Chain_Initialize_node( Chain_Node *the_node )
{
#if defined(RTEMS_DEBUG)
  _Chain_Set_off_chain( the_node );
#else
  (void) the_node;
#endif
}
 
static inline bool _Chain_Is_node_off_chain( const Chain_Node *node )
{
  if ( node->next == NULL ) {
#if defined( RTEMS_DEBUG )
    return node->previous == NULL;
#else
    return true;
#endif
  }
 
  return false;
}
 
static inline bool _Chain_Are_nodes_equal(
  const Chain_Node *left,
  const Chain_Node *right
)
{
  return left == right;
}
 
static inline Chain_Node *_Chain_Head(
  Chain_Control *the_chain
)
{
  return &the_chain->Head.Node;
}
 
static inline const Chain_Node *_Chain_Immutable_head(
  const Chain_Control *the_chain
)
{
  return &the_chain->Head.Node;
}
 
static inline Chain_Node *_Chain_Tail(
  Chain_Control *the_chain
)
{
  return &the_chain->Tail.Node;
}
 
static inline const Chain_Node *_Chain_Immutable_tail(
  const Chain_Control *the_chain
)
{
  return &the_chain->Tail.Node;
}
 
static inline Chain_Node *_Chain_First(
  const Chain_Control *the_chain
)
{
  return _Chain_Immutable_head( the_chain )->next;
}
 
static inline const Chain_Node *_Chain_Immutable_first(
  const Chain_Control *the_chain
)
{
  return _Chain_Immutable_head( the_chain )->next;
}
 
static inline Chain_Node *_Chain_Last(
  const Chain_Control *the_chain
)
{
  return _Chain_Immutable_tail( the_chain )->previous;
}
 
static inline const Chain_Node *_Chain_Immutable_last(
  const Chain_Control *the_chain
)
{
  return _Chain_Immutable_tail( the_chain )->previous;
}
 
static inline Chain_Node *_Chain_Next(
  const Chain_Node *the_node
)
{
  return the_node->next;
}
 
static inline const Chain_Node *_Chain_Immutable_next(
  const Chain_Node *the_node
)
{
  return the_node->next;
}
 
static inline Chain_Node *_Chain_Previous(
  const Chain_Node *the_node
)
{
  return the_node->previous;
}
 
static inline const Chain_Node *_Chain_Immutable_previous(
  const Chain_Node *the_node
)
{
  return the_node->previous;
}
 
static inline bool _Chain_Is_empty(
  const Chain_Control *the_chain
)
{
  return _Chain_Immutable_first( the_chain )
    == _Chain_Immutable_tail( the_chain );
}
 
static inline bool _Chain_Is_first(
  const Chain_Node *the_node
)
{
  return (the_node->previous->previous == NULL);
}
 
static inline bool _Chain_Is_last(
  const Chain_Node *the_node
)
{
  return (the_node->next->next == NULL);
}
 
static inline bool _Chain_Has_only_one_node(
  const Chain_Control *the_chain
)
{
  return _Chain_Immutable_first( the_chain )
    == _Chain_Immutable_last( the_chain );
}
 
static inline bool _Chain_Is_head(
  const Chain_Control *the_chain,
  const Chain_Node    *the_node
)
{
  return (the_node == _Chain_Immutable_head( the_chain ));
}
 
static inline bool _Chain_Is_tail(
  const Chain_Control *the_chain,
  const Chain_Node    *the_node
)
{
  return (the_node == _Chain_Immutable_tail( the_chain ));
}
 
static inline void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  Chain_Node *head;
  Chain_Node *tail;
 
  _Assert( the_chain != NULL );
 
  head = _Chain_Head( the_chain );
  tail = _Chain_Tail( the_chain );
 
  head->next = tail;
  head->previous = NULL;
  tail->previous = head;
}
 
static inline void _Chain_Initialize_one(
  Chain_Control *the_chain,
  Chain_Node    *the_node
)
{
  Chain_Node *head;
  Chain_Node *tail;
 
  _Assert( _Chain_Is_node_off_chain( the_node ) );
 
  head = _Chain_Head( the_chain );
  tail = _Chain_Tail( the_chain );
 
  the_node->next = tail;
  the_node->previous = head;
 
  head->next = the_node;
  head->previous = NULL;
  tail->previous = the_node;
}
 
static inline void _Chain_Extract_unprotected(
  Chain_Node *the_node
)
{
  Chain_Node *next;
  Chain_Node *previous;
 
  _Assert( !_Chain_Is_node_off_chain( the_node ) );
 
  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
  previous->next = next;
 
#if defined(RTEMS_DEBUG)
  _Chain_Set_off_chain( the_node );
#endif
}
 
static inline Chain_Node *_Chain_Get_first_unprotected(
  Chain_Control *the_chain
)
{
  Chain_Node *head;
  Chain_Node *old_first;
  Chain_Node *new_first;
 
  _Assert( !_Chain_Is_empty( the_chain ) );
 
  head = _Chain_Head( the_chain );
  old_first = head->next;
  new_first = old_first->next;
 
  head->next = new_first;
  new_first->previous = head;
 
#if defined(RTEMS_DEBUG)
  _Chain_Set_off_chain( old_first );
#endif
 
  return old_first;
}
 
static inline Chain_Node *_Chain_Get_unprotected(
  Chain_Control *the_chain
)
{
  if ( !_Chain_Is_empty(the_chain))
    return _Chain_Get_first_unprotected(the_chain);
  else
    return NULL;
}
 
static inline void _Chain_Insert_unprotected(
  Chain_Node *after_node,
  Chain_Node *the_node
)
{
  Chain_Node *before_node;
 
  _Assert( _Chain_Is_node_off_chain( the_node ) );
 
  the_node->previous    = after_node;
  before_node           = after_node->next;
  after_node->next      = the_node;
  the_node->next        = before_node;
  before_node->previous = the_node;
}
 
static inline void _Chain_Append_unprotected(
  Chain_Control *the_chain,
  Chain_Node    *the_node
)
{
  Chain_Node *tail;
  Chain_Node *old_last;
 
  _Assert( _Chain_Is_node_off_chain( the_node ) );
 
  tail = _Chain_Tail( the_chain );
  old_last = tail->previous;
 
  the_node->next = tail;
  tail->previous = the_node;
  old_last->next = the_node;
  the_node->previous = old_last;
}
 
static inline void _Chain_Append_if_is_off_chain_unprotected(
  Chain_Control *the_chain,
  Chain_Node    *the_node
)
{
  if ( _Chain_Is_node_off_chain( the_node ) ) {
    _Chain_Append_unprotected( the_chain, the_node );
  }
}
 
static inline void _Chain_Prepend_unprotected(
  Chain_Control *the_chain,
  Chain_Node    *the_node
)
{
  _Chain_Insert_unprotected(_Chain_Head(the_chain), the_node);
}
 
static inline bool _Chain_Append_with_empty_check_unprotected(
  Chain_Control *the_chain,
  Chain_Node    *the_node
)
{
  bool was_empty = _Chain_Is_empty( the_chain );
 
  _Chain_Append_unprotected( the_chain, the_node );
 
  return was_empty;
}
 
static inline bool _Chain_Prepend_with_empty_check_unprotected(
  Chain_Control *the_chain,
  Chain_Node    *the_node
)
{
  bool was_empty = _Chain_Is_empty( the_chain );
 
  _Chain_Prepend_unprotected( the_chain, the_node );
 
  return was_empty;
}
 
static inline bool _Chain_Get_with_empty_check_unprotected(
  Chain_Control *the_chain,
  Chain_Node **the_node
)
{
  bool is_empty_now = true;
  Chain_Node *head = _Chain_Head( the_chain );
  Chain_Node *tail = _Chain_Tail( the_chain );
  Chain_Node *old_first = head->next;
 
  if ( old_first != tail ) {
    Chain_Node *new_first = old_first->next;
 
    head->next = new_first;
    new_first->previous = head;
 
    *the_node = old_first;
 
    is_empty_now = new_first == tail;
  } else
    *the_node = NULL;
 
  return is_empty_now;
}
 
typedef bool ( *Chain_Node_order )(
  const void       *key,
  const Chain_Node *left,
  const Chain_Node *right
);
 
static inline void _Chain_Insert_ordered_unprotected(
  Chain_Control    *the_chain,
  Chain_Node       *to_insert,
  const void       *key,
  Chain_Node_order  order
)
{
  const Chain_Node *tail = _Chain_Immutable_tail( the_chain );
  Chain_Node *previous = _Chain_Head( the_chain );
  Chain_Node *next = _Chain_First( the_chain );
 
  while ( next != tail && !( *order )( key, to_insert, next ) ) {
    previous = next;
    next = _Chain_Next( next );
  }
 
  _Chain_Insert_unprotected( previous, to_insert );
}
 
typedef enum {
  CHAIN_ITERATOR_FORWARD,
 
  CHAIN_ITERATOR_BACKWARD
} Chain_Iterator_direction;
 
typedef struct {
  Chain_Node Registry_node;
 
  Chain_Iterator_direction  direction;
 
  Chain_Node *position;
} Chain_Iterator;
 
typedef struct {
  Chain_Control Iterators;
} Chain_Iterator_registry;
 
#define CHAIN_ITERATOR_REGISTRY_INITIALIZER( name ) \
  { CHAIN_INITIALIZER_EMPTY( name.Iterators ) }
 
static inline void _Chain_Iterator_registry_initialize(
  Chain_Iterator_registry *the_registry
)
{
  _Chain_Initialize_empty( &the_registry->Iterators );
}
 
static inline void _Chain_Iterator_registry_update(
  Chain_Iterator_registry *the_registry,
  Chain_Node              *the_node_to_extract
)
{
  Chain_Node *iter_node;
  Chain_Node *iter_tail;
 
  iter_node = _Chain_Head( &the_registry->Iterators );
  iter_tail = _Chain_Tail( &the_registry->Iterators );
 
  while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) {
    Chain_Iterator *iter;
 
    iter = (Chain_Iterator *) iter_node;
 
    if ( iter->position == the_node_to_extract ) {
      if ( iter->direction == CHAIN_ITERATOR_FORWARD ) {
        iter->position = _Chain_Previous( the_node_to_extract );
      } else {
        iter->position = _Chain_Next( the_node_to_extract );
      }
    }
  }
}
 
static inline void _Chain_Iterator_initialize(
  Chain_Control            *the_chain,
  Chain_Iterator_registry  *the_registry,
  Chain_Iterator           *the_iterator,
  Chain_Iterator_direction  direction
)
{
  _Chain_Initialize_node( &the_iterator->Registry_node );
  _Chain_Append_unprotected(
    &the_registry->Iterators,
    &the_iterator->Registry_node
  );
 
  the_iterator->direction = direction;
 
  if ( direction == CHAIN_ITERATOR_FORWARD ) {
    the_iterator->position = _Chain_Head( the_chain );
  } else {
    the_iterator->position = _Chain_Tail( the_chain );
  }
}
 
static inline Chain_Node *_Chain_Iterator_next(
  const Chain_Iterator *the_iterator
)
{
  if ( the_iterator->direction == CHAIN_ITERATOR_FORWARD ) {
    return _Chain_Next( the_iterator->position );
  } else {
    return _Chain_Previous( the_iterator->position );
  }
}
 
static inline void _Chain_Iterator_set_position(
  Chain_Iterator *the_iterator,
  Chain_Node     *the_node
)
{
  the_iterator->position = the_node;
}
 
static inline void _Chain_Iterator_destroy(
  Chain_Iterator *the_iterator
)
{
  _Chain_Extract_unprotected( &the_iterator->Registry_node );
}
 
#ifdef __cplusplus
}
#endif
 
#endif
/* end of include file */