enhance relative id

Author: fbchen

example/relative_id.dart

@@ -31,6 +31,20 @@ class RelativeIdExample extends StatelessWidget {
             right: rId(0).right,
             top: rId(0).top,
             bottom: rId(0).top,
+          ),
+          Container(
+            color: Colors.green,
+          ).applyConstraint(
+            width: 50,
+            height: 50,
+            centerBottomRightTo: sId(-1),
+          ),
+          Container(
+            color: Colors.blue,
+          ).applyConstraint(
+            width: 50,
+            height: 50,
+            centerBottomRightTo: sId(-3),
           )
         ],
       ),

lib/src/constraint_layout.dart

@@ -682,30 +682,59 @@ class ConstraintId {
   }
 }
 
+class IndexConstraintId extends ConstraintId {
+  final int siblingIndex;
+
+  IndexConstraintId(this.siblingIndex)
+      : super('parent.children[$siblingIndex]');
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      super == other &&
+          other is IndexConstraintId &&
+          runtimeType == other.runtimeType &&
+          siblingIndex == other.siblingIndex;
+
+  @override
+  int get hashCode => super.hashCode ^ siblingIndex.hashCode;
+
+  @override
+  String toString() {
+    return 'IndexConstraintId{siblingIndex: $siblingIndex}';
+  }
+}
+
+ConstraintId rId(int childIndex) {
+  return IndexConstraintId(childIndex);
+}
+
 class RelativeConstraintId extends ConstraintId {
-  final int childIndex;
+  final int siblingIndexOffset;
 
-  RelativeConstraintId(this.childIndex) : super('child[$childIndex]');
+  RelativeConstraintId(this.siblingIndexOffset)
+      : super('sibling@$siblingIndexOffset');
 
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
       super == other &&
           other is RelativeConstraintId &&
           runtimeType == other.runtimeType &&
-          childIndex == other.childIndex;
+          siblingIndexOffset == other.siblingIndexOffset;
 
   @override
-  int get hashCode => super.hashCode ^ childIndex.hashCode;
+  int get hashCode => super.hashCode ^ siblingIndexOffset.hashCode;
 
   @override
   String toString() {
-    return 'RelativeConstraintId{childIndex: $childIndex}';
+    return 'RelativeConstraintId{siblingIndexOffset: $siblingIndexOffset}';
   }
 }
 
-ConstraintId rId(int childIndex) {
-  return RelativeConstraintId(childIndex);
+ConstraintId sId(int siblingIndexOffset) {
+  assert(siblingIndexOffset != 0);
+  return RelativeConstraintId(siblingIndexOffset);
 }
 
 class _Align {
@@ -731,7 +760,9 @@ typedef OnLayoutCallback = void Function(RenderObject renderObject, Rect rect);
 class ConstraintDefine {
   final ConstraintId? id;
 
-  ConstraintDefine(this.id);
+  ConstraintDefine(this.id)
+      : assert(id is! IndexConstraintId),
+        assert(id is! RelativeConstraintId);
 
   @override
   bool operator ==(Object other) =>
@@ -1931,11 +1962,13 @@ class _ConstraintRenderBox extends RenderBox
 
     /// The id used by all constraints must be defined
     Set<ConstraintId> illegalIdSet = constraintsIdSet.difference(idSet);
+    Set<IndexConstraintId> indexIds =
+        illegalIdSet.whereType<IndexConstraintId>().toSet();
     Set<RelativeConstraintId> relativeIds =
         illegalIdSet.whereType<RelativeConstraintId>().toSet();
-    if (relativeIds.length != illegalIdSet.length) {
+    if ((indexIds.length + relativeIds.length) != illegalIdSet.length) {
       throw ConstraintLayoutException(
-          'These ids ${illegalIdSet.difference(relativeIds)} are not yet defined.');
+          'These ids ${illegalIdSet.difference(indexIds).difference(relativeIds)} are not yet defined.');
     }
   }
 
@@ -2061,11 +2094,17 @@ class _ConstraintRenderBox extends RenderBox
     Map<ConstraintId, _ConstrainedNode> nodesMap = HashMap();
     _buildNodeTreesCount++;
 
-    _ConstrainedNode _getConstrainedNodeForChild(ConstraintId id) {
+    _ConstrainedNode _getConstrainedNodeForChild(ConstraintId id,
+        [int? childIndex]) {
       if (id == parent) {
         return _parentNode;
       }
 
+      if (id is RelativeConstraintId) {
+        int targetIndex = childIndex! + id.siblingIndexOffset;
+        id = IndexConstraintId(targetIndex);
+      }
+
       /// Fewer reads to nodesMap for faster constraint building
       _ConstrainedNode? node = id.getCacheNode(_buildNodeTreesCount ^ hashCode);
       if (node != null) {
@@ -2123,38 +2162,38 @@ class _ConstraintRenderBox extends RenderBox
       childParentData._constrainedNodeMap = nodesMap;
 
       _ConstrainedNode currentNode = _getConstrainedNodeForChild(
-          childParentData.id ?? RelativeConstraintId(childIndex));
+          childParentData.id ?? IndexConstraintId(childIndex));
       currentNode.parentData = childParentData;
       currentNode.index = childIndex;
       currentNode.renderBox = child;
 
       if (childParentData.left != null) {
         currentNode.leftConstraint =
-            _getConstrainedNodeForChild(childParentData.left!.id!);
+            _getConstrainedNodeForChild(childParentData.left!.id!, childIndex);
         currentNode.leftAlignType = childParentData.left!.type;
       }
 
       if (childParentData.top != null) {
         currentNode.topConstraint =
-            _getConstrainedNodeForChild(childParentData.top!.id!);
+            _getConstrainedNodeForChild(childParentData.top!.id!, childIndex);
         currentNode.topAlignType = childParentData.top!.type;
       }
 
       if (childParentData.right != null) {
         currentNode.rightConstraint =
-            _getConstrainedNodeForChild(childParentData.right!.id!);
+            _getConstrainedNodeForChild(childParentData.right!.id!, childIndex);
         currentNode.rightAlignType = childParentData.right!.type;
       }
 
       if (childParentData.bottom != null) {
-        currentNode.bottomConstraint =
-            _getConstrainedNodeForChild(childParentData.bottom!.id!);
+        currentNode.bottomConstraint = _getConstrainedNodeForChild(
+            childParentData.bottom!.id!, childIndex);
         currentNode.bottomAlignType = childParentData.bottom!.type;
       }
 
       if (childParentData.baseline != null) {
-        currentNode.baselineConstraint =
-            _getConstrainedNodeForChild(childParentData.baseline!.id!);
+        currentNode.baselineConstraint = _getConstrainedNodeForChild(
+            childParentData.baseline!.id!, childIndex);
         currentNode.baselineAlignType = childParentData.baseline!.type;
       }