AAO DRAMA/DRAMA2 C++ Interface
Public Member Functions | Static Public Member Functions | Protected Member Functions | List of all members
drama::Path Class Reference

Detailed Description

A Class which provides access to DRAMA's message sending facilities.

An object of the drama::Path class provides an methods allowing you to send messages to other DRAMA tasks. They can only be used within threaded actions (or UFACE threads).

You must first "Get" the path - using GetPath(). From that point, various methods to send the assorted DRAMA messages are available.

The GetPath() operation can also load the target task, if it is not currently running and details on where to find it have been loaded.

Most of the "Set*" methods need to be invoked before calling GetPath(), to have any impact.

The are methods to send the DRAMA messages with endless wait for waiting until a time has passed.

See also
DcppTask
drama::sds
DitsInitiateMessage()
DitsInitMessBulk()
DRAMA DITS Specification
Examples:
monitor1.cpp, monitor2.cpp, and tocker.cpp.

#include "path.hh"

Inheritance diagram for drama::Path:
drama::git::Path

Public Member Functions

 Path (Path &&source)=default
 Move copy constructor. More...
 
 Path (std::weak_ptr< Task > theTask, const std::string &name, const std::string &host="", const std::string &file="")
 Normal constructor. More...
 
 Path (std::weak_ptr< Task > theTask)
 Path to self constructor. More...
 
 Path (std::weak_ptr< Task > theTask, DitsPathType path)
 Construct from existing DITS path. More...
 
 Path ()
 Construct a null object. More...
 
virtual ~Path ()
 Destructor. More...
 
virtual bool Active () const
 Indicate if a task is active. More...
 
virtual bool Busy () const
 Returns true if we can't send a message because path is busy. More...
 
virtual void ClearState ()
 Clear the task state. More...
 
void Control (thread::TMessHandler *action, const std::string &name, const sds::Id &argIn=sds::Id::CreateNullItem(), sds::IdPtr *const argOut=nullptr, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends a control message to a task and blocks the current thread until the reply is received. More...
 
bool ControlWaitUntil (std::chrono::steady_clock::time_point until, thread::TMessHandler *action, const std::string &name, const sds::Id &argIn=sds::Id::CreateNullItem(), sds::IdPtr *const argOut=nullptr, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends a control message to a task and block the current thread until the reply is received or a timeout has occurred. More...
 
virtual void Delete (int force)
 Delete the task. More...
 
virtual void Died ()
 Note that a task has died. More...
 
const std::string & GetArgument () const
 Fetch the load argument. More...
 
virtual DitsPathType GetDitsPath (bool nothrow=false)
 Return the underlying DITS path object. More...
 
const std::string & GetHost () const
 Fetch the task host name. More...
 
void GetParam (thread::TMessHandler *action, const std::string &name, sds::IdPtr *const argOut, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends a get parameter message to a task and blocks the current thread until it completes. More...
 
void GetParam (thread::TMessHandler *action, const std::initializer_list< std::string > names, sds::IdPtr *const argOut, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends a get parameter message to a task and blocks the current thread until it completes. More...
 
bool GetParamWaitUntil (std::chrono::steady_clock::time_point until, thread::TMessHandler *action, const std::string &name, sds::IdPtr *const argOut, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends a get parameter message to a task and blocks the current thread until it completes. More...
 
bool GetParamWaitUntil (std::chrono::steady_clock::time_point until, thread::TMessHandler *action, const std::initializer_list< std::string > names, sds::IdPtr *const argOut, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends a get parameter message to a task and blocks the current thread until it completes. More...
 
void GetPath (thread::TMessHandler *action, thread::TransEvtProcessor *const eventProcessor=&_getPathEventProcessor)
 Get a path to a the task. More...
 
virtual void GetPathImmed ()
 Get a path to a task if DITS already has it. More...
 
bool GetPathLoaded () const
 Indicate if a the task was loaded. More...
 
bool GetPathWaitUntil (std::chrono::steady_clock::time_point until, thread::TMessHandler *action, thread::TransEvtProcessor *const eventProcessor=&_getPathEventProcessor)
 Get a path to a the task. More...
 
virtual std::shared_ptr< TaskGetTask () const
 Get a reference to the DRAMA task we are part of. More...
 
const std::string GetTaskName () const
 Fetch the task name. More...
 
virtual bool Initial () const
 Return true if a GetPath operation is required. More...
 
virtual bool IsDead () const
 Return true if a previously active task has disconnected. More...
 
void Kick (thread::TMessHandler *action, const std::string &name, const sds::Id &argIn=sds::Id::CreateNullItem(), sds::IdPtr *const argOut=nullptr, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends a kick message to a task and blocks the current thread until the reply is received. More...
 
void KickBulk (thread::TMessHandler *action, const std::string &name, BulkData *argIn, bool isSds, unsigned notifyBytes=1024 *1024, sds::IdPtr *const argOut=nullptr, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends a kick message, with bulk data argument, to a task and blocks the current thread until the reply is received. More...
 
void KickBulk (thread::TMessHandler *action, const std::string &name, BulkDataSds *argIn, unsigned notifyBytes=1024 *1024, sds::IdPtr *const argOut=nullptr, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends a kick message, with SDS bulk data argument, to a task and blocks the current thread until the reply is received. More...
 
bool KickBulkWaitUntil (std::chrono::steady_clock::time_point until, thread::TMessHandler *action, const std::string &name, BulkData *argIn, bool isSds, unsigned notifyBytes=1024 *1024, sds::IdPtr *const argOut=nullptr, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends a kick message to a task and block the current thread until the reply is received or a timeout has occurred. More...
 
bool KickBulkWaitUntil (std::chrono::steady_clock::time_point until, thread::TMessHandler *action, const std::string &name, BulkDataSds *argIn, unsigned notifyBytes=1024 *1024, sds::IdPtr *const argOut=nullptr, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends a kick message to a task and block the current thread until the reply is received or a timeout has occurred. More...
 
bool KickWaitUntil (std::chrono::steady_clock::time_point until, thread::TMessHandler *action, const std::string &name, const sds::Id &argIn=sds::Id::CreateNullItem(), sds::IdPtr *const argOut=nullptr, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends a kick message to a task and block the current thread until the reply is received or a timeout has occurred. More...
 
virtual void LogLoad (const bool Flag=true)
 Load use MsgOut() a lines indicating the load operations. More...
 
virtual void LosePath ()
 Lose the path and then set as if the task has died. More...
 
void MonitorCancel (thread::TMessHandler *action, int monId, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Send a Monitor Forward message to a task and block until it is complete. More...
 
void MonitorForward (thread::TMessHandler *action, const sds::Id &argIn, MessageEventHandler *const eventProcessor)
 Send a Monitor Forward message to a task and block until it is complete. More...
 
void MonitorStart (thread::TMessHandler *action, const sds::Id &argIn, MessageEventHandler *const eventProcessor)
 Send a Monitor Start message to a task and block until is it is complete. More...
 
void Obey (thread::TMessHandler *action, const std::string &name, const sds::Id &argIn=sds::Id::CreateNullItem(), sds::IdPtr *const argOut=nullptr, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends an obey message to a task and blocks the current thread until the action is complete. More...
 
void ObeyBulk (thread::TMessHandler *action, const std::string &name, BulkData *argIn, bool isSds, unsigned notifyBytes=1024 *1024, sds::IdPtr *const argOut=nullptr, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends an obey message to a task, with bulk data argument, and blocks the current thread until the action is complete. More...
 
void ObeyBulk (thread::TMessHandler *action, const std::string &name, BulkDataSds *argIn, unsigned notifyBytes=1024 *1024, sds::IdPtr *const argOut=nullptr, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends an obey message to a task, with SDS bulk data argument, and blocks the current thread until the action is complete. More...
 
bool ObeyBulkWaitUntil (std::chrono::steady_clock::time_point until, thread::TMessHandler *action, const std::string &name, BulkData *argIn, bool isSds, unsigned notifyBytes=1024 *1024, sds::IdPtr *const argOut=nullptr, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends an obey message to a task, with a bulk data argument, and blocks the current thread until the action is complete or a timeout has occurred. More...
 
bool ObeyBulkWaitUntil (std::chrono::steady_clock::time_point until, thread::TMessHandler *action, const std::string &name, BulkDataSds *argIn, unsigned notifyBytes=1024 *1024, sds::IdPtr *const argOut=nullptr, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends an obey message to a task, with a SDS bulk data argument, and blocks the current thread until the action is complete or a timeout has occurred. More...
 
bool ObeyWaitUntil (std::chrono::steady_clock::time_point until, thread::TMessHandler *action, const std::string &name, const sds::Id &argIn=sds::Id::CreateNullItem(), sds::IdPtr *const argOut=nullptr, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends an obey message to a task and blocks the current thread until the action is complete or a timeout has occurred. More...
 
Pathoperator= (Path &&rhs)=default
 Move assignment operator. More...
 
void Report (thread::TMessHandler *action) const
 Dump details using MsgOut(). More...
 
virtual void SetArgument (const std::string &LoadArg, bool const Append=false)
 Set the load time argument string. More...
 
virtual void SetBuffers (const Buffers &buffs)
 Set the DRAMA path buffers. More...
 
virtual void SetFile (const std::string &File)
 Set the executable file name. More...
 
virtual void SetFlowControl ()
 Set the FLOW control flag. More...
 
virtual void SetHost (const std::string &Host)
 Set the task host name. More...
 
virtual void SetName (const std::string &TaskName)
 Set the task name. More...
 
virtual void SetNames (const bool Flag=true)
 Insist that symbols known to IMP_Master be known to the task. More...
 
void SetParam (thread::TMessHandler *action, const std::string &name, const sds::Id &argIn, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends a set parameter message to a task and blocks the current thread until it completes. More...
 
bool SetParamWaitUntil (std::chrono::steady_clock::time_point until, thread::TMessHandler *action, const std::string &name, const sds::Id &argIn, MessageEventHandler *const eventProcessor=&_simpleEventProcessor)
 Sends a set parameter message to a task and blocks the current thread until it completes or a timeout has occurred. More...
 
virtual void SetPriority (const int Priority, const bool Absolute=false)
 Set the load time priority for a task when loaded. More...
 
virtual void SetProcess (const std::string &ProcessName)
 Set the process names. More...
 
virtual void SetProg (const bool Flag=true)
 Interpert file name as a program name. More...
 
virtual void SetStackSize (unsigned bytes)
 Set the stack size for the load. More...
 
virtual void SetSymbols (const bool Flag=true)
 Interpert file name as a symbol (VMS Target only) More...
 

Static Public Member Functions

static std::chrono::steady_clock::time_point DeltaToTimePoint (int secs)
 Given a number of seconds, return a time point that number of seconds into the future. More...
 
static void HandleDisconnected (const char *task, DitsPathType path, StatusType *status)
 Handle task disconnection. More...
 

Protected Member Functions

virtual void Disconnected ()
 Invoked when the task we are talking to disappears. More...
 

Constructor & Destructor Documentation

drama::Path::Path ( Path &&  source)
default

Move copy constructor.

drama::Path::Path ( std::weak_ptr< Task theTask,
const std::string &  name,
const std::string &  host = "",
const std::string &  file = "" 
)

Normal constructor.

Allows the the task name, host and file to be set

Parameters
theTaskThe DRAMA Task we are part of. This is passed by pointer, but Path is not taking ownership of the subject object, which must continue to exist until the Path object is destroyed.
nameThe name the task will be known as (unless loaded, when the name the task registers as will be used)
hostThe node name on which the task is running or is to be loaded. Only used if not already running locally or known locally.
fileThe file of the task, as required by DitsLoad(). Normally a file name, but may be different depending on the location, e.g. on a VxWorks machine.
drama::Path::Path ( std::weak_ptr< Task theTask)
explicit

Path to self constructor.

Construct a drama::Path object which can be used to send messages to the invoking task itself.

Parameters
theTaskThe DRAMA Task we are part of. This is passed by pointer, but Path is not taking ownership of the subject object, which must continue to exist until the Path object is destroyed.
drama::Path::Path ( std::weak_ptr< Task theTask,
DitsPathType  path 
)

Construct from existing DITS path.

Constructs an drama::Path object from an existing DITS path.

If the path is valid, then the state is set to ACTIVE, otherwise it is set to died and you would to set the task name before trying to get a path to the task.

Parameters
theTaskThe DRAMA Task we are part of. This is passed by pointer, but Path is not taking ownership of the subject object, which must continue to exist until the Path object is destroyed.
pathThe valid DITS path to be used.
drama::Path::Path ( )
inline

Construct a null object.

Objects created this way are only suitable as the destination of a move assignment or move copy operation.

virtual drama::Path::~Path ( )
virtual

Destructor.

Reimplemented in drama::git::Path.

Member Function Documentation

virtual bool drama::Path::Active ( ) const
inlinevirtual

Indicate if a task is active.

Returns
true if it is safe to send a message along a path. That is, a Path::GetPath operation is not needed and is not underway.
virtual bool drama::Path::Busy ( ) const
inlinevirtual

Returns true if we can't send a message because path is busy.

You can't send a message along a path whilst the getting a path on it or whilst a Notify operation is current.

Returns
true if you cannot currently send a message on a path.
virtual void drama::Path::ClearState ( )
inlinevirtual

Clear the task state.

This function clears the state of the drama::Path object, such that it will will presume is has just been constructed.

void drama::Path::Control ( thread::TMessHandler action,
const std::string &  name,
const sds::Id argIn = sds::Id::CreateNullItem(),
sds::IdPtr *const  argOut = nullptr,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends a control message to a task and blocks the current thread until the reply is received.

Parameters
actionA pointer to the threaded action or threaded uface handler which is executing this operation.
nameName of the control message.
argInArgument to the control message, if any.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the message completes.
argOutThe reply message argument, if any. An address of and sds::IdPtr is supplied. If you supply a null pointer, it is ignored. Otherwise, any argument to the message completion is copied into here. If there is no argument to the reply, it will refer to a null SDS item.

References drama::TransEvtInfo::complete, DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransaction().

bool drama::Path::ControlWaitUntil ( std::chrono::steady_clock::time_point  until,
thread::TMessHandler action,
const std::string &  name,
const sds::Id argIn = sds::Id::CreateNullItem(),
sds::IdPtr *const  argOut = nullptr,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends a control message to a task and block the current thread until the reply is received or a timeout has occurred.

For a relative time, something like the following is needed. (ten second timeout).

   std::chrono::steady_clock::time_point until =  
      std::chrono::steady_clock::now() + std::chrono::seconds(10);
      ControlWaitUntil(until,...);
*
Parameters
untilUntil when should we wait for this.
actionA pointer to the threaded action or threaded uface handler which is executing this operation.
nameName of the control message to send.
argInArgument to the control message, if any.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the message completes.
argOutThe reply message argument, if any. An address of and sds::IdPtr is supplied. If you supply a null pointer, it is ignored. Otherwise, any argument to the message completion is copied into here. If there is no argument to the reply, it will refer to a null SDS item.
Returns
Returns true if the transaction completed, false for a timeout.

References drama::TransEvtInfo::complete, DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransactionUntil().

virtual void drama::Path::Delete ( int  force)
virtual

Delete the task.

Tell IMP to delete the task we are talking to. Ignored if the object is talking to self.

Parameters
forceIf true, force the task to be deleted, rather then asking it nicely to delete itself.
static std::chrono::steady_clock::time_point drama::Path::DeltaToTimePoint ( int  secs)
inlinestatic

Given a number of seconds, return a time point that number of seconds into the future.

This is a quick way of converting a delta number of seconds to a time point, as required by various methods.

virtual void drama::Path::Died ( )
inlinevirtual

Note that a task has died.

virtual void drama::Path::Disconnected ( )
protectedvirtual

Invoked when the task we are talking to disappears.

The base class implementation does nothing, through the path has already been marked as died. Subclasses can override this as necessary, but should not attempt to get the path again immediately.

const std::string& drama::Path::GetArgument ( ) const
inline

Fetch the load argument.

returns A const pointer to the load argument previously specified.

virtual DitsPathType drama::Path::GetDitsPath ( bool  nothrow = false)
virtual

Return the underlying DITS path object.

This method returns the underlying DITS path object being used by the drama::Path object. If it is not yet active then an exception will be thrown unless nothrow is set true, in which case a nullptr is returned.

Parameters
nothrowIf set true, return nullptr rather then throw an exception if the path is not yet active.
Returns
The DITS path.
const std::string& drama::Path::GetHost ( ) const
inline

Fetch the task host name.

Returns the name of the node on which the task is running (unless it was already known locally when drama::Path::GetPath was running, in which case we don't know where it is, but the value specified to the constructor is returns)

returns A const pointer to the node name.

void drama::Path::GetParam ( thread::TMessHandler action,
const std::string &  name,
sds::IdPtr *const  argOut,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends a get parameter message to a task and blocks the current thread until it completes.

Single parameter verion.

Parameters
actionA pointer to the threaded action or threaded uface handler which is executing this operation.
nameName of the parameter to get.
argOutThe value of the parameter is copied here.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the set completes.

References drama::TransEvtInfo::complete, drama::sds::Id::CreateNullItem(), DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransaction().

void drama::Path::GetParam ( thread::TMessHandler action,
const std::initializer_list< std::string >  names,
sds::IdPtr *const  argOut,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends a get parameter message to a task and blocks the current thread until it completes.

Multiple parameter version.

Parameters
actionA pointer to the threaded action or threaded uface handler which is executing this operation.
namesAn initializer list of the name of the parameters to get.
argOutThe value of the parameters is copied here.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the set completes.

References drama::TransEvtInfo::complete, drama::sds::Id::CreateArgCmdStruct(), DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransaction().

bool drama::Path::GetParamWaitUntil ( std::chrono::steady_clock::time_point  until,
thread::TMessHandler action,
const std::string &  name,
sds::IdPtr *const  argOut,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends a get parameter message to a task and blocks the current thread until it completes.

Single parameter version with timeout.

For a relative time, something like the following is needed. (ten second timeout).

   std::chrono::steady_clock::time_point until =  
      std::chrono::steady_clock::now() + std::chrono::seconds(10);
      GetParamWaitUntil(until,...);
*
Parameters
untilUntil when should we wait for this.
actionA pointer to the threaded action or threaded uface handler which is executing this operation.
nameName of the parameter to get.
argOutThe value of the parameter is copied here.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the set completes.
Returns
Returns true if the transaction completed, false for a timeout.

References drama::TransEvtInfo::complete, drama::sds::Id::CreateNullItem(), DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransactionUntil().

bool drama::Path::GetParamWaitUntil ( std::chrono::steady_clock::time_point  until,
thread::TMessHandler action,
const std::initializer_list< std::string >  names,
sds::IdPtr *const  argOut,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends a get parameter message to a task and blocks the current thread until it completes.

Multiple parameter version with timeout.

For a relative time, something like the following is needed. (ten second timeout).

   std::chrono::steady_clock::time_point until =  
      std::chrono::steady_clock::now() + std::chrono::seconds(10);
      GetParamWaitUntil(until,...);
*
Parameters
untilUntil when should we wait for this.
actionA pointer to the threaded action or threaded uface handler which is executing this operation.
namesAn initializer list of the name of the parameters to get.
argOutThe value of the parameters is copied here.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the set completes.
Returns
Returns true if the transaction completed, false for a timeout.

References drama::TransEvtInfo::complete, drama::sds::Id::CreateArgCmdStruct(), DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransactionUntil().

void drama::Path::GetPath ( thread::TMessHandler action,
thread::TransEvtProcessor *const  eventProcessor = &_getPathEventProcessor 
)

Get a path to a the task.

If it is not running, load it if we have the details.

This call initiates getting a path to the task. If the task is not running, it will be loaded if a sufficent information has been specified and the DRAMA Master task is running (or this task is allowed to load tasks itself)

This call must be made from a DRAMA Threaded action implementation, the address of the threaded action object must be passed. The thread will block until the operation is successful.

Parameters
actionA pointer to the threaded action which is executing this operation.
eventProcessorAn object to use to process events. Defaults to a simple get path processor that causes the method to return the get path has completed. If this is successful and the program was loaded, a transaction will remain outstanding (until the program exits) but will have been orphaned.
Examples:
monitor1.cpp, monitor2.cpp, and tocker.cpp.
virtual void drama::Path::GetPathImmed ( )
virtual

Get a path to a task if DITS already has it.

This method fetches that path to the task from DITS, if DITS already knows about it. No messages are initiated and an exception is throw if DITS does not know about this task already.

If this method returns successfully, you may use this object to send messages.

bool drama::Path::GetPathLoaded ( ) const
inline

Indicate if a the task was loaded.

returns True if the task we are talking too was loaded.

bool drama::Path::GetPathWaitUntil ( std::chrono::steady_clock::time_point  until,
thread::TMessHandler action,
thread::TransEvtProcessor *const  eventProcessor = &_getPathEventProcessor 
)

Get a path to a the task.

If it is not running, load it if we have the details. Version with timeout.

This call initiates getting a path to the task. If the task is not running, it will be loaded if a sufficent information has been specified and the DRAMA Master task is running (or this task is allowed to load tasks itself)

This call must be made from a DRAMA Threaded action implementation, the address of the threaded action object must be passed. The thread will block until the operation is successful.

For a relative time, something like the following is needed. (ten second timeout).

   std::chrono::steady_clock::time_point until =  
      std::chrono::steady_clock::now() + std::chrono::seconds(10);
      GetPathWaitUntil(until,...);
*
Parameters
untilUntil when should we wait for this.
actionA pointer to the threaded action which is executing this operation.
eventProcessorAn object to use to process events. Defaults to a simple get path processor that causes the method to return the get path has completed. If this is successful and the program was loaded, a transaction will remain outstanding (until the program exits) but will have been orphaned.
Returns
Returns true if the transaction completed, false for a timeout.
virtual std::shared_ptr<Task> drama::Path::GetTask ( ) const
inlinevirtual

Get a reference to the DRAMA task we are part of.

const std::string drama::Path::GetTaskName ( ) const

Fetch the task name.

The task name may not be as specified by the constructor in the case where the task was loaded - in that case, the task can specify its own name to DRAMA and that is used.

returns A const pointer to the task name string.

static void drama::Path::HandleDisconnected ( const char *  task,
DitsPathType  path,
StatusType *  status 
)
static

Handle task disconnection.

Used internally only, callback from DITS code.

virtual bool drama::Path::Initial ( ) const
inlinevirtual

Return true if a GetPath operation is required.

Returns
true if a drama::Path::GetPath operation is needed.
virtual bool drama::Path::IsDead ( ) const
inlinevirtual

Return true if a previously active task has disconnected.

Returns
true if the task has disconnected.
void drama::Path::Kick ( thread::TMessHandler action,
const std::string &  name,
const sds::Id argIn = sds::Id::CreateNullItem(),
sds::IdPtr *const  argOut = nullptr,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends a kick message to a task and blocks the current thread until the reply is received.

Parameters
actionA pointer to the threaded action which is executing this operation.
nameName of the action to kick.
argInArgument to the kick, if any.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the kick completes.
argOutThe reply message argument, if any. An address of and sds::IdPtr is supplied. If you supply a null pointer, it is ignored. Otherwise, any argument to the kick completion is copied into here. If there is no argument to the reply, it will refer to a null SDS item.

References drama::TransEvtInfo::complete, DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransaction().

void drama::Path::KickBulk ( thread::TMessHandler action,
const std::string &  name,
BulkData argIn,
bool  isSds,
unsigned  notifyBytes = 1024*1024,
sds::IdPtr *const  argOut = nullptr,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends a kick message, with bulk data argument, to a task and blocks the current thread until the reply is received.

Parameters
actionA pointer to the threaded action which is executing this operation.
nameName of the action to kick.
argInThe Bulk Data segment to be the argument to the obey message.
isSdsDoes arg contain an SDS item? If true, the target task can access the item as an argument using using SDS in the normal way If false, the shared memory contains data in an application private format and DRAMA makes no attempt to interpret it.
notifyBytesIf non-zero, it indicates your action should be notified (using EntryCode::BulkTransferred entries) every time the specified number of bytes are transferred. Note the this effect is somewhat dependent on the target task behavior and you may only receive the final EntryCode::BulkDone message.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the kick completes.
argOutThe reply message argument, if any. An address of and sds::IdPtr is supplied. If you supply a null pointer, it is ignored. Otherwise, any argument to the kick completion is copied into here. If there is no argument to the reply, it will refer to a null SDS item.

References drama::TransEvtInfo::complete, DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransaction().

Referenced by KickBulk().

void drama::Path::KickBulk ( thread::TMessHandler action,
const std::string &  name,
BulkDataSds argIn,
unsigned  notifyBytes = 1024*1024,
sds::IdPtr *const  argOut = nullptr,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends a kick message, with SDS bulk data argument, to a task and blocks the current thread until the reply is received.

Parameters
actionA pointer to the threaded action which is executing this operation.
nameName of the action to kick.
argInThe SDS Bulk Data segment to be the argument to the obey message.
notifyBytesIf non-zero, it indicates your action should be notified (using EntryCode::BulkTransferred entries) every time the specified number of bytes are transferred. Note the this effect is somewhat dependent on the target task behavior and you may only receive the final EntryCode::BulkDone message.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the kick completes.
argOutThe reply message argument, if any. An address of and sds::IdPtr is supplied. If you supply a null pointer, it is ignored. Otherwise, any argument to the kick completion is copied into here. If there is no argument to the reply, it will refer to a null SDS item.

References KickBulk().

bool drama::Path::KickBulkWaitUntil ( std::chrono::steady_clock::time_point  until,
thread::TMessHandler action,
const std::string &  name,
BulkData argIn,
bool  isSds,
unsigned  notifyBytes = 1024*1024,
sds::IdPtr *const  argOut = nullptr,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends a kick message to a task and block the current thread until the reply is received or a timeout has occurred.

For a relative time, something like the following is needed. (ten second timeout).

   std::chrono::steady_clock::time_point until =  
      std::chrono::steady_clock::now() + std::chrono::seconds(10);
      KickWaitUntil(until,...);
*
Parameters
untilUntil when should we wait for this.
actionA pointer to the threaded action which is executing this operation.
nameName of the action to kick.
argInThe Bulk Data segment to be the argument to the obey message.
isSdsDoes arg contain an SDS item? If true, the target task can access the item as an argument using using SDS in the normal way If false, the shared memory contains data in an application private format and DRAMA makes no attempt to interpret it.
notifyBytesIf non-zero, it indicates your action should be notified (using EntryCode::BulkTransferred entries) every time the specified number of bytes are transferred. Note the this effect is somewhat dependent on the target task behavior and you may only receive the final EntryCode::BulkDone message.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the kick completes.
argOutThe reply message argument, if any. An address of and sds::IdPtr is supplied. If you supply a null pointer, it is ignored. Otherwise, any argument to the kick completion is copied into here. If there is no argument to the reply, it will refer to a null SDS item.
Returns
Returns true if the transaction completed, false for a timeout.

References drama::TransEvtInfo::complete, DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransactionUntil().

Referenced by KickBulkWaitUntil().

bool drama::Path::KickBulkWaitUntil ( std::chrono::steady_clock::time_point  until,
thread::TMessHandler action,
const std::string &  name,
BulkDataSds argIn,
unsigned  notifyBytes = 1024*1024,
sds::IdPtr *const  argOut = nullptr,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends a kick message to a task and block the current thread until the reply is received or a timeout has occurred.

For a relative time, something like the following is needed. (ten second timeout).

   std::chrono::steady_clock::time_point until =  
      std::chrono::steady_clock::now() + std::chrono::seconds(10);
      KickWaitUntil(until,...);
*
Parameters
untilUntil when should we wait for this.
actionA pointer to the threaded action which is executing this operation.
nameName of the action to kick.
argInThe SDS Bulk Data segment to be the argument to the obey message.
notifyBytesIf non-zero, it indicates your action should be notified (using EntryCode::BulkTransferred entries) every time the specified number of bytes are transferred. Note the this effect is somewhat dependent on the target task behavior and you may only receive the final EntryCode::BulkDone message.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the kick completes.
argOutThe reply message argument, if any. An address of and sds::IdPtr is supplied. If you supply a null pointer, it is ignored. Otherwise, any argument to the kick completion is copied into here. If there is no argument to the reply, it will refer to a null SDS item.
Returns
Returns true if the transaction completed, false for a timeout.

References KickBulkWaitUntil().

bool drama::Path::KickWaitUntil ( std::chrono::steady_clock::time_point  until,
thread::TMessHandler action,
const std::string &  name,
const sds::Id argIn = sds::Id::CreateNullItem(),
sds::IdPtr *const  argOut = nullptr,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends a kick message to a task and block the current thread until the reply is received or a timeout has occurred.

For a relative time, something like the following is needed. (ten second timeout).

   std::chrono::steady_clock::time_point until =  
      std::chrono::steady_clock::now() + std::chrono::seconds(10);
      KickWaitUntil(until,...);
*
Parameters
untilUntil when should we wait for this.
actionA pointer to the threaded action which is executing this operation.
nameName of the action to kick.
argInArgument to the kick, if any.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the kick completes.
argOutThe reply message argument, if any. An address of and sds::IdPtr is supplied. If you supply a null pointer, it is ignored. Otherwise, any argument to the kick completion is copied into here. If there is no argument to the reply, it will refer to a null SDS item.
Returns
Returns true if the transaction completed, false for a timeout.

References drama::TransEvtInfo::complete, DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransactionUntil().

virtual void drama::Path::LogLoad ( const bool  Flag = true)
inlinevirtual

Load use MsgOut() a lines indicating the load operations.

If set true, this flag causes MsgOut() messages to be output around the load operations, if they occur.

Parameters
FlagThe value for the flag.
virtual void drama::Path::LosePath ( )
virtual

Lose the path and then set as if the task has died.

After invoking this method, you can no longer send messages to the subject task. The task in question is told we have disconnected.

This will cause a full DRAMA DitsPathGet() to be done by the next Path::GetPath call.

void drama::Path::MonitorCancel ( thread::TMessHandler action,
int  monId,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Send a Monitor Forward message to a task and block until it is complete.

Parameters
actionA pointer to the threaded action or threaded uface handler which is executing this operation.
monIdThe ID of the monitor to be canceled.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the monitor completes.

References drama::TransEvtInfo::complete, drama::sds::Id::CreateArgCmdStruct(), DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransaction().

void drama::Path::MonitorForward ( thread::TMessHandler action,
const sds::Id argIn,
MessageEventHandler *const  eventProcessor 
)
inline

Send a Monitor Forward message to a task and block until it is complete.

Parameters
actionA pointer to the threaded action or threaded uface handler which is executing this operation.
argInArgument to the action. The first item is the name of the task to forward the monitor too, the second is the action to be invoked, subsequent arguments are the parameters to be monitored. You can use "drama::sds::Id::CreateArgCmdStruct() to create this argument.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the monitor completes.

References drama::TransEvtInfo::complete, DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransaction().

void drama::Path::MonitorStart ( thread::TMessHandler action,
const sds::Id argIn,
MessageEventHandler *const  eventProcessor 
)
inline

Send a Monitor Start message to a task and block until is it is complete.

This method is used by the drama::thread::Monitor class, user code should use that class to implement non-forward monitors.

Parameters
actionA pointer to the threaded action or threaded uface handler which is executing this operation.
argInArgument to the message, will contain the list of parameters to monitor. You can use "drama::sds::Id::CreateArgCmdStruct() to create this argument.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the monitor completes.

References drama::TransEvtInfo::complete, DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransaction().

void drama::Path::Obey ( thread::TMessHandler action,
const std::string &  name,
const sds::Id argIn = sds::Id::CreateNullItem(),
sds::IdPtr *const  argOut = nullptr,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends an obey message to a task and blocks the current thread until the action is complete.

Parameters
actionA pointer to the threaded action which is executing this operation.
nameName of the action to start.
argInArgument to the action, if any.
argOutThe reply message argument, if any. An address of and sds::IdPtr is supplied. If you supply a null pointer, it is ignored. Otherwise, any argument to the obey completion is copied into here. If there is no argument to the reply, it will refer to a null SDS item.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the subsidiary action completes.

References drama::TransEvtInfo::complete, DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransaction().

void drama::Path::ObeyBulk ( thread::TMessHandler action,
const std::string &  name,
BulkData argIn,
bool  isSds,
unsigned  notifyBytes = 1024*1024,
sds::IdPtr *const  argOut = nullptr,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends an obey message to a task, with bulk data argument, and blocks the current thread until the action is complete.

Parameters
actionA pointer to the threaded action which is executing this operation.
nameName of the action to start.
argInThe Bulk Data segment to be the argument to the obey message.
isSdsDoes arg contain an SDS item? If true, the target task can access the item as an argument using using SDS in the normal way If false, the shared memory contains data in an application private format and DRAMA makes no attempt to interpret it.
notifyBytesIf non-zero, it indicates your action should be notified (using EntryCode::BulkTransferred entries) every time the specified number of bytes are transferred. Note the this effect is somewhat dependent on the target task behavior and you may only receive the final EntryCode::BulkDone message.
argOutThe reply message argument, if any. An address of and sds::IdPtr is supplied. If you supply a null pointer, it is ignored. Otherwise, any argument to the obey completion is copied into here. If there is no argument to the reply, it will refer to a null SDS item.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the subsidiary action completes.

References drama::TransEvtInfo::complete, DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransaction().

Referenced by ObeyBulk().

void drama::Path::ObeyBulk ( thread::TMessHandler action,
const std::string &  name,
BulkDataSds argIn,
unsigned  notifyBytes = 1024*1024,
sds::IdPtr *const  argOut = nullptr,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends an obey message to a task, with SDS bulk data argument, and blocks the current thread until the action is complete.

Parameters
actionA pointer to the threaded action which is executing this operation.
nameName of the action to start.
argInThe SDS Bulk Data segment to be the argument to the obey message. Contains an SDS item.
notifyBytesIf non-zero, it indicates your action should be notified (using EntryCode::BulkTransferred entries) every time the specified number of bytes are transferred. Note the this effect is somewhat dependent on the target task behavior and you may only receive the final EntryCode::BulkDone message.
argOutThe reply message argument, if any. An address of and sds::IdPtr is supplied. If you supply a null pointer, it is ignored. Otherwise, any argument to the obey completion is copied into here. If there is no argument to the reply, it will refer to a null SDS item.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the subsidiary action completes.

References ObeyBulk().

bool drama::Path::ObeyBulkWaitUntil ( std::chrono::steady_clock::time_point  until,
thread::TMessHandler action,
const std::string &  name,
BulkData argIn,
bool  isSds,
unsigned  notifyBytes = 1024*1024,
sds::IdPtr *const  argOut = nullptr,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends an obey message to a task, with a bulk data argument, and blocks the current thread until the action is complete or a timeout has occurred.

For a relative time, something like the following is needed. (ten second timeout).

   std::chrono::steady_clock::time_point until =  
      std::chrono::steady_clock::now() + std::chrono::seconds(10);
      ObeyBulkWaitUntil(until,...);
*
Parameters
untilUntil when should we wait for this.
actionA pointer to the threaded action which is executing this operation.
nameName of the action to start.
argInThe Bulk Data segment to be the argument to the obey message.
isSdsDoes arg contain an SDS item? If true, the target task can access the item as an argument using using SDS in the normal way If false, the shared memory contains data in an application private format and DRAMA makes no attempt to interpret it.
notifyBytesIf non-zero, it indicates your action should be notified (using EntryCode::BulkTransferred entries) every time the specified number of bytes are transferred. Note the this effect is somewhat dependent on the target task behavior and you may only receive the final EntryCode::BulkDone message.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the subsidiary action completes.
argOutThe reply message argument, if any. An address of and sds::IdPtr is supplied. If you supply a null pointer, it is ignored. Otherwise, any argument to the obey completion is copied into here. If there is no argument to the reply, it will refer to a null SDS item.
Returns
Returns true if the transaction completed, false for a timeout.

References drama::TransEvtInfo::complete, DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransactionUntil().

Referenced by ObeyBulkWaitUntil().

bool drama::Path::ObeyBulkWaitUntil ( std::chrono::steady_clock::time_point  until,
thread::TMessHandler action,
const std::string &  name,
BulkDataSds argIn,
unsigned  notifyBytes = 1024*1024,
sds::IdPtr *const  argOut = nullptr,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends an obey message to a task, with a SDS bulk data argument, and blocks the current thread until the action is complete or a timeout has occurred.

For a relative time, something like the following is needed. (ten second timeout).

   std::chrono::steady_clock::time_point until =  
      std::chrono::steady_clock::now() + std::chrono::seconds(10);
      ObeyBulkWaitUntil(until,...);
*
Parameters
untilUntil when should we wait for this.
actionA pointer to the threaded action which is executing this operation.
nameName of the action to start.
argInThe SDS Bulk Data segment to be the argument to the obey message.
notifyBytesIf non-zero, it indicates your action should be notified (using EntryCode::BulkTransferred entries) every time the specified number of bytes are transferred. Note the this effect is somewhat dependent on the target task behavior and you may only receive the final EntryCode::BulkDone message.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the subsidiary action completes.
argOutThe reply message argument, if any. An address of and sds::IdPtr is supplied. If you supply a null pointer, it is ignored. Otherwise, any argument to the obey completion is copied into here. If there is no argument to the reply, it will refer to a null SDS item.
Returns
Returns true if the transaction completed, false for a timeout.

References ObeyBulkWaitUntil().

bool drama::Path::ObeyWaitUntil ( std::chrono::steady_clock::time_point  until,
thread::TMessHandler action,
const std::string &  name,
const sds::Id argIn = sds::Id::CreateNullItem(),
sds::IdPtr *const  argOut = nullptr,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends an obey message to a task and blocks the current thread until the action is complete or a timeout has occurred.

For a relative time, something like the following is needed. (ten second timeout).

   std::chrono::steady_clock::time_point until =  
      std::chrono::steady_clock::now() + std::chrono::seconds(10);
      ObeyWaitUntil(until,...);
*
Parameters
untilUntil when should we wait for this.
actionA pointer to the threaded action which is executing this operation.
nameName of the action to start.
argInArgument to the action, if any.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the subsidiary action completes.
argOutThe reply message argument, if any. An address of and sds::IdPtr is supplied. If you supply a null pointer, it is ignored. Otherwise, any argument to the obey completion is copied into here. If there is no argument to the reply, it will refer to a null SDS item.
Returns
Returns true if the transaction completed, false for a timeout.

References drama::TransEvtInfo::complete, DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransactionUntil().

Path& drama::Path::operator= ( Path &&  rhs)
default

Move assignment operator.

void drama::Path::Report ( thread::TMessHandler action) const

Dump details using MsgOut().

This call causes details of this object to be output using action->MessageUser.

Parameters
actionA pointer to the threaded action which is executing this operation.
virtual void drama::Path::SetArgument ( const std::string &  LoadArg,
bool const  Append = false 
)
virtual

Set the load time argument string.

This is a string is becomes the load argument if the task is loaded. For example, under unix it is put into the argv array.

Parameters
LoadArgThe new load argument string.
AppendIf true, append to the previous value, otherwise overwrite.
virtual void drama::Path::SetBuffers ( const Buffers buffs)
inlinevirtual

Set the DRAMA path buffers.

These are used by Path::GetPath when getting the path to the task. It is ignored if we already have a path to the task.

virtual void drama::Path::SetFile ( const std::string &  File)
inlinevirtual

Set the executable file name.

This is only used if drama::Path::GetPath must load the task

virtual void drama::Path::SetFlowControl ( )
inlinevirtual

Set the FLOW control flag.

This flag is used by drama::Path::GetPath. See DitsPathGet() for more details.

virtual void drama::Path::SetHost ( const std::string &  Host)
inlinevirtual

Set the task host name.

This is the host used to find the task on (drama::Path::GetPath) if it is not known locally, or to load it on if it is not running

Parameters
HostThe node name.
virtual void drama::Path::SetName ( const std::string &  TaskName)
virtual

Set the task name.

This is the name to be used on drama::Path::GetPath operations, and is ignored if we already have the path. It can include the nodename using the "taskname\@nodename" format, in which case the node name is removed and used in (in effect) a call to Path::SetLocation.

See also
Path:SetLocation
Parameters
TaskNameThe new name to be used as the task name for this object.
virtual void drama::Path::SetNames ( const bool  Flag = true)
inlinevirtual

Insist that symbols known to IMP_Master be known to the task.

Used to control the inheritance of symbols (logical names and symbols under VMS, environment variables under UNIX) by the new task. If specified, this flag insists that symbols known to the IMP_Master task be inherited by the new task. If not set, it is at the discretion of the master task whether this is done.

Only used when loading the task.

Parameters
FlagThe value for the flag.
void drama::Path::SetParam ( thread::TMessHandler action,
const std::string &  name,
const sds::Id argIn,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends a set parameter message to a task and blocks the current thread until it completes.

Parameters
actionA pointer to the threaded action which is executing this operation.
nameName of the parameter to set.
argInThe new value for the parameter.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the set completes.

References drama::TransEvtInfo::complete, DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransaction().

bool drama::Path::SetParamWaitUntil ( std::chrono::steady_clock::time_point  until,
thread::TMessHandler action,
const std::string &  name,
const sds::Id argIn,
MessageEventHandler *const  eventProcessor = &_simpleEventProcessor 
)
inline

Sends a set parameter message to a task and blocks the current thread until it completes or a timeout has occurred.

For a relative time, something like the following is needed. (ten second timeout).

   std::chrono::steady_clock::time_point until =  
      std::chrono::steady_clock::now() + std::chrono::seconds(10);
      SetParamWaitUntil(until,...);
*
Parameters
untilUntil when should we wait for this.
actionA pointer to the threaded action or threaded uface handler which is executing this operation.
nameName of the parameter to set.
argInThe new value for the parameter.
eventProcessorAn object to use to process events. Defaults to a simple event processor that causes the method to return when the set completes.
Returns
Returns true if the transaction completed, false for a timeout.

References drama::TransEvtInfo::complete, DramaTHROW_S, drama::TransEvtInfo::entryStatus, and drama::thread::TMessHandler::WaitForTransactionUntil().

virtual void drama::Path::SetPriority ( const int  Priority,
const bool  Absolute = false 
)
virtual

Set the load time priority for a task when loaded.

Most operating systems allow the priority of a task to be set, through many do now allow a higher priority for unless appropiate privledges are available. This method allows the priority to be set if the task is to be loaded.

Parameters
PriorityThe new priority
AbsoluteIf true, Priority is absolute, otherwise it is relative (an may be negative).
virtual void drama::Path::SetProcess ( const std::string &  ProcessName)
virtual

Set the process names.

Some operating systems (VMS, VxWorks and Windows) assoicate a process name with a process. This method allow this to be set.

Parameters
ProcessNameThe process name string. If a null string, then any previous value is cleared and a default process name will be used.
virtual void drama::Path::SetProg ( const bool  Flag = true)
inlinevirtual

Interpert file name as a program name.

Used where the target system is a VMS system to cover any ambiguity in the interpretation of a 'Program' string as either the actual name of a program to be executed or a symbol that causes a program to be executed. If this is set, it forces the string to be interpreted as a program name. (The difference is that a program name needs to be run using a spawned RUN command, or - if no arguments are to be passed to it, by a direct call the the VMS $CREPAR system routine.)

Only used when loading the task.

Parameters
FlagThe value for the flag.
virtual void drama::Path::SetStackSize ( unsigned  bytes)
virtual

Set the stack size for the load.

Some operating systems (VxWorks) allow you to set the stack size when the program is loaded. This method allows you to set the value. It is ignored for other operation systems.

Parameters
bytesThe number of bytes. If 0, then use the default.
virtual void drama::Path::SetSymbols ( const bool  Flag = true)
inlinevirtual

Interpert file name as a symbol (VMS Target only)

Used where the target system is a VMS system to cover any ambiguity in the interpretation of a 'Program' string as either the actual name of a program to be executed or a symbol that causes a program to be executed. If this is set, it forces the string to be interpreted as a symbol.

Only used when loading the task.

Parameters
FlagThe value for the flag.

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

Click here for the DRAMA home page and here for the AAO home page.

For more information, contact tjf@aao.gov.au 

Generated on Mon Feb 22 2016 15:57:52 for AAO DRAMA/DRAMA2 C++ Interface by doxygen 1.8.10