merge abstract method

Object merge(Object parent)

Merge the current value set with that of the supplied object.

This method performs an intelligent combination of the current object's state with the parent object's state. The merging strategy should be:

• Non-destructive (parent values are not modified)
• Preferential (child values typically override parent values)
• Type-aware (handles different data structures appropriately)

parent: The parent object to merge with. This should be of the same type as the current object, but implementations may handle type mismatches gracefully.

Returns a new object containing the merged state, or the current object if merging is not possible or not enabled.

Example with map merging:

class MergeableMap implements Mergeable {
  final Map<String, dynamic> data;

  MergeableMap(this.data);

  @override
  bool isMergeEnabled() => true;

  @override
  Object merge(Object parent) {
    if (parent is MergeableMap) {
      // Child values override parent values
      return MergeableMap({...parent.data, ...data});
    }
    return this;
  }
}

final parent = MergeableMap({'common': 'parent', 'parentOnly': true});
final child = MergeableMap({'common': 'child', 'childOnly': 42});
final result = child.merge(parent) as MergeableMap;
print(result.data); 
// {'common': 'child', 'parentOnly': true, 'childOnly': 42}

Example with list merging (append strategy):

class MergeableList implements Mergeable {
  final List<dynamic> items;

  MergeableList(this.items);

  @override
  bool isMergeEnabled() => true;

  @override
  Object merge(Object parent) {
    if (parent is MergeableList) {
      // Append child items to parent items
      return MergeableList([...parent.items, ...items]);
    }
    return this;
  }
}

final parent = MergeableList([1, 2, 3]);
final child = MergeableList([4, 5]);
final result = child.merge(parent) as MergeableList;
print(result.items); // [1, 2, 3, 4, 5]

Implementation

Object merge(Object parent);