AttachRequest custom parameters about cppdap

[ben-clayton]

Hi @rapgenic,

Thank you for your interest in cppdap.
There was no easy way to do this (without duplicating the field reflection of the base class into the derived class). #33 however gives you the ability to do this.

Once this lands you can use typeinfo_test.cpp as a reference for usage.

Many thanks,
Ben

[ben-clayton]

Now landed.

[rapgenic]

@ben-clayton Thank you for your quick answer and implementation!

I tried and I am actually able to subclass the AttachRequest type, however I do not understand how to register the handler: I tried using my custom type in the callback but it does not compile.

I tried to dynamic_cast the AttachRequest to my custom type, but that did not work either.

Could you give me a simple example for making it work? Thank you very much, again

[ben-clayton]

If you want to just add some custom fields to the request (not the response) you'd declare your extended AttachRequest request message type as:

namespace dap {

class AttachRequestEx : public AttachRequest {
 public:
  dap::number some_custom_data;
};

DAP_STRUCT_TYPEINFO_EXT(AttachRequestEx,
                        AttachRequest,
                        "attach", // This is the wire protocol name for the AttachRequest
                        DAP_FIELD(some_custom_data, "some_custom_data")); // Repeat these for each of your custom fields

}  // namespace dap

You can then set up a handler for this extended message type with:

void bindAttachRequestExHandler(std::unique_ptr<dap::Session> session) {
  session->registerHandler([](const dap::AttachRequestEx& request) {
    dap::AttachResponse response;
    return response;
  });
}

If you want to send a AttachRequestEx you can with:

void sendAttachRequestEx(std::unique_ptr<dap::Session> session) {
  dap::AttachRequestEx request; // Assign to the custom fields.
  session->send(request);
}

If you also want a custom derived response type:

namespace dap {

class AttachResponseEx : public AttachResponse {
 public:
  dap::number some_custom_data;
};

DAP_STRUCT_TYPEINFO_EXT(AttachResponseEx,
                        AttachResponse,
                        "",
                        DAP_FIELD(some_custom_data, "some_custom_data"));

class AttachRequestEx : public AttachRequest {
 public:
  using Response = AttachResponseEx; // This is the magic that binds the AttachRequestEx to the AttachResponseEx
  dap::number some_custom_data;
};

DAP_STRUCT_TYPEINFO_EXT(AttachRequestEx,
                        AttachRequest,
                        "attach", // This is the wire protocol name for the AttachRequest
                        DAP_FIELD(some_custom_data, "some_custom_data"));

}  // namespace dap

void bindAttachRequestExHandler(std::unique_ptr<dap::Session> session) {
  session->registerHandler([](const dap::AttachRequestEx&) {
    dap::AttachResponseEx response; // Note the Ex suffix
    return response;
  });
}

void sendAttachRequestEx(std::unique_ptr<dap::Session> session) {
  dap::AttachRequestEx request; // This is the same...
  session->send(request); // but the return type is a dap::AttachResponseEx
}

If you're still having difficulties, please share with me your code snippet and compiler error.

Many thanks,
Ben

---

Edit: Fixed the wire protocol name which should have been "attach". See:

cppdap/src/protocol_requests.cpp

Lines 24 to 26 in cc93ba9

	DAP_IMPLEMENT_STRUCT_TYPEINFO(AttachRequest,
	"attach",
	DAP_FIELD(restart, "__restart"));

[rapgenic]

I think I have managed to do it.

The error was mine, the source was not compiling because I did not return a response.

Thank you very much for your help, I think the issue can be closed now!
Giulio

[ben-clayton]

Great to hear.
Shout if you have any other questions or issues!

[kuafuwang]

This is my way . Name another AttachRequest type.

namespace dap {
	// The attach request is sent from the client to the debug adapter to attach to
	// a debuggee that is already running. Since attaching is debugger/runtime
	// specific, the arguments for this request are not part of this specification.
	struct JavaDebugAttachRequest : public Request {
		using Response = AttachResponse;

		JavaDebugAttachRequest() = default;
		~JavaDebugAttachRequest() = default;

		// Optional data from the previous, restarted session.
		// The data is sent as the 'restart' attribute of the 'terminated' event.
		// The client should leave the data intact.
	   // optional<variant<array<any>, boolean, integer, null, number, object, string>>
		//    restart;
		string type;
		string name;
		string request;
		optional<string> projectName;
		array<string> sourcePaths;

		string hostName;
		integer port;
		integer timeout;
	};

	DAP_DECLARE_STRUCT_TYPEINFO(JavaDebugAttachRequest);

	DAP_IMPLEMENT_STRUCT_TYPEINFO(JavaDebugAttachRequest,
		"attach",
		DAP_FIELD(type, "type"),
		DAP_FIELD(name, "name"),
		DAP_FIELD(request, "request"),
		DAP_FIELD(projectName, "projectName"),
		DAP_FIELD(sourcePaths, "sourcePaths"),
		DAP_FIELD(hostName, "hostName"),
		DAP_FIELD(port, "port"),
		DAP_FIELD(timeout, "timeout"));
}

[ben-clayton]

@kuafuwang - your solution works, but the DAP_STRUCT_TYPEINFO_EXT solution is more future proof - if the DAP specification later adds additional fields to the AttachRequest, these will automatically be included in your derived type. You could of course just embed those new fields directly into your JavaDebugAttachRequest, but this a tedious and manual process that you'd need to do every time you update cppdap that's rolled to the new spec.

Also - DAP_STRUCT_TYPEINFO is a helper that performs both the DAP_DECLARE_STRUCT_TYPEINFO and DAP_IMPLEMENT_STRUCT_TYPEINFO macros into one:

cppdap/include/dap/typeof.h

Lines 212 to 217 in cc93ba9

	// DAP_STRUCT_TYPEINFO() is a helper for declaring and implementing a TypeOf<>
	// specialization for STRUCT in a single statement.
	// Must be used within the 'dap' namespace.
	#define DAP_STRUCT_TYPEINFO(STRUCT, NAME, ...) \
	DAP_DECLARE_STRUCT_TYPEINFO(STRUCT); \
	DAP_IMPLEMENT_STRUCT_TYPEINFO(STRUCT, NAME, __VA_ARGS__)