/*
 * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code 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
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

#ifndef SHARE_GC_Z_ZLIST_INLINE_HPP
#define SHARE_GC_Z_ZLIST_INLINE_HPP

#include "gc/z/zList.hpp"
#include "utilities/debug.hpp"

template <typename T>
inline ZListNode<T>::ZListNode(ZListNode* next, ZListNode* prev) :
    _next(next),
    _prev(prev) {}

template <typename T>
inline void ZListNode<T>::set_unused() {
  _next = NULL;
  _prev = NULL;
}

template <typename T>
inline ZListNode<T>::ZListNode() {
  set_unused();
}

template <typename T>
inline ZListNode<T>::~ZListNode() {
  set_unused();
}

template <typename T>
inline bool ZListNode<T>::is_unused() const {
  return _next == NULL && _prev == NULL;
}

template <typename T>
inline void ZList<T>::verify() const {
  assert(_head._next->_prev == &_head, "List corrupt");
  assert(_head._prev->_next == &_head, "List corrupt");
}

template <typename T>
inline void ZList<T>::insert(ZListNode<T>* before, ZListNode<T>* node) {
  verify();

  assert(node->is_unused(), "Already in a list");
  node->_prev = before;
  node->_next = before->_next;
  before->_next = node;
  node->_next->_prev = node;

  _size++;
}

template <typename T>
inline ZListNode<T>* ZList<T>::cast_to_inner(T* elem) const {
  return &elem->_node;
}

template <typename T>
inline T* ZList<T>::cast_to_outer(ZListNode<T>* node) const {
  return (T*)((uintptr_t)node - offset_of(T, _node));
}

template <typename T>
inline ZList<T>::ZList() :
    _head(&_head, &_head),
    _size(0) {
  verify();
}

template <typename T>
inline size_t ZList<T>::size() const {
  verify();
  return _size;
}

template <typename T>
inline bool ZList<T>::is_empty() const {
  return _size == 0;
}

template <typename T>
inline T* ZList<T>::first() const {
  return is_empty() ? NULL : cast_to_outer(_head._next);
}

template <typename T>
inline T* ZList<T>::last() const {
  return is_empty() ? NULL : cast_to_outer(_head._prev);
}

template <typename T>
inline T* ZList<T>::next(T* elem) const {
  verify();
  ZListNode<T>* next = cast_to_inner(elem)->_next;
  return (next == &_head) ? NULL : cast_to_outer(next);
}

template <typename T>
inline T* ZList<T>::prev(T* elem) const {
  verify();
  ZListNode<T>* prev = cast_to_inner(elem)->_prev;
  return (prev == &_head) ? NULL : cast_to_outer(prev);
}

template <typename T>
inline void ZList<T>::insert_first(T* elem) {
  insert(&_head, cast_to_inner(elem));
}

template <typename T>
inline void ZList<T>::insert_last(T* elem) {
  insert(_head._prev, cast_to_inner(elem));
}

template <typename T>
inline void ZList<T>::insert_before(T* before, T* elem) {
  insert(cast_to_inner(before)->_prev, cast_to_inner(elem));
}

template <typename T>
inline void ZList<T>::insert_after(T* after, T* elem) {
  insert(cast_to_inner(after), cast_to_inner(elem));
}

template <typename T>
inline void ZList<T>::remove(T* elem) {
  verify();

  ZListNode<T>* const node = cast_to_inner(elem);
  assert(!node->is_unused(), "Not in a list");

  ZListNode<T>* const next = node->_next;
  ZListNode<T>* const prev = node->_prev;
  assert(next->_prev == node, "List corrupt");
  assert(prev->_next == node, "List corrupt");

  prev->_next = next;
  next->_prev = prev;
  node->set_unused();

  _size--;
}

template <typename T>
inline T* ZList<T>::remove_first() {
  T* elem = first();
  if (elem != NULL) {
    remove(elem);
  }

  return elem;
}

template <typename T>
inline T* ZList<T>::remove_last() {
  T* elem = last();
  if (elem != NULL) {
    remove(elem);
  }

  return elem;
}

template <typename T>
inline void ZList<T>::transfer(ZList<T>* list) {
  verify();

  if (!list->is_empty()) {
    list->_head._next->_prev = _head._prev;
    list->_head._prev->_next = _head._prev->_next;

    _head._prev->_next = list->_head._next;
    _head._prev = list->_head._prev;

    list->_head._next = &list->_head;
    list->_head._prev = &list->_head;

    _size += list->_size;
    list->_size = 0;

    list->verify();
    verify();
  }
}

template <typename T, bool forward>
inline ZListIteratorImpl<T, forward>::ZListIteratorImpl(const ZList<T>* list) :
    _list(list),
    _next(forward ? list->first() : list->last()) {}

template <typename T, bool forward>
inline bool ZListIteratorImpl<T, forward>::next(T** elem) {
  if (_next != NULL) {
    *elem = _next;
    _next = forward ? _list->next(_next) : _list->prev(_next);
    return true;
  }

  // No more elements
  return false;
}

template <typename T>
inline ZListIterator<T>::ZListIterator(const ZList<T>* list) :
    ZListIteratorImpl<T, ZLIST_FORWARD>(list) {}

template <typename T>
inline ZListReverseIterator<T>::ZListReverseIterator(const ZList<T>* list) :
    ZListIteratorImpl<T, ZLIST_REVERSE>(list) {}

#endif // SHARE_GC_Z_ZLIST_INLINE_HPP