Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
d47434c2ec
haiku/headers/private/debugger/target_host_interface/TargetHostInterface.h

130 lines
3.3 KiB
C
Raw Normal View History

Debugger: Start implementing host interface. - Add new model class TargetHost for host-specific information such as the running team list. - Add new interface class TargetHostInterface and implementing subclass LocalTargetHostInterface. Not yet complete/usable due to some as of yet unresolved issues with the involved system APIs.
2016-04-03 00:14:49 +03:00
/*
* Copyright 2016, Rene Gollent, rene@gollent.com.
* Distributed under the terms of the MIT License.
*/
#ifndef TARGET_HOST_INTERFACE_H
#define TARGET_HOST_INTERFACE_H
#include <OS.h>
Debugger: Rework to fully use TargetHostInterface. Application objects: - Rework and simplify to take into account that they will no longer be directly managing the team debugger list. Requests to start a new debugger are still funnelled through here however, and as such, said requests must now provide the appropriate target host to start with. Adjust StartTeamWindow and TeamsWindow accordingly. - On global init, always create an instance of the local interface. TargetHostInterface: - Convert to BLooper and implement TeamDebugger's Listener interface. TargetHostInterfaces now directly manage their TeamDebugger instances, and consequently take over the equivalent duties that the main application previously had. - Adjust signatures of Attach/CreateTeam to add const. Adjust LocalTargetHostInterface accordingly. - Add accessor to determine if a given interface is local or not. Will be needed for the TeamDebugger's file manager eventually so it knows if it needs to request remote files if no matching local file is found. - Add accessor to start a TeamDebugger instance, and corresponding options structure. TargetHostInterfaceRoster: - Minor adjustments to host interface initialization to take into account needing to start the looper. - Add accessor for number of running team debuggers, for the main app to use when deciding to quit. TeamDebugger: - Add accessor for SettingsManager. Needed for the case of a restart request, as the host interfaces do not have direct access to it. TeamsWindow: - For now, always grab the local host interface when initializing the window. Once the remote interface is implemented, this will need to be adjusted, but the appropriate UI for creating/selecting it is needed first anyways. With these changes, the main application is fully host-agnostic, and all management of actual debuggers is delegated to their parent host interfaces. There still needs to be a listener interface for the host interface and/or roster though, so that the application can be made aware of when debuggers quit, as this drives whether it's time to terminate the app or not.
2016-04-21 02:23:01 +03:00
#include <Looper.h>
Debugger: Start implementing host interface. - Add new model class TargetHost for host-specific information such as the running team list. - Add new interface class TargetHostInterface and implementing subclass LocalTargetHostInterface. Not yet complete/usable due to some as of yet unresolved issues with the involved system APIs.
2016-04-03 00:14:49 +03:00
Debugger: Further additions to TargetHostInterface. TargetHostInterface: - Provide interface for tracking list of TeamDebuggers attached to this particular interface instance. Will eventually replace the current mechanism where the Debugger app tracks this directly. LocalTargetHostInterface: - Cleanups.
2016-04-07 03:55:50 +03:00
#include <ObjectList.h>
Debugger: Rework to fully use TargetHostInterface. Application objects: - Rework and simplify to take into account that they will no longer be directly managing the team debugger list. Requests to start a new debugger are still funnelled through here however, and as such, said requests must now provide the appropriate target host to start with. Adjust StartTeamWindow and TeamsWindow accordingly. - On global init, always create an instance of the local interface. TargetHostInterface: - Convert to BLooper and implement TeamDebugger's Listener interface. TargetHostInterfaces now directly manage their TeamDebugger instances, and consequently take over the equivalent duties that the main application previously had. - Adjust signatures of Attach/CreateTeam to add const. Adjust LocalTargetHostInterface accordingly. - Add accessor to determine if a given interface is local or not. Will be needed for the TeamDebugger's file manager eventually so it knows if it needs to request remote files if no matching local file is found. - Add accessor to start a TeamDebugger instance, and corresponding options structure. TargetHostInterfaceRoster: - Minor adjustments to host interface initialization to take into account needing to start the looper. - Add accessor for number of running team debuggers, for the main app to use when deciding to quit. TeamDebugger: - Add accessor for SettingsManager. Needed for the case of a restart request, as the host interfaces do not have direct access to it. TeamsWindow: - For now, always grab the local host interface when initializing the window. Once the remote interface is implemented, this will need to be adjusted, but the appropriate UI for creating/selecting it is needed first anyways. With these changes, the main application is fully host-agnostic, and all management of actual debuggers is delegated to their parent host interfaces. There still needs to be a listener interface for the host interface and/or roster though, so that the application can be made aware of when debuggers quit, as this drives whether it's time to terminate the app or not.
2016-04-21 02:23:01 +03:00
Debugger: Add listener interface for TargetHostInterface.
2016-04-21 02:58:51 +03:00
#include <util/DoublyLinkedList.h>
Debugger: Split into core library and application. - Add subfolder src/kits/debugger which contains the debugger's core functionality and lower layers. Correspondingly add headers/private/debugger for shared headers to be used by clients such as the Debugger application and eventual remote_debug_server. Adjust various files to account for differences as a result of the split and moves. - Add libdebugger.so to minimal Jamfile.
2016-05-29 20:52:47 +03:00
#include "controllers/TeamDebugger.h"
Debugger: Start implementing host interface. - Add new model class TargetHost for host-specific information such as the running team list. - Add new interface class TargetHostInterface and implementing subclass LocalTargetHostInterface. Not yet complete/usable due to some as of yet unresolved issues with the involved system APIs.
2016-04-03 00:14:49 +03:00
class DebuggerInterface;
Debugger: Add initial version of TargetHostInterfaceRoster. TargetHostInterfaceRoster: - Provides a singleton interface to enumerate both the available interface types, and all currently running instances. This will provide clients like the TeamsWindow with a way to present the user with all available types, as well as the necessary information to configure/instantiate them. TargetHostInterfaceInfo: - Provides an information object for each available type of interface, including an optional description of the settings needed to configure it. Callers can then use this to provide a configuration UI as needed, and once complete, request a corresponding interface instance for the desired configuration. {Local}TargetHostInterface: - Add Settings parameter to Init(). Adjust LocalTargetHostInterface accordingly. LocalTargetHostInterfaceInfo: - Implementation of TargetHostInterfaceInfo for the local system case.
2016-04-07 03:58:01 +03:00
class Settings;
Debugger: Rework to fully use TargetHostInterface. Application objects: - Rework and simplify to take into account that they will no longer be directly managing the team debugger list. Requests to start a new debugger are still funnelled through here however, and as such, said requests must now provide the appropriate target host to start with. Adjust StartTeamWindow and TeamsWindow accordingly. - On global init, always create an instance of the local interface. TargetHostInterface: - Convert to BLooper and implement TeamDebugger's Listener interface. TargetHostInterfaces now directly manage their TeamDebugger instances, and consequently take over the equivalent duties that the main application previously had. - Adjust signatures of Attach/CreateTeam to add const. Adjust LocalTargetHostInterface accordingly. - Add accessor to determine if a given interface is local or not. Will be needed for the TeamDebugger's file manager eventually so it knows if it needs to request remote files if no matching local file is found. - Add accessor to start a TeamDebugger instance, and corresponding options structure. TargetHostInterfaceRoster: - Minor adjustments to host interface initialization to take into account needing to start the looper. - Add accessor for number of running team debuggers, for the main app to use when deciding to quit. TeamDebugger: - Add accessor for SettingsManager. Needed for the case of a restart request, as the host interfaces do not have direct access to it. TeamsWindow: - For now, always grab the local host interface when initializing the window. Once the remote interface is implemented, this will need to be adjusted, but the appropriate UI for creating/selecting it is needed first anyways. With these changes, the main application is fully host-agnostic, and all management of actual debuggers is delegated to their parent host interfaces. There still needs to be a listener interface for the host interface and/or roster though, so that the application can be made aware of when debuggers quit, as this drives whether it's time to terminate the app or not.
2016-04-21 02:23:01 +03:00
class SettingsManager;
Debugger: Start implementing host interface. - Add new model class TargetHost for host-specific information such as the running team list. - Add new interface class TargetHostInterface and implementing subclass LocalTargetHostInterface. Not yet complete/usable due to some as of yet unresolved issues with the involved system APIs.
2016-04-03 00:14:49 +03:00
class TargetHost;
Debugger: Rework to fully use TargetHostInterface. Application objects: - Rework and simplify to take into account that they will no longer be directly managing the team debugger list. Requests to start a new debugger are still funnelled through here however, and as such, said requests must now provide the appropriate target host to start with. Adjust StartTeamWindow and TeamsWindow accordingly. - On global init, always create an instance of the local interface. TargetHostInterface: - Convert to BLooper and implement TeamDebugger's Listener interface. TargetHostInterfaces now directly manage their TeamDebugger instances, and consequently take over the equivalent duties that the main application previously had. - Adjust signatures of Attach/CreateTeam to add const. Adjust LocalTargetHostInterface accordingly. - Add accessor to determine if a given interface is local or not. Will be needed for the TeamDebugger's file manager eventually so it knows if it needs to request remote files if no matching local file is found. - Add accessor to start a TeamDebugger instance, and corresponding options structure. TargetHostInterfaceRoster: - Minor adjustments to host interface initialization to take into account needing to start the looper. - Add accessor for number of running team debuggers, for the main app to use when deciding to quit. TeamDebugger: - Add accessor for SettingsManager. Needed for the case of a restart request, as the host interfaces do not have direct access to it. TeamsWindow: - For now, always grab the local host interface when initializing the window. Once the remote interface is implemented, this will need to be adjusted, but the appropriate UI for creating/selecting it is needed first anyways. With these changes, the main application is fully host-agnostic, and all management of actual debuggers is delegated to their parent host interfaces. There still needs to be a listener interface for the host interface and/or roster though, so that the application can be made aware of when debuggers quit, as this drives whether it's time to terminate the app or not.
2016-04-21 02:23:01 +03:00
struct TeamDebuggerOptions;
class UserInterface;
Debugger: Start implementing host interface. - Add new model class TargetHost for host-specific information such as the running team list. - Add new interface class TargetHostInterface and implementing subclass LocalTargetHostInterface. Not yet complete/usable due to some as of yet unresolved issues with the involved system APIs.
2016-04-03 00:14:49 +03:00
Debugger: Rework to fully use TargetHostInterface. Application objects: - Rework and simplify to take into account that they will no longer be directly managing the team debugger list. Requests to start a new debugger are still funnelled through here however, and as such, said requests must now provide the appropriate target host to start with. Adjust StartTeamWindow and TeamsWindow accordingly. - On global init, always create an instance of the local interface. TargetHostInterface: - Convert to BLooper and implement TeamDebugger's Listener interface. TargetHostInterfaces now directly manage their TeamDebugger instances, and consequently take over the equivalent duties that the main application previously had. - Adjust signatures of Attach/CreateTeam to add const. Adjust LocalTargetHostInterface accordingly. - Add accessor to determine if a given interface is local or not. Will be needed for the TeamDebugger's file manager eventually so it knows if it needs to request remote files if no matching local file is found. - Add accessor to start a TeamDebugger instance, and corresponding options structure. TargetHostInterfaceRoster: - Minor adjustments to host interface initialization to take into account needing to start the looper. - Add accessor for number of running team debuggers, for the main app to use when deciding to quit. TeamDebugger: - Add accessor for SettingsManager. Needed for the case of a restart request, as the host interfaces do not have direct access to it. TeamsWindow: - For now, always grab the local host interface when initializing the window. Once the remote interface is implemented, this will need to be adjusted, but the appropriate UI for creating/selecting it is needed first anyways. With these changes, the main application is fully host-agnostic, and all management of actual debuggers is delegated to their parent host interfaces. There still needs to be a listener interface for the host interface and/or roster though, so that the application can be made aware of when debuggers quit, as this drives whether it's time to terminate the app or not.
2016-04-21 02:23:01 +03:00
class TargetHostInterface : public BLooper, private TeamDebugger::Listener {
Debugger: Start implementing host interface. - Add new model class TargetHost for host-specific information such as the running team list. - Add new interface class TargetHostInterface and implementing subclass LocalTargetHostInterface. Not yet complete/usable due to some as of yet unresolved issues with the involved system APIs.
2016-04-03 00:14:49 +03:00
public:
Debugger: Add listener interface for TargetHostInterface.
2016-04-21 02:58:51 +03:00
class Listener;
Debugger: Further additions to TargetHostInterface. TargetHostInterface: - Provide interface for tracking list of TeamDebuggers attached to this particular interface instance. Will eventually replace the current mechanism where the Debugger app tracks this directly. LocalTargetHostInterface: - Cleanups.
2016-04-07 03:55:50 +03:00
TargetHostInterface();
Debugger: Start implementing host interface. - Add new model class TargetHost for host-specific information such as the running team list. - Add new interface class TargetHostInterface and implementing subclass LocalTargetHostInterface. Not yet complete/usable due to some as of yet unresolved issues with the involved system APIs.
2016-04-03 00:14:49 +03:00
virtual ~TargetHostInterface();
Debugger: Rework to fully use TargetHostInterface. Application objects: - Rework and simplify to take into account that they will no longer be directly managing the team debugger list. Requests to start a new debugger are still funnelled through here however, and as such, said requests must now provide the appropriate target host to start with. Adjust StartTeamWindow and TeamsWindow accordingly. - On global init, always create an instance of the local interface. TargetHostInterface: - Convert to BLooper and implement TeamDebugger's Listener interface. TargetHostInterfaces now directly manage their TeamDebugger instances, and consequently take over the equivalent duties that the main application previously had. - Adjust signatures of Attach/CreateTeam to add const. Adjust LocalTargetHostInterface accordingly. - Add accessor to determine if a given interface is local or not. Will be needed for the TeamDebugger's file manager eventually so it knows if it needs to request remote files if no matching local file is found. - Add accessor to start a TeamDebugger instance, and corresponding options structure. TargetHostInterfaceRoster: - Minor adjustments to host interface initialization to take into account needing to start the looper. - Add accessor for number of running team debuggers, for the main app to use when deciding to quit. TeamDebugger: - Add accessor for SettingsManager. Needed for the case of a restart request, as the host interfaces do not have direct access to it. TeamsWindow: - For now, always grab the local host interface when initializing the window. Once the remote interface is implemented, this will need to be adjusted, but the appropriate UI for creating/selecting it is needed first anyways. With these changes, the main application is fully host-agnostic, and all management of actual debuggers is delegated to their parent host interfaces. There still needs to be a listener interface for the host interface and/or roster though, so that the application can be made aware of when debuggers quit, as this drives whether it's time to terminate the app or not.
2016-04-21 02:23:01 +03:00
status_t StartTeamDebugger(const TeamDebuggerOptions& options);
Debugger: Further additions to TargetHostInterface. TargetHostInterface: - Provide interface for tracking list of TeamDebuggers attached to this particular interface instance. Will eventually replace the current mechanism where the Debugger app tracks this directly. LocalTargetHostInterface: - Cleanups.
2016-04-07 03:55:50 +03:00
int32 CountTeamDebuggers() const;
TeamDebugger* TeamDebuggerAt(int32 index) const;
TeamDebugger* FindTeamDebugger(team_id team) const;
status_t AddTeamDebugger(TeamDebugger* debugger);
void RemoveTeamDebugger(TeamDebugger* debugger);
Debugger: Add initial version of TargetHostInterfaceRoster. TargetHostInterfaceRoster: - Provides a singleton interface to enumerate both the available interface types, and all currently running instances. This will provide clients like the TeamsWindow with a way to present the user with all available types, as well as the necessary information to configure/instantiate them. TargetHostInterfaceInfo: - Provides an information object for each available type of interface, including an optional description of the settings needed to configure it. Callers can then use this to provide a configuration UI as needed, and once complete, request a corresponding interface instance for the desired configuration. {Local}TargetHostInterface: - Add Settings parameter to Init(). Adjust LocalTargetHostInterface accordingly. LocalTargetHostInterfaceInfo: - Implementation of TargetHostInterfaceInfo for the local system case.
2016-04-07 03:58:01 +03:00
virtual status_t Init(Settings* settings) = 0;
Debugger: Further additions to TargetHostInterface. TargetHostInterface: - Provide interface for tracking list of TeamDebuggers attached to this particular interface instance. Will eventually replace the current mechanism where the Debugger app tracks this directly. LocalTargetHostInterface: - Cleanups.
2016-04-07 03:55:50 +03:00
virtual void Close() = 0;
Debugger: Rework to fully use TargetHostInterface. Application objects: - Rework and simplify to take into account that they will no longer be directly managing the team debugger list. Requests to start a new debugger are still funnelled through here however, and as such, said requests must now provide the appropriate target host to start with. Adjust StartTeamWindow and TeamsWindow accordingly. - On global init, always create an instance of the local interface. TargetHostInterface: - Convert to BLooper and implement TeamDebugger's Listener interface. TargetHostInterfaces now directly manage their TeamDebugger instances, and consequently take over the equivalent duties that the main application previously had. - Adjust signatures of Attach/CreateTeam to add const. Adjust LocalTargetHostInterface accordingly. - Add accessor to determine if a given interface is local or not. Will be needed for the TeamDebugger's file manager eventually so it knows if it needs to request remote files if no matching local file is found. - Add accessor to start a TeamDebugger instance, and corresponding options structure. TargetHostInterfaceRoster: - Minor adjustments to host interface initialization to take into account needing to start the looper. - Add accessor for number of running team debuggers, for the main app to use when deciding to quit. TeamDebugger: - Add accessor for SettingsManager. Needed for the case of a restart request, as the host interfaces do not have direct access to it. TeamsWindow: - For now, always grab the local host interface when initializing the window. Once the remote interface is implemented, this will need to be adjusted, but the appropriate UI for creating/selecting it is needed first anyways. With these changes, the main application is fully host-agnostic, and all management of actual debuggers is delegated to their parent host interfaces. There still needs to be a listener interface for the host interface and/or roster though, so that the application can be made aware of when debuggers quit, as this drives whether it's time to terminate the app or not.
2016-04-21 02:23:01 +03:00
virtual bool IsLocal() const = 0;
Debugger: Start implementing host interface. - Add new model class TargetHost for host-specific information such as the running team list. - Add new interface class TargetHostInterface and implementing subclass LocalTargetHostInterface. Not yet complete/usable due to some as of yet unresolved issues with the involved system APIs.
2016-04-03 00:14:49 +03:00
virtual bool Connected() const = 0;
virtual TargetHost* GetTargetHost() = 0;
virtual status_t Attach(team_id id, thread_id threadID,
Debugger: Rework to fully use TargetHostInterface. Application objects: - Rework and simplify to take into account that they will no longer be directly managing the team debugger list. Requests to start a new debugger are still funnelled through here however, and as such, said requests must now provide the appropriate target host to start with. Adjust StartTeamWindow and TeamsWindow accordingly. - On global init, always create an instance of the local interface. TargetHostInterface: - Convert to BLooper and implement TeamDebugger's Listener interface. TargetHostInterfaces now directly manage their TeamDebugger instances, and consequently take over the equivalent duties that the main application previously had. - Adjust signatures of Attach/CreateTeam to add const. Adjust LocalTargetHostInterface accordingly. - Add accessor to determine if a given interface is local or not. Will be needed for the TeamDebugger's file manager eventually so it knows if it needs to request remote files if no matching local file is found. - Add accessor to start a TeamDebugger instance, and corresponding options structure. TargetHostInterfaceRoster: - Minor adjustments to host interface initialization to take into account needing to start the looper. - Add accessor for number of running team debuggers, for the main app to use when deciding to quit. TeamDebugger: - Add accessor for SettingsManager. Needed for the case of a restart request, as the host interfaces do not have direct access to it. TeamsWindow: - For now, always grab the local host interface when initializing the window. Once the remote interface is implemented, this will need to be adjusted, but the appropriate UI for creating/selecting it is needed first anyways. With these changes, the main application is fully host-agnostic, and all management of actual debuggers is delegated to their parent host interfaces. There still needs to be a listener interface for the host interface and/or roster though, so that the application can be made aware of when debuggers quit, as this drives whether it's time to terminate the app or not.
2016-04-21 02:23:01 +03:00
DebuggerInterface*& _interface) const = 0;
Debugger: Start implementing host interface. - Add new model class TargetHost for host-specific information such as the running team list. - Add new interface class TargetHostInterface and implementing subclass LocalTargetHostInterface. Not yet complete/usable due to some as of yet unresolved issues with the involved system APIs.
2016-04-03 00:14:49 +03:00
virtual status_t CreateTeam(int commandLineArgc,
const char* const* arguments,
Debugger: Rework to fully use TargetHostInterface. Application objects: - Rework and simplify to take into account that they will no longer be directly managing the team debugger list. Requests to start a new debugger are still funnelled through here however, and as such, said requests must now provide the appropriate target host to start with. Adjust StartTeamWindow and TeamsWindow accordingly. - On global init, always create an instance of the local interface. TargetHostInterface: - Convert to BLooper and implement TeamDebugger's Listener interface. TargetHostInterfaces now directly manage their TeamDebugger instances, and consequently take over the equivalent duties that the main application previously had. - Adjust signatures of Attach/CreateTeam to add const. Adjust LocalTargetHostInterface accordingly. - Add accessor to determine if a given interface is local or not. Will be needed for the TeamDebugger's file manager eventually so it knows if it needs to request remote files if no matching local file is found. - Add accessor to start a TeamDebugger instance, and corresponding options structure. TargetHostInterfaceRoster: - Minor adjustments to host interface initialization to take into account needing to start the looper. - Add accessor for number of running team debuggers, for the main app to use when deciding to quit. TeamDebugger: - Add accessor for SettingsManager. Needed for the case of a restart request, as the host interfaces do not have direct access to it. TeamsWindow: - For now, always grab the local host interface when initializing the window. Once the remote interface is implemented, this will need to be adjusted, but the appropriate UI for creating/selecting it is needed first anyways. With these changes, the main application is fully host-agnostic, and all management of actual debuggers is delegated to their parent host interfaces. There still needs to be a listener interface for the host interface and/or roster though, so that the application can be made aware of when debuggers quit, as this drives whether it's time to terminate the app or not.
2016-04-21 02:23:01 +03:00
team_id& _teamID) const = 0;
Debugger: Integrate core handling into TargetHostInterface. {Local}TargetHostInterface: - Add virtual method for requesting a debugger interface for a core file. Implement accordingly in LocalTargetHostInterface based on Ingo's previous implementation in the Debugger app. TeamDebuggerOptions: - Add an enum to define the type of team debugger request being made to explicitly make this clear rather than guessing based on the provided arguments. Set accordingly in the various cases. - Add a parameter for the core file path. Debugger: - Refactor to fill in TeamDebuggerOptions appropriately for core file requests, and consequently simplify code. This doesn't yet deal with the fact that a post-mortem team's ID can clash with that of a live team, which may lead to issues when attempting to attach to a live team in such a case.
2016-04-25 03:26:36 +03:00
virtual status_t LoadCore(const char* coreFilePath,
DebuggerInterface*& _interface,
thread_id& _thread) const = 0;
Debugger: Rework to fully use TargetHostInterface. Application objects: - Rework and simplify to take into account that they will no longer be directly managing the team debugger list. Requests to start a new debugger are still funnelled through here however, and as such, said requests must now provide the appropriate target host to start with. Adjust StartTeamWindow and TeamsWindow accordingly. - On global init, always create an instance of the local interface. TargetHostInterface: - Convert to BLooper and implement TeamDebugger's Listener interface. TargetHostInterfaces now directly manage their TeamDebugger instances, and consequently take over the equivalent duties that the main application previously had. - Adjust signatures of Attach/CreateTeam to add const. Adjust LocalTargetHostInterface accordingly. - Add accessor to determine if a given interface is local or not. Will be needed for the TeamDebugger's file manager eventually so it knows if it needs to request remote files if no matching local file is found. - Add accessor to start a TeamDebugger instance, and corresponding options structure. TargetHostInterfaceRoster: - Minor adjustments to host interface initialization to take into account needing to start the looper. - Add accessor for number of running team debuggers, for the main app to use when deciding to quit. TeamDebugger: - Add accessor for SettingsManager. Needed for the case of a restart request, as the host interfaces do not have direct access to it. TeamsWindow: - For now, always grab the local host interface when initializing the window. Once the remote interface is implemented, this will need to be adjusted, but the appropriate UI for creating/selecting it is needed first anyways. With these changes, the main application is fully host-agnostic, and all management of actual debuggers is delegated to their parent host interfaces. There still needs to be a listener interface for the host interface and/or roster though, so that the application can be made aware of when debuggers quit, as this drives whether it's time to terminate the app or not.
2016-04-21 02:23:01 +03:00
virtual status_t FindTeamByThread(thread_id thread,
team_id& _teamID) const = 0;
Debugger: Add listener interface for TargetHostInterface.
2016-04-21 02:58:51 +03:00
void AddListener(Listener* listener);
void RemoveListener(Listener* listener);
Debugger: Rework to fully use TargetHostInterface. Application objects: - Rework and simplify to take into account that they will no longer be directly managing the team debugger list. Requests to start a new debugger are still funnelled through here however, and as such, said requests must now provide the appropriate target host to start with. Adjust StartTeamWindow and TeamsWindow accordingly. - On global init, always create an instance of the local interface. TargetHostInterface: - Convert to BLooper and implement TeamDebugger's Listener interface. TargetHostInterfaces now directly manage their TeamDebugger instances, and consequently take over the equivalent duties that the main application previously had. - Adjust signatures of Attach/CreateTeam to add const. Adjust LocalTargetHostInterface accordingly. - Add accessor to determine if a given interface is local or not. Will be needed for the TeamDebugger's file manager eventually so it knows if it needs to request remote files if no matching local file is found. - Add accessor to start a TeamDebugger instance, and corresponding options structure. TargetHostInterfaceRoster: - Minor adjustments to host interface initialization to take into account needing to start the looper. - Add accessor for number of running team debuggers, for the main app to use when deciding to quit. TeamDebugger: - Add accessor for SettingsManager. Needed for the case of a restart request, as the host interfaces do not have direct access to it. TeamsWindow: - For now, always grab the local host interface when initializing the window. Once the remote interface is implemented, this will need to be adjusted, but the appropriate UI for creating/selecting it is needed first anyways. With these changes, the main application is fully host-agnostic, and all management of actual debuggers is delegated to their parent host interfaces. There still needs to be a listener interface for the host interface and/or roster though, so that the application can be made aware of when debuggers quit, as this drives whether it's time to terminate the app or not.
2016-04-21 02:23:01 +03:00
// BLooper
virtual void Quit();
virtual void MessageReceived(BMessage* message);
private:
// TeamDebugger::Listener
virtual void TeamDebuggerStarted(TeamDebugger* debugger);
virtual void TeamDebuggerRestartRequested(
TeamDebugger* debugger);
virtual void TeamDebuggerQuit(TeamDebugger* debugger);
Debugger: Start implementing host interface. - Add new model class TargetHost for host-specific information such as the running team list. - Add new interface class TargetHostInterface and implementing subclass LocalTargetHostInterface. Not yet complete/usable due to some as of yet unresolved issues with the involved system APIs.
2016-04-03 00:14:49 +03:00
Debugger: Further additions to TargetHostInterface. TargetHostInterface: - Provide interface for tracking list of TeamDebuggers attached to this particular interface instance. Will eventually replace the current mechanism where the Debugger app tracks this directly. LocalTargetHostInterface: - Cleanups.
2016-04-07 03:55:50 +03:00
private:
Debugger: Rework to fully use TargetHostInterface. Application objects: - Rework and simplify to take into account that they will no longer be directly managing the team debugger list. Requests to start a new debugger are still funnelled through here however, and as such, said requests must now provide the appropriate target host to start with. Adjust StartTeamWindow and TeamsWindow accordingly. - On global init, always create an instance of the local interface. TargetHostInterface: - Convert to BLooper and implement TeamDebugger's Listener interface. TargetHostInterfaces now directly manage their TeamDebugger instances, and consequently take over the equivalent duties that the main application previously had. - Adjust signatures of Attach/CreateTeam to add const. Adjust LocalTargetHostInterface accordingly. - Add accessor to determine if a given interface is local or not. Will be needed for the TeamDebugger's file manager eventually so it knows if it needs to request remote files if no matching local file is found. - Add accessor to start a TeamDebugger instance, and corresponding options structure. TargetHostInterfaceRoster: - Minor adjustments to host interface initialization to take into account needing to start the looper. - Add accessor for number of running team debuggers, for the main app to use when deciding to quit. TeamDebugger: - Add accessor for SettingsManager. Needed for the case of a restart request, as the host interfaces do not have direct access to it. TeamsWindow: - For now, always grab the local host interface when initializing the window. Once the remote interface is implemented, this will need to be adjusted, but the appropriate UI for creating/selecting it is needed first anyways. With these changes, the main application is fully host-agnostic, and all management of actual debuggers is delegated to their parent host interfaces. There still needs to be a listener interface for the host interface and/or roster though, so that the application can be made aware of when debuggers quit, as this drives whether it's time to terminate the app or not.
2016-04-21 02:23:01 +03:00
status_t _StartTeamDebugger(team_id teamID,
const TeamDebuggerOptions& options,
bool stopInMain);
Debugger: Add listener interface for TargetHostInterface.
2016-04-21 02:58:51 +03:00
void _NotifyTeamDebuggerStarted(
TeamDebugger* debugger);
void _NotifyTeamDebuggerQuit(
TeamDebugger* debugger);
Debugger: Further additions to TargetHostInterface. TargetHostInterface: - Provide interface for tracking list of TeamDebuggers attached to this particular interface instance. Will eventually replace the current mechanism where the Debugger app tracks this directly. LocalTargetHostInterface: - Cleanups.
2016-04-07 03:55:50 +03:00
static int _CompareDebuggers(const TeamDebugger* a,
const TeamDebugger* b);
private:
Debugger: Add listener interface for TargetHostInterface.
2016-04-21 02:58:51 +03:00
typedef DoublyLinkedList<Listener> ListenerList;
Debugger: Further additions to TargetHostInterface. TargetHostInterface: - Provide interface for tracking list of TeamDebuggers attached to this particular interface instance. Will eventually replace the current mechanism where the Debugger app tracks this directly. LocalTargetHostInterface: - Cleanups.
2016-04-07 03:55:50 +03:00
typedef BObjectList<TeamDebugger> TeamDebuggerList;
Debugger: Start implementing host interface. - Add new model class TargetHost for host-specific information such as the running team list. - Add new interface class TargetHostInterface and implementing subclass LocalTargetHostInterface. Not yet complete/usable due to some as of yet unresolved issues with the involved system APIs.
2016-04-03 00:14:49 +03:00
private:
Debugger: Add listener interface for TargetHostInterface.
2016-04-21 02:58:51 +03:00
ListenerList fListeners;
Debugger: Further additions to TargetHostInterface. TargetHostInterface: - Provide interface for tracking list of TeamDebuggers attached to this particular interface instance. Will eventually replace the current mechanism where the Debugger app tracks this directly. LocalTargetHostInterface: - Cleanups.
2016-04-07 03:55:50 +03:00
TeamDebuggerList fTeamDebuggers;
Debugger: Start implementing host interface. - Add new model class TargetHost for host-specific information such as the running team list. - Add new interface class TargetHostInterface and implementing subclass LocalTargetHostInterface. Not yet complete/usable due to some as of yet unresolved issues with the involved system APIs.
2016-04-03 00:14:49 +03:00
};
Debugger: Add listener interface for TargetHostInterface.
2016-04-21 02:58:51 +03:00
class TargetHostInterface::Listener
: public DoublyLinkedListLinkImpl<Listener> {
public:
virtual ~Listener();
virtual void TeamDebuggerStarted(TeamDebugger* debugger);
virtual void TeamDebuggerQuit(TeamDebugger* debugger);
virtual void TargetHostInterfaceQuit(
TargetHostInterface* interface);
};
Debugger: Integrate core handling into TargetHostInterface. {Local}TargetHostInterface: - Add virtual method for requesting a debugger interface for a core file. Implement accordingly in LocalTargetHostInterface based on Ingo's previous implementation in the Debugger app. TeamDebuggerOptions: - Add an enum to define the type of team debugger request being made to explicitly make this clear rather than guessing based on the provided arguments. Set accordingly in the various cases. - Add a parameter for the core file path. Debugger: - Refactor to fill in TeamDebuggerOptions appropriately for core file requests, and consequently simplify code. This doesn't yet deal with the fact that a post-mortem team's ID can clash with that of a live team, which may lead to issues when attempting to attach to a live team in such a case.
2016-04-25 03:26:36 +03:00
enum {
TEAM_DEBUGGER_REQUEST_UNKNOWN = 0,
TEAM_DEBUGGER_REQUEST_CREATE,
TEAM_DEBUGGER_REQUEST_ATTACH,
TEAM_DEBUGGER_REQUEST_LOAD_CORE
};
Debugger: Rework to fully use TargetHostInterface. Application objects: - Rework and simplify to take into account that they will no longer be directly managing the team debugger list. Requests to start a new debugger are still funnelled through here however, and as such, said requests must now provide the appropriate target host to start with. Adjust StartTeamWindow and TeamsWindow accordingly. - On global init, always create an instance of the local interface. TargetHostInterface: - Convert to BLooper and implement TeamDebugger's Listener interface. TargetHostInterfaces now directly manage their TeamDebugger instances, and consequently take over the equivalent duties that the main application previously had. - Adjust signatures of Attach/CreateTeam to add const. Adjust LocalTargetHostInterface accordingly. - Add accessor to determine if a given interface is local or not. Will be needed for the TeamDebugger's file manager eventually so it knows if it needs to request remote files if no matching local file is found. - Add accessor to start a TeamDebugger instance, and corresponding options structure. TargetHostInterfaceRoster: - Minor adjustments to host interface initialization to take into account needing to start the looper. - Add accessor for number of running team debuggers, for the main app to use when deciding to quit. TeamDebugger: - Add accessor for SettingsManager. Needed for the case of a restart request, as the host interfaces do not have direct access to it. TeamsWindow: - For now, always grab the local host interface when initializing the window. Once the remote interface is implemented, this will need to be adjusted, but the appropriate UI for creating/selecting it is needed first anyways. With these changes, the main application is fully host-agnostic, and all management of actual debuggers is delegated to their parent host interfaces. There still needs to be a listener interface for the host interface and/or roster though, so that the application can be made aware of when debuggers quit, as this drives whether it's time to terminate the app or not.
2016-04-21 02:23:01 +03:00
struct TeamDebuggerOptions {
TeamDebuggerOptions();
Debugger: Integrate core handling into TargetHostInterface. {Local}TargetHostInterface: - Add virtual method for requesting a debugger interface for a core file. Implement accordingly in LocalTargetHostInterface based on Ingo's previous implementation in the Debugger app. TeamDebuggerOptions: - Add an enum to define the type of team debugger request being made to explicitly make this clear rather than guessing based on the provided arguments. Set accordingly in the various cases. - Add a parameter for the core file path. Debugger: - Refactor to fill in TeamDebuggerOptions appropriately for core file requests, and consequently simplify code. This doesn't yet deal with the fact that a post-mortem team's ID can clash with that of a live team, which may lead to issues when attempting to attach to a live team in such a case.
2016-04-25 03:26:36 +03:00
int requestType;
Debugger: Rework to fully use TargetHostInterface. Application objects: - Rework and simplify to take into account that they will no longer be directly managing the team debugger list. Requests to start a new debugger are still funnelled through here however, and as such, said requests must now provide the appropriate target host to start with. Adjust StartTeamWindow and TeamsWindow accordingly. - On global init, always create an instance of the local interface. TargetHostInterface: - Convert to BLooper and implement TeamDebugger's Listener interface. TargetHostInterfaces now directly manage their TeamDebugger instances, and consequently take over the equivalent duties that the main application previously had. - Adjust signatures of Attach/CreateTeam to add const. Adjust LocalTargetHostInterface accordingly. - Add accessor to determine if a given interface is local or not. Will be needed for the TeamDebugger's file manager eventually so it knows if it needs to request remote files if no matching local file is found. - Add accessor to start a TeamDebugger instance, and corresponding options structure. TargetHostInterfaceRoster: - Minor adjustments to host interface initialization to take into account needing to start the looper. - Add accessor for number of running team debuggers, for the main app to use when deciding to quit. TeamDebugger: - Add accessor for SettingsManager. Needed for the case of a restart request, as the host interfaces do not have direct access to it. TeamsWindow: - For now, always grab the local host interface when initializing the window. Once the remote interface is implemented, this will need to be adjusted, but the appropriate UI for creating/selecting it is needed first anyways. With these changes, the main application is fully host-agnostic, and all management of actual debuggers is delegated to their parent host interfaces. There still needs to be a listener interface for the host interface and/or roster though, so that the application can be made aware of when debuggers quit, as this drives whether it's time to terminate the app or not.
2016-04-21 02:23:01 +03:00
int commandLineArgc;
const char* const* commandLineArgv;
team_id team;
thread_id thread;
SettingsManager* settingsManager;
UserInterface* userInterface;
Debugger: Integrate core handling into TargetHostInterface. {Local}TargetHostInterface: - Add virtual method for requesting a debugger interface for a core file. Implement accordingly in LocalTargetHostInterface based on Ingo's previous implementation in the Debugger app. TeamDebuggerOptions: - Add an enum to define the type of team debugger request being made to explicitly make this clear rather than guessing based on the provided arguments. Set accordingly in the various cases. - Add a parameter for the core file path. Debugger: - Refactor to fill in TeamDebuggerOptions appropriately for core file requests, and consequently simplify code. This doesn't yet deal with the fact that a post-mortem team's ID can clash with that of a live team, which may lead to issues when attempting to attach to a live team in such a case.
2016-04-25 03:26:36 +03:00
const char* coreFilePath;
Debugger: Rework to fully use TargetHostInterface. Application objects: - Rework and simplify to take into account that they will no longer be directly managing the team debugger list. Requests to start a new debugger are still funnelled through here however, and as such, said requests must now provide the appropriate target host to start with. Adjust StartTeamWindow and TeamsWindow accordingly. - On global init, always create an instance of the local interface. TargetHostInterface: - Convert to BLooper and implement TeamDebugger's Listener interface. TargetHostInterfaces now directly manage their TeamDebugger instances, and consequently take over the equivalent duties that the main application previously had. - Adjust signatures of Attach/CreateTeam to add const. Adjust LocalTargetHostInterface accordingly. - Add accessor to determine if a given interface is local or not. Will be needed for the TeamDebugger's file manager eventually so it knows if it needs to request remote files if no matching local file is found. - Add accessor to start a TeamDebugger instance, and corresponding options structure. TargetHostInterfaceRoster: - Minor adjustments to host interface initialization to take into account needing to start the looper. - Add accessor for number of running team debuggers, for the main app to use when deciding to quit. TeamDebugger: - Add accessor for SettingsManager. Needed for the case of a restart request, as the host interfaces do not have direct access to it. TeamsWindow: - For now, always grab the local host interface when initializing the window. Once the remote interface is implemented, this will need to be adjusted, but the appropriate UI for creating/selecting it is needed first anyways. With these changes, the main application is fully host-agnostic, and all management of actual debuggers is delegated to their parent host interfaces. There still needs to be a listener interface for the host interface and/or roster though, so that the application can be made aware of when debuggers quit, as this drives whether it's time to terminate the app or not.
2016-04-21 02:23:01 +03:00
};
Debugger: Start implementing host interface. - Add new model class TargetHost for host-specific information such as the running team list. - Add new interface class TargetHostInterface and implementing subclass LocalTargetHostInterface. Not yet complete/usable due to some as of yet unresolved issues with the involved system APIs.
2016-04-03 00:14:49 +03:00
#endif // TARGET_HOST_INTERFACE_H
Reference in New Issue Copy Permalink