Nebula
Loading...
Searching...
No Matches
Public Member Functions | Private Member Functions | List of all members
Debug::DebugInterface Class Reference

#include <debuginterface.h>

Detailed Description

Interface object of the Debug subsystem.

This just creates a DebugHandler which runs the DebugServer in its own thread.

Copyright
(C) 2008 Radon Labs GmbH (C) 2013-2020 Individual contributors, see AUTHORS file

Inherits Interface::InterfaceBase.

Public Member Functions

 DebugInterface ()
 constructor
 
virtual ~DebugInterface ()
 destructor
 
virtual void Open ()
 open the interface object
 
- Public Member Functions inherited from Interface::InterfaceBase
 InterfaceBase ()
 constructor
 
virtual ~InterfaceBase ()
 destructor
 
virtual void AttachHandler (const Ptr< Messaging::Handler > &h)
 attach a handler to the port (call before open!)
 
virtual void Close ()
 close the async port
 
const Util::StringAtom & GetCompanyName () const
 get the company name
 
const Util::StringAtom & GetAppName () const
 get the application name
 
const Util::StringAtom & GetRootDirectory () const
 get the root directory
 
- Public Member Functions inherited from Messaging::AsyncPort
 AsyncPort ()
 constructor
 
virtual ~AsyncPort ()
 destructor
 
void SetHandlerThread (const Ptr< HandlerThreadBase > &handlerThread)
 set pointer to handler thread object (must be derived from HandlerThreadBase)
 
const Ptr< HandlerThreadBase > & GetHandlerThread () const
 get pointer to handler thread object
 
virtual void RemoveHandler (const Ptr< Handler > &h)
 dynamically remove a handler from the port
 
bool IsOpen () const
 return true if port is open
 
template<class MESSAGETYPE >
void Send (const Ptr< MESSAGETYPE > &msg)
 send an asynchronous message to the port
 
template<class MESSAGETYPE >
void SendWait (const Ptr< MESSAGETYPE > &msg)
 send a message and wait for completion
 
template<class MESSAGETYPE >
void Wait (const Ptr< MESSAGETYPE > &msg)
 wait for a message to be handled
 
template<class MESSAGETYPE >
bool Peek (const Ptr< MESSAGETYPE > &msg)
 peek a message whether it has been handled
 
template<class MESSAGETYPE >
void Cancel (const Ptr< MESSAGETYPE > &msg)
 cancel a pending message
 
- Public Member Functions inherited from Core::RefCounted
 RefCounted ()
 constructor
 
int GetRefCount () const
 get the current refcount
 
void AddRef ()
 increment refcount by one
 
void Release ()
 decrement refcount and destroy object if refcount is zero
 
bool IsInstanceOf (const Rtti &rtti) const
 return true if this object is instance of given class
 
bool IsInstanceOf (const Util::String &className) const
 return true if this object is instance of given class by string
 
bool IsInstanceOf (const Util::FourCC &classFourCC) const
 return true if this object is instance of given class by fourcc
 
bool IsA (const Rtti &rtti) const
 return true if this object is instance of given class, or a derived class
 
bool IsA (const Util::String &rttiName) const
 return true if this object is instance of given class, or a derived class, by string
 
bool IsA (const Util::FourCC &rttiFourCC) const
 return true if this object is instance of given class, or a derived class, by fourcc
 
const Util::String & GetClassName () const
 get the class name
 
Util::FourCC GetClassFourCC () const
 get the class FourCC code
 

Private Member Functions

 __DeclareClass (DebugInterface)
 
 __DeclareInterfaceSingleton (DebugInterface)
 

Additional Inherited Members

- Static Public Member Functions inherited from Core::RefCounted
static void DumpRefCountingLeaks ()
 dump refcounting leaks, call at end of application (NEBULA_DEBUG builds only!)
 
- Protected Member Functions inherited from Core::RefCounted
virtual ~RefCounted ()
 destructor (called when refcount reaches zero)
 

Constructor & Destructor Documentation

◆ DebugInterface()

Debug::DebugInterface::DebugInterface ( )

constructor

◆ ~DebugInterface()

Debug::DebugInterface::~DebugInterface ( )
virtual

destructor

Member Function Documentation

◆ __DeclareClass()

Debug::DebugInterface::__DeclareClass ( DebugInterface )
private

◆ __DeclareInterfaceSingleton()

Debug::DebugInterface::__DeclareInterfaceSingleton ( DebugInterface )
private

◆ Open()

void Debug::DebugInterface::Open ( )
virtual

open the interface object

Reimplemented from Interface::InterfaceBase.

The documentation for this class was generated from the following files: