combineList<D extends Sortable> static method

CombinedList<D>? combineList<D extends Sortable>({ required List<D> list1, required List<D> list2, Sort order = Sort.ASCENDING, int? limit, })

Implementation

static CombinedList<D>? combineList<D extends Sortable>({required List<D> list1, required List<D> list2, Sort order = Sort.ASCENDING, int? limit}){
  if(order == Sort.ASCENDING){
    //Ascending order
    final comparator = (Sortable item1, Sortable item2){
      return item1.sortWeight().compareTo(item2.sortWeight());
    };

    if(list1.isNotNullAndEmpty() && list2.isNotNullAndEmpty()) {
      D list1First = list1.first;
      D list1Last = list1.last;

      D list2First = list2.first;
      D list2Last = list2.last;

      if(list1First.sortWeight() <= list2First.sortWeight() && list1Last.sortWeight() >= list2Last.sortWeight()){
        //List 2 is sitting in between list 1
        final combined = <D>[];
        combined.addAll(list1);
        combined.addAll(list2);
        combined.sort(comparator);
        return CombinedList<D>(combinedList: combined, merged: true, cursor: list1Last);
      }
      else if(list2First.sortWeight() <= list1First.sortWeight() && list2Last.sortWeight() >= list1Last.sortWeight()){
        //List 1 is sitting in between list 2
        final combined = <D>[];
        combined.addAll(list1);
        combined.addAll(list2);
        combined.sort(comparator);
        return CombinedList<D>(combinedList: combined, merged: true, cursor: list2Last);
      }
      else if(list1First.sortWeight() <= list2First.sortWeight() && list1Last.sortWeight() <= list2Last.sortWeight()) {
        //List 1 and list 2 are running simultaneously with list 1 running first and list 2 ending last
        final combined = <D>[];
        if (limit != null && list1.length >= limit) {
          //There's probably more data for list 1
          combined.addAll(list1);
          for (D d in list2) {
            if (d.sortWeight() <= list1Last.sortWeight()) {
              combined.add(d);
            }
          }
          combined.sort(comparator);
          return CombinedList<D>(combinedList: combined, merged: true, cursor: list1Last);
        }
        else {
          //List 1 has been queried all
          combined.addAll(list1);
          combined.addAll(list2);
          combined.sort(comparator);
          return CombinedList<D>(combinedList: combined, merged: true, cursor: list1Last.sortWeight() >= list2Last.sortWeight() ? list1Last : list2Last);
        }
      }
      else if(list2First.sortWeight() <= list1First.sortWeight() && list2Last.sortWeight() <= list1Last.sortWeight()){
        //List 1 and list 2 are running simultaneously with list 2 running first and list 1 ending last
        final combined = <D>[];
        if(limit != null && list2.length >= limit){
          //There's probably more data for list 2
          combined.addAll(list2);
          for(D d in list1){
            if(d.sortWeight() <= list2Last.sortWeight()){
             combined.add(d);
            }
          }
          combined.sort(comparator);
          return CombinedList<D>(combinedList: combined, cursor: list2Last, merged: true);
        }
        else{
          //List 2 has been queried all
          combined.addAll(list1);
          combined.addAll(list2);
          combined.sort(comparator);
          return CombinedList<D>(combinedList: combined, cursor: list2Last.sortWeight() >= list1Last.sortWeight() ? list2Last : list1Last);
        }
      }
    }
    else if(list1.isNullOrEmpty() && list2.isNotNullAndEmpty()){
      return CombinedList<D>(combinedList: list2, merged: false, cursor: list2.last);
    }
    else if(list2.isNullOrEmpty() && list1.isNotNullAndEmpty()){
      return CombinedList<D>(combinedList: list1, merged: false, cursor: list1.last);
    }
    else{
      //Both list are empty
      return CombinedList<D>(combinedList: [], merged: false, cursor: null);
    }
  }
  else{
    //Descending order
    final comparator = (Sortable item1, Sortable item2){
      return item2.sortWeight().compareTo(item1.sortWeight());
    };

    if(list1.isNotNullAndEmpty() && list2.isNotNullAndEmpty()) {
      final list1Earliest = list1.last;
      final list1Latest = list1.first;

      final list2Earliest = list2.last;
      final list2Latest = list2.first;

      if(list1Earliest.sortWeight() <= list2Earliest.sortWeight() && list1Latest.sortWeight() >= list2Latest.sortWeight()){
        log("Sorting -> list 2 is between list 1");
        //List 2 is sitting in between list 1
        final combined = <D>[];
        combined.addAll(list1);
        combined.addAll(list2);
        combined.sort(comparator);
        return CombinedList<D>(combinedList: combined, merged: true, cursor: list1Earliest);
      }
      else if(list2Earliest.sortWeight() <= list1Earliest.sortWeight() && list2Latest.sortWeight() >= list1Latest.sortWeight()){
        log("Sorting -> list 1 is between list 2");
        //List 1 is sitting in between list 2
        final combined = <D>[];
        combined.addAll(list1);
        combined.addAll(list2);
        combined.sort(comparator);
        return CombinedList<D>(combinedList: combined, merged: true, cursor: list2Earliest);
      }
      else if(list1Earliest.sortWeight() <= list2Earliest.sortWeight() && list1Latest.sortWeight() <= list2Latest.sortWeight()){
        log("Sorting -> List 1 and list 2 are running simultaneously with list 2 running first and list 1 ending last");
        //List 1 and list 2 are running simultaneously with list 2 running first and list 1 ending last
        final combined = <D>[];
        if(limit != null && list2.length >= limit){
          log("Sorting -> List 2 has more data going on");
          //There's probably more data for list 2
          combined.addAll(list2);
          for(D d in list1){
            if(d.sortWeight() >= list2Earliest.sortWeight()){
             combined.add(d);
            }
          }
          combined.sort(comparator);
          return CombinedList<D>(combinedList: combined, merged: true, cursor: list2Earliest);
        }
        else{
          log("Sorting -> List 2 has no more data at count of : ${list2.length}");
          //List 2 has been queried all
          combined.addAll(list1);
          combined.addAll(list2);
          combined.sort(comparator);
          return CombinedList<D>(combinedList: combined, merged: true, cursor: list1Earliest.sortWeight() <= list2Earliest.sortWeight() ? list1Earliest : list2Earliest);
        }
      }
      else if(list2Earliest.sortWeight() <= list1Earliest.sortWeight() && list2Latest.sortWeight() <= list1Latest.sortWeight()){
        log("Sorting -> List 1 and list 2 are running simultaneously with list 1 running first and list 2 ending last");
        //List 1 and list 2 are running simultaneously with list 1 running first and list 2 ending last
        final combined = <D>[];
        if(limit != null && list1.length >= limit){
          log("Sorting -> List 1 has more data going on");
          //There's probably more data for list 1
          combined.addAll(list1);
          for(D d in list2){
            if(d.sortWeight() >= list1Earliest.sortWeight()){
             combined.add(d);
            }
          }
          combined.sort(comparator);
          return CombinedList<D>(combinedList: combined, merged: true, cursor: list1Earliest);
        }
        else{
          log("Sorting -> List 1 has no more data at count of : ${list1.length}");
          //List 1 has been queried all
          combined.addAll(list1);
          combined.addAll(list2);
          combined.sort(comparator);
          return CombinedList<D>(combinedList: combined, merged: true, cursor: list1Earliest.sortWeight() <= list2Earliest.sortWeight() ? list1Earliest : list2Earliest);
        }
      }
    }
    else if(list1.isNullOrEmpty() && list2.isNotNullAndEmpty()){
      log("Sorting -> List 1 has no more data but list 2 has");
      return CombinedList<D>(combinedList: list2, merged: false, cursor: list2.last);
    }
    else if(list2.isNullOrEmpty() && list1.isNotNullAndEmpty()){
      log("Sorting -> List 2 has no more data but list 1 has");
      return CombinedList<D>(combinedList: list1, merged: false, cursor: list1.last);
    }
    else{
      log("Sorting -> Both list are empty");
      //Both list are empty
      return CombinedList<D>(combinedList: [], merged: false, cursor: null);
    }
  }
  return null;
}