/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - Initial contribution

*

* Contributors:

* Ixonos Plc

*

* Description:  

* List handling functions.

*

*/

#include "h263dconfig.h"

#include "list.h"

#ifndef NULL

   #define NULL 0

#endif

/*

 * fifoClose

 *    

 *

 * Parameters:

 *    list                       a pointer to a FIFO list

 *

 * Function:

 *    This function deinitializes the given FIFO list. Notice that no dynamic

 *    allocation for the list is done. This function must be called when

 *    the list is no longer used.

 *

 * Returns:

 *    >= 0 if the function was successful

 *    < 0  indicating an error

 *

 */

int fifoClose(fifo_t *list)

{

   list->head = list->tail = NULL;

   list->numItems = 0;

   return 0;

}

/*

 * fifoGet

 *    

 *

 * Parameters:

 *    list                       a pointer to a FIFO list

 *    item                       used to return a pointer to the removed

 *                               list item

 *

 * Function:

 *    This function removes an item from the list. Notice that no copying of

 *    contents of the given item is done, i.e. only the pointer to the item

 *    is used.

 *

 *    If there are no items left in the list, NULL will be returned in

 *    the item parameter.

 *

 * Returns:

 *    >= 0 if the function was successful

 *    < 0  indicating an error

 *

 */

int fifoGet(fifo_t *list, void **item)

{

   if (list->head) {

      *item = (void *) list->head;

      list->head = (lstListItem_t *) list->head->next;

      if (list->head == NULL)

         list->tail = NULL;

      list->numItems--;

   }

   else

      *item = NULL;

   return 0;

}

/*

 * fifoOpen

 *    

 *

 * Parameters:

 *    list                       a pointer to a FIFO list

 *

 * Function:

 *    This function initializes the given FIFO list. Notice that no dynamic

 *    allocation for the list is done. This function must be called before

 *    the list is used.

 *

 * Returns:

 *    >= 0 if the function was successful

 *    < 0  indicating an error

 *

 */

int fifoOpen(fifo_t *list)

{

   list->head = list->tail = NULL;

   list->numItems = 0;

   return 0;

}

/*

 * fifoPeek

 *    

 *

 * Parameters:

 *    list                       a pointer to a FIFO list

 *    item                       used to return a pointer to the removed

 *                               list item

 *

 * Function:

 *    This function returns a pointer to the next in the list but does not

 *    remove the item from the list. Notice that no copying of

 *    contents of the given item is done, i.e. only the pointer to the item

 *    is used.

 *

 *    If there are no items left in the list, NULL will be returned in

 *    the item parameter.

 *

 * Returns:

 *    >= 0 if the function was successful

 *    < 0  indicating an error

 *

 */

int fifoPeek(fifo_t *list, void **item)

{

   if (list->head)

      *item = (void *) list->head;

   else

      *item = NULL;

   return 0;

}

/*

 * fifoPut

 *    

 *

 * Parameters:

 *    list                       a pointer to a FIFO list

 *    item                       an item to add to the list

 *

 * Function:

 *    This function adds an item into the list. Notice that no copying of

 *    contents of the given item is done, i.e. only the pointer to the item

 *    is used.

 *

 * Returns:

 *    >= 0 if the function was successful

 *    < 0  indicating an error

 *

 */

int fifoPut(fifo_t *list, void *item)

{

   ((lstListItem_t *) item)->next = NULL;

   if (list->tail) {

      list->tail->next = item;

      list->tail = (lstListItem_t *) (item);

   }

   else

      list->head = list->tail = (lstListItem_t *) item;

   list->numItems++;

   return 0;

}

/*

 * lifoClose

 *    

 *

 * Parameters:

 *    list                       a pointer to a LIFO list

 *

 * Function:

 *    This function deinitializes the given LIFO list. Notice that no dynamic

 *    allocation for the list is done. This function must be called when

 *    the list is no longer used.

 *

 * Returns:

 *    >= 0 if the function was successful

 *    < 0  indicating an error

 *

 */

int lifoClose(lifo_t *list)

{

   list->head = NULL;

   return 0;

}

/*

 * lifoGet

 *    

 *

 * Parameters:

 *    list                       a pointer to a LIFO list

 *    item                       used to return a pointer to the removed

 *                               list item

 *

 * Function:

 *    This function removes an item from the list. Notice that no copying of

 *    contents of the given item is done, i.e. only the pointer to the item

 *    is used.

 *

 *    If there are no items left in the list, NULL will be returned in

 *    the item parameter.

 *

 * Returns:

 *    >= 0 if the function was successful

 *    < 0  indicating an error

 *

 */

int lifoGet(lifo_t *list, void **item)

{

   if (list->head) {

      *item = list->head;

      list->head = (lstListItem_t *) list->head->next;

   }

   else

      *item = NULL;

   return 0;

}

/*

 * lifoOpen

 *    

 *

 * Parameters:

 *    list                       a pointer to a LIFO list

 *

 * Function:

 *    This function initializes the given LIFO list. Notice that no dynamic

 *    allocation for the list is done. This function must be called before

 *    the list is used.

 *

 * Returns:

 *    >= 0 if the function was successful

 *    < 0  indicating an error

 *

 */

int lifoOpen(lifo_t *list)

{

   list->head = NULL;

   return 0;

}

/*

 * lifoPut

 *    

 *

 * Parameters:

 *    list                       a pointer to a LIFO list

 *    item                       an item to add to the list

 *

 * Function:

 *    This function adds an item into the list. Notice that no copying of

 *    contents of the given item is done, i.e. only the pointer to the item

 *    is used.

 *

 * Returns:

 *    >= 0 if the function was successful

 *    < 0  indicating an error

 *

 */

int lifoPut(lifo_t *list, void *item)

{

   ((lstListItem_t *) item)->next = list->head;

   list->head = (lstListItem_t *) item;

   return 0;

}

/*

 * lstClose

 *    

 *

 * Parameters:

 *    list                       a pointer to a list

 *

 * Function:

 *    This function deinitializes the given list. Notice that no dynamic

 *    allocation for the list is done. This function must be called when

 *    the list is no longer used.

 *

 * Returns:

 *    >= 0 if the function was successful

 *    < 0  indicating an error

 *

 */

int lstClose(lst_t *list)

{

   list->head = list->prev = list->curr = NULL;

   list->numItems = 0;

   return 0;

}

/*

 * lstRemove

 *    

 *

 * Parameters:

 *    list                       a pointer to a lst list

 *    item                       used to return a pointer to the removed

 *                               list item

 *

 * Function:

 *    This function removes an item from the list. Notice that no copying of

 *    contents of the given item is done, i.e. only the pointer to the item

 *    is used.

 *

 *    If there are no items left in the list, NULL will be returned in

 *    the item parameter.

 *

 * Returns:

 *    >= 0 if the function was successful

 *    < 0  indicating an error

 *

 */

int lstRemove(lst_t *list, void **item)

{

   if (list->curr) {

      *item = (void *) list->curr;

      if (list->prev)

         list->prev->next = list->curr->next;

      else

         list->head = (lstListItem_t *) (list->curr->next);

      list->curr = (lstListItem_t *) (list->curr->next);

      ((lstListItem_t *) *item)->next = NULL;

      list->numItems--;

   }

   else

      *item = NULL;

   return 0;

}

/*

 * lstOpen

 *    

 *

 * Parameters:

 *    list                       a pointer to a list

 *

 * Function:

 *    This function initializes the given list. Notice that no dynamic

 *    allocation for the list is done. This function must be called before

 *    the list is used.

 *

 * Returns:

 *    >= 0 if the function was successful

 *    < 0  indicating an error

 *

 */

int lstOpen(lst_t *list)

{

   list->head = list->prev = list->curr = NULL;

   list->numItems = 0;

   return 0;

}

/*

 * lstHead

 *    

 *

 * Parameters:

 *    list                       a pointer to a lst list

 *    item                       used to return a pointer to the head item

 *                               of the list

 *

 * Function:

 *    This function sets the current access point to the head of the list and

 *    returns a pointer to the head item. Notice that no copying of

 *    contents of the given item is done, i.e. only the pointer to the item

 *    is used.

 *

 *    If there are no items left in the list, NULL will be returned in

 *    the item parameter.

 *

 * Returns:

 *    >= 0 if the function was successful

 *    < 0  indicating an error

 *

 */

int lstHead(lst_t *list, void **item)

{

   if (list->head)

      *item = (void *) list->head;

   else

      *item = NULL;

   list->curr = list->head;

   list->prev = NULL;

   return 0;

}

/*

 * lstEnd

 *    

 *

 * Parameters:

 *    list                       a pointer to a lst list

 *

 * Function:

 *    This function sets the current access point to the tail of the list

 *    enabling the item addition to the end of the list.

 *

 * Returns:

 *    >= 0 if the function was successful

 *    < 0  indicating an error

 *

 */

int lstEnd(lst_t *list)

{

   while (list->curr) {

      list->prev = list->curr;

      list->curr = (lstListItem_t *) (list->curr->next);

   }

   return 0;

}

/*

 * lstTail

 *    

 *

 * Parameters:

 *    list                       a pointer to a lst list

 *

 * Function:

 *    This function sets the current access point to the tail of the list

 *    enabling the item addition to the end of the list.

 *

 * Returns:

 *    >= 0 if the function was successful

 *    < 0  indicating an error

 *

 */

int lstTail(lst_t *list, void **item)

{

   if (!list->curr) {

      list->curr = list->head;

      list->prev = NULL;

   }

   if (!list->curr) {

      *item = NULL;

      return 0;

   }

   while (list->curr->next) {

      list->prev = list->curr;

      list->curr = (lstListItem_t *) (list->curr->next);

   }

   *item = list->curr;

   return 0;

}

/*

 * lstCurr

 *    

 *

 * Parameters:

 *    list                       a pointer to a lst list

 *    item                       used to return a pointer to the current item

 *                               of the list

 *

 * Function:

 *    This returns a pointer to the current item of the list. 

 *    Notice that no copying of contents of the given item is done, 

 *    i.e. only the pointer to the item is used.

 *