Package net.sf.tweety.arg.adf.reasoner.processor

Class SatPartialKBipolarInterpretationProcessor

java.lang.Object

net.sf.tweety.arg.adf.reasoner.processor.SatPartialKBipolarInterpretationProcessor

All Implemented Interfaces:

InterpretationProcessor<SatReasonerContext>

public class SatPartialKBipolarInterpretationProcessor
extends java.lang.Object
implements InterpretationProcessor<SatReasonerContext>

Author:

Mathias Hofer

Field Summary

Fields

Modifier and Type	Field	Description
private static SatEncoding	BIPOLAR_ENCODING
private static SatEncoding	K_BIPOLAR_ENCODING

Constructor Summary

Constructors

Constructor	Description
SatPartialKBipolarInterpretationProcessor()

Method Summary

Modifier and Type	Method	Description
Interpretation	process(SatReasonerContext context, Interpretation interpretation, AbstractDialecticalFramework adf)	Performs the processing of the given interpretation on a potential isolated state, meaning that the updates on this state are not seen by the subsequent processors.
void	updateState(SatReasonerContext context, Interpretation processed, AbstractDialecticalFramework adf)	This method is called by the Pipeline on the shared state and the result of the process method, hence after the processing is done.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

BIPOLAR_ENCODING

private static final SatEncoding BIPOLAR_ENCODING

K_BIPOLAR_ENCODING

private static final SatEncoding K_BIPOLAR_ENCODING

Constructor Detail

SatPartialKBipolarInterpretationProcessor

public SatPartialKBipolarInterpretationProcessor()

Method Detail

process

public Interpretation process(SatReasonerContext context,
                              Interpretation interpretation,
                              AbstractDialecticalFramework adf)

Description copied from interface: InterpretationProcessor

Performs the processing of the given interpretation on a potential isolated state, meaning that the updates on this state are not seen by the subsequent processors. If the given state is isolated or shared by the other processors depends on the configuration of the Pipeline and hence by the user.

Necessary updates on the shared state have to be performed in the updateState method, which is called by the pipeline after the processing is done.

Specified by:

process in interface InterpretationProcessor<SatReasonerContext>

Parameters:

context - a potentially isolated state or the shared one

interpretation - the result of the previous processor

adf - the corresponding adf

Returns:

an interpretation

updateState

public void updateState(SatReasonerContext context,
                        Interpretation processed,
                        AbstractDialecticalFramework adf)

Description copied from interface: InterpretationProcessor

This method is called by the Pipeline on the shared state and the result of the process method, hence after the processing is done.

Note that if this processor has to update the shared state, it has to happen in this method. Since process may only have access to an isolated state to perform its processing.

Specified by:

updateState in interface InterpretationProcessor<SatReasonerContext>

Parameters:

context - the shared state

processed - the result of the process method

adf - the corresponding adf