DispatchResponse::Status DispatcherImpl::setBreakpointByUrl()

in lib/Debugger.Protocol/Generated/protocol/Debugger.cpp [839:892]
51 lines of code
14 McCabe index (conditional complexity)

DispatchResponse::Status DispatcherImpl::setBreakpointByUrl(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
{
    // Prepare input parameters.
    protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
    errors->push();
    protocol::Value* lineNumberValue = object ? object->get("lineNumber") : nullptr;
    errors->setName("lineNumber");
    int in_lineNumber = ValueConversions<int>::fromValue(lineNumberValue, errors);
    protocol::Value* urlValue = object ? object->get("url") : nullptr;
    Maybe<String> in_url;
    if (urlValue) {
        errors->setName("url");
        in_url = ValueConversions<String>::fromValue(urlValue, errors);
    }
    protocol::Value* urlRegexValue = object ? object->get("urlRegex") : nullptr;
    Maybe<String> in_urlRegex;
    if (urlRegexValue) {
        errors->setName("urlRegex");
        in_urlRegex = ValueConversions<String>::fromValue(urlRegexValue, errors);
    }
    protocol::Value* columnNumberValue = object ? object->get("columnNumber") : nullptr;
    Maybe<int> in_columnNumber;
    if (columnNumberValue) {
        errors->setName("columnNumber");
        in_columnNumber = ValueConversions<int>::fromValue(columnNumberValue, errors);
    }
    protocol::Value* conditionValue = object ? object->get("condition") : nullptr;
    Maybe<String> in_condition;
    if (conditionValue) {
        errors->setName("condition");
        in_condition = ValueConversions<String>::fromValue(conditionValue, errors);
    }
    errors->pop();
    if (errors->hasErrors()) {
        reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
        return DispatchResponse::kError;
    }
    // Declare output parameters.
    String out_breakpointId;
    std::unique_ptr<protocol::Array<protocol::Debugger::Location>> out_locations;

    std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    DispatchResponse response = m_backend->setBreakpointByUrl(in_lineNumber, std::move(in_url), std::move(in_urlRegex), std::move(in_columnNumber), std::move(in_condition), &out_breakpointId, &out_locations);
    if (response.status() == DispatchResponse::kFallThrough)
        return response.status();
    std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
    if (response.status() == DispatchResponse::kSuccess) {
        result->setValue("breakpointId", ValueConversions<String>::toValue(out_breakpointId));
        result->setValue("locations", ValueConversions<protocol::Array<protocol::Debugger::Location>>::toValue(out_locations.get()));
    }
    if (weak->get())
        weak->get()->sendResponse(callId, response, std::move(result));
    return response.status();
}