DoubleLinkedList.h

Ugrás a fájl dokumentációjához.

/*
    Double Linked List
    Copyright (C) 2006  giszo

    This program 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 2 of the License, or
    (at your option) any later version.

    This program 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; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/
#ifndef DOUBLELINKEDLIST_H
#define DOUBLELINKEDLIST_H
#include <stdlib.h>
#include <Locking.h>

template<typename T>
class DoubleLinkedList {
  public:
    DoubleLinkedList() {
      firstItem = NULL;
    }

    ~DoubleLinkedList() {
      clear();
    }

    bool add( T data ) {
      Lock l( cs );

      struct _ListItem* newItem = ( struct _ListItem* )malloc( sizeof( struct _ListItem ) );
      if ( newItem == NULL ) { return false; }

      newItem->data = data;
      if ( firstItem == NULL ) {
        firstItem = newItem;
        newItem->prev = NULL;
        newItem->next = NULL;
      } else {
        newItem->prev = NULL;
        newItem->next = firstItem;
        firstItem->prev = newItem;
        firstItem = newItem;
      }

      return true;
    }

    T get( int ind ) {
      Lock l( cs );

      int _ind = 0;
      struct _ListItem* tmpItem = firstItem;

      while ( tmpItem ) {
        if ( _ind == ind ) {
          return tmpItem->data;
        }

        _ind++;
        tmpItem = tmpItem->next;
      }

      return NULL;
    }

    void remove( int ind ) {
      Lock l( cs );

      struct _ListItem* delItem = NULL;

      if ( firstItem == NULL ) { return; }
      if ( ind == 0 ) {
        delItem = firstItem;
        firstItem = firstItem->next;
        if ( firstItem ) { firstItem->prev = NULL; }
        free( delItem );
      } else {
        int _ind = 0;
        struct _ListItem* tmpItem = firstItem;

        while ( tmpItem ) {
          if ( _ind == ind ) {
            delItem = tmpItem;
            if ( tmpItem->prev ) { tmpItem->prev->next = tmpItem->next; }
            if ( tmpItem->next ) { tmpItem->next->prev = tmpItem->prev; }
            free( delItem );
            return;
          }

          _ind++;
          tmpItem = tmpItem->next;
        }
      }
    }

    void remove( T data ) {
      Lock l( cs );

      struct _ListItem* delItem = NULL;

      if ( firstItem == NULL ) { return; }
      if ( firstItem->data == data ) {
        delItem = firstItem;
        firstItem = firstItem->next;
        if ( firstItem ) { firstItem->prev = NULL; }
        free( delItem );
      } else {
        struct _ListItem* tmpItem = firstItem;

        while ( tmpItem ) {
          if ( tmpItem->data == data ) {
            delItem = tmpItem;
            if ( tmpItem->prev ) { tmpItem->prev->next = tmpItem->next; }
            if ( tmpItem->next ) { tmpItem->next->prev = tmpItem->prev; }
            free( delItem );
            return;
          }

          tmpItem = tmpItem->next;
        }
      }
    }

    void clear() {
      Lock l( cs );

      struct _ListItem* delItem = NULL;
      struct _ListItem* tmpItem = NULL;

      tmpItem = firstItem;
      while ( tmpItem ) {
        delItem = tmpItem;
        tmpItem = tmpItem->next;

        free( delItem );
      }
    }

    int size() {
      Lock l( cs );

      int size = 0;
      struct _ListItem* tmpItem = firstItem;

      while ( tmpItem ) {
        size++;
        tmpItem = tmpItem->next;
      }

      return size;
    }

    int indexOf( T data ) {
      Lock l( cs );

      int ind = 0;
      struct _ListItem* tmpItem = firstItem;

      while ( tmpItem ) {
        if ( tmpItem->data == data ) {
          return ind;
        }

        ind++;
        tmpItem = tmpItem->next;
      }

      return -1;
    }

  private:
    struct _ListItem {
      struct _ListItem* prev;
      struct _ListItem* next;

      T data;
    };

    CriticalSection cs;
    struct _ListItem* firstItem;
};

#endif