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

Interface AbstractDialecticalFramework

All Superinterfaces:

ArgumentationFramework<Argument>, BeliefBase, Collection<Argument>, GeneralGraph<Argument>, Graph<Argument>, Iterable<Argument>

public interface AbstractDialecticalFramework
extends Graph<Argument>, Collection<Argument>, ArgumentationFramework<Argument>

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	Builder interface for constructing instances of AbstractDialecticalFramework.

Field Summary

Fields inherited from interface org.tweetyproject.graphs.Graph

IGNORE_SELFLOOPS, INVERT_SELFLOOPS, REMOVE_SELFLOOPS

Method Summary

Modifier and Type	Method	Description
default boolean	bipolar()	Checks if the ADF is bipolar, meaning all links are either supporting or attacking.
static AbstractDialecticalFramework.Builder	builder()	Returns a builder for constructing a new AbstractDialecticalFramework.
Set<Argument>	children(Argument parent)	Returns a set of child arguments for the given parent argument.
boolean	contains(Argument arg)	Checks if the given argument is contained in this AbstractDialecticalFramework.
static AbstractDialecticalFramework	empty()	Returns an empty AbstractDialecticalFramework.
static AbstractDialecticalFramework	fromFile(File file)	Reads an AbstractDialecticalFramework from a file.
static AbstractDialecticalFramework.Builder	fromMap(Map<Argument,AcceptanceCondition> map)	Creates a builder from a map of arguments and their corresponding acceptance conditions.
AcceptanceCondition	getAcceptanceCondition(Argument argument)	Retrieves the acceptance condition for the specified argument.
Set<Argument>	getArguments()	Returns an unmodifiable set of all the arguments in this AbstractDialecticalFramework.
int	incomingDegree(Argument arg)	Returns the number of incoming links to the given argument.
int	kBipolar()	Returns the number of non-bipolar links, indicating the degree of bipolarity in this ADF.
Link	link(Argument parent, Argument child)	Computes and returns the link between the given parent and child arguments.
Set<Link>	links()	Returns an unmodifiable set of all the links in this AbstractDialecticalFramework.
Set<Link>	linksFrom(Argument parent)	Returns a set of links originating from the specified parent argument.
default Stream<Link>	linksStream()	Returns a stream of the links in this AbstractDialecticalFramework.
Set<Link>	linksTo(Argument child)	Returns a set of links directed towards the specified child argument.
int	outgoingDegree(Argument arg)	Returns the number of outgoing links from the given argument.
Set<Argument>	parents(Argument child)	Returns a set of parent arguments for the given child argument.
default SemanticsStep	query()	Initiates a query on this AbstractDialecticalFramework using the default configuration.
default int	size()	Returns the number of arguments in this AbstractDialecticalFramework.
AbstractDialecticalFramework	transform(BiFunction<Argument,AcceptanceCondition,AcceptanceCondition> transformer)	Creates a new AbstractDialecticalFramework with acceptance conditions transformed based on both the argument and its acceptance condition.
AbstractDialecticalFramework	transform(Function<AcceptanceCondition,AcceptanceCondition> transformer)	Creates a new AbstractDialecticalFramework with acceptance conditions transformed using the provided function.
AbstractDialecticalFramework	transform(Transformer<AcceptanceCondition> transformer)	Creates a new AbstractDialecticalFramework with acceptance conditions transformed using a Transformer.

Methods inherited from interface org.tweetyproject.arg.dung.syntax.ArgumentationFramework

containsAll, getNodes, isAttacked

Methods inherited from interface org.tweetyproject.commons.BeliefBase

getMinimalSignature, toString

Methods inherited from interface java.util.Collection

add, addAll, clear, contains, containsAll, equals, hashCode, isEmpty, iterator, parallelStream, remove, removeAll, removeIf, retainAll, spliterator, stream, toArray, toArray, toArray

Methods inherited from interface org.tweetyproject.graphs.GeneralGraph

getRestriction

Methods inherited from interface org.tweetyproject.graphs.Graph

add, add, areAdjacent, contains, existsDirectedPath, getAdjacencyMatrix, getChildren, getComplementGraph, getEdge, getEdges, getNeighbors, getNodes, getNumberOfEdges, getNumberOfNodes, getParents, getStronglyConnectedComponents, getSubgraphs, hasSelfLoops, isWeightedGraph, iterator, toString

Methods inherited from interface java.lang.Iterable

forEach

Method Details

empty

static AbstractDialecticalFramework empty()

Returns an empty AbstractDialecticalFramework. This can be used to create an ADF with no arguments or links.

Returns:

an empty AbstractDialecticalFramework instance

builder

static AbstractDialecticalFramework.Builder builder()

Returns a builder for constructing a new AbstractDialecticalFramework. The builder allows for adding arguments, acceptance conditions, and links incrementally.

Returns:

a builder for constructing an AbstractDialecticalFramework

fromFile

static AbstractDialecticalFramework fromFile(File file)
                                      throws FileNotFoundException,
IOException

Reads an AbstractDialecticalFramework from a file. The file is parsed into an ADF using a format parser.

Parameters:

file - the file containing the ADF definition

Returns:

an AbstractDialecticalFramework parsed from the file

Throws:

FileNotFoundException - if the file is not found

IOException - if an I/O error occurs while reading the file

fromMap

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

Creates a builder from a map of arguments and their corresponding acceptance conditions.

Parameters:

map - a map of arguments to acceptance conditions

Returns:

a builder for constructing an AbstractDialecticalFramework from the given map

transform

AbstractDialecticalFramework transform(Function<AcceptanceCondition,AcceptanceCondition> transformer)

Creates a new AbstractDialecticalFramework with acceptance conditions transformed using the provided function.

Parameters:

transformer - the transformer to apply to each acceptance condition

Returns:

a new ADF with transformed acceptance conditions

transform

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

Creates a new AbstractDialecticalFramework with acceptance conditions transformed based on both the argument and its acceptance condition.

Parameters:

transformer - the transformer to apply to each acceptance condition and argument

Returns:

a new ADF with transformed acceptance conditions

transform

AbstractDialecticalFramework transform(Transformer<AcceptanceCondition> transformer)

Creates a new AbstractDialecticalFramework with acceptance conditions transformed using a Transformer.

Parameters:

transformer - the transformer to apply to each acceptance condition

Returns:

a new ADF with transformed acceptance conditions

query

default SemanticsStep query()

Initiates a query on this AbstractDialecticalFramework using the default configuration. The returned SemanticsStep allows further refinement of the query.

Returns:

a SemanticsStep to refine the query

size

default int size()

Returns the number of arguments in this AbstractDialecticalFramework.

Specified by:

size in interface Collection<Argument>

Returns:

the number of arguments in this ADF

getArguments

Set<Argument> getArguments()

Returns an unmodifiable set of all the arguments in this AbstractDialecticalFramework.

Returns:

an unmodifiable set of arguments

linksStream

default Stream<Link> linksStream()

Returns a stream of the links in this AbstractDialecticalFramework. This method is preferable if the caller only needs to consume some of the links.

Returns:

a stream of links in this ADF

links

Set<Link> links()

Returns an unmodifiable set of all the links in this AbstractDialecticalFramework. This method returns all the links and should be used when access to all links is needed.

Returns:

an unmodifiable set of links in this ADF

link

Link link(Argument parent,
 Argument child)

Computes and returns the link between the given parent and child arguments.

Parameters:

parent - the parent argument

child - the child argument

Returns:

the link between the parent and child

Throws:

IllegalArgumentException - if the ADF does not contain a link between the parent and child

linksTo

Set<Link> linksTo(Argument child)

Returns a set of links directed towards the specified child argument.

Parameters:

child - the target argument

Returns:

a set of links pointing to the given argument

linksFrom

Set<Link> linksFrom(Argument parent)

Returns a set of links originating from the specified parent argument.

Parameters:

parent - the source argument

Returns:

a set of links originating from the given argument

parents

Set<Argument> parents(Argument child)

Returns a set of parent arguments for the given child argument.

Parameters:

child - the target argument

Returns:

a set of parent arguments

children

Set<Argument> children(Argument parent)

Returns a set of child arguments for the given parent argument.

Parameters:

parent - the source argument

Returns:

a set of child arguments

outgoingDegree

int outgoingDegree(Argument arg)

Returns the number of outgoing links from the given argument.

Parameters:

arg - the argument

Returns:

the number of outgoing links

incomingDegree

int incomingDegree(Argument arg)

Returns the number of incoming links to the given argument.

Parameters:

arg - the argument

Returns:

the number of incoming links

contains

boolean contains(Argument arg)

Checks if the given argument is contained in this AbstractDialecticalFramework.

Parameters:

arg - the argument to check

Returns:

true if the argument is contained, false otherwise

getAcceptanceCondition

AcceptanceCondition getAcceptanceCondition(Argument argument)

Retrieves the acceptance condition for the specified argument. The acceptance condition is guaranteed to be non-null if the argument is present in the ADF.

Parameters:

argument - the argument for which to retrieve the acceptance condition

Returns:

the acceptance condition for the given argument

Throws:

IllegalArgumentException - if the argument is not contained in the ADF

bipolar

default boolean bipolar()

Checks if the ADF is bipolar, meaning all links are either supporting or attacking.

Returns:

true if the ADF is bipolar, false otherwise

kBipolar

int kBipolar()

Returns the number of non-bipolar links, indicating the degree of bipolarity in this ADF.

Returns:

the count of non-bipolar links