|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectkodkod.util.ints.AbstractSparseSequence<V>
kodkod.util.ints.HomogenousSequence<V>
public final class HomogenousSequence<V>
A sparse sequence implementation based on an IntSet
.
This implementation can be used only when all entries in the sequence map to the same value.
Important Implementation Note: As this implementation does not actually store any
indexed entries
,
the methods first()
, last()
, ceil(int)
, and floor(int)
may re-use the same IndexedEntry object. For example, suppose that an entry e with e.index = 1
is returned by a call to predecessor(2) on a homogenous sequence h = {<0,v>, <1,v>, <2,v>}.
A subsequent call to h.predecessor(1) may return the same object e, with its index set to 0. Hence,
the following assertion may fail:
IndexedEntrye1 = h.predecessor(2); assert e1.index()==1; // this will work IndexedEntry e2 = h.predecessor(1); assert e1.index()==1; // this may fail, as e1 may be == to e2
The entries returned by this implementation's AbstractSparseSequence.iterator()
are unique
to that iterator (but not necessarily independent of each other). For example,
// let s be a range sequence abstractly represented as { 0->v, 1->v, 2->v } Iterator> iter1 = s.iterator(); IndexedEntry e1 = iter1.next(); assert e1.index()==0; // this will work iter1.next(); assert e1.index()==0; // this may fail, as the previous call may have changed the state of e1 Iterator > iter2 = s.iterator(); IndexedEntry e2 = iter2.next(); iter1.next(); assert e2.index()==0; // this will work
indeces: set int |
entries: indeces -> one V |
Constructor Summary | |
---|---|
HomogenousSequence(SparseSequence<? extends V> seq)
Constructs a new homogeneous sequence from the provided sequence. |
|
HomogenousSequence(V value)
Constructs a new homogenous sequence for the given value, backed by a IntTreeSet instance. |
|
HomogenousSequence(V value,
IntSet indices)
Constructs a new homogenous sequence for the given value, backed by the specified intset. |
Method Summary | |
---|---|
IndexedEntry<V> |
ceil(int index)
If an entry for the given index exists, it is returned. |
void |
clear()
Removes all entries from this sequences. |
HomogenousSequence<V> |
clone()
Returns a copy of this sparse sequence. |
boolean |
contains(java.lang.Object value)
Returns true if this sequence has an entry with the given value; otherwise returns false. |
boolean |
containsIndex(int index)
Returns true if this sparse sequence has an entry for the given index; otherwise returns false. |
IndexedEntry<V> |
first()
Returns the entry with the smallest index. |
IndexedEntry<V> |
floor(int index)
If an entry for the given index exists, it is returned. |
V |
get(int index)
Returns the value to which this sequence maps the given index. |
IntSet |
indices()
Returns the set of all indices mapped by this sparse sequence. |
java.util.Iterator<IndexedEntry<V>> |
iterator(int from,
int to)
Returns an iterator over the entries in this sequence, whose indeces are between from and to. |
IndexedEntry<V> |
last()
Returns the entry with the largest index. |
V |
put(int index,
V value)
Puts the given value at the specified index. |
V |
remove(int index)
Removes the entry with the given index, if it exists, and returns the value previously stored at the index. |
int |
size()
Returns the number of entries in this sequence. |
Methods inherited from class kodkod.util.ints.AbstractSparseSequence |
---|
equals, hashCode, isEmpty, iterator, putAll, toString, values |
Methods inherited from class java.lang.Object |
---|
getClass, notify, notifyAll, wait, wait, wait |
Constructor Detail |
---|
public HomogenousSequence(V value)
IntTreeSet
instance.
this.value' = value && no this.indices' |
public HomogenousSequence(V value, IntSet indices)
this.value' = value && this.indices' = indices |
indices is cloneable |
public HomogenousSequence(SparseSequence<? extends V> seq)
IntTreeSet
instance.
java.lang.NullPointerException
- - seq = null
java.lang.IllegalArgumentException
- - seq.isEmpty()
java.lang.IllegalArgumentException
- - #seq.entries[int] > 1this.value' = seq.entries[int] && this.indices' = seq.indices() |
one seq.entries[int] |
Method Detail |
---|
public IntSet indices()
indices
in interface SparseSequence<V>
indices
in class AbstractSparseSequence<V>
public java.util.Iterator<IndexedEntry<V>> iterator(int from, int to)
While the returned iterator i re-uses the same IndexedEntry object, it is not shared with other iterators or other method calls. In particular, no other call except i.next() can change the value of the re-used object.
SparseSequence.iterator(int, int)
public int size()
SparseSequence.size()
public void clear()
clear
in interface SparseSequence<V>
clear
in class AbstractSparseSequence<V>
SparseSequence.clear()
no this.entries' |
public V put(int index, V value)
put
in interface SparseSequence<V>
put
in class AbstractSparseSequence<V>
java.lang.IllegalArgumentException
- - this.value != valueSparseSequence.put(int, Object)
this.indices' = this.indices + index |
this.value = value |
public V get(int index)
SparseSequence.get(int)
public V remove(int index)
remove
in interface SparseSequence<V>
remove
in class AbstractSparseSequence<V>
SparseSequence.remove(int)
this.entries' = this.entries - index->E |
public boolean containsIndex(int index)
containsIndex
in interface SparseSequence<V>
containsIndex
in class AbstractSparseSequence<V>
SparseSequence.containsIndex(int)
public boolean contains(java.lang.Object value)
contains
in interface SparseSequence<V>
contains
in class AbstractSparseSequence<V>
SparseSequence.contains(java.lang.Object)
public IndexedEntry<V> first()
first
in interface SparseSequence<V>
first
in class AbstractSparseSequence<V>
SparseSequence.first()
public IndexedEntry<V> last()
last
in interface SparseSequence<V>
last
in class AbstractSparseSequence<V>
SparseSequence.last()
public IndexedEntry<V> ceil(int index)
ceil
in interface SparseSequence<V>
ceil
in class AbstractSparseSequence<V>
SparseSequence.ceil(int)
public IndexedEntry<V> floor(int index)
floor
in interface SparseSequence<V>
floor
in class AbstractSparseSequence<V>
SparseSequence.floor(int)
public HomogenousSequence<V> clone()
clone
in interface SparseSequence<V>
clone
in class AbstractSparseSequence<V>
SparseSequence.clone()
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |