/*

 * Copyright (C) 2004-2012 David Anderson

 *

 * This file is part of SourcePawn.

 *

 * SourcePawn 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 of the License, or (at your option)

 * any later version.

 * 

 * SourcePawn 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

 * SourcePawn. If not, see http://www.gnu.org/licenses/.

 */

#ifndef _include_ke_inline_list_h_

#define _include_ke_inline_list_h_

#include <stddef.h>

namespace ke {

template <typename T> class InlineList;

template <typename T>

class InlineListNode

{

    friend class InlineList<T>;

  public:

    InlineListNode()

      : next_(NULL),

        prev_(NULL)

    {

    }

    InlineListNode(InlineListNode *next, InlineListNode *prev)

      : next_(next),

        prev_(prev)

    {

    }

  protected:

    InlineListNode *next_;

    InlineListNode *prev_;

};

template <typename T>

class InlineList

{

    typedef InlineListNode<T> Node;

    Node head_;

  public:

    InlineList()

      : head_(&head_, &head_)

    {

    }

  public:

    class iterator

    {

        friend class InlineList;

        Node *iter_;

      public:

        iterator(Node *iter)

          : iter_(iter)

        {

        }

        iterator & operator++() {

            iter_ = iter_->next_;

            return *this;

        }

        iterator operator ++(int) {

            iterator old(*this);

            iter_ = iter_->next_;

            return old;

        }

        T * operator *() {

            return static_cast<T *>(iter_);

        }

        T * operator ->() {

            return static_cast<T *>(iter_);

        }

        bool operator !=(const iterator &where) const {

            return iter_ != where.iter_;

        }

        bool operator ==(const iterator &where) const {

            return iter_ == where.iter_;

        }

        iterator prev() const {

            return iterator(iter_->prev_);

        }

        iterator next() const {

            return iterator(iter_->next_);

        }

    };

    iterator begin() {

        return iterator(head_.next_);

    }

    iterator end() {

        return iterator(&head_);

    }

    void append(Node *t) {

        t->prev_ = head_.prev_;

        t->next_ = &head_;

        head_.prev_->next_ = t;

        head_.prev_ = t;

    }

    iterator erase(iterator i) {

        iterator next = ++i;

        remove(i.iter_);

        return next;

    }

    void remove(Node *t) {

        t->prev_->next_ = t->next_;

        t->next_->prev_ = t->prev_;

    }

};

}

#endif // _include_ke_inline_list_h_