Package de.monochromata.anaphors.ast.reference.strategy.concept

Class Hyponymy<N,E,TB,S,I,QI,EV,PP>

java.lang.Object

de.monochromata.AbstractStrategy

de.monochromata.anaphors.ast.reference.strategy.AbstractReferentializationStrategy<N,E,TB,S,I,QI,EV,PP>

de.monochromata.anaphors.ast.reference.strategy.concept.AbstractConceptReferentializationStrategy<N,E,TB,S,I,QI,EV,PP>

de.monochromata.anaphors.ast.reference.strategy.concept.Hyponymy<N,E,TB,S,I,QI,EV,PP>

Type Parameters:

N - The node type in the AST

E - The expression type

TB - The type binding type

S - The scope type (optional)

I - The type used to represent identifiers

QI - The type used to represent qualified identifiers

EV - The type of the event contained in the condition that is evaluated to check when the perspectivations shall be applied.

PP - The type used for positions that carry perspectivations

All Implemented Interfaces:

ConceptReferentializationStrategy<E,TB,S,I,QI>, ReferentializationStrategy<E,TB,S,I,QI>, Strategy

public class Hyponymy<N,E,TB,S,I,QI,EV,PP>
extends AbstractConceptReferentializationStrategy<N,E,TB,S,I,QI,EV,PP>

Referentialization based on case-insensitive hyponymy (i.e. matching referents whose type is a - potentially transitive - super-class or a - potentially transitively - implemented interface of the type of the definite expression).

Field Summary

Fields

Modifier and Type	Field	Description
static String	Hy_KIND

Fields inherited from class de.monochromata.anaphors.ast.reference.strategy.AbstractReferentializationStrategy

anaphorsSpi

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	Hyponymy()	Used in contract testing.
	Hyponymy(AnaphorsSpi<N,E,TB,S,I,QI,EV,PP> anaphorsSpi, Function<TB,Optional<TB>> getSuperClass, Function<TB,List<TB>> getImplementedInterfaces)
	Hyponymy(Function<TB,Optional<TB>> getSuperClass, Function<TB,List<TB>> getImplementedInterfaces, Function<I,Function<TB,Boolean>> nameOfIdentifierEqualsSimpleNameOfTypeBinding, Function<I,Function<TB,Boolean>> conceptualTypeInIdentifierEqualsSimpleNameOfTypeBinding)

Method Summary

Modifier and Type	Method	Description
boolean	canReferTo(I idFromDefiniteExpression, Referent<TB,S,I,QI> potentialReferent, S scope)	Checks whether the given definite expression can, using this referentialization strategy, refer to the given potential referent in the given scope.
boolean	canReferToUsingConceptualType(I idFromDefiniteExpression, Referent<TB,S,I,QI> potentialReferent, S scope)	Checks whether the given definite expression can, using this referentialization strategy, refer to the given potential referent in the given scope.
FeatureContainer<QI>	getFeaturesRemainingInIdentifierIfItCanReferUsingConceptualType(I idFromDefiniteExpression, Referent<TB,S,I,QI> potentialReferent, S scope)	If ConceptReferentializationStrategy.canReferToUsingConceptualType(Object, Referent, Object) returns true for the given arguments, there is a suffix in the given definite expression that represents a conceptual type and can be used to refer to the given potential referent.
String	getKind()	Returns a short mnemonic string that uniquely identifies this strategy among the type of strategies it belongs to.

Methods inherited from class de.monochromata.AbstractStrategy

equals, hashCode, toString

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Details

Hy_KIND

public static final String Hy_KIND

See Also:

Constant Field Values

Constructor Details

Hyponymy

protected Hyponymy()

Used in contract testing.

Hyponymy

public Hyponymy(AnaphorsSpi<N,E,TB,S,I,QI,EV,PP> anaphorsSpi,
Function<TB,Optional<TB>> getSuperClass,
Function<TB,List<TB>> getImplementedInterfaces)

Hyponymy

public Hyponymy(Function<TB,Optional<TB>> getSuperClass,
Function<TB,List<TB>> getImplementedInterfaces,
Function<I,Function<TB,Boolean>> nameOfIdentifierEqualsSimpleNameOfTypeBinding,
Function<I,Function<TB,Boolean>> conceptualTypeInIdentifierEqualsSimpleNameOfTypeBinding)

Method Details

canReferTo

public boolean canReferTo(I idFromDefiniteExpression,
Referent<TB,S,I,QI> potentialReferent,
S scope)

Description copied from interface: ReferentializationStrategy

Checks whether the given definite expression can, using this referentialization strategy, refer to the given potential referent in the given scope. All information in the definite expression needs to be matched by the given potential referent for the method to return true. Matching is performed in a way that is specific to the referentialization strategy.

Parameters:

idFromDefiniteExpression - the ID from the definite expression that shall refer to the given potential referent

potentialReferent - the potential referent to refer to

scope - the scope in which the definite expression occurs

Returns:

true if all information provided by the definite expression matches information provided by the potential referent, where matching depends on the implementation of this method, false otherwise.

canReferToUsingConceptualType

public boolean canReferToUsingConceptualType(I idFromDefiniteExpression,
Referent<TB,S,I,QI> potentialReferent,
S scope)

Description copied from interface: ConceptReferentializationStrategy

Checks whether the given definite expression can, using this referentialization strategy, refer to the given potential referent in the given scope. Unlike ReferentializationStrategy.canReferTo(Object, Referent, Object), this method requires only conceptual-type information in a suffix of the definite expression to be matched by the information of the given potential referent for the method to return true. Matching is performed in a way that is specific to the referentialization strategy.

Parameters:

idFromDefiniteExpression - the ID from the definite expression that shall refer to the given potential referent

potentialReferent - the potential referent to refer to

scope - the scope in which the definite expression occurs

Returns:

true if the conceptual-type information provided by a suffix of the definite expression matches the information provided by the potential referent, where matching depends on the implementation of this method, false otherwise.

getFeaturesRemainingInIdentifierIfItCanReferUsingConceptualType

public FeatureContainer<QI> getFeaturesRemainingInIdentifierIfItCanReferUsingConceptualType(I idFromDefiniteExpression,
Referent<TB,S,I,QI> potentialReferent,
S scope)

Description copied from interface: ConceptReferentializationStrategy

If ConceptReferentializationStrategy.canReferToUsingConceptualType(Object, Referent, Object) returns true for the given arguments, there is a suffix in the given definite expression that represents a conceptual type and can be used to refer to the given potential referent. In this case, this method returns a FeatureContainer with all features that can be extracted from the remainder of the given definite expression after the suffix has been removed. If the remainder is empty, the FeatureContainer is empty, too.

Parameters:

idFromDefiniteExpression - The ID from the definite expression whose features are to be extracted.

potentialReferent - The potential referent of the definite expression.

scope - An optional scope object specific to the AST implementation.

Returns:

null, if ConceptReferentializationStrategy.canReferToUsingConceptualType(Object, Referent, Object) returns false, a (possibly) empty FeatureContainer if ConceptReferentializationStrategy.canReferToUsingConceptualType(Object, Referent, Object) returns true.

See Also:

FeatureReferentializationStrategy

getKind

public String getKind()

Description copied from interface: Strategy

Returns a short mnemonic string that uniquely identifies this strategy among the type of strategies it belongs to.

Returns:

the kind of strategy