src/qsa/src/engine/qstypes.h

Ir a la documentación de este archivo.

/****************************************************************************
** $Id: qstypes.h  1.1.5   edited 2006-02-23T15:39:57$
**
** Copyright (C) 2001-2006 Trolltech AS.  All rights reserved.
**
** This file is part of the Qt Script for Applications framework (QSA).
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding a valid Qt Script for Applications license may use
** this file in accordance with the Qt Script for Applications License
** Agreement provided with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
**   information about QSA Commercial License Agreements.
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
*****************************************************************************/

#ifndef QSTYPES_H
#define QSTYPES_H

#include "qsvalues.h"

class QSList;
class QSListIterator;

class QUICKCORE_EXPORT ListNode
{
  friend class QSList;
  friend class QSListIterator;
  ListNode(QSObject obj, ListNode *p, ListNode *n)
    : member(obj), prev(p), next(n) {};
  QSObject member;
  ListNode *prev, *next;
};

class QUICKCORE_EXPORT QSListIterator
{
  friend class QSList;
  QSListIterator();
  QSListIterator(ListNode *n) : node(n) { }
public:
  QSListIterator(const QSList &list);
  QSListIterator &operator=(const QSListIterator &iterator) {
    node = iterator.node;
    return *this;
  }
  QSListIterator(const QSListIterator &i) : node(i.node) { }
  QSObject *operator->() const {
    return &node->member;
  }
  QSObject operator*() const {
    return node->member;
  }
  QSObject operator++() {
    node = node->next;
    return node->member;
  }
  QSObject operator++(int) {
    const ListNode *n = node;
    ++*this;
    return n->member;
  }
  QSObject operator--() {
    node = node->prev;
    return node->member;
  }
  QSObject operator--(int) {
    const ListNode *n = node;
    --*this;
    return n->member;
  }
  bool operator==(const QSListIterator &it) const {
    return node == it.node;
  }
  bool operator!=(const QSListIterator &it) const {
    return node != it.node;
  }
private:
  ListNode *node;
};

class QUICKCORE_EXPORT QSList
{
  friend class QSListIterator;
public:
  QSList() {
#if QS_DEBUG_MEM == 1
    count++;
#endif
    init();
  }

  QSList(const QSObject &first) {
#if QS_DEBUG_MEM == 1
    count++;
#endif
    init();
    append(first);
  }

  ~QSList() {
#if QS_DEBUG_MEM == 1
    count--;
#endif

    clear();
    delete hook;
  }
  void append(const QSObject &obj);
  void prepend(const QSObject &obj);
  void removeFirst();
  void removeLast();
  /*
   * Remove obj from list.
   */
  void remove(const QSObject &obj);
  void clear();
  QSList *copy() const;
  QSListIterator begin() const {
    return QSListIterator(hook->next);
  }
  QSListIterator end() const {
    return QSListIterator(hook);
  }
  bool isEmpty() const {
    return hook->prev == hook;
  }
  int size() const {
    //### AbanQ
    return size_;
  }
  QSObject at(int i) const;
  QSObject operator[](int i) const {
    return at(i);
  }

#if QS_DEBUG_MEM == 1

  static int count;
#endif
private:
  // not implemented
  QSList(const QSList &);
  QSList &operator=(const QSList &);

  void init();
  void erase(ListNode *n);
  ListNode *hook;

  //### AbanQ
  int size_;
};

//### AbanQ
inline void QSList::init()
{
  hook = new ListNode(QSObject(), 0L, 0L);
  hook->next = hook;
  hook->prev = hook;

  //### AbanQ
  size_ = 0;
}
inline void QSList::append(const QSObject &obj)
{
  ListNode *n = new ListNode(obj, hook->prev, hook);
  hook->prev->next = n;
  hook->prev = n;

  //### AbanQ
  ++size_;
}
inline void QSList::prepend(const QSObject &obj)
{
  ListNode *n = new ListNode(obj, hook, hook->next);
  hook->next->prev = n;
  hook->next = n;

  //### AbanQ
  ++size_;
}
inline void QSList::removeFirst()
{
  erase(hook->next);
}
inline void QSList::removeLast()
{
  erase(hook->prev);
}
inline void QSList::remove(const QSObject &obj)
{
  Q_UNUSED(obj)

#if 0 // ###
  if (!obj.isValid())
    return;

  ListNode *n = hook->next;
  while (n != hook) {
    if (n->member.imp() == obj.imp()) {
      erase(n);
      return;
    }
    n = n->next;
  }
#endif
}
inline void QSList::clear()
{
  ListNode *n = hook->next;
  while (n != hook) {
    n = n->next;
    delete n->prev;
  }

  hook->next = hook;
  hook->prev = hook;

  //### AbanQ
  size_ = 0;
}
inline QSList *QSList::copy() const
{
  QSList *newList = new QSList();
  QSListIterator e = end();
  QSListIterator it = begin();

  while (it != e) {
    newList->append(*it);
    ++it;
  }

  return newList;
}
inline void QSList::erase(ListNode *n)
{
  if (n != hook) {
    n->next->prev = n->prev;
    n->prev->next = n->next;
    delete n;

    //### AbanQ
    --size_;
  }
}
inline QSObject QSList::at(int i) const
{
  const ListNode *n = hook->next;
  while (i > 0 && n != hook) {
    n = n->next;
    --i;
  }
  return n->member;
}
//### AbanQ

#endif