Package org.tweetyproject.arg.adf.syntax.adf

Interface AbstractDialecticalFramework

public interface AbstractDialecticalFramework

The implementing subtypes must ensure the following properties:

• Immutability
• All methods return a non-null value if its parameters, e.g. arguments, are from this ADF
• If a method returns a collection or stream, all its elements are non-null

This makes the usage of AbstractDialecticalFramework implementations more convenient to the user, since it avoids unnecessary nullchecks and therefore leads to more readable code. Immutability should lead to more robust code, since an ADF always remains in a valid state after creation. It makes it also easier to use in a parallel context.

Author:

Mathias Hofer

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static interface	AbstractDialecticalFramework.Builder

Method Summary

Modifier and Type	Method	Description
default boolean	bipolar()	Checks if the ADF is bipolar.
static AbstractDialecticalFramework.Builder	builder()
Set<Argument>	children(Argument parent)
boolean	contains(Argument arg)
static AbstractDialecticalFramework	empty()
static AbstractDialecticalFramework	fromFile(File file)
static AbstractDialecticalFramework.Builder	fromMap(Map<Argument,AcceptanceCondition> map)
AcceptanceCondition	getAcceptanceCondition(Argument argument)	Guaranteed to be non-null if the ADF contains the argument.
Set<Argument>	getArguments()
int	incomingDegree(Argument arg)
int	kBipolar()	Returns the count k of non-bipolar links, which makes this ADF k-bipolar.
Link	link(Argument parent, Argument child)	Computes the link (parent, child) iff necessary and returns it afterwards.
Set<Link>	links()	If the caller just consumes some of the links, the method linksStream() should be preferred to this one.
Set<Link>	linksFrom(Argument parent)
default Stream<Link>	linksStream()	If the caller just consumes some links, this method should be used.
Set<Link>	linksTo(Argument child)
int	outgoingDegree(Argument arg)
Set<Argument>	parents(Argument child)
default SemanticsStep	query()
default int	size()
AbstractDialecticalFramework	transform(BiFunction<Argument,AcceptanceCondition,AcceptanceCondition> transformer)
AbstractDialecticalFramework	transform(Function<AcceptanceCondition,AcceptanceCondition> transformer)	Creates a new AbstractDialecticalFramework with transformed acceptance conditions.
AbstractDialecticalFramework	transform(Transformer<AcceptanceCondition> transformer)	Creates a new AbstractDialecticalFramework with transformed acceptance conditions.

Method Details

empty

static AbstractDialecticalFramework empty()

builder

static AbstractDialecticalFramework.Builder builder()

fromFile

static AbstractDialecticalFramework fromFile(File file)
                                      throws FileNotFoundException,
IOException

Throws:

FileNotFoundException

IOException

fromMap

static AbstractDialecticalFramework.Builder fromMap(Map<Argument,AcceptanceCondition> map)

transform

AbstractDialecticalFramework transform(Function<AcceptanceCondition,AcceptanceCondition> transformer)

Creates a new AbstractDialecticalFramework with transformed acceptance conditions.

Parameters:

transformer - the transformer to use

Returns:

a new ADF with transformed acceptance conditions

transform

AbstractDialecticalFramework transform(BiFunction<Argument,AcceptanceCondition,AcceptanceCondition> transformer)

transform

AbstractDialecticalFramework transform(Transformer<AcceptanceCondition> transformer)

Creates a new AbstractDialecticalFramework with transformed acceptance conditions.

Parameters:

transformer - the transformer to use

Returns:

a new ADF with transformed acceptance conditions

query

default SemanticsStep query()

size

default int size()

getArguments

Set<Argument> getArguments()

Returns:

an unmodifiable set of all the arguments

linksStream

default Stream<Link> linksStream()

If the caller just consumes some links, this method should be used. Depending on the implementation, the links may be computed lazily and therefore we may avoid unnecessary computation.

Returns:

a stream of the links of this adf

links

Set<Link> links()

If the caller just consumes some of the links, the method linksStream() should be preferred to this one. Depending on the implementation, the links may be computed lazily and therefore we may avoid unnecessary computation.

Returns:

an unmodifiable set of all the links

link

Link link(Argument parent,
 Argument child)

Computes the link (parent, child) iff necessary and returns it afterwards.

Parameters:

parent - the parent

child - the child

Returns:

the link (parent, child)

Throws:

IllegalArgumentException - if the adf does not contain a link (parent, child)

linksTo

Set<Link> linksTo(Argument child)

Parameters:

child - the child

Returns:

a set of links (parent, child)

linksFrom

Set<Link> linksFrom(Argument parent)

Parameters:

parent - the parent

Returns:

a set of links (parent, child)

parents

Set<Argument> parents(Argument child)

children

Set<Argument> children(Argument parent)

outgoingDegree

int outgoingDegree(Argument arg)

incomingDegree

int incomingDegree(Argument arg)

contains

boolean contains(Argument arg)

getAcceptanceCondition

AcceptanceCondition getAcceptanceCondition(Argument argument)

Guaranteed to be non-null if the ADF contains the argument.

Parameters:

argument - some argument of this ADF

Returns:

the found acceptance condition, never null

Throws:

IllegalArgumentException - if the argument is not contained in the ADF

bipolar

default boolean bipolar()

Checks if the ADF is bipolar. May compute all links to do so.

Returns:

true iff all of the links are bipolar

kBipolar

int kBipolar()

Returns the count k of non-bipolar links, which makes this ADF k-bipolar.

Returns:

k