VerifyResultList class | verify.t[428]

Verification result list.

`class VerifyResultList : object`

Superclass Tree (in declaration order)

`VerifyResultList`
`object`

Subclass Tree

(none)

Global Objects

(none)

Summary of Properties

`obj_ origOrder remapAction_ remapRole_ remapTarget_ results_`

Summary of Methods

`addResult allowAction allowImplicit compareTo construct excludePluralMatches getEffectiveResult matchForCombineRemapped showMessage`

Properties

`obj_` | `verify.t[694]`

The ResolveInfo for the object being verified. Note that this isn't saved until AFTER the verification is completed.

`origOrder` | `verify.t[701]`

The original list index for this result. We use this when sorting a list of results to preserve the original ordering of otherwise equivalent items.

`remapAction_` | `verify.t[684]`

the action and role of the remapped action

`remapRole_` | `verify.t[685]`

no description available

`remapTarget_` | `verify.t[681]`

The remapped target object. This will filled in during verification if we decide that we want to remap the nominal object of the command to a different object. This should be set to the ultimate target object after all remappings.

`results_` | `verify.t[688]`

our list of results

Methods

`addResult (result)` | `verify.t[438]`

Add a result to our result list.

`allowAction ( )` | `verify.t[474]`

Is the action allowed? We return true if we have no results; otherwise, we allow the action if *all* of our results allow it, nil if even one disapproves.

`allowImplicit ( )` | `verify.t[495]`

Is the action allowed as an implicit action? Returns true if we have no results; otherwise, returns true if *all* of our results allow the implicit action, nil if even one disapproves.

`compareTo (other)` | `verify.t[547]`

Compare my cumulative result (i.e., my most disapproving result) to that of another result list's cumulative result. Returns a value suitable for sorting: -1 if I'm worse than the other one, 0 if we're the same, and 1 if I'm better than the other one. This can be used to compare the cumulative verification results for two objects to determine which object is more logical.

`construct ( )` | `verify.t[429]`

no description available

`excludePluralMatches ( )` | `verify.t[484]`

Do we exclude plural matches? We do if we have at least one result that excludes plural matches.

`getEffectiveResult ( )` | `verify.t[525]`

Get my effective result object. If I have no explicitly-set result object, my effective result is the defaut logical result. Otherwise, we return the most disapproving result in our list.

`matchForCombineRemapped (other, action, role)` | `verify.t[637]`

Determine if we match another verify result list after remapping. This determines if the other verify result is equivalent to us after considering the effects of remapping. We'll return true if all of the following are true:

- compareTo returns zero, indicating that we have the same weighting in the verification results

- we refer to the same object after remapping; the effective object after remapping is our original resolved object, if we're not remapped, or our remap target if we are

- we use the object for the same action and in the same role

Note: this can only be called on remapped results. Results can only be combined in the first place when remapped, so there's no need to ever call this on an unremapped result.

`showMessage ( )` | `verify.t[506]`

Show the message. If I have any results, we'll show the message for the effective (i.e., most disapproving) result; otherwise we show nothing.

TADS 3 Library Manual
Generated on 5/16/2013 from TADS version 3.1.3