Object
- Invariant
- - Joiner
  - - AndJoiner

All Implemented Interfaces:

Serializable, Cloneable
```
public class AndJoiner
extends Joiner
```
This is a special invariant used internally by Daikon to represent an antecedent invariant in an implication where that antecedent consists of two invariants anded together.

See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from class Invariant
  Invariant.ClassVarnameComparator, Invariant.ClassVarnameFormulaComparator, Invariant.InvariantComparatorForPrinting, Invariant.Match

Field Summary
- Fields inherited from class Joiner
  left, right
- Fields inherited from class Invariant
  CONFIDENCE_JUSTIFIED, CONFIDENCE_NEVER, CONFIDENCE_UNJUSTIFIED, debug, debugFlow, debugGuarding, debugIsObvious, debugIsWorthPrinting, debugPrint, debugPrintEquality, dkconfig_confidence_limit, dkconfig_fuzzy_ratio, dkconfig_simplify_define_predicates, falsified, invariantEnabledDefault, isGuardingPredicate, min_mod_non_missing_samples, ppt, PROBABILITY_JUSTIFIED, PROBABILITY_NEVER, PROBABILITY_UNJUSTIFIED

Constructor Summary

Constructors
Constructor Description

AndJoiner(PptTopLevel ppt, Invariant left, Invariant right)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`protected double`	`computeConfidence()`	This method computes the confidence that this invariant occurred by chance.
`List<Invariant>`	`conjuncts()`
`boolean`	`enabled()`	Returns whether or not this class of invariants is currently enabled.
`String`	`format_using(OutputFormat format)`	Return a printed representation of this invariant, in the given format.
`protected AndJoiner`	`instantiate_dyn(PptSlice slice)`	Instantiates (creates) an invariant of the same class on the specified slice.
`@Nullable DiscardInfo`	`isObviousDynamically(VarInfo[] vis)`	Return non-null if this invariant is necessarily true from a fact that can be determined dynamically (after checking data) -- for the given varInfos rather than the varInfos of this.
`@Nullable DiscardInfo`	`isObviousStatically(VarInfo[] vis)`	Return true if this invariant is necessarily true from a fact that can be determined statically -- for the given varInfos rather than the varInfos of this.
`boolean`	`isSameInvariant(Invariant other)`	Returns true iff the argument is the "same" invariant as this.
`String`	`repr()`	For printing invariants, there are two interfaces: repr gives a low-level representation (`Invariant.repr_prob()` also prints the confidence), and `Invariant.format()` gives a high-level representation for user output.
`boolean`	`valid_types(VarInfo[] vis)`	Returns whether or not the invariant is valid over the basic types in vis.

Methods inherited from class Joiner
isObviousDerived, isObviousImplied, isSameFormula, isValidEscExpression, resurrect_done

Methods inherited from class Invariant
add_sample, asInvClass, checkRep, clear_falsified, clone, clone_and_permute, conf_is_ge, confidence_and, confidence_and, confidence_or, createGuardedInvariant, createGuardingPredicate, enoughSamples, falsify, find, format, format_classname, format_too_few_samples, format_unimplemented, formatFuzzy, get_comparability, get_ni_suppressions, getConfidence, getGuardingList, getGuardingList, hasUninterestingConstant, instantiate, instantiate_ok, is_false, is_ni_suppressed, isActive, isAllPrestate, isEqualityComparison, isExact, isExclusiveFormula, isObvious, isObviousDynamically, isObviousDynamically_SomeInEquality, isObviousDynamically_SomeInEqualityHelper, isObviousStatically, isObviousStatically_AllInEquality, isObviousStatically_SomeInEquality, isObviousStatically_SomeInEqualityHelper, isReflexive, isValidExpression, isWorthPrinting, justified, log, log, logDetail, logOn, match, merge, mergeFormulasOk, permute, prob_and, prob_and, prob_is_ge, prob_or, repCheck, repr_prob, resurrect, simplify_format_double, simplify_format_long, simplify_format_string, state_match, toString, toString, transfer, usesVar, usesVar, usesVarDerived, varNames

Methods inherited from class Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - AndJoiner
```
public AndJoiner(PptTopLevel ppt,
                 Invariant left,
                 Invariant right)
```
- Method Detail
  - computeConfidence
```
protected double computeConfidence()
```
    Description copied from class: Invariant
    
    This method computes the confidence that this invariant occurred by chance. Clients should call Invariant.getConfidence() instead.
    This method need not check the value of field "falsified", as the caller does that.
    
    Specified by:
    
    computeConfidence in class Invariant
    
    Returns:
    
    confidence of this invariant
    
    See Also:
    
    Invariant.getConfidence()
  - repr
```
public String repr(@GuardSatisfied AndJoiner this)
```
    Description copied from class: Invariant
    
    For printing invariants, there are two interfaces: repr gives a low-level representation (Invariant.repr_prob() also prints the confidence), and Invariant.format() gives a high-level representation for user output.
    
    Specified by:
    
    repr in class Joiner
    
    Returns:
    
    a string representation of this
  - format_using
```
@SideEffectFree
public String format_using(@GuardSatisfied AndJoiner this,
                           OutputFormat format)
```
    Description copied from class: Invariant
    
    Return a printed representation of this invariant, in the given format.
    
    Specified by:
    
    format_using in class Joiner
  - conjuncts
```
public List<Invariant> conjuncts(@GuardSatisfied AndJoiner this)
```
  - isObviousDynamically
```
@Pure
public @Nullable DiscardInfo isObviousDynamically(VarInfo[] vis)
```
    Description copied from class: Invariant
    
    Return non-null if this invariant is necessarily true from a fact that can be determined dynamically (after checking data) -- for the given varInfos rather than the varInfos of this. Conceptually, this means, "Is this invariant dynamically obvious if its VarInfos were switched with vis?" Intended to be overriden by subclasses so they can filter invariants after checking; the overriding method should first call "super.isObviousDynamically(vis)". Since this method is dynamic, it should only be called after all processing.
    
    Overrides:
    
    isObviousDynamically in class Invariant
  - isObviousStatically
```
@Pure
public @Nullable DiscardInfo isObviousStatically(VarInfo[] vis)
```
    Description copied from class: Invariant
    
    Return true if this invariant is necessarily true from a fact that can be determined statically -- for the given varInfos rather than the varInfos of this. Conceptually, this means "is this invariant statically obvious if its VarInfos were switched with vis?" Intended to be overridden by subclasses. Should only do static checking.
    Precondition: vis.length == this.ppt.var_infos.length
    
    Overrides:
    
    isObviousStatically in class Invariant
    
    Parameters:
    
    vis - the VarInfos this invariant is obvious over. The position and data type of the variables is the *same* as that of this.ppt.var_infos.
  - isSameInvariant
```
@Pure
public boolean isSameInvariant(Invariant other)
```
    Description copied from class: Invariant
    
    Returns true iff the argument is the "same" invariant as this. Same, in this case, means a matching type, formula, and variable names.
    
    Overrides:
    
    isSameInvariant in class Joiner
    
    Parameters:
    
    other - the other invariant to compare to this one
    
    Returns:
    
    true iff the argument is the "same" invariant as this
  - enabled
```
public boolean enabled( AndJoiner this)
```
    Description copied from class: Invariant
    
    Returns whether or not this class of invariants is currently enabled.
    Its implementation is almost always return dkconfig_enabled;.
    
    Specified by:
    
    enabled in class Invariant
  - valid_types
```
public boolean valid_types( AndJoiner this,
                           VarInfo[] vis)
```
    Description copied from class: Invariant
    
    Returns whether or not the invariant is valid over the basic types in vis. This only checks basic types (scalar, string, array, etc) and should match the basic superclasses of invariant (SingleFloat, SingleScalarSequence, ThreeScalar, etc). More complex checks that depend on variable details can be implemented in instantiate_ok().
    
    Specified by:
    
    valid_types in class Invariant
    
    See Also:
    
    Invariant.instantiate_ok(VarInfo[])
  - instantiate_dyn
```
protected AndJoiner instantiate_dyn( AndJoiner this,
                                    PptSlice slice)
```
    Description copied from class: Invariant
    
    Instantiates (creates) an invariant of the same class on the specified slice. Must be overridden in each class. Must be used rather than Invariant.clone() so that checks in Invariant.instantiate(daikon.PptSlice) for reasonable invariants are done.
    The implementation of this method is almost always return new <em>InvName</em>(slice);
    
    Specified by:
    
    instantiate_dyn in class Invariant
    
    Returns:
    
    the new invariant

Class AndJoiner

Nested Class Summary

Nested classes/interfaces inherited from class Invariant

Field Summary

Fields inherited from class Joiner

Fields inherited from class Invariant

Constructor Summary

Method Summary

Methods inherited from class Joiner

Methods inherited from class Invariant

Methods inherited from class Object

Constructor Detail

AndJoiner

Method Detail

computeConfidence

repr

format_using

conjuncts

isObviousDynamically

isObviousStatically

isSameInvariant

enabled

valid_types

instantiate_dyn