Package org.apache.cayenne.util

## Class EqualsBuilder

- java.lang.Object
- - org.apache.cayenne.util.EqualsBuilder

-     public class EqualsBuilder
      extends Object

  Assists in implementing `Object.equals(Object)` methods. The code is based on EqualsBuilder from commons-lang 2.1.
  Since:
    3.0

- - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `EqualsBuilder()` |

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `EqualsBuilder` | `append​(boolean[] lhs, boolean[] rhs)` | Deep comparison of array of `boolean`.
    `EqualsBuilder` | `append​(boolean lhs, boolean rhs)` | Test if two `booleans`s are equal.
    `EqualsBuilder` | `append​(byte[] lhs, byte[] rhs)` | Deep comparison of array of `byte`.
    `EqualsBuilder` | `append​(byte lhs, byte rhs)` | Test if two `byte`s are equal.
    `EqualsBuilder` | `append​(char[] lhs, char[] rhs)` | Deep comparison of array of `char`.
    `EqualsBuilder` | `append​(char lhs, char rhs)` | Test if two `char`s are equal.
    `EqualsBuilder` | `append​(double[] lhs, double[] rhs)` | Deep comparison of array of `double`.
    `EqualsBuilder` | `append​(double lhs, double rhs)` | Test if two `double`s are equal by testing that the pattern of bits returned by `doubleToLong` are equal.
    `EqualsBuilder` | `append​(float[] lhs, float[] rhs)` | Deep comparison of array of `float`.
    `EqualsBuilder` | `append​(float lhs, float rhs)` | Test if two `float`s are equal byt testing that the pattern of bits returned by doubleToLong are equal.
    `EqualsBuilder` | `append​(int[] lhs, int[] rhs)` | Deep comparison of array of `int`.
    `EqualsBuilder` | `append​(int lhs, int rhs)` | Test if two `int`s are equal.
    `EqualsBuilder` | `append​(long[] lhs, long[] rhs)` | Deep comparison of array of `long`.
    `EqualsBuilder` | `append​(long lhs, long rhs)` | Test if two `long` s are equal.
    `EqualsBuilder` | `append​(short[] lhs, short[] rhs)` | Deep comparison of array of `short`.
    `EqualsBuilder` | `append​(short lhs, short rhs)` | Test if two `short`s are equal.
    `EqualsBuilder` | `append​(Object[] lhs, Object[] rhs)` | Performs a deep comparison of two `Object` arrays.
    `EqualsBuilder` | `append​(Object lhs, Object rhs)` | Test if two `Object`s are equal using their `equals` method.
    `EqualsBuilder` | `appendSuper​(boolean superEquals)` | Adds the result of `super.equals()` to this builder.
    `boolean` | `isEquals()` | Returns `true` if the fields that have been checked are all equal.
    `protected void` | `setEquals​(boolean isEquals)` | Sets the `isEquals` value.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### EqualsBuilder

          public EqualsBuilder()

  - ### Method Detail

    - #### appendSuper

          public EqualsBuilder appendSuper​(boolean superEquals)

      Adds the result of `super.equals()` to this builder.

      Parameters:
        `superEquals` - the result of calling `super.equals()`
      Returns:
        EqualsBuilder - used to chain calls.
      Since:
        2.0

    - #### append

          public EqualsBuilder append​(Object lhs,
                                      Object rhs)

      Test if two `Object`s are equal using their `equals` method.

      Parameters:
        `lhs` - the left hand object
        `rhs` - the right hand object
      Returns:
        EqualsBuilder - used to chain calls.

    - #### append

          public EqualsBuilder append​(long lhs,
                                      long rhs)

      Test if two `long` s are equal.

      Parameters:
        `lhs` - the left hand `long`
        `rhs` - the right hand `long`
      Returns:
        EqualsBuilder - used to chain calls.

    - #### append

          public EqualsBuilder append​(int lhs,
                                      int rhs)

      Test if two `int`s are equal.

      Parameters:
        `lhs` - the left hand `int`
        `rhs` - the right hand `int`
      Returns:
        EqualsBuilder - used to chain calls.

    - #### append

          public EqualsBuilder append​(short lhs,
                                      short rhs)

      Test if two `short`s are equal.

      Parameters:
        `lhs` - the left hand `short`
        `rhs` - the right hand `short`
      Returns:
        EqualsBuilder - used to chain calls.

    - #### append

          public EqualsBuilder append​(char lhs,
                                      char rhs)

      Test if two `char`s are equal.

      Parameters:
        `lhs` - the left hand `char`
        `rhs` - the right hand `char`
      Returns:
        EqualsBuilder - used to chain calls.

    - #### append

          public EqualsBuilder append​(byte lhs,
                                      byte rhs)

      Test if two `byte`s are equal.

      Parameters:
        `lhs` - the left hand `byte`
        `rhs` - the right hand `byte`
      Returns:
        EqualsBuilder - used to chain calls.

    - #### append

          public EqualsBuilder append​(double lhs,
                                      double rhs)

      Test if two `double`s are equal by testing that the pattern of bits returned by `doubleToLong` are equal.

      This handles NaNs, Infinities, and `-0.0`.

      It is compatible with the hash code generated by `HashCodeBuilder`.

      Parameters:
        `lhs` - the left hand `double`
        `rhs` - the right hand `double`
      Returns:
        EqualsBuilder - used to chain calls.

    - #### append

          public EqualsBuilder append​(float lhs,
                                      float rhs)

      Test if two `float`s are equal byt testing that the pattern of bits returned by doubleToLong are equal.

      This handles NaNs, Infinities, and `-0.0`.

      It is compatible with the hash code generated by `HashCodeBuilder`.

      Parameters:
        `lhs` - the left hand `float`
        `rhs` - the right hand `float`
      Returns:
        EqualsBuilder - used to chain calls.

    - #### append

          public EqualsBuilder append​(boolean lhs,
                                      boolean rhs)

      Test if two `booleans`s are equal.

      Parameters:
        `lhs` - the left hand `boolean`
        `rhs` - the right hand `boolean`
      Returns:
        EqualsBuilder - used to chain calls.

    - #### append

          public EqualsBuilder append​(Object[] lhs,
                                      Object[] rhs)

      Performs a deep comparison of two `Object` arrays.

      This also will be called for the top level of multi-dimensional, ragged, and multi-typed arrays.

      Parameters:
        `lhs` - the left hand `Object[]`
        `rhs` - the right hand `Object[]`
      Returns:
        EqualsBuilder - used to chain calls.

    - #### append

          public EqualsBuilder append​(long[] lhs,
                                      long[] rhs)

      Deep comparison of array of `long`. Length and all values are compared.

      The method `append(long, long)` is used.

      Parameters:
        `lhs` - the left hand `long[]`
        `rhs` - the right hand `long[]`
      Returns:
        EqualsBuilder - used to chain calls.

    - #### append

          public EqualsBuilder append​(int[] lhs,
                                      int[] rhs)

      Deep comparison of array of `int`. Length and all values are compared.

      The method `append(int, int)` is used.

      Parameters:
        `lhs` - the left hand `int[]`
        `rhs` - the right hand `int[]`
      Returns:
        EqualsBuilder - used to chain calls.

    - #### append

          public EqualsBuilder append​(short[] lhs,
                                      short[] rhs)

      Deep comparison of array of `short`. Length and all values are compared.

      The method `append(short, short)` is used.

      Parameters:
        `lhs` - the left hand `short[]`
        `rhs` - the right hand `short[]`
      Returns:
        EqualsBuilder - used to chain calls.

    - #### append

          public EqualsBuilder append​(char[] lhs,
                                      char[] rhs)

      Deep comparison of array of `char`. Length and all values are compared.

      The method `append(char, char)` is used.

      Parameters:
        `lhs` - the left hand `char[]`
        `rhs` - the right hand `char[]`
      Returns:
        EqualsBuilder - used to chain calls.

    - #### append

          public EqualsBuilder append​(byte[] lhs,
                                      byte[] rhs)

      Deep comparison of array of `byte`. Length and all values are compared.

      The method `append(byte, byte)` is used.

      Parameters:
        `lhs` - the left hand `byte[]`
        `rhs` - the right hand `byte[]`
      Returns:
        EqualsBuilder - used to chain calls.

    - #### append

          public EqualsBuilder append​(double[] lhs,
                                      double[] rhs)

      Deep comparison of array of `double`. Length and all values are compared.

      The method `append(double, double)` is used.

      Parameters:
        `lhs` - the left hand `double[]`
        `rhs` - the right hand `double[]`
      Returns:
        EqualsBuilder - used to chain calls.

    - #### append

          public EqualsBuilder append​(float[] lhs,
                                      float[] rhs)

      Deep comparison of array of `float`. Length and all values are compared.

      The method `append(float, float)` is used.

      Parameters:
        `lhs` - the left hand `float[]`
        `rhs` - the right hand `float[]`
      Returns:
        EqualsBuilder - used to chain calls.

    - #### append

          public EqualsBuilder append​(boolean[] lhs,
                                      boolean[] rhs)

      Deep comparison of array of `boolean`. Length and all values are compared.

      The method `append(boolean, boolean)` is used.

      Parameters:
        `lhs` - the left hand `boolean[]`
        `rhs` - the right hand `boolean[]`
      Returns:
        EqualsBuilder - used to chain calls.

    - #### isEquals

          public boolean isEquals()

      Returns `true` if the fields that have been checked are all equal.

      Returns:
        boolean

    - #### setEquals

          protected void setEquals​(boolean isEquals)

      Sets the `isEquals` value.
      Parameters:
        `isEquals` - The value to set.
      Since:
        2.1