Description :

    To be used by DIM Servers - Implements Command creation.
    DimCommand constructors add a DIM Command to the list of known services.
    The DimCommand will only be registered (published) and served after "Starting" the DimServer.
    DimCommands can be treated either by a command handler (asynchronously) or be queued and
    retrieved to the user when requested, please refer to Usage for examples.

Constructors :

• public DimCommand ( char * name, char * format) ; Create a DimCommand. Format parameter specifies the contents of the expected data in the form described here.
• public DimCommand ( char * name, char * format, DimCommandHandler * handler); Format parameter as above. A handler can be specified if a different class is handling the command (specially useful if a class is handling multiple commands, as in the example).  

• public ~ DimCommand ( ) ;

    Generic

• char* getName ( ) ; Get the command name.

• int getNext ( ) ; Get Next queued command. returns 1 if there is a command queued, 0 otherwise. After a getNext is issued and until the next one the methods in "Access to the Command Data" can be used in order to retrieve the command data.

• virtual void commandHandler ( ) ; To be overloaded if the user specified a handler. The methods in "Access to the Command Data" can be used inside the Handler in order to retrieve the command data:

• int getInt ( ) ; For an integer command.
• float getFloat ( ) ; A float.
• double getDouble ( ) ; A double.
• short getShort( ) ; A short.
• longlong getLonglong ( ) ; A longlong (64 bit).
• char* getString ( ) ; A character string.
• void* getData ( ) ; A structure or a vector.
• int getSize ( ) ; The size of the command data.

• DimCommand * getCommand ( ) ; The command received (See example)

    DimCommands can be created in three different ways
    Examples:

        - Without a handler:

            DimCommand runCmnd("DELPHI/RUNCMND","C");
            DimServer::start("DelphiServer");
            ...
            while(1)
            {
                sleep(5);
                while(runCmnd.getNext()) {
                    //treat the command
                    char *cmnd = runCmnd.getString();
                    ...
            }

        - Using a commandHandler

            class RunCmnd : public DimCommand // In order to inherit "commandHandler"
            {
                // Overloaded method commandHandler called whenever commands arrive,
                void commandHandler()
                { //treat the command
                    cout << "command " << getString() << " received" << endl;
                }
            public:
                // The constructor initializes the DimCommand
                RunCmnd() : DimCommand("/DELPHI/RUNCMND", "C") {};
            };

         - Using a CommandHandler for multiple Commands

            class RunCmnds : public DimCommandHandler // In order to inherit "commandHandler"
            {
                DimCommand *runNumber;
                DimCommand *runType;
                // Overloaded method commandHandler called whenever commands arrive,
                void comandHandler( )
                {
                    DimCommand *currCmnd = getCommand();
                    if(currCmnd == runNumber)
                    {
                        int run = currCmnd->getInt( );
                        // treat runNumber command
                    }
                    else
                    {
                        char *type = currCmnd->getString( );
                        // treat runType command
                    }
                }
            public:
                // The constructor creates the Commands
                RunCmnds( )
                {
                    runNumber = new DimCommand("/DELPHI/RUN_NUMBER/CMD", "I", this);
                    runType = new DimCommand("/DELPHI/RUN_TYPE/CMD", "C", this);
                }
            };