io.qt.core.AbstractList Maven / Gradle / Ivy
/****************************************************************************
**
** Copyright (C) 2009-2024 Dr. Peter Droste, Omix Visualization GmbH & Co. KG. All rights reserved.
**
** This file is part of Qt Jambi.
**
** $BEGIN_LICENSE$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
** $END_LICENSE$
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/
package io.qt.core;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.NoSuchElementException;
import io.qt.QtUninvokable;
abstract class AbstractList extends AbstractSequentialContainer implements java.util.List {
AbstractList(QPrivateConstructor p) {
super(p);
}
/**
* Creates and returns a copy of this sequential container.
*/
@Override
public abstract AbstractList clone();
@QtUninvokable
protected abstract QSequentialIterator begin();
@QtUninvokable
protected abstract QSequentialIterator end();
public abstract void removeAt(int i);
public abstract void append(java.util.Collection t);
/**
* Appends all of the elements in the specified collection to the end of
* this list.
*/
@Override
@SuppressWarnings("unchecked")
@QtUninvokable
public final boolean addAll(Collection c) {
append((Collection)c);
return true;
}
/**
* Inserts all of the elements in the specified collection into this
* list at the specified position.
*/
@Override
@QtUninvokable
public final boolean addAll(int index, Collection c) {
for (T o : c) {
add(index++, o);
}
return true;
}
/**
* Removes the element at the specified position in this list.
*/
@Override
@QtUninvokable
public final T remove(int index) {
T result = get(index);
this.removeAt(index);
return result;
}
/**
* Returns a list iterator over the elements in this list (in proper
* sequence).
*/
@Override
@QtUninvokable
public final java.util.ListIterator listIterator() {
return listIterator(0);
}
private static class ListIterator implements java.util.ListIterator{
private final AbstractList list;
private QSequentialConstIterator current;
private QSequentialConstIterator begin;
private QSequentialConstIterator end;
private int icursor;
private boolean hasNext;
private boolean hasPrevious;
ListIterator(AbstractList list, int index){
this.list = list;
initialize(index);
}
private void initialize(int index){
begin = list.begin();
current = list.begin();
end = list.end();
icursor = 0;
for (int i = 0; i < index && end!=null && !current.equals(end); i++) {
current.increment();
icursor++;
}
hasNext = end!=null && !current.equals(end);
hasPrevious = begin!=null && !current.equals(begin);
}
@Override
public boolean hasNext() {
return hasNext;
}
@Override
public T next() {
if(!hasNext())
throw new NoSuchElementException();
checkModification();
T e = current._value();
current.increment();
hasNext = end!=null && !current.equals(end);
hasPrevious = begin!=null && !current.equals(begin);
icursor++;
return e;
}
@Override
public T previous() {
if(!hasPrevious())
throw new NoSuchElementException();
checkModification();
current.decrement();
hasNext = end!=null && !current.equals(end);
hasPrevious = begin!=null && !current.equals(begin);
T e = current._value();
icursor--;
return e;
}
@Override
public void remove() {
checkModification();
if(icursor==0)
throw new IndexOutOfBoundsException(-1);
list.remove(icursor-1);
initialize(icursor-1);
}
@Override
public void set(T e) {
checkModification();
if(icursor==0)
throw new IndexOutOfBoundsException(-1);
current.decrement();
((QSequentialIterator)current).setValue(e);
current.increment();
}
@Override
public int previousIndex() {
return icursor-1;
}
@Override
public int nextIndex() {
return icursor;
}
@Override
public boolean hasPrevious() {
return hasPrevious;
}
@Override
public void add(T e) {
checkModification();
list.add(icursor, e);
initialize(icursor+1);
}
void checkModification() {
// if(!end.equals(citer.end()))
// throw new IllegalMonitorStateException();
}
}
/**
* Returns a list iterator over the elements in this list (in proper
* sequence), starting at the specified position in the list.
*/
@Override
@QtUninvokable
public final java.util.ListIterator listIterator(int index) {
return new ListIterator<>(this, index);
}
/**
* Returns a view of the portion of this list between the specified
* {@code fromIndex}, inclusive, and {@code toIndex}, exclusive. (If
* {@code fromIndex} and {@code toIndex} are equal, the returned list is
* empty.) The returned list is backed by this list, so non-structural
* changes in the returned list are reflected in this list, and vice-versa.
* The returned list supports all of the optional list operations supported
* by this list.
*/
@SuppressWarnings("unchecked")
@Override
@QtUninvokable
public final List subList(int fromIndex, int toIndex) {
if (fromIndex < 0)
throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
if (toIndex > size())
throw new IndexOutOfBoundsException("toIndex = " + toIndex);
if (fromIndex > toIndex)
throw new IllegalArgumentException("fromIndex(" + fromIndex +
") > toIndex(" + toIndex + ")");
List sublist = clone();
sublist.clear();
if(!sublist.isEmpty()) {
try {
sublist = this.getClass().getConstructor().newInstance();
}catch(Throwable e) {
sublist = new ArrayList<>();
}
}
for (int i = 0; i < toIndex - fromIndex; i++) {
sublist.add(get(fromIndex+i));
}
return sublist;
}
/**
* Retains only the elements in this list that are contained in the
* specified collection (optional operation). In other words, removes
* from this list all of its elements that are not contained in the
* specified collection.
*/
@Override
@QtUninvokable
public final boolean retainAll(Collection c) {
boolean changed = false;
for(int i=0; i © 2015 - 2025 Weber Informatics LLC | Privacy Policy