if (error)
  CDPMessage("Error in %s\n", name.c_str());

bool MyKeyboardHandler(char ch)
{
  switch (ch)
  {
    case 'h':
    {
      CDPMessage("Keys supported my MyLib:\n");
      CDPMessage(" b: Print an info message.\n");
      // Special case for 'h': return false to allow all handlers to print help
      return false;
    }
    case 'b':
    {
      CDPMessage("'b' pressed!\n");
      // Normally, return true to indicate theat the key has been handled
      return true;
    }
  }
  return false;
}

Application::AddKeyboardHandler( MyKeyboardHandler );

Member Function Documentation

Application::Application(int argc = 0, char **argv = 0)

Default constructs an instance of Application.

[override virtual] Application::~Application()

Destroys the instance of Application. The destructor is virtual.

[static] void Application::AddKeyboardHandler(KeyboardHandlerFunction myKeyboardHandler)

Registers a function that will be called when a key is pressed on the keyboard. The keyboard handler returns true to indicate that no further processing of the keyboard event should occur, or false to allow other keyboard-handlers to handle the event. The handler registered last is called first, allowing override of the default behaviour.

[virtual] void Application::AddOneShotWorkerFunction(const char *pzProcessName, const std::function<void() > &function)

[virtual] void Application::AddOneShotWorkerProcess(const char *pzProcessName, CDPComponent *pComp, CDPCOMPONENT_STATEPROCESS pProc)

Adds a component function to be executed once at low priority in worker thread.

The following function adds a (possibly lengthy) process function to be executed to the Application Worker thread execution fifo queue. The function must exit after some time to allow other worker-threads to run. The function takes as input a name and a (CDPCOMPONENT_PROCESS) type (i.e. a void MyComponent::ProcessFunction(void) ) function. The Process function may change the priority of the workerprocess, but it will be reset to the initial low priority after it exits. Exceptions are caught and printed through CDPMessage.

bool Application::CDPClockSyncEnabled()

Returns true if CDP ClockSync is enabled (property m_strClockSync has value "CDPClockSync").

void Application::CDPTimeChangedHandler(double secondsChanged, const std::string &oldDateTime, const std::string &newDateTime)

Will generate an extended event if secondsChanged is larger than 1s. This function has been registered into CDPTime::AddGlobalTimeChangedHandler(), and is called if CDPTime has changed, typically by clocksynch.

void Application::CancelBeforeStopRun(unsigned int callbackId)

Unregister a callback to run before application stop sequence will be started, that was registered via RunBeforeStop() and using the callbackId that was returned by it on register.

[virtual] void Application::Configure()

Configures Application. CDP System components are configured first. Then all other components are created and configured.

[virtual] void Application::Create()

Creates Application component and CDP system components

[override virtual protected] void Application::CreateModel()

Reimplemented from CDPBaseObject::CreateModel().

Creates the Application model.

[virtual] void Application::CreateXMLConfigurationDirectory(std::string &src, const std::string &shortName)

Figures out where the subcomponent configuration is, and updates src.

[static] void Application::DeferredNodeDelete(CDP::StudioAPI::CDPNode *property)

[override virtual] void Application::Destroy()

Reimplemented from CDPBaseObject::Destroy().

Suspends and destroys the application and all subcomponents.

[static] void Application::EnableKeyboardHandling(bool bEnable)

Set if keyboard handling is enabled or not.

[override virtual] void Application::FillNodeChildren(CDP::StudioAPI::NodeStream &stream) const

Reimplemented from CDPNode::FillNodeChildren().

Fills the nodestream with information. Calls baseclass implementation.

[static] std::string Application::GetArgumentValue(const std::string &argument)

Returns the corresponding value for argument (e.g. my-argument my_value)

char **Application::GetArguments() const

Returns argument pointer this application was invoked with

int Application::GetArgumentsCount() const

Returns number of arguments this application was invoked with

[static] Application *Application::GetInstance()

Returns the only Application instance

double Application::GetMemUsedRelative()

Returns memory used by the system, relative to available memory. Relative memory used will be returned in range [0.0 .. 1.0].

[override virtual] unsigned int Application::GetNodeID() const

Reimplemented from ICDPNode::GetNodeID().

Returns the application handle

[override virtual] CDP::StudioAPI::CDPNodeType Application::GetNodeType() const

Reimplemented from ICDPNode::GetNodeType().

Returns CDPNode type

[static] bool Application::GetNotRootEnabled()

Returns true if executing CDP as non root is enabled.

[override virtual] std::string Application::GetProperty(std::string propertyName)

Reimplemented from CDPBaseObject::GetProperty().

Returns the property value for a named property. May return a base property if propertyName is not found in this instance. Supports "GlobalTime"

[static] std::set<std::string> Application::GetRemoteFullNameByHandle(unsigned int objectHandle)

Returns a set of connection-names (remote fullnames), if found in CDPConnection's connectionsByHandle. Usually, only one connection is found for one handle, but if there are several connections having CDPNodes at the end of the remote names, after the same CDPComponent/CDPObject, there will be several connections for one handle. E.g.if there are two connections named 'App.CDPComponent.CDPNode1' and 'App.CDPComponent.CDPNode2', both will have same handle. Both these names will be returned by this function.

See also GetRemoteFullNameByHandleParentCDPObject().

[static] std::string Application::GetRemoteFullNameByHandleParentCDPObject(unsigned int objectHandle)

Returns remote fullname to nearest CDPObject identified by name of the connection, if connected and found in CDPConnection connectionsByHandle.

If e.g. the name of the connection is 'App.CDPComponent.CDPObject', this function will return 'App.CDPComponent.CDPObject'.

If e.g. the name of the connection is 'App.CDPComponent', this function will return 'App.CDPComponent'.

If e.g. there are several connections for same handle, like 'App.CDPComponent.CDPObject.CDPNode1.CDPNode2'and 'App.CDPComponent.CDPObject.CDPNode1.CDPNode3', this function will return 'App.CDPComponent.CDPObject'.

See also GetRemoteFullNameByHandle().

uint64_t Application::GetStartupTimestamp() const

Returns the startup time of the application in nanoseconds from epoch.

[override virtual] XMLElementEx *Application::GetXMLElement()

Reimplemented from CDPObject::GetXMLElement().

Get the XMLElement pointing to <Application>

void Application::HandleKeyboard()

Checks keyboard input and calls all registered keyboard handlers.

[static] bool Application::HasArgument(const std::string &argument)

Returns true if argument is found in the application argument list.

bool Application::IsActivationFromUnhandledExceptionAllowed() const

Returns true if re-activation from Suspend state caused by earlier unhandled exception is allowed (i.e. "OnException" attribute is set to "Suspend").

This member function is thread-safe to be called from any context.

bool Application::IsConfigurationSaveBlocked()

Returns true if DelayConfigurationSave is set and time spent delaying save is less than MaxConfigurationSaveDelay. If not it returns false. If DelayConfigurationSave is set and time spent delaying save is equal or more than MaxConfigurationSaveDelay, the DelayConfigurationSaveAborted alarm is set.

bool Application::IsReadyForOperation()

[override virtual] bool Application::IsReadyToActivate()

bool Application::IsStarted(void)

Returns true when Application::Configure() is finished, meaning all components are configured and ready to start.

bool Application::IsTerminateOnException() const

Returns true if the application is configured to terminate on unhandled exception (i.e. "OnException" attribute is set to "Terminate").

This member function is thread-safe to be called from any context.

[virtual] bool Application::IsTimeServer()

Returns true if this Application shall act as a Time server for CDPClockSync. Only relevant if clocksynch is "CDPClockSync".

bool Application::IsUnhandledExceptionDetected() const

Returns true if any of the CDP application components has thrown an unhandled exception or crashed (and it was caught by the crash handler).

This member function is thread-safe to be called from any context.

void Application::ListComponentThreads()

Prints all thread id's in this application space to CDPMessages console.

void Application::ListObjectStates()

Prints all object states in this application space to CDPMessages console.

void Application::ListObjects(CDPObject *pObject, int level)

Prints all objects in this application space to CDPMessages console.

[virtual protected] int Application::MessageSendKeyToKeyboard(void *message)

Messagehandler that forwards specified key/char to Keyboard handler. message must be a MessageTextCommandWithParameterSend-pointer. Character found in MessageTextCommandWithParameterSend's parameters[0] will be used as argument when calling ReceiveKey().

[virtual protected] int Application::MessageSetDiskAlarmAndText(void *message)

Messagehandler for the alarm "Disk Alarm". message must be a MessageDiskAlarmText-pointer. The alarm will be Set with updated alarm-text.

bool Application::OSTimeClockSyncEnabled()

Returns true if OS Time ClockSync is enabled (property m_strClockSync has value "OS_Time").

[virtual] unsigned int Application::OStimeInterval()

Returns value of Interval (in s) of reading OS time. Only relevant if clocksynch is "OS_Time".

[static] void Application::PrintCommandLineArgumentList()

Prints supported command line arguments

[virtual protected] void Application::ProcessBootup()

[virtual protected] void Application::ProcessNull()

[virtual protected] void Application::ProcessPreOperational()

[virtual protected] void Application::ProcessRunning()

Runs periodic state process. Updates CDPConnections, handles clock sync and updates CPU info etc.

void Application::RealSuspend()

Stops the application by suspending all components and stopping cdp infrastructure

void Application::ReceiveKey(char key)

Inserts key into keyboard input buffer.

[override virtual protected] int Application::ReceiveMessage(void *message)

Reimplemented from CDPBaseObject::ReceiveMessage().

Processes application messages. Will call CDPComponent::ReceiveMessage() if not handled here.

void Application::RunAfterStart(const std::function<void() > &callback)

Register a callback to run after application is fully started (i.e. all components and objects are fully activated).

Note, that the callbacks are run in main (startup) thread of the application, but as worker threads are then already launched callback needs to take care of the thread safety - for example by locking member access mutex or by postponing the actual work using RunInComponentThread() method.

void Application::RunBeforeStart(const std::function<void() > &callback)

Register a callback to run after all components of the application are configured, just before the application Start().

Note, that although the callbacks will be run in main (startup) thread of the application, the worker threads of all components are already created and running (in a idle Start-waiting mode) by this time - so when this callback needs to immediately modify components data then component member access mutex must be locked first.

Note, that new RunBeforeStart() callbacks can be registered inside the callback - these are then run after all other callbacks are finished.

unsigned int Application::RunBeforeStop(const std::function<void() > &callback)

Register a callback to run before application stop sequence will be started (i.e. before application starts to suspend its components and objects). Stop sequence is usually initiated either when application receives CM_STOP message or when application (graceful) exit signal is received from operating system.

Returns a unique callbackId that can later be used to cancel the callback from being called.

Note, that the callbacks are run in main (startup) thread of the application, but as worker threads are still running the callback needs to take care of the thread safety - for example by locking member access mutex or by postponing the actual work using RunInComponentThread() method.

[static] void Application::RunInMainThread(std::function<void() > command, double delayInSeconds = 0.0)

Executes a callback command in the thread were `int main()` is defined.

Usually this is the only thread were functions are allowed to access GUI components. If optional parameter delayInSeconds is set, the command is run after specified delay.

Application::RunInMainThread([=] () { m_label.setText("New text"); }, 0.5);

[static] bool Application::Running()

Returns true after Start is called and before RealSuspend is executed

void Application::SetClockSyncType(const std::string &newClockSyncType)

Specifies which clocksync to use. The property m_strClockSync gets value "CDPClockSync", "OS_Time", "PTP" or "None".

void Application::SetDiskAlarm(std::string strAlarmText)

Sets the Disk Alarm in the application in a thread-safe manner. The strAlarmText should include information such as filename and type of error (read/write/seek etc).

[static] void Application::SetGlobalDebugLevel(int value)

Set the global debugEx variable (also adjusted by keyboard input 'Z' and 'z')

[virtual] void Application::SetIsTimeServer(bool newIsTimeServer)

Sets if this Application shall act as a Time server or not. Only relevant if clocksynch is "CDPClockSync". Default value is false.

void Application::SetNonMonotonicClockAlarm()

Sets that CDP Scheduler has detected time jumps in backwards. It can indicate faulty hardware or badly configured PTP time synchronization or PTP synchronization run on non-PTP-compatible controllers or network devices.

[static] void Application::SetNotRootEnabled(bool enable = true)

Sets value of flag enabling executing CDP as non root (not real time) or not.

[virtual] void Application::SetOStimeInterval(unsigned int newOStimeInterval)

Sets new value of Interval (in s) of reading OS time. Only relevant if clocksynch is "OS_Time".

[override virtual] void Application::SetProperty(std::string propertyName, std::string propertyValue)

Reimplemented from CDPBaseObject::SetProperty().

Sets a property in the object to a specified value. Called by MessageSetProperty after property name and value has been figured out. If propery is not found, CDPComponent::SetProperty() is called. Supported Properties: "ApplicationHandle".

[override virtual] void Application::SetPropertyHandler(CDPPropertyBase *pProp)

Reimplemented from CDPObject::SetPropertyHandler().

Catches property 'Set' events

[static] void Application::SetReturnStatus(int status)

Set the application exit status.

void Application::SetUnhandledExceptionDetected(const std::string &exceptionDescription)

Marks that some CDP application component has thrown an unhandled exception or crashed. Is called from CDP default exception handlers. Sets the Application "UnhandledExceptionDetected" alarm about the exception.

This member function is thread-safe to be called from any context.

int Application::Start()

Starts system components. Will not return before application is stopped. Returns application exit status.

[static] void Application::Stop()

Stops execution of all components and system services in this application space.

[static] bool Application::Stopped()

Returns true when RealSuspend has started or finished executing

[override virtual] void Application::Suspend()

Reimplemented from CDPBaseObject::Suspend().

Suspends the application and all other components.

[static] void Application::TerminateImmediately()

Terminates (exits) the application immediately. Useful to call from exception handlers when it is clear that current application state is unstable, for fast restart (by external restart script) and/or redundant application takeover.

[virtual protected] bool Application::TransitionBootupToPreOperational()

[virtual protected] bool Application::TransitionNullToBootup()

[virtual protected] bool Application::TransitionPreOperationalToRunning()

[override virtual] bool Application::ValidatePropertyHandler(CDP::StudioAPI::CDPVariantValue &newValue, CDPPropertyBase *property)

Reimplemented from CDPObject::ValidatePropertyHandler().

Validates properties before they are set to a new value. Return true to allow change, or false to disallow.

[virtual protected] void Application::WorkerTask(void)

This is the he WorkerTask which processes list of worker processes, and executes them in sequence. Restores initial Process priority after each run.

[static protected] OSAPITASK Application::WorkerTaskWrapper(LPVOID pClass)

Starts the worker task

[virtual] std::string &Application::XMLConfigurationDirectory()

Returns the XML configuration directory where subcomponent configuration is. If directory is not set, this will call CreateXMLConfigurationDirectory().