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

Interface ConceptReferentializationStrategy<E,TB,S,I,QI>

Type Parameters:

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

All Superinterfaces:

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

All Known Implementing Classes:

AbstractConceptReferentializationStrategy, CaseSensitiveNameRecurrence, CaseSensitiveTypeRecurrence, FauxHyponymy, Hyponymy, NameRecurrence, TypeRecurrence

public interface ConceptReferentializationStrategy<E,TB,S,I,QI>
extends ReferentializationStrategy<E,TB,S,I,QI>

A referentialization strategy that interprets identifiers from right to left and refers to the conceptual type(TODO: ?), assuming that the conceptual type is not just another feature (TODO: find literature reference).

A number of cases can be distinguished:

1. Neither the entire definite expression nor a suffix of it refer to the conceptual type of the potential referent. In this case canReferToUsingConceptualType(Object, Referent, Object) returns false and getFeaturesRemainingInIdentifierIfItCanReferUsingConceptualType(Object, Referent, Object) returns null.
2. The entire definite expression refers to the conceptual type of the potential referent. In this case canReferToUsingConceptualType(Object, Referent, Object) returns true and getFeaturesRemainingInIdentifierIfItCanReferUsingConceptualType(Object, Referent, Object) returns an empty FeatureContainer.
3. A suffix of the definite expression refers to the conceptual type of the potential referent. In this case canReferToUsingConceptualType(Object, Referent, Object) returns true and getFeaturesRemainingInIdentifierIfItCanReferUsingConceptualType(Object, Referent, Object) returns a non-empty FeatureContainer.

See Also:

FeatureContainer.isEmpty()

Method Summary

Modifier and Type	Method	Description
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 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.

Methods inherited from interface de.monochromata.anaphors.ast.reference.strategy.ReferentializationStrategy

canReferTo

Methods inherited from interface de.monochromata.Strategy

getKind

Method Details

canReferToUsingConceptualType

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. 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

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

If 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 canReferToUsingConceptualType(Object, Referent, Object) returns false, a (possibly) empty FeatureContainer if canReferToUsingConceptualType(Object, Referent, Object) returns true.

See Also:

FeatureReferentializationStrategy