Description :

    To be used by DIM Servers - Implements mainly static methods related to the Server.
    DimServer::start(<server name>) should be called after DimServices and/or DimCommands
    have been created, in order to register them within the DIM Name Server.
    DimServices created after "start" has been called will be automatically registered.
    The class DimServer can be inherited by user classes wishing to handle multiple DimCommands
    in the same class. Please refer to Usage for examples on the use of DimServer.

Constructors :

• public DimServer ( ) ;

• static void setDnsNode ( char * node_name) ; Sets the DNS node name for a DIM server (the default DNS node name is taken from the environment variable DIM_DNS_NODE).
• static void setDnsNode ( char * node_name, int port_number) ; Sets the DNS node name and port number for a DIM server (the default port number is 2505).
• static char *getDnsNode ( ) ; Gets the DNS node name defined for a DIM server.
• static int getDnsPort ( ) ; Gets the DNS port number defined for a DIM server.
• static void start ( char * name) ; Starts the Server i.e. Publishes all declared services and starts serving Client Requests. Services declared afterwards may or may not be automatically registered within the Name Server depending on the autoStart flag.
• static void autoStartOn ( ) ; Instructs the server to immediately register any new services after the first start(name) to the name server without waiting for a new start(name). This is the default.
• static void autoStartOff ( ) ; Instructs the server to wait for a new start(name) in order to register newly declared services.
• static int getClientId ( ) ; Get Current Client Identifier, returns a non-zero id only if the server is currently serving a Client, i.e inside the virtual methods : commandHandler and clientExitHandler.
• static char *getClientName ( ) ; Get Current Client Name, returns a non-zero name of the form "task@node" only if the server is currently serving a Client.
• static addExitHandler (DimExitHandler *handler ) ; Instruct the Server to execute the virtual method exitHandler whenever the DIM server is requested to exit.
• static addErrorHandler (DimErrorHandler *handler ) ; Instruct the Server to execute the virtual method errorHandler whenever the DIM server sees an error. If no errorHandler is declared the DIM server prints an error message.
• static addClientExitHandler (DimServer *handler ) ; Instruct the Server to execute the virtual method clientExitHandler whenever "special" clients die. A client can declare himself has a "special" client by executing setExitHandler or the Server can choose a client to be one of the "special" clients by using the two next methods.
• static setClientExitHandler ( int clientId) ; Sets a client exit handler for the client which clientId was returned from getClient().
• static clearClientExitHandler ( int clientId) ; Cancels the exit handler for clientId.
• virtual void clientExitHandler ( ) ; To be overloaded by the user. Gets called when "special" clients die.

• virtual void commandHandler ( ) ; The Server can be a DimCommand handler when multiple commands are to be treated as in the example.
• DimCommand* getCommand ( ) ; Can be used inside "commandHandler" in order to return a pointer to the command beeing handled.

    The DimServer class implements Server functions - the most important is "start".
    Example:

            DimService runNumber("DELPHI/RUN_NUMBER",123);
            DimServer::start("DelphiServer");

    DimServer can be used as a base class when the user class wishes to handle DimCommands using
    Handlers.
    Example:

                class Handler : public DimServer
                {
                    DimCommand cmd;
                    int val;
                    void commandHandler( ) { val = cmd.getInt( ); };
                public:
                    Handler( ) :
                         cmd("TEST/CMD", "I", this) {val = 0; };
                };
 

    The DimServer can also be used to set up exit handlers to be executed when "special" clients die.
    The installation of a exit handler for a client can be done in two ways:

        - The client decides it is one of the "special" ones. Example: The Server should die when the
        client dies.

            Server Part:

                class ClientHandler : public DimServer
                {
                public:
                    ClientHandler() {
                        DimServer::addClientExitHandler(this);
                        DimServer::start("TheServer"); };
                    void clientExitHandler( ) {
                        cout << "Client " << getClientName() << " died" << endl;
                        exit(0);
                    };
                };

             Client Part:

                main()
                {
                     DimClient::setExitHandler("TheServer");
                     ...
                }

        - The server decides a client is "special" - example: The Server wants to be "released" when the
          client that "allocated" it dies.

                class Allocation : public Server
                {
                    DimCommand *allocate;
                    int allocationState;
                public:
                    Allocation( ) {
                        allocate = new DimCommand("SRV/ALLOCATE","I",this);
                        DimServer::addClientExitHandler(this);
                        DimServer::start("SRV"};
                    void commandHandler( ); {
                        if ( getInt( ) == 1) {                     // Client Allocated
                            allocateState = 1;
                            DimServer::setClientExitHandler(DimServer::getClientId( )); // Set the exitHandler for this client
                        }
                        else {                                                 // Client Released
                            allocateState = 0;
                            DimServer::clearClientExitHandler(DimServer::getClientId( )); // Clear the exitHandler for this client
                        }
                     void clientExitHandler( ) {                       // Client died  (while Allocated) - Release
                        cout << "Client " << getClientName() << " died" << endl;
                        allocateState = 0;
                    };
                };