getBestConstructorsFor method

List<ConstructorReflection<O>> getBestConstructorsFor({ Iterable<String> requiredParameters = const <String>[], Iterable<String> optionalParameters = const <String>[], Iterable<String> nullableParameters = const <String>[], Iterable<String> presentParameters = const <String>[], bool allowEmptyConstructors = true, bool allowOptionalOnlyConstructors = true, bool jsonName = false, })

Returns a List of the best ConstructorReflection for requiredParameters, optionalParameters, nullableParameters and presentParameters.

Implementation

List<ConstructorReflection<O>> getBestConstructorsFor({
  Iterable<String> requiredParameters = const <String>[],
  Iterable<String> optionalParameters = const <String>[],
  Iterable<String> nullableParameters = const <String>[],
  Iterable<String> presentParameters = const <String>[],
  bool allowEmptyConstructors = true,
  bool allowOptionalOnlyConstructors = true,
  bool jsonName = false,
}) {
  if (nullableParameters is! List && nullableParameters is! Set) {
    nullableParameters = nullableParameters.toList(growable: false);
  }

  var constructors = allConstructors().toList();
  if (constructors.isEmpty) return <ConstructorReflection<O>>[];

  if (!allowEmptyConstructors) {
    var emptyConstructors = constructors
        .where((c) => c.parametersLength == 0)
        .toList();

    if (emptyConstructors.isNotEmpty) {
      constructors = constructors
          .where((c) => !emptyConstructors.contains(c))
          .toList();
    }

    if (constructors.isEmpty) return <ConstructorReflection<O>>[];
  }

  if (!allowOptionalOnlyConstructors) {
    var optionalOnlyConstructors = constructors
        .where(
          (c) =>
              (c.normalParameters.isEmpty &&
              c.optionalParameters.none((c) => c.required) &&
              c.namedParameters.values.none((c) => c.required)),
        )
        .toList();

    if (optionalOnlyConstructors.isNotEmpty) {
      constructors = constructors
          .where((c) => !optionalOnlyConstructors.contains(c))
          .toList();
    }

    if (constructors.isEmpty) return <ConstructorReflection<O>>[];
  }

  var presentParametersResolved = presentParameters.toSet();

  String paramNameResolver(ParameterReflection p, String name) {
    var f = field(p.name);
    var alias = f?.jsonFieldAliasAnnotations.alias;
    return alias ?? name;
  }

  var paramNameResolverJson = jsonName ? paramNameResolver : null;

  var invalidConstructors = constructors.where((c) {
    var paramsRequired = c
        .parametersNamesWhere(
          (p) => p.required && !p.nullable,
          jsonName: jsonName,
          nameResolver: paramNameResolverJson,
        )
        .toList();
    return _elementsInCount(
          presentParameters,
          paramsRequired,
          _nameNormalizer,
        ) <
        paramsRequired.length;
  }).toList();

  if (invalidConstructors.isNotEmpty) {
    constructors = constructors
        .where((c) => !invalidConstructors.contains(c))
        .toList();

    if (constructors.isEmpty) return <ConstructorReflection<O>>[];
  }

  if (requiredParameters.isNotEmpty) {
    var constructorsWithRequired = constructors.where((c) {
      var paramsAll = c
          .parametersNamesWhere(
            (p) => true,
            jsonName: jsonName,
            nameResolver: paramNameResolverJson,
          )
          .toList();
      return _elementsInCount<String>(
            requiredParameters,
            paramsAll,
            _nameNormalizer,
          ) ==
          requiredParameters.length;
    }).toList();

    constructors = constructorsWithRequired;
    if (constructors.isEmpty) return <ConstructorReflection<O>>[];

    presentParametersResolved.addAll(requiredParameters);
  }

  if (nullableParameters.isNotEmpty) {
    var constructorsWithNullables = constructors.where((c) {
      var paramsNullable = c
          .parametersNamesWhere(
            (p) => p.nullable || !p.required,
            jsonName: jsonName,
            nameResolver: paramNameResolverJson,
          )
          .toList();
      return _elementsInCount(
            nullableParameters,
            paramsNullable,
            _nameNormalizer,
          ) ==
          nullableParameters.length;
    }).toList();

    constructors = constructorsWithNullables;
    if (constructors.isEmpty) return <ConstructorReflection<O>>[];

    presentParametersResolved.addAll(nullableParameters);
  }

  presentParametersResolved.addAll(optionalParameters);

  constructors = constructors.where((c) {
    var paramsRequired = c
        .parametersNamesWhere(
          (p) => p.required,
          jsonName: jsonName,
          nameResolver: paramNameResolverJson,
        )
        .toList();
    return _elementsInCount<String>(
          presentParametersResolved,
          paramsRequired,
          _nameNormalizer,
        ) ==
        paramsRequired.length;
  }).toList();

  if (constructors.length <= 1) {
    return constructors;
  }

  var constructorsInfo = Map.fromEntries(
    constructors.map((c) {
      var requiredCount = c
          .getParametersByNames(requiredParameters, jsonName: jsonName)
          .length;
      var optionalCount = c
          .getParametersByNames(optionalParameters, jsonName: jsonName)
          .length;
      return MapEntry(c, [requiredCount, optionalCount]);
    }),
  );

  constructors.sort((c1, c2) {
    var i1 = constructorsInfo[c1]!;
    var i2 = constructorsInfo[c2]!;

    var req1 = i1[0];
    var req2 = i2[0];

    var cmp = req2.compareTo(req1);
    if (cmp == 0) {
      var opt1 = i1[1];
      var opt2 = i2[1];
      cmp = opt2.compareTo(opt1);
    }
    return cmp;
  });

  return constructors;
}