or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

index.md jaxb-lifecycle.md jaxb-model.md object-locators.md strategic-patterns.md utilities.md

tile.json

Strategic Pattern Implementations

Core behavioral interfaces and strategy implementations that enable JAXB2 Basics plugins to generate efficient, reflection-free method implementations for equals, hashCode, toString, copy, and merge operations on JAXB-generated classes.

Capabilities

Behavioral Interfaces

The main interfaces that JAXB-generated classes implement to provide strategic pattern support.

Equals Functionality

interface Equals2 {
    boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, 
                  Object object, EqualsStrategy2 strategy);
}

// Deprecated legacy interface
interface Equals {
    boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, 
                  Object object, EqualsStrategy strategy);
}

HashCode Functionality

interface HashCode2 {
    int hashCode(ObjectLocator locator, HashCodeStrategy2 strategy);
}

// Deprecated legacy interface  
interface HashCode {
    int hashCode(ObjectLocator locator, HashCodeStrategy strategy);
}

ToString Functionality

interface ToString2 {
    StringBuilder append(ObjectLocator locator, StringBuilder buffer, 
                        ToStringStrategy2 strategy);
    StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, 
                              ToStringStrategy2 strategy);
}

// Deprecated legacy interface
interface ToString {
    StringBuilder append(ObjectLocator locator, StringBuilder buffer, 
                        ToStringStrategy strategy);
    StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, 
                              ToStringStrategy strategy);
}

Copy Functionality

interface CopyTo2 {
    Object createNewInstance();
    Object copyTo(Object target);
    Object copyTo(ObjectLocator locator, Object target, CopyStrategy2 strategy);
}

// Deprecated legacy interface
interface CopyTo {
    Object createNewInstance();
    Object copyTo(Object target);
    Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy);
}

Merge Functionality

interface MergeFrom2 {
    Object createNewInstance();
    void mergeFrom(Object left, Object right);
    void mergeFrom(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                  Object left, Object right, MergeStrategy2 strategy);
}

// Deprecated legacy interface
interface MergeFrom {
    Object createNewInstance();
    void mergeFrom(Object left, Object right);
    void mergeFrom(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                  Object left, Object right, MergeStrategy strategy);
}

Strategy Interfaces

Strategy interfaces define how operations are performed on different data types. The "2" versions include value set tracking for handling optional/nullable fields.

Equals Strategies

interface EqualsStrategy2 {
    boolean equals(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                  boolean left, boolean right, boolean leftSet, boolean rightSet);
    boolean equals(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                  byte left, byte right, boolean leftSet, boolean rightSet);
    boolean equals(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                  char left, char right, boolean leftSet, boolean rightSet);
    boolean equals(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                  double left, double right, boolean leftSet, boolean rightSet);
    boolean equals(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                  float left, float right, boolean leftSet, boolean rightSet);
    boolean equals(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                  int left, int right, boolean leftSet, boolean rightSet);
    boolean equals(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                  long left, long right, boolean leftSet, boolean rightSet);
    boolean equals(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                  short left, short right, boolean leftSet, boolean rightSet);
    boolean equals(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                  Object left, Object right, boolean leftSet, boolean rightSet);
    // Array comparison methods for all primitive types and Object arrays
    boolean equals(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                  boolean[] left, boolean[] right, boolean leftSet, boolean rightSet);
    // ... additional array methods for byte[], char[], double[], float[], int[], long[], short[], Object[]
}

// Deprecated legacy interface without value set tracking
interface EqualsStrategy {
    boolean equals(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                  boolean left, boolean right);
    boolean equals(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                  Object left, Object right);
    // ... methods for all primitive types and arrays
}

HashCode Strategies

interface HashCodeStrategy2 {
    int hashCode(ObjectLocator locator, int hashCode, boolean value, boolean valueSet);
    int hashCode(ObjectLocator locator, int hashCode, byte value, boolean valueSet);
    int hashCode(ObjectLocator locator, int hashCode, char value, boolean valueSet);
    int hashCode(ObjectLocator locator, int hashCode, double value, boolean valueSet);
    int hashCode(ObjectLocator locator, int hashCode, float value, boolean valueSet);
    int hashCode(ObjectLocator locator, int hashCode, int value, boolean valueSet);
    int hashCode(ObjectLocator locator, int hashCode, long value, boolean valueSet);
    int hashCode(ObjectLocator locator, int hashCode, short value, boolean valueSet);
    int hashCode(ObjectLocator locator, int hashCode, Object value, boolean valueSet);
    // Array hash code methods for all primitive types and Object arrays
    int hashCode(ObjectLocator locator, int hashCode, boolean[] value, boolean valueSet);
    // ... additional array methods
}

// Deprecated legacy interface
interface HashCodeStrategy {
    int hashCode(ObjectLocator locator, int hashCode, boolean value);
    int hashCode(ObjectLocator locator, int hashCode, Object value);
    // ... methods for all primitive types and arrays
}

ToString Strategies

interface ToStringStrategy2 {
    StringBuilder appendStart(ObjectLocator locator, Object object, StringBuilder buffer);
    StringBuilder appendEnd(ObjectLocator locator, Object object, StringBuilder buffer);
    StringBuilder appendField(ObjectLocator locator, Object object, String fieldName, 
                             StringBuilder buffer, boolean value, boolean valueSet);
    StringBuilder appendField(ObjectLocator locator, Object object, String fieldName, 
                             StringBuilder buffer, byte value, boolean valueSet);
    StringBuilder appendField(ObjectLocator locator, Object object, String fieldName, 
                             StringBuilder buffer, char value, boolean valueSet);
    StringBuilder appendField(ObjectLocator locator, Object object, String fieldName, 
                             StringBuilder buffer, double value, boolean valueSet);
    StringBuilder appendField(ObjectLocator locator, Object object, String fieldName, 
                             StringBuilder buffer, float value, boolean valueSet);
    StringBuilder appendField(ObjectLocator locator, Object object, String fieldName, 
                             StringBuilder buffer, int value, boolean valueSet);
    StringBuilder appendField(ObjectLocator locator, Object object, String fieldName, 
                             StringBuilder buffer, long value, boolean valueSet);
    StringBuilder appendField(ObjectLocator locator, Object object, String fieldName, 
                             StringBuilder buffer, short value, boolean valueSet);
    StringBuilder appendField(ObjectLocator locator, Object object, String fieldName, 
                             StringBuilder buffer, Object value, boolean valueSet);
    // Array field methods for all primitive types and Object arrays
    StringBuilder appendField(ObjectLocator locator, Object object, String fieldName, 
                             StringBuilder buffer, boolean[] value, boolean valueSet);
    // ... additional array field methods
}

// Deprecated legacy interface
interface ToStringStrategy {
    StringBuilder appendStart(ObjectLocator locator, Object object, StringBuilder buffer);
    StringBuilder appendEnd(ObjectLocator locator, Object object, StringBuilder buffer);
    StringBuilder appendField(ObjectLocator locator, Object object, String fieldName, 
                             StringBuilder buffer, boolean value);
    StringBuilder appendField(ObjectLocator locator, Object object, String fieldName, 
                             StringBuilder buffer, Object value);
    // ... methods for all primitive types and arrays
}

Copy Strategies

interface CopyStrategy2 {
    Boolean shouldBeCopiedAndSet(ObjectLocator locator, boolean valueSet);
    boolean copy(ObjectLocator locator, boolean value, boolean valueSet);
    byte copy(ObjectLocator locator, byte value, boolean valueSet);
    char copy(ObjectLocator locator, char value, boolean valueSet);
    double copy(ObjectLocator locator, double value, boolean valueSet);
    float copy(ObjectLocator locator, float value, boolean valueSet);
    int copy(ObjectLocator locator, int value, boolean valueSet);
    long copy(ObjectLocator locator, long value, boolean valueSet);
    short copy(ObjectLocator locator, short value, boolean valueSet);
    Object copy(ObjectLocator locator, Object value, boolean valueSet);
    // Array copy methods for all primitive types and Object arrays
    boolean[] copy(ObjectLocator locator, boolean[] value, boolean valueSet);
    // ... additional array copy methods
}

// Deprecated legacy interface
interface CopyStrategy {
    boolean copy(ObjectLocator locator, boolean value);
    Object copy(ObjectLocator locator, Object value);
    // ... methods for all primitive types and arrays
}

Merge Strategies

interface MergeStrategy2 {
    Boolean shouldBeMergedAndSet(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                                boolean leftSet, boolean rightSet);
    boolean merge(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                 boolean left, boolean right, boolean leftSet, boolean rightSet);
    byte merge(ObjectLocator leftLocator, ObjectLocator rightLocator, 
              byte left, byte right, boolean leftSet, boolean rightSet);
    char merge(ObjectLocator leftLocator, ObjectLocator rightLocator, 
              char left, char right, boolean leftSet, boolean rightSet);
    double merge(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                double left, double right, boolean leftSet, boolean rightSet);
    float merge(ObjectLocator leftLocator, ObjectLocator rightLocator, 
               float left, float right, boolean leftSet, boolean rightSet);
    int merge(ObjectLocator leftLocator, ObjectLocator rightLocator, 
             int left, int right, boolean leftSet, boolean rightSet);
    long merge(ObjectLocator leftLocator, ObjectLocator rightLocator, 
              long left, long right, boolean leftSet, boolean rightSet);
    short merge(ObjectLocator leftLocator, ObjectLocator rightLocator, 
               short left, short right, boolean leftSet, boolean rightSet);
    Object merge(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                Object left, Object right, boolean leftSet, boolean rightSet);
    // Array merge methods for all primitive types and Object arrays
    boolean[] merge(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                   boolean[] left, boolean[] right, boolean leftSet, boolean rightSet);
    // ... additional array merge methods
}

// Deprecated legacy interface
interface MergeStrategy {
    boolean merge(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                 boolean left, boolean right);
    Object merge(ObjectLocator leftLocator, ObjectLocator rightLocator, 
                Object left, Object right);
    // ... methods for all primitive types and arrays
}

Default Implementations

Standard implementations that provide sensible default behavior for all strategy interfaces.

class DefaultEqualsStrategy implements EqualsStrategy2, EqualsStrategy {
    public static final DefaultEqualsStrategy INSTANCE = new DefaultEqualsStrategy();
    // Implements deep equals comparison for objects and arrays
    // Delegates to Equals/Equals2 interfaces when available
}

class DefaultHashCodeStrategy implements HashCodeStrategy2, HashCodeStrategy {
    public DefaultHashCodeStrategy();
    public DefaultHashCodeStrategy(int multiplierNonZeroOddNumber);
    public static final DefaultHashCodeStrategy INSTANCE = new DefaultHashCodeStrategy();
    // Implements hash code calculation with configurable multiplier
    // Delegates to HashCode/HashCode2 interfaces when available
}

class DefaultToStringStrategy implements ToStringStrategy2, ToStringStrategy {
    public DefaultToStringStrategy();
    // Constructor with extensive configuration options for field names, 
    // class names, separators, delimiters, etc.
    public static final DefaultToStringStrategy INSTANCE = new DefaultToStringStrategy();
    // Implements configurable string representation
    // Delegates to ToString/ToString2 interfaces when available
}

class DefaultCopyStrategy implements CopyStrategy2, CopyStrategy {
    public static final DefaultCopyStrategy INSTANCE = new DefaultCopyStrategy();
    // Implements object copying with support for Cloneable objects
    // Delegates to CopyTo/CopyTo2 interfaces when available
    // Provides array copying support
}

class DefaultMergeStrategy implements MergeStrategy2, MergeStrategy {
    public static final DefaultMergeStrategy INSTANCE = new DefaultMergeStrategy();
    // Implements null-safe merging logic
    // Delegates to MergeFrom/MergeFrom2 interfaces when available
}

JAXB-Specific Implementations

Specialized implementations that provide XML-aware behavior for JAXB types like JAXBElement and Collections.

class JAXBEqualsStrategy extends DefaultEqualsStrategy {
    public static final JAXBEqualsStrategy INSTANCE = new JAXBEqualsStrategy();
    // Special handling for JAXBElement comparison (name, declaredType, scope, value)
    // Iterator-based List comparison for consistent ordering
}

class JAXBHashCodeStrategy extends DefaultHashCodeStrategy {
    public static final JAXBHashCodeStrategy INSTANCE = new JAXBHashCodeStrategy();
    // JAXBElement hash code includes name, declaredType, scope, and value
    // Special List handling (empty lists treated as null)
}

class JAXBToStringStrategy extends DefaultToStringStrategy {
    public static final JAXBToStringStrategy INSTANCE = new JAXBToStringStrategy();
    // XML-like formatting for JAXBElement with configurable markers
    // Special formatting for JAXB-generated classes
}

class JAXBCopyStrategy extends DefaultCopyStrategy {
    public static final JAXBCopyStrategy INSTANCE = new JAXBCopyStrategy();
    // DOM Node deep cloning support
    // JAXBElement copying with proper value copying
    // ArrayList copying for List types
}

class JAXBMergeStrategy extends DefaultMergeStrategy {
    public static final JAXBMergeStrategy INSTANCE = new JAXBMergeStrategy();
    // Collection merging (non-empty collection takes precedence)
}

class JAXBMergeCollectionsStrategy extends JAXBMergeStrategy {
    public static final JAXBMergeCollectionsStrategy INSTANCE = new JAXBMergeCollectionsStrategy();
    // Advanced collection merging:
    // - List merging (concatenation)
    // - Set merging (union)
}

Supporting Types

interface EnumValue<T> {
    T enumValue();
}

Usage Examples

Basic Strategic Implementation

// JAXB-generated class implementing strategic patterns
public class Customer implements Equals2, HashCode2, ToString2 {
    private String name;
    private String email;
    private boolean active;
    
    @Override
    public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, 
                         Object object, EqualsStrategy2 strategy) {
        if (!(object instanceof Customer)) {
            return false;
        }
        Customer that = (Customer) object;
        return strategy.equals(LocatorUtils.property(thisLocator, "name", this.name),
                              LocatorUtils.property(thatLocator, "name", that.name),
                              this.name, that.name, (this.name != null), (that.name != null)) &&
               strategy.equals(LocatorUtils.property(thisLocator, "email", this.email),
                              LocatorUtils.property(thatLocator, "email", that.email),
                              this.email, that.email, (this.email != null), (that.email != null)) &&
               strategy.equals(LocatorUtils.property(thisLocator, "active", this.active),
                              LocatorUtils.property(thatLocator, "active", that.active),
                              this.active, that.active, true, true);
    }
    
    @Override
    public int hashCode(ObjectLocator locator, HashCodeStrategy2 strategy) {
        int hashCode = 1;
        hashCode = strategy.hashCode(LocatorUtils.property(locator, "name", this.name),
                                    hashCode, this.name, (this.name != null));
        hashCode = strategy.hashCode(LocatorUtils.property(locator, "email", this.email),
                                    hashCode, this.email, (this.email != null));
        hashCode = strategy.hashCode(LocatorUtils.property(locator, "active", this.active),
                                    hashCode, this.active, true);
        return hashCode;
    }
    
    // Standard method implementations using JAXB strategies
    @Override
    public boolean equals(Object object) {
        return equals(new DefaultRootObjectLocator(this),
                     new DefaultRootObjectLocator(object),
                     object, JAXBEqualsStrategy.INSTANCE);
    }
    
    @Override
    public int hashCode() {
        return hashCode(new DefaultRootObjectLocator(this), JAXBHashCodeStrategy.INSTANCE);
    }
}

Custom Strategy Implementation

// Custom strategy for case-insensitive string comparison
public class CaseInsensitiveEqualsStrategy extends DefaultEqualsStrategy {
    @Override
    public boolean equals(ObjectLocator leftLocator, ObjectLocator rightLocator,
                         Object left, Object right, boolean leftSet, boolean rightSet) {
        if (!leftSet && !rightSet) return true;
        if (!leftSet || !rightSet) return false;
        
        if (left instanceof String && right instanceof String) {
            return ((String) left).equalsIgnoreCase((String) right);
        }
        return super.equals(leftLocator, rightLocator, left, right, leftSet, rightSet);
    }
}

// Usage with custom strategy
Customer customer1 = new Customer();
customer1.setName("John");

Customer customer2 = new Customer(); 
customer2.setName("JOHN");

boolean isEqual = customer1.equals(new DefaultRootObjectLocator(customer1),
                                  new DefaultRootObjectLocator(customer2),
                                  customer2, new CaseInsensitiveEqualsStrategy());
// Returns true with case-insensitive strategy