AbstractRelation (Concept Explorer FX 6.0.0-SNAPSHOT API)

java.lang.Object
- conexp.fx.core.collections.relation.AbstractRelation<R,C>

All Implemented Interfaces:

Relation<R,C>, PartialComparable<Relation<R,C>>, Cloneable, Comparable<Relation<R,C>>, Iterable<Pair<R,C>>

Direct Known Subclasses:

AbstractContext, MatrixRelation
```
public abstract class AbstractRelation<R,C>
extends Object
implements Relation<R,C>
```

Nested Class Summary
- Nested classes/interfaces inherited from interface conexp.fx.core.collections.relation.Relation
  Relation.NoHomogenRelationException

Field Summary

Fields
Modifier and Type Field and Description

protected SetList<C> colHeads

protected boolean homogen

protected SetList<R> rowHeads

Fields
Modifier and Type	Field and Description
`protected SetList<C>`	`colHeads`
`protected boolean`	`homogen`
`protected SetList<R>`	`rowHeads`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`AbstractRelation(boolean homogen)`
`protected`	`AbstractRelation(SetList<R> rowHeads, SetList<C> colHeads, boolean homogen)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`add(R row, C col)`
`boolean`	`addAll(Relation<? extends R,? extends C> r)`
`boolean`	`addAllFast(Relation<?,?> r)`
`boolean`	`addFast(Object o1, Object o2)`
`protected void`	`checkHomogen()`
`MatrixRelation<R,C>`	`clone()`
`Set<R>`	`col(Object o)`
`Set<R>`	`colAnd(Collection<?> cols)`
`Set<R>`	`colAnd(Object... cols)`
`SetList<C>`	`colHeads()`
`int`	`compareTo(Relation<R,C> r)`
`abstract boolean`	`contains(Object o1, Object o2)`
`boolean`	`containsAll(Relation<?,?> r)`
`void`	`dispose()`
`void`	`empty()`
`boolean`	`equals(Object o)`
`SetList<Set<R>>`	`equivalenceClasses()`
`void`	`fill()`
`Relation<R,C>`	`filter(com.google.common.base.Predicate<? super R> rowPredicate, com.google.common.base.Predicate<? super C> colPredicate, com.google.common.base.Predicate<Pair<R,C>> relationPredicate)`
`static <R> AbstractRelation<R,R>`	`fromPredicate(SetList<R> heads, BiPredicate<R,R> predicate)`
`static <R,C> AbstractRelation<R,C>`	`fromPredicate(SetList<R> rowHeads, SetList<C> colHeads, BiPredicate<R,C> predicate)`
`boolean`	`greater(Relation<R,C> r)`
`boolean`	`greaterEq(Relation<R,C> r)`
`boolean`	`isEmpty()`
`boolean`	`isFull()`
`boolean`	`isHomogen()`
`Iterator<Pair<R,C>>`	`iterator()`
`MatrixRelation<R,R>`	`neighborhood()`
`MatrixRelation<R,R>`	`order()`
`boolean`	`remove(Object o1, Object o2)`
`boolean`	`removeAll(Relation<?,?> r)`
`boolean`	`retainAll(Relation<?,?> r)`
`Set<C>`	`row(Object o)`
`Set<C>`	`rowAnd(Collection<?> rows)`
`Set<C>`	`rowAnd(Object... rows)`
`SetList<R>`	`rowHeads()`
`int`	`size()`
`boolean`	`smaller(Relation<R,C> r)`
`boolean`	`smallerEq(Relation<R,C> r)`
`Relation<R,C>`	`subRelation(Collection<?> rows, Collection<?> cols)`
`boolean[][]`	`toArray()`
`String`	`toString()`
`boolean`	`uncomparable(Relation<R,C> r)`

Methods inherited from class java.lang.Object
finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface conexp.fx.core.collections.relation.Relation
density

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface conexp.fx.core.math.PartialComparable
equivalent

Field Detail

homogen
```
protected final boolean homogen
```

rowHeads
```
protected SetList<R> rowHeads
```

colHeads
```
protected SetList<C> colHeads
```

Constructor Detail

AbstractRelation

protected AbstractRelation(SetList<R> rowHeads,
                           SetList<C> colHeads,
                           boolean homogen)

AbstractRelation

protected AbstractRelation(boolean homogen)

Method Detail

fromPredicate

public static <R,C> AbstractRelation<R,C> fromPredicate(SetList<R> rowHeads,
                                                        SetList<C> colHeads,
                                                        BiPredicate<R,C> predicate)

fromPredicate

public static <R> AbstractRelation<R,R> fromPredicate(SetList<R> heads,
                                                      BiPredicate<R,R> predicate)

rowHeads
```
public SetList<R> rowHeads()
```
Specified by:

rowHeads in interface Relation<R,C>

colHeads
```
public SetList<C> colHeads()
```
Specified by:

colHeads in interface Relation<R,C>

contains

public abstract boolean contains(Object o1,
                                 Object o2)

Specified by:: contains in interface Relation<R,C>

containsAll
```
public boolean containsAll(Relation<?,?> r)
```
Specified by:

containsAll in interface Relation<R,C>

row
```
public Set<C> row(Object o)
```
Specified by:

row in interface Relation<R,C>

col
```
public Set<R> col(Object o)
```
Specified by:

col in interface Relation<R,C>

rowAnd
```
public final Set<C> rowAnd(Object... rows)
```
Specified by:

rowAnd in interface Relation<R,C>

colAnd
```
public final Set<R> colAnd(Object... cols)
```
Specified by:

colAnd in interface Relation<R,C>

rowAnd
```
public Set<C> rowAnd(Collection<?> rows)
```
Specified by:

rowAnd in interface Relation<R,C>

colAnd
```
public Set<R> colAnd(Collection<?> cols)
```
Specified by:

colAnd in interface Relation<R,C>

subRelation

public Relation<R,C> subRelation(Collection<?> rows,
                                 Collection<?> cols)

Specified by:: subRelation in interface Relation<R,C>

filter

public Relation<R,C> filter(com.google.common.base.Predicate<? super R> rowPredicate,
                            com.google.common.base.Predicate<? super C> colPredicate,
                            com.google.common.base.Predicate<Pair<R,C>> relationPredicate)

Specified by:: filter in interface Relation<R,C>

equals
```
public boolean equals(Object o)
```
Overrides:

equals in class Object

smallerEq
```
public final boolean smallerEq(Relation<R,C> r)
```
Specified by:

smallerEq in interface PartialComparable<Relation<R,C>>

smaller
```
public final boolean smaller(Relation<R,C> r)
```
Specified by:

smaller in interface PartialComparable<Relation<R,C>>

greaterEq
```
public final boolean greaterEq(Relation<R,C> r)
```
Specified by:

greaterEq in interface PartialComparable<Relation<R,C>>

greater
```
public final boolean greater(Relation<R,C> r)
```
Specified by:

greater in interface PartialComparable<Relation<R,C>>

uncomparable
```
public final boolean uncomparable(Relation<R,C> r)
```
Specified by:

uncomparable in interface PartialComparable<Relation<R,C>>

compareTo
```
public final int compareTo(Relation<R,C> r)
```
Specified by:

compareTo in interface Comparable<Relation<R,C>>

iterator
```
public Iterator<Pair<R,C>> iterator()
```
Specified by:

iterator in interface Iterable<Pair<R,C>>

size
```
public int size()
```
Specified by:

size in interface Relation<R,C>

isFull
```
public boolean isFull()
```
Specified by:

isFull in interface Relation<R,C>

isEmpty
```
public boolean isEmpty()
```
Specified by:

isEmpty in interface Relation<R,C>

clone
```
public MatrixRelation<R,C> clone()
```
Specified by:

clone in interface Relation<R,C>

Overrides:

clone in class Object

toArray
```
public boolean[][] toArray()
```
Specified by:

toArray in interface Relation<R,C>

toString
```
public String toString()
```
Overrides:

toString in class Object

empty
```
public void empty()
```
Specified by:

empty in interface Relation<R,C>

fill
```
public void fill()
```
Specified by:

fill in interface Relation<R,C>

dispose
```
public void dispose()
```
Specified by:

dispose in interface Relation<R,C>

add

public boolean add(R row,
                   C col)

Specified by:: add in interface Relation<R,C>

addFast

public boolean addFast(Object o1,
                       Object o2)

Specified by:: addFast in interface Relation<R,C>

addAll

public boolean addAll(Relation<? extends R,? extends C> r)

Specified by:: addAll in interface Relation<R,C>

addAllFast
```
public boolean addAllFast(Relation<?,?> r)
```
Specified by:

addAllFast in interface Relation<R,C>

remove

public boolean remove(Object o1,
                      Object o2)

Specified by:: remove in interface Relation<R,C>

removeAll
```
public boolean removeAll(Relation<?,?> r)
```
Specified by:

removeAll in interface Relation<R,C>

retainAll
```
public boolean retainAll(Relation<?,?> r)
```
Specified by:

retainAll in interface Relation<R,C>

isHomogen
```
public boolean isHomogen()
```
Specified by:

isHomogen in interface Relation<R,C>

checkHomogen

protected final void checkHomogen()
                           throws Relation.NoHomogenRelationException

Throws:: Relation.NoHomogenRelationException

neighborhood
```
public MatrixRelation<R,R> neighborhood()
```
Specified by:

neighborhood in interface Relation<R,C>

order
```
public MatrixRelation<R,R> order()
```
Specified by:

order in interface Relation<R,C>

equivalenceClasses
```
public SetList<Set<R>> equivalenceClasses()
```
Specified by:

equivalenceClasses in interface Relation<R,C>

Class AbstractRelation<R,C>

Nested Class Summary

Nested classes/interfaces inherited from interface conexp.fx.core.collections.relation.Relation

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface conexp.fx.core.collections.relation.Relation

Methods inherited from interface java.lang.Iterable

Methods inherited from interface conexp.fx.core.math.PartialComparable

Field Detail

homogen

rowHeads

colHeads

Constructor Detail

AbstractRelation

AbstractRelation

Method Detail

fromPredicate

fromPredicate

rowHeads

colHeads

contains

containsAll

row

col

rowAnd

colAnd

rowAnd

colAnd

subRelation

filter

equals

smallerEq

smaller

greaterEq

greater

uncomparable

compareTo

iterator

size

isFull

isEmpty

clone

toArray

toString

empty

fill

dispose

add

addFast

addAll

addAllFast

remove

removeAll

retainAll

isHomogen

checkHomogen

neighborhood

order

equivalenceClasses