logical (P2J - Progress 4GL to Java Conversion and Runtime)

java.lang.Object
- com.goldencode.p2j.util.LazyUndoable
- - com.goldencode.p2j.util.BaseDataType
  - - com.goldencode.p2j.util.logical

All Implemented Interfaces:: Undoable, java.io.Externalizable, java.io.Serializable, java.lang.Comparable

Direct Known Subclasses:: logical.logicalConstant

public class logical
extends BaseDataType

A class that represents a Progress 4GL compatible logical object whose data is mutable. All Progress language features related to logical types are supported including all function that can be accessed via the logical operators. In particular, the AND, OR and NOT operators are implemented in this class (they are unique to logicals) and all other logical operators are implemented in the CompareOps class.

The only reason this class exists is to provide an object that represents 3 possible states: true, false and the unknown value. This is the only difference between the Progress 4GL logical data type and the Java primitive boolean. While a java.lang.Boolean could be used and set to null to indicate the unknown value, this approach has the significant drawback of requiring unwrapping everywhere and in addition, null checks are required wherever the data is unwrapped. This would require a very nasty bit of refactoring for most expressions, which is made unnecessary by this class which represents the tri-state of a logical using only internal means. Since all operators have been implemented as method calls and these methods are aware of the unknown value, the resulting expressions are clean and as close to the original level of expressiveness as possible.

Format string related processing is handled in this class, see method toString(String).

The following is the mapping of Progress language features to the corresponding feature in this class:

 not      operator                       not(boolean) and _not(com.goldencode.p2j.util.logical)
 and      operator                       and(boolean, boolean) and _and(boolean, boolean)
 or       operator                       or(boolean, boolean) and _or(boolean, boolean)
 =  or EQ operator                       CompareOps.isEqual(com.goldencode.p2j.util.BaseDataType, com.goldencode.p2j.util.BaseDataType)
 <> or NE operator                       CompareOps.isNotEqual(com.goldencode.p2j.util.BaseDataType, com.goldencode.p2j.util.BaseDataType)
 >  or GT operator                       CompareOps.isGreaterThan(com.goldencode.p2j.util.BaseDataType, com.goldencode.p2j.util.BaseDataType)
 >= or GE operator                       CompareOps.isGreaterThanOrEqual(com.goldencode.p2j.util.BaseDataType, com.goldencode.p2j.util.BaseDataType)
 <  or LT operator                       CompareOps.isLessThan(com.goldencode.p2j.util.BaseDataType, com.goldencode.p2j.util.BaseDataType)
 <= or LE operator                       CompareOps.isLessThanOrEqual(com.goldencode.p2j.util.BaseDataType, com.goldencode.p2j.util.BaseDataType)
 maximum  function                       CompareOps.maximum(BaseDataType[])
 minimum  function                       CompareOps.minimum(BaseDataType[])

     OR Operator Truth Table

   Left       Right     Result
 ---------  ---------  ---------
 true       true       true
 false      true       true
 unknown    true       true
 true       false      true
 false      false      false
 unknown    false      unknown
 true       unknown    true
 false      unknown    unknown
 unknown    unknown    unknown

    AND Operator Truth Table

   Left       Right     Result
 ---------  ---------  ---------
 true       true       true
 false      true       false
 unknown    true       unknown
 true       false      false
 false      false      false
 unknown    false      false
 true       unknown    unknown
 false      unknown    false
 unknown    unknown    unknown

    NOT Operator Truth Table

  Operand    Result
 ---------  ---------
 true       false
 false      true
 unknown    unknown

There are convenience versions of each operator that directly return boolean values such that unwrapping is not needed. These are named the same as the operator methods above except there is no 'Operator' appended. For example, the not operator is not(boolean).

Author:: GES
See Also:: Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`logical.logicalConstant` An immutable logical type, to be used for TRUE/FALSE/UNKNOWN singletons required within FWD runtime.

Nested classes/interfaces inherited from class com.goldencode.p2j.util.BaseDataType
BaseDataType.Type, BaseDataType.WrapperHandler

Field Summary

Fields
Modifier and Type	Field and Description
`static java.lang.String`	`DEFAULT_FORMAT` The default format string.
`static logical`	`FALSE` Singleton and immutable for the logical FALSE value.
`static logical`	`TRUE` Singleton and immutable for the logical TRUE value.
`private boolean`	`unknown` Stores the state of whether or not this instance represents the `unknown value`, independent of the state of this logical's value as `true` or `false`.
`static logical`	`UNKNOWN` Singleton and immutable for the logical UNKNOWN value.
`private boolean`	`value` Stores the state of this logical as `true` or `false`, independent of the state of whether or not this instance represents the `unknown value`.

Constructor Summary

Constructors
Constructor and Description
`logical()` Default constructor, creates an instance that represents the unknown value.
`logical(BaseDataType value)` This is a special c'tor which should be used only when converting the value returned by a function or method with polymorphic return type into the expected type (i.e.
`logical(BaseDataType value, character fmt)` This is a special c'tor which should be used only when converting the value returned by a function or method with polymorphic return type into the expected type (i.e.
`logical(BaseDataType value, java.lang.String fmt)` This is a special c'tor which should be used only when converting the value returned by a function or method with polymorphic return type into the expected type (i.e.
`logical(boolean value)` Constructs an instance that has the `boolean` value passed in and which does not represent the `unknown value`.
`logical(java.lang.Boolean value)` Constructs an instance after copying the parameter's data into the internal representation of this class.
`logical(character value)` Converts the given string into a logical value.
`logical(character value, character fmt)` Converts the given string into a logical value.
`logical(character value, java.lang.String fmt)` Converts the given string into a logical value.
`logical(logical value)` Constructs an instance that has the `boolean` value and `unknown value` that exactly matches that of the passed-in instance.
`logical(java.lang.String value)` Converts the given string into a logical value.
`logical(java.lang.String value, java.lang.String fmt)` Converts the given string into a logical value.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`_and(boolean op1, boolean op2)` Implements the `AND` logical operator with the convenience of converting the result to a primitive `boolean`.
`static boolean`	`_and(boolean op1, logical op2)` Implements the `AND` logical operator with the convenience of converting the result to a primitive `boolean`.
`static boolean`	`_and(boolean op1, LogicalOp op2)` Implements the `AND` logical operator with the convenience of converting the result to a primitive `boolean`.
`static boolean`	`_and(logical op1, boolean op2)` Implements the `AND` logical operator with the convenience of converting the result to a primitive `boolean`.
`static boolean`	`_and(logical op1, logical op2)` Implements the `AND` logical operator with the convenience of converting the result to a primitive `boolean`.
`static boolean`	`_and(logical op1, LogicalOp op2)` Implements the `AND` logical operator with the convenience of converting the result to a primitive `boolean`.
`static boolean`	`_not(logical op)` Implements the `NOT` logical operator with the convenience of converting the result to a primitive `boolean`.
`static boolean`	`_or(boolean op1, boolean op2)` Implements the `OR` logical operator with the convenience of converting the result to a primitive `boolean`.
`static boolean`	`_or(boolean op1, logical op2)` Implements the `OR` logical operator with the convenience of converting the result to a primitive `boolean`.
`static boolean`	`_or(boolean op1, LogicalOp op2)` Implements the `OR` logical operator with the convenience of converting the result to a primitive `boolean`.
`static boolean`	`_or(logical op1, boolean op2)` Implements the `OR` logical operator with the convenience of converting the result to a primitive `boolean`.
`static boolean`	`_or(logical op1, logical op2)` Implements the `OR` logical operator with the convenience of converting the result to a primitive `boolean`.
`static boolean`	`_or(logical op1, LogicalOp op2)` Implements the `OR` logical operator with the convenience of converting the result to a primitive `boolean`.
`static logical`	`and(boolean op1, boolean op2)` Implements the `AND` logical operator (just a convenience method for the Java logical AND).
`static logical`	`and(boolean op1, logical op2)` Implements the `AND` logical operator with proper processing of the `unknown value`.
`static logical`	`and(boolean op1, LogicalOp op2)` Implements the `AND` logical operator with proper processing of the `unknown value`.
`static logical`	`and(logical op1, boolean op2)` Implements the `AND` logical operator with proper processing of the `unknown value`.
`static logical`	`and(logical op1, logical op2)` Implements the `AND` logical operator with proper processing of the `unknown value`.
`static logical`	`and(logical op1, LogicalOp op2)` Implements the `AND` logical operator with proper processing of the `unknown value`.
`void`	`assign(BaseDataType value)` Sets the state (data and unknown value) of this instance based on the state of the passed instance.
`void`	`assign(boolean value)` Sets the state (data) of this instance based on the given value.
`void`	`assign(logical value)` Sets the state (data and unknown value) of this instance based on the state of the passed instance.
`void`	`assign(Undoable value)` Sets the state (data and unknown value) of this instance based on the state of the passed instance.
`boolean`	`booleanValue()` Accesses the state of this instance's `boolean` value.
`int`	`compareTo(java.lang.Object obj)` Compares this instance with the specified instance and returns a -1 if this instance is less than the specified, 0 if the two instances are equal and 1 if this instance is greater than the specified instance.
`private logical`	`convertString(java.lang.String val)` Helper to convert a text value into a logical value with ERROR processing SUPPRESSED.
`java.lang.String`	`defaultFormatString()` Return the default display format string for this type.
`logical`	`duplicate()` Does the same as standard `clone()` method but returns an instance of `BaseDataType` and doesn't throw the `CloneNotSupportedException`.
`boolean`	`equals(java.lang.Object o)` An equality test which handles the most common cases with the least amount of overhead.
`int`	`formatLength(java.lang.String fmt)` Calculate the length of a formatted value (the text form of the value) using this format string.
`static java.lang.Boolean`	`fromString(java.lang.String val, java.lang.String fmt)` Check if the given value matches the received format.
`int`	`getSize()` Obtain the length (in bytes) of this BDT will use when serialized.
`BaseDataType.Type`	`getType()` Get the type
`boolean`	`getValue()` Accesses the state of this instance's `boolean` value independently of the state of whether this instance represents the `unknown value`.
`int`	`hashCode()` Hash code implementation which is consistent with `BaseDataType.equals(java.lang.Object)`.
`BaseDataType`	`instantiateDefault()` Creates a new instance of the same type that represents the default initialized value.
`protected BaseDataType`	`instantiateDefaultExtent()` Get the default initialization for an extent variable of this type.
`BaseDataType`	`instantiateUnknown()` Creates a new instance of the same type that represents the `unknown value`.
`protected boolean`	`isIncompatibleTypesOnConversion(BaseDataType value)` Returns `true` if dynamic data type conversion should not be attempted, it can also throw an `ErrorConditionException` in case of incompatible types for a POLY conversion.
`boolean`	`isUnknown()` Determines if this instance represents the `unknown value`.
`static logical`	`maximum(logical... list)` Returns the largest instance (`false` is smaller than `true`) from the list.
`logical`	`maximum(logical l)` Returns the larger (`false` is smaller than `true`) of the current or passed-in instance.
`static int`	`maximumStringSize(java.lang.String fmt)` Determines the largest possible string length that can match either of the specified values in a valid format string.
`static logical`	`minimum(logical... list)` Returns the smallest instance (`false` is smaller than `true`) from the list.
`logical`	`minimum(logical l)` Returns the smaller (`false` is smaller than `true`) of the current or passed-in instance.
`static logical`	`not(boolean op)` Implements the `NOT` logical operator using the Java logical NOT.
`static logical`	`not(logical op)` Implements the `NOT` logical operator with proper processing of the `unknown value`.
`static logical`	`of(boolean value)` Resolve the given boolean value to a logical TRUE/FALSE singleton.
`static logical`	`or(boolean op1, boolean op2)` Implements the `OR` logical operator using the Java logical OR.
`static logical`	`or(boolean op1, logical op2)` Implements the `OR` logical operator with proper processing of the `unknown value`.
`static logical`	`or(boolean op1, LogicalOp op2)` Implements the `OR` logical operator with proper processing of the `unknown value`.
`static logical`	`or(logical op1, boolean op2)` Implements the `OR` logical operator with proper processing of the `unknown value`.
`static logical`	`or(logical op1, logical op2)` Implements the `OR` logical operator with proper processing of the `unknown value`.
`static logical`	`or(logical op1, LogicalOp op2)` Implements the `OR` logical operator with proper processing of the `unknown value`.
`void`	`readExternal(java.io.ObjectInput in)` Replacement for the default object reading method.
`void`	`setUnknown()` Sets the state of this instance's `unknown value` flag to `true`.
`void`	`setValue(boolean value)` Sets the state of this instance's `boolean` value independently of the state of whether this instance represents the `unknown value`.
`static java.lang.String[]`	`splitFormat(java.lang.String fmt)` Split a valid logical format string in a safe way that handles all possible edge cases.
`java.lang.Boolean`	`toJavaType()` Return the current value as a Java wrapper.
`java.lang.String`	`toString()` Creates a string representation of the instance data using the default Progress 4GL format of `'yes/no'`.
`java.lang.String`	`toString(java.lang.String fmt)` Creates a string representation of the instance data using the user- specified Progress 4GL format string.
`java.lang.String`	`toStringExport()` Creates a string representation of the instance data using the 'export' format.
`java.lang.String`	`toStringMessage()` Creates a string representation of the instance data in a form that is compatible with the `MESSAGE` language statement.
`void`	`writeExternal(java.io.ObjectOutput out)` Replacement for the default object writing method.

Methods inherited from class com.goldencode.p2j.util.BaseDataType
assign, assign, calcFormatLength, createProxy, createProxy, deepCopy, elementsOfType, fallback, fromTypeName, generateDefault, generateUnknown, getAssigner, getTypeName, incompatibleTypesOnConversion, initialize, initializeDefaultExtent, invalidInitializer, isAllKnown, isAllKnown, isAssignDirect, isProxy, isUnknownValue, maximum, minimum, notUnknownValue, sameType, val, variable

Methods inherited from class com.goldencode.p2j.util.LazyUndoable
changed, checkUndoable, checkUndoable, checkUndoable, getTransLevel, isGlobal, isUndoable, markUndoable, popBlock, rollback, setGlobal

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - TRUE
```
public static final logical TRUE
```
    Singleton and immutable for the logical TRUE value.
  - FALSE
```
public static final logical FALSE
```
    Singleton and immutable for the logical FALSE value.
  - UNKNOWN
```
public static final logical UNKNOWN
```
    Singleton and immutable for the logical UNKNOWN value.
  - DEFAULT_FORMAT
```
public static final java.lang.String DEFAULT_FORMAT
```
    The default format string.
    
    See Also:
    
    Constant Field Values
  - value
```
private boolean value
```
    Stores the state of this logical as true or false, independent of the state of whether or not this instance represents the unknown value.
  - unknown
```
private boolean unknown
```
    Stores the state of whether or not this instance represents the unknown value, independent of the state of this logical's value as true or false.
- Constructor Detail
  - logical
```
public logical()
```
    Default constructor, creates an instance that represents the unknown value.
  - logical
```
public logical(BaseDataType value)
```
    This is a special c'tor which should be used only when converting the value returned by a function or method with polymorphic return type into the expected type (i.e. DYNAMIC-FUNCTION()). In such cases, the 4GL does some automatic type conversion (see assign(BaseDataType)).
    
    Parameters:
    
    value - The value to be used for this instance.
  - logical
```
public logical(BaseDataType value,
               character fmt)
```
    This is a special c'tor which should be used only when converting the value returned by a function or method with polymorphic return type into the expected type (i.e. DYNAMIC-FUNCTION()). In such cases, the 4GL does some automatic type conversion (see assign(BaseDataType)).
    
    Parameters:
    
    value - The value to be used for this instance.
    
    fmt - The format string to use.
  - logical
```
public logical(BaseDataType value,
               java.lang.String fmt)
```
    This is a special c'tor which should be used only when converting the value returned by a function or method with polymorphic return type into the expected type (i.e. DYNAMIC-FUNCTION()). In such cases, the 4GL does some automatic type conversion (see assign(BaseDataType)).
    
    Parameters:
    
    value - The value to be used for this instance.
    
    fmt - The format string to use.
  - logical
```
public logical(boolean value)
```
    Constructs an instance that has the boolean value passed in and which does not represent the unknown value.
    
    Parameters:
    
    value - The logical value of the resulting instance.
  - logical
```
public logical(logical value)
```
    Constructs an instance that has the boolean value and unknown value that exactly matches that of the passed-in instance.
    
    Parameters:
    
    value - The logical and unknown value of the resulting instance.
  - logical
```
public logical(java.lang.String value)
```
    Converts the given string into a logical value. A '?' is interpreted as the unknown value and the strings 'yes' and 'true' (and any abbreviations thereof) are considered true and any other input is considered false.
    
    Parameters:
    
    value - The text representation of the logical value.
  - logical
```
public logical(character value)
```
    Converts the given string into a logical value. A '?' is interpreted as the unknown value and the strings 'yes' and 'true' (and any abbreviations thereof) are considered true and any other input is considered false.
    
    Parameters:
    
    value - The text representation of the logical value.
  - logical
```
public logical(character value,
               java.lang.String fmt)
```
    Converts the given string into a logical value. A '?' is interpreted as the unknown value and the strings 'yes' and 'true' (and any abbreviations thereof) are considered true and any other input is considered false.
    Parses the string using default formats 'yes/no' and 'true/false' and the passed in format string. Any any abbreviations of the above formats are also considered as a match. TODO: when a LOGICAL argument is passed as OUTPUT parameter to a procedure the implicit conversion will fails without reason. The following message is displayed: [** Input value: should be yes/no. (87)] When the argument is passes to a INPUT-OUTPUT parameter, everything is fine.
    
    Parameters:
    
    value - The text representation of the logical value.
    
    fmt - The format string to use.
  - logical
```
public logical(character value,
               character fmt)
```
    Converts the given string into a logical value. A '?' is interpreted as the unknown value and the strings 'yes' and 'true' (and any abbreviations thereof) are considered true and any other input is considered false.
    Parses the string using default formats 'yes/no' and 'true/false' and the passed in format string. Any any abbreviations of the above formats are also considered as a match. TODO: when a LOGICAL argument is passed as OUTPUT parameter to a procedure the implicit conversion will fails without reason. The following message is displayed: [** Input value: should be yes/no. (87)] When the argument is passes to a INPUT-OUTPUT parameter, everything is fine.
    
    Parameters:
    
    value - The text representation of the logical value.
    
    fmt - The format string to use.
  - logical
```
public logical(java.lang.String value,
               java.lang.String fmt)
        throws ErrorConditionException
```
    Converts the given string into a logical value. A '?' is interpreted as the unknown value. Parses the string using default formats 'yes/no' and 'true/false' and the passed in format string. Any any abbreviations of the above formats are also considered as a match.
    
    Parameters:
    
    value - The text representation of the logical value.
    
    fmt - The format string to use.
    
    Throws:
    
    ErrorConditionException - If no match is found.
  - logical
```
public logical(java.lang.Boolean value)
```
    Constructs an instance after copying the parameter's data into the internal representation of this class.
    If the parameter is null, this instance will represent the unknown value.
    
    Parameters:
    
    value - The value to be used for this instance.
- Method Detail
  - of
```
public static logical of(boolean value)
```
    Resolve the given boolean value to a logical TRUE/FALSE singleton.
    WARNING: this must be used only from within the fwd runtime or as an instance returned to the converted code, to be assigned to a mutable instance. The return instance is immutable!
    
    Parameters:
    
    value - The value to resolve
    
    Returns:
    
    See above.
  - fromString
```
public static java.lang.Boolean fromString(java.lang.String val,
                                           java.lang.String fmt)
```
    Check if the given value matches the received format. This method is called at runtime (from this class' constructor) or at conversion time (used for "boolean manhandling").
    The default formats of "yes/no" and "true/false" are always considered and will match in preference to an explicitly provided format string. This means that any conflict with the explicitly provided format string will match one of the default formats first (in preference).
    Matching is done on a case-insensitive basis.
    Interestingly, any matching subset of valid match text will match. This means that an exact match or an unambiguous abbreviated match to a format string of the form 'XXX/YYY' will make x, X, xx, XX, xxx, XXX all resolve to true and y, Y, yy, YY, yyy, YYY all resolve to false. This optional abbreviation support works for matches to both the default formats AND to explicitly provided custom formats.
    The default formats have an additional "trash matching" behavior. When specifying yes, no, true or false, the string can contain any trash so long as the trash is following a space character. This means a yes . bogus text. matches a yes in a default format. This same ridiculous trick does not work for explicit custom formats.
    All of the above behavior is indeed how the 4GL does it. No, it doesn't make any sense.
    At conversion time, all enclosing quote characters should already have been removed from both input parameters. It is expected that this is always already the case with runtime strings.
    
    Parameters:
    
    val - The value to be checked.
    
    fmt - The format; if null, the DEFAULT_FORMAT will be used.
    
    Returns:
    
    null if the value does not match the format. Otherwise, the value's true or false state.
  - getType
```
public BaseDataType.Type getType()
```
    Get the type
    
    Specified by:
    
    getType in class BaseDataType
    
    Returns:
    
    type
  - maximum
```
public static logical maximum(logical... list)
```
    Returns the largest instance (false is smaller than true) from the list. This list may not include null values.
    
    Parameters:
    
    list - The list of logicals to check.
    
    Returns:
    
    The largest instance or unknown value if any entries in the list are unknown or null if an empty list is passed.
  - minimum
```
public static logical minimum(logical... list)
```
    Returns the smallest instance (false is smaller than true) from the list. This list may not include null values.
    
    Parameters:
    
    list - The list of decimals to check.
    
    Returns:
    
    The smallest instance or unknown value if any entries in the list are unknown or null if an empty list is passed.
  - _not
```
public static boolean _not(logical op)
```
    Implements the NOT logical operator with the convenience of converting the result to a primitive boolean. If the result is the unknown value, this will be converted to a false.
    
    Parameters:
    
    op - The operand.
    
    Returns:
    
    The result of the operator.
  - not
```
public static logical not(boolean op)
```
    Implements the NOT logical operator using the Java logical NOT.
    
    Parameters:
    
    op - The operand.
    
    Returns:
    
    The result of the operator.
  - not
```
public static logical not(logical op)
```
    Implements the NOT logical operator with proper processing of the unknown value. In particular, if the operand is unknown, then unknown value is returned.
    If the operand is not unknown, the boolean value will be negated and returned using the Java logical NOT.
    
    Parameters:
    
    op - The operand.
    
    Returns:
    
    The result of the operator.
  - _and
```
public static boolean _and(boolean op1,
                           boolean op2)
```
    Implements the AND logical operator with the convenience of converting the result to a primitive boolean.
    Warning: this form requires that both operand expressions are evaluated in the context of the caller. It does not maintain the standard semantic of a logical operator where the right operand is not evaluated unless the left operand requires it.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - _and
```
public static boolean _and(logical op1,
                           boolean op2)
```
    Implements the AND logical operator with the convenience of converting the result to a primitive boolean. If the result is the unknown value, this will be converted to a false.
    Warning: this form requires that both operand expressions are evaluated in the context of the caller. It does not maintain the standard semantic of a logical operator where the right operand is not evaluated unless the left operand requires it.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - _and
```
public static boolean _and(boolean op1,
                           logical op2)
```
    Implements the AND logical operator with the convenience of converting the result to a primitive boolean. If the result is the unknown value, this will be converted to a false.
    Warning: this form requires that both operand expressions are evaluated in the context of the caller. It does not maintain the standard semantic of a logical operator where the right operand is not evaluated unless the left operand requires it.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - _and
```
public static boolean _and(logical op1,
                           logical op2)
```
    Implements the AND logical operator with the convenience of converting the result to a primitive boolean. If the result is the unknown value, this will be converted to a false.
    Warning: this form requires that both operand expressions are evaluated in the context of the caller. It does not maintain the standard semantic of a logical operator where the right operand is not evaluated unless the left operand requires it.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - _and
```
public static boolean _and(boolean op1,
                           LogicalOp op2)
```
    Implements the AND logical operator with the convenience of converting the result to a primitive boolean. If the result is the unknown value, this will be converted to a false.
    This form of the method allows the original semantic of the operator to be maintained. In particular, the expression defining the right operand will not be evaluated unless the left operand does not fail the logical test.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - _and
```
public static boolean _and(logical op1,
                           LogicalOp op2)
```
    Implements the AND logical operator with the convenience of converting the result to a primitive boolean. If the result is the unknown value, this will be converted to a false.
    This form of the method allows the original semantic of the operator to be maintained. In particular, the expression defining the right operand will not be evaluated unless the left operand does not fail the logical test.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - and
```
public static logical and(boolean op1,
                          boolean op2)
```
    Implements the AND logical operator (just a convenience method for the Java logical AND).
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - and
```
public static logical and(boolean op1,
                          logical op2)
```
    Implements the AND logical operator with proper processing of the unknown value.
    If one operand is unknown, then unknown is returned if the other operand is true and false is returned if the other operand is false. If both operands are unknown, then unknown is returned.
    If no operand is unknown, the boolean values of each logical are tested using the Java logical AND.
    Warning: this form requires that both operand expressions are evaluated in the context of the caller. It does not maintain the standard semantic of a logical operator where the right operand is not evaluated unless the left operand requires it.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - and
```
public static logical and(logical op1,
                          boolean op2)
```
    Implements the AND logical operator with proper processing of the unknown value.
    If one operand is unknown, then unknown is returned if the other operand is true and false is returned if the other operand is false. If both operands are unknown, then unknown is returned.
    If no operand is unknown, the boolean values of each logical are tested using the Java logical AND.
    Warning: this form requires that both operand expressions are evaluated in the context of the caller. It does not maintain the standard semantic of a logical operator where the right operand is not evaluated unless the left operand requires it.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - and
```
public static logical and(logical op1,
                          logical op2)
```
    Implements the AND logical operator with proper processing of the unknown value.
    If one operand is unknown, then unknown is returned if the other operand is true and false is returned if the other operand is false. If both operands are unknown, then unknown is returned.
    If no operand is unknown, the boolean values of each logical are tested using the Java logical AND.
    Warning: this form requires that both operand expressions are evaluated in the context of the caller. It does not maintain the standard semantic of a logical operator where the right operand is not evaluated unless the left operand requires it.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - and
```
public static logical and(boolean op1,
                          LogicalOp op2)
```
    Implements the AND logical operator with proper processing of the unknown value.
    If one operand is unknown, then unknown is returned if the other operand is true and false is returned if the other operand is false. If both operands are unknown, then unknown is returned.
    If no operand is unknown, the boolean values of each logical are tested using the Java logical AND.
    This form of the method allows the original semantic of the operator to be maintained. In particular, the expression defining the right operand will not be evaluated unless the left operand does not fail the logical test.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - and
```
public static logical and(logical op1,
                          LogicalOp op2)
```
    Implements the AND logical operator with proper processing of the unknown value.
    If one operand is unknown, then unknown is returned if the other operand is true and false is returned if the other operand is false. If both operands are unknown, then unknown is returned.
    If no operand is unknown, the boolean values of each logical are tested using the Java logical AND.
    This form of the method allows the original semantic of the operator to be maintained. In particular, the expression defining the right operand will not be evaluated unless the left operand does not fail the logical test.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - _or
```
public static boolean _or(boolean op1,
                          boolean op2)
```
    Implements the OR logical operator with the convenience of converting the result to a primitive boolean.
    Warning: this form requires that both operand expressions are evaluated in the context of the caller. It does not maintain the standard semantic of a logical operator where the right operand is not evaluated unless the left operand requires it.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - _or
```
public static boolean _or(logical op1,
                          boolean op2)
```
    Implements the OR logical operator with the convenience of converting the result to a primitive boolean. If the result is the unknown value, this will be converted to a false.
    Warning: this form requires that both operand expressions are evaluated in the context of the caller. It does not maintain the standard semantic of a logical operator where the right operand is not evaluated unless the left operand requires it.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - _or
```
public static boolean _or(boolean op1,
                          logical op2)
```
    Implements the OR logical operator with the convenience of converting the result to a primitive boolean. If the result is the unknown value, this will be converted to a false.
    Warning: this form requires that both operand expressions are evaluated in the context of the caller. It does not maintain the standard semantic of a logical operator where the right operand is not evaluated unless the left operand requires it.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - _or
```
public static boolean _or(logical op1,
                          logical op2)
```
    Implements the OR logical operator with the convenience of converting the result to a primitive boolean. If the result is the unknown value, this will be converted to a false.
    Warning: this form requires that both operand expressions are evaluated in the context of the caller. It does not maintain the standard semantic of a logical operator where the right operand is not evaluated unless the left operand requires it.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - _or
```
public static boolean _or(boolean op1,
                          LogicalOp op2)
```
    Implements the OR logical operator with the convenience of converting the result to a primitive boolean. If the result is the unknown value, this will be converted to a false.
    This form of the method allows the original semantic of the operator to be maintained. In particular, the expression defining the right operand will not be evaluated unless the left operand does not fail the logical test.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - _or
```
public static boolean _or(logical op1,
                          LogicalOp op2)
```
    Implements the OR logical operator with the convenience of converting the result to a primitive boolean. If the result is the unknown value, this will be converted to a false.
    This form of the method allows the original semantic of the operator to be maintained. In particular, the expression defining the right operand will not be evaluated unless the left operand does not fail the logical test.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - or
```
public static logical or(boolean op1,
                         boolean op2)
```
    Implements the OR logical operator using the Java logical OR.
    Warning: this form requires that both operand expressions are evaluated in the context of the caller. It does not maintain the standard semantic of a logical operator where the right operand is not evaluated unless the left operand requires it.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - or
```
public static logical or(boolean op1,
                         logical op2)
```
    Implements the OR logical operator with proper processing of the unknown value.
    If one operand is unknown, then unknown is returned if the other operand is false and true is returned if the other operand is true. If both operands are unknown, then unknown is returned.
    If no operand is unknown, the boolean values of each logical are tested using the Java logical OR.
    Warning: this form requires that both operand expressions are evaluated in the context of the caller. It does not maintain the standard semantic of a logical operator where the right operand is not evaluated unless the left operand requires it.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - or
```
public static logical or(logical op1,
                         boolean op2)
```
    Implements the OR logical operator with proper processing of the unknown value.
    If one operand is unknown, then unknown is returned if the other operand is false and true is returned if the other operand is true. If both operands are unknown, then unknown is returned.
    If no operand is unknown, the boolean values of each logical are tested using the Java logical OR.
    Warning: this form requires that both operand expressions are evaluated in the context of the caller. It does not maintain the standard semantic of a logical operator where the right operand is not evaluated unless the left operand requires it.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - or
```
public static logical or(logical op1,
                         logical op2)
```
    Implements the OR logical operator with proper processing of the unknown value.
    If one operand is unknown, then unknown is returned if the other operand is false and true is returned if the other operand is true. If both operands are unknown, then unknown is returned.
    If no operand is unknown, the boolean values of each logical are tested using the Java logical OR.
    Warning: this form requires that both operand expressions are evaluated in the context of the caller. It does not maintain the standard semantic of a logical operator where the right operand is not evaluated unless the left operand requires it.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - or
```
public static logical or(boolean op1,
                         LogicalOp op2)
```
    Implements the OR logical operator with proper processing of the unknown value.
    If one operand is unknown, then unknown is returned if the other operand is false and true is returned if the other operand is true. If both operands are unknown, then unknown is returned.
    If no operand is unknown, the boolean values of each logical are tested using the Java logical OR.
    This form of the method allows the original semantic of the operator to be maintained. In particular, the expression defining the right operand will not be evaluated unless the left operand does not fail the logical test.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - or
```
public static logical or(logical op1,
                         LogicalOp op2)
```
    Implements the OR logical operator with proper processing of the unknown value.
    If one operand is unknown, then unknown is returned if the other operand is false and true is returned if the other operand is true. If both operands are unknown, then unknown is returned.
    If no operand is unknown, the boolean values of each logical are tested using the Java logical OR.
    This form of the method allows the original semantic of the operator to be maintained. In particular, the expression defining the right operand will not be evaluated unless the left operand does not fail the logical test.
    
    Parameters:
    
    op1 - The left operand.
    
    op2 - The right operand.
    
    Returns:
    
    The result of the operator.
  - splitFormat
```
public static java.lang.String[] splitFormat(java.lang.String fmt)
                                      throws ErrorConditionException
```
    Split a valid logical format string in a safe way that handles all possible edge cases. Examples:
    - an empty or null format string is invalid
    - a format that starts with '/' has an empty string for the true value
    - a format that ends with '/' or has no '/' has an empty string for the false
    - otherwise the format string is split into 2 pieces at the '/' character and the left side is used as the true representation and the right side is the false
    Parameters:
    
    fmt - Format to split.
    
    Returns:
    
    The split format string as a string array with 2 elements, where the first element is the true value and the second element is the false value. Return null if the provided format is invalid, and error was not thrown.
    
    Throws:
    
    ErrorConditionException - if the provided format is invalid (null, empty or a single slash character). The error code is 74.
  - maximumStringSize
```
public static int maximumStringSize(java.lang.String fmt)
```
    Determines the largest possible string length that can match either of the specified values in a valid format string. For example, if the format string was specified as "Yep/Nope" then the largest size would be returned as 4. The format string will be split and the length of the larger of the 2 values will be returned.
    
    Parameters:
    
    fmt - A valid format string for the logical type.
    
    Returns:
    
    The length of the longer of the 2 values in the format string.
  - formatLength
```
public int formatLength(java.lang.String fmt)
```
    Calculate the length of a formatted value (the text form of the value) using this format string.
    
    Overrides:
    
    formatLength in class BaseDataType
    
    Parameters:
    
    fmt - The format string.
    
    Returns:
    
    The length in characters of the any resulting formatted value.
  - equals
```
public boolean equals(java.lang.Object o)
```
    An equality test which handles the most common cases with the least amount of overhead. The superclass implementation is invoked otherwise.
    This implementation is consistent with hashCode().
    
    Overrides:
    
    equals in class BaseDataType
    
    Parameters:
    
    o - The instance to compare against.
    
    Returns:
    
    true if the objects compare equivalently; false if they do not, or if the parameter is not a BaseDataType instance.
    
    See Also:
    
    BaseDataType.equals(java.lang.Object)
  - hashCode
```
public int hashCode()
```
    Hash code implementation which is consistent with BaseDataType.equals(java.lang.Object).
    
    Specified by:
    
    hashCode in class BaseDataType
    
    Returns:
    
    Hash code value for this object instance.
  - instantiateUnknown
```
public BaseDataType instantiateUnknown()
```
    Creates a new instance of the same type that represents the unknown value.
    
    Specified by:
    
    instantiateUnknown in class BaseDataType
    
    Returns:
    
    An instance that represents the unknown value.
  - instantiateDefault
```
public BaseDataType instantiateDefault()
```
    Creates a new instance of the same type that represents the default initialized value.
    
    Specified by:
    
    instantiateDefault in class BaseDataType
    
    Returns:
    
    An instance that represents the default value.
  - duplicate
```
public logical duplicate()
```
    Does the same as standard clone() method but returns an instance of BaseDataType and doesn't throw the CloneNotSupportedException.
    
    Specified by:
    
    duplicate in class BaseDataType
    
    Returns:
    
    A clone of this instance.
  - booleanValue
```
public boolean booleanValue()
```
    Accesses the state of this instance's boolean value. If this instance represents the unknown value, then this method will return false even if the internal state is true!
    
    Returns:
    
    The state of this instance's boolean value or false if this instance represents the unknown value.
  - isUnknown
```
public boolean isUnknown()
```
    Determines if this instance represents the unknown value.
    
    Specified by:
    
    isUnknown in class BaseDataType
    
    Returns:
    
    true if this instance is set to the unknown value.
  - setUnknown
```
public void setUnknown()
```
    Sets the state of this instance's unknown value flag to true.
    Warning: a separate call is needed to ensure that the data of this instance is set to the correct value.
    
    Specified by:
    
    setUnknown in class BaseDataType
  - getValue
```
public boolean getValue()
```
    Accesses the state of this instance's boolean value independently of the state of whether this instance represents the unknown value. If this instance represents the unknown value, the returned boolean is not valid!
    
    Returns:
    
    The state of this instance's boolean value.
  - setValue
```
public void setValue(boolean value)
```
    Sets the state of this instance's boolean value independently of the state of whether this instance represents the unknown value. This also sets the unknown value state for this instance to false.
    
    Parameters:
    
    value - The state to set this instance's boolean value.
  - isIncompatibleTypesOnConversion
```
protected boolean isIncompatibleTypesOnConversion(BaseDataType value)
```
    Returns true if dynamic data type conversion should not be attempted, it can also throw an ErrorConditionException in case of incompatible types for a POLY conversion. (e.g. DYNAMIC-FUNCTION()).
    
    Overrides:
    
    isIncompatibleTypesOnConversion in class BaseDataType
    
    Throws:
    
    ErrorConditionException - If dynamic conversion of input value is not supported.
  - assign
```
public void assign(BaseDataType value)
```
    Sets the state (data and unknown value) of this instance based on the state of the passed instance.
    If the value is not of type logical, the following automatic type conversions will occur:
    1. if the value is a logical value, the current value is returned
    2. if the value is unknown (including unknown literal), sets the instance to unknown
    3. if the value is a non-unknown rowid or BinaryData (raw or memptr) value the string representation is converted to a logical value
    4. if the value is a non-unknown numeric value, returns a logical value set to true when the numeric value is not zero, false if the numeric value is 0
    5. if the value is a non-unknown character or longchar value, it attempts to convert the character value to a logical value (if the character is "yes", it is set to true, if is "no", it is set to false
    6. if the value is a non-unknown date or datetime it returns a logical false for a value of 31/12/-4714 and true for other values. Basically the number of days from 1/1/4713 B.C. to that date are converted to logical value. If the number of days are 0 a false value is returned otherwise a true value is returned.
    7. if the value is a non-unknown handle or comhandle value, it returns a logical false if the resource id is 0 and true if the resource id is not 0.
    8. else, it attempts to convert the value's string representation to logical
    This variant is meant to handle the cases of built-in functions and methods in the 4GL which have polymorphic return types (e.g. DYNAMIC-FUNCTION()). This should NOT be used for non-polymorphic assignments.
    Specified by:
    
    assign in class BaseDataType
    
    Parameters:
    
    value - The instance from which to copy state.
  - assign
```
public void assign(logical value)
```
    Sets the state (data and unknown value) of this instance based on the state of the passed instance.
    
    Parameters:
    
    value - The instance from which to copy state.
  - assign
```
public void assign(boolean value)
```
    Sets the state (data) of this instance based on the given value.
    
    Parameters:
    
    value - The data from which to copy state.
  - assign
```
public void assign(Undoable value)
```
    Sets the state (data and unknown value) of this instance based on the state of the passed instance.
    
    Parameters:
    
    value - The instance from which to copy state.
  - compareTo
```
public int compareTo(java.lang.Object obj)
```
    Compares this instance with the specified instance and returns a -1 if this instance is less than the specified, 0 if the two instances are equal and 1 if this instance is greater than the specified instance. This is the implementation of the Comparable interface.
    The algorithm will fail to give meaningful results in the case where one tries to sort against other objects that do not represent compatible values.
    
    Parameters:
    
    obj - The instance to compare against.
    
    Returns:
    
    -1, 0 or 1 depending on if this instance is less than, equal to or greater (respectively) than the specified instance obj.
  - maximum
```
public logical maximum(logical l)
```
    Returns the larger (false is smaller than true) of the current or passed-in instance.
    
    Parameters:
    
    l - The instance to compare against.
    
    Returns:
    
    The largest instance.
  - minimum
```
public logical minimum(logical l)
```
    Returns the smaller (false is smaller than true) of the current or passed-in instance.
    
    Parameters:
    
    l - The instance to compare against.
    
    Returns:
    
    The smallest instance.
  - toJavaType
```
public java.lang.Boolean toJavaType()
```
    Return the current value as a Java wrapper.
    
    Returns:
    
    Current value or null if unknown.
  - toString
```
public java.lang.String toString()
```
    Creates a string representation of the instance data using the default Progress 4GL format of 'yes/no'. If the instance represents the unknown value, a '?' will be returned.
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    
    A short string representation of the object.
  - toStringMessage
```
public java.lang.String toStringMessage()
```
    Creates a string representation of the instance data in a form that is compatible with the MESSAGE language statement. If the instance represents the unknown value, a '?' will be returned.
    
    Specified by:
    
    toStringMessage in class BaseDataType
    
    Returns:
    
    The 'message' formatted string.
  - toStringExport
```
public java.lang.String toStringExport()
```
    Creates a string representation of the instance data using the 'export' format. For the logical data type this is the same as the default format string of 'yes/no'. If the instance represents the unknown value, a '?' will be returned.
    
    Specified by:
    
    toStringExport in class BaseDataType
    
    Returns:
    
    The 'export' formatted string.
  - toString
```
public java.lang.String toString(java.lang.String fmt)
                          throws ErrorConditionException
```
    Creates a string representation of the instance data using the user- specified Progress 4GL format string. If the passed-in format is null, then a default format string of 'yes/no' will be used. Please note that due to the implementation, it is faster to use a null format string than to explicitly encode 'yes/no'. If the instance represents the unknown value, a '?' will be returned.
    The format string must be in the form of 'xxx/yyy' where xxx is the text for a true and yyy is the text for a false value. For example, one might want a 'true/false' to be used instead of the default. The user cannot override the '?' returned for the unknown value.
    
    Specified by:
    
    toString in class BaseDataType
    
    Parameters:
    
    fmt - The Progress 4GL format string for a logical data type.
    
    Returns:
    
    The formatted string.
    
    Throws:
    
    ErrorConditionException
  - defaultFormatString
```
public java.lang.String defaultFormatString()
```
    Return the default display format string for this type.
    
    Specified by:
    
    defaultFormatString in class BaseDataType
    
    Returns:
    
    The default format string.
  - getSize
```
public int getSize()
```
    Obtain the length (in bytes) of this BDT will use when serialized.
    
    Overrides:
    
    getSize in class BaseDataType
    
    Returns:
    
    the length of this BDT will use when serialized.
  - readExternal
```
public void readExternal(java.io.ObjectInput in)
                  throws java.io.IOException,
                         java.lang.ClassNotFoundException
```
    Replacement for the default object reading method. The latest state is read from the input source.
    
    Parameters:
    
    in - The input source from which fields will be restored.
    
    Throws:
    
    java.io.IOException - In case of I/O errors.
    
    java.lang.ClassNotFoundException - If payload can't be instantiated.
  - writeExternal
```
public void writeExternal(java.io.ObjectOutput out)
                   throws java.io.IOException
```
    Replacement for the default object writing method. The latest state is written to the output destination.
    
    Parameters:
    
    out - The output destination to which fields will be saved.
    
    Throws:
    
    java.io.IOException - In case of I/O errors.
  - instantiateDefaultExtent
```
protected BaseDataType instantiateDefaultExtent()
```
    Get the default initialization for an extent variable of this type.
    
    Overrides:
    
    instantiateDefaultExtent in class BaseDataType
    
    Returns:
    
    See above.
  - convertString
```
private logical convertString(java.lang.String val)
```
    Helper to convert a text value into a logical value with ERROR processing SUPPRESSED. The only known instance where we use this is in a validation expression, so the suppression of error processing should be OK when it normally might be dangerous.
    
    Parameters:
    
    val - The value to attempt to convert. If it does not match the string "yes" or "no", then an error would normally occur. This error will be suppressed, but the resulting failure will be detected.
    
    Returns:
    
    The converted instance or null on any failure.

Class logical

Nested Class Summary

Nested classes/interfaces inherited from class com.goldencode.p2j.util.BaseDataType

Field Summary

Constructor Summary

Method Summary

Methods inherited from class com.goldencode.p2j.util.BaseDataType

Methods inherited from class com.goldencode.p2j.util.LazyUndoable

Methods inherited from class java.lang.Object

Field Detail

TRUE

FALSE

UNKNOWN

DEFAULT_FORMAT

value

unknown

Constructor Detail

logical

logical

logical

logical

logical

logical

logical

logical

logical

logical

logical

logical

Method Detail

of

fromString

getType

maximum

minimum

_not

not

not

_and

_and

_and

_and

_and

_and

and

and

and

and

and

and

_or

_or

_or

_or

_or

_or

or

or

or

or

or

or

splitFormat

maximumStringSize

formatLength

equals

hashCode

instantiateUnknown

instantiateDefault

duplicate

booleanValue

isUnknown

setUnknown

getValue

setValue

isIncompatibleTypesOnConversion

assign

assign

assign

assign