All Known Implementing Classes:

AbstractIndexMissPolicyHandler
```
public interface ICustomReferencePolicyHandler<TYPE>
```

Field Summary

Fields
Modifier and Type Field Description

static ICustomReferencePolicyHandler<?> IGNORE_INDEX_MISS_POLICY

Method Summary

All Methods Instance Methods Default Methods
Modifier and Type	Method	Description
`default boolean`	`handleIdentifierNonMatch(ICustomReferencePolicy<TYPE> policy, TYPE reference, IReferenceVisitor<?> visitor)`	A callback used to handle the case where an identifier could not be parsed from the reference text.
`default boolean`	`handleIndexHit(ICustomReferencePolicy<TYPE> policy, TYPE reference, IEntityItem item, IReferenceVisitor<?> visitor)`	A callback used to handle the case where an identifier could be parsed and the index contains a matching entity.
`default boolean`	`handleIndexMiss(ICustomReferencePolicy<TYPE> policy, TYPE reference, List<IEntityItem.ItemType> itemTypes, String identifier, IReferenceVisitor<?> visitor)`	A callback used to handle the case where an identifier could be parsed from the reference text, but the index didn't contain a matching entity.

Field Detail

IGNORE_INDEX_MISS_POLICY

@NonNull
static final ICustomReferencePolicyHandler<?> IGNORE_INDEX_MISS_POLICY

Method Detail

handleIdentifierNonMatch

default boolean handleIdentifierNonMatch(@NonNull
                                         ICustomReferencePolicy<TYPE> policy,
                                         @NonNull
                                         TYPE reference,
                                         @NonNull
                                         IReferenceVisitor<?> visitor)

A callback used to handle the case where an identifier could not be parsed from the reference text.

Parameters:: policy - the reference policy for this reference; reference - the reference object; visitor - the reference visitor used to resolve referenced objects
Returns:: true if the reference is considered handled, or false otherwise

handleIndexMiss

default boolean handleIndexMiss(@NonNull
                                ICustomReferencePolicy<TYPE> policy,
                                @NonNull
                                TYPE reference,
                                @NonNull
                                List<IEntityItem.ItemType> itemTypes,
                                @NonNull
                                String identifier,
                                @NonNull
                                IReferenceVisitor<?> visitor)

A callback used to handle the case where an identifier could be parsed from the reference text, but the index didn't contain a matching entity.

Parameters:: policy - the reference policy for this reference; reference - the reference object; itemTypes - the item types that were checked; identifier - the parsed identifier; visitor - the reference visitor used to resolve referenced objects
Returns:: true if the reference is considered handled, or false otherwise

handleIndexHit

default boolean handleIndexHit(@NonNull
                               ICustomReferencePolicy<TYPE> policy,
                               @NonNull
                               TYPE reference,
                               @NonNull
                               IEntityItem item,
                               @NonNull
                               IReferenceVisitor<?> visitor)

A callback used to handle the case where an identifier could be parsed and the index contains a matching entity.

Parameters:: policy - the reference policy for this reference; reference - the reference object; item - the entity that is referenced; visitor - the reference visitor used to resolve referenced objects
Returns:: true if the reference is considered handled, or false otherwise

Interface ICustomReferencePolicyHandler<TYPE>