std::unique_ptr TypeConstraint::from_json()

in source/model-generator/TypeConstraints.cpp [289:347]

• 58 lines of code
• 16 McCabe index (conditional complexity)

std::unique_ptr<TypeConstraint> TypeConstraint::from_json(
    const Json::Value& constraint) {
  JsonValidation::validate_object(constraint);

  std::string constraint_name =
      JsonValidation::string(constraint, "constraint");
  if (constraint_name == "name") {
    return std::make_unique<TypeNameConstraint>(
        JsonValidation::string(constraint, "pattern"));
  } else if (constraint_name == "extends") {
    bool includes_self = constraint.isMember("include_self")
        ? JsonValidation::boolean(constraint, /* field */ "include_self")
        : true;
    return std::make_unique<ExtendsConstraint>(
        TypeConstraint::from_json(
            JsonValidation::object(constraint, /* field */ "inner")),
        includes_self);
  } else if (constraint_name == "super") {
    return std::make_unique<SuperConstraint>(TypeConstraint::from_json(
        JsonValidation::object(constraint, /* field */ "inner")));
  } else if (constraint_name == "not") {
    return std::make_unique<NotTypeConstraint>(TypeConstraint::from_json(
        JsonValidation::object(constraint, /* field */ "inner")));
  } else if (constraint_name == "any_of" || constraint_name == "all_of") {
    std::vector<std::unique_ptr<TypeConstraint>> constraints;
    for (const auto& inner :
         JsonValidation::null_or_array(constraint, /* field */ "inners")) {
      constraints.push_back(TypeConstraint::from_json(inner));
    }
    if (constraint_name == "any_of") {
      return std::make_unique<AnyOfTypeConstraint>(std::move(constraints));
    } else {
      return std::make_unique<AllOfTypeConstraint>(std::move(constraints));
    }
  } else if (constraint_name == "has_annotation") {
    return std::make_unique<HasAnnotationTypeConstraint>(
        JsonValidation::string(constraint, "type"),
        constraint.isMember("pattern")
            ? std::optional<std::string>{JsonValidation::string(
                  constraint, "pattern")}
            : std::nullopt);
  } else if (
      constraint_name == "is_class" || constraint_name == "is_interface") {
    bool expected = constraint.isMember("value")
        ? JsonValidation::boolean(constraint, /* field */ "value")
        : true;
    if (constraint_name == "is_class") {
      return std::make_unique<IsClassTypeConstraint>(expected);
    } else {
      return std::make_unique<IsInterfaceTypeConstraint>(expected);
    }
  } else {
    throw JsonValidationError(
        constraint,
        /* field */ "constraint",
        /* expected */ "valid constraint type");
    return nullptr;
  }
}