### Navigation

- index
- next |
- previous |
- Modeling Guide »

# 10. Appendix A

This appendix contains the example, user-written Java source code included with the Vortex OpenSplice Modeler `Chatroom` example. The Chatroom system is the example used in the Tutorial.

The source code is given in the following order:

> Chatter Application

> MessageBoard Application

> UserLoad Application

> Error Handler

## 10.1. A Chatroom Example, Java Source Code

### 10.1.1. Chatter Application

    ChatterApplication.java

    /*******************************************************************************
     * Copyright (c) 2012 to 2018 ADLINK Technology Limited. All rights Reserved.
     * LOGICAL_NAME: ChatterApplication.java
     * FUNCTION:     Vortex OpenSplice Modeler Tutorial example code.
     * MODULE:       Tutorial for the Java programming language.
     * DATE:         January 2012.
     * ***********************************************************************
     * This file contains the implementation for the 'Chatter' executable.
     ******************************************************************************/

    package Chat;

    import Chat.ChatMessage;
    import Chat.ChatMessageDataWriter;
    import Chat.NameService;
    import Chat.NameServiceDataWriter;
    import Chat.ChatterApplicationWrapper;
    import Chat.ChatterApplicationWrapper.WrapperException;
    import DDS.HANDLE_NIL;

    public class ChatterApplication
    {
       public static final int NUM_MSG = 10;

       public static final int TERMINATION_MESSAGE = -1;

       public static void main (String[] args)
       {

          try
          {
             /* Initialize the application */
             ChatterApplicationWrapper.start ();
          }
          catch (WrapperException e)
          {
             System.out.println ("Error while starting the application:");
             System.out.println (e.getReason ());
             return;
          }

          /* Type-specific DDS entities */
          ChatMessageDataWriter talker =
                ChatterApplicationWrapper.ParticipantWrapper.PublisherWrapper.
                ChatMessageDataWriterWrapper
                .getDataWriter ();

          NameServiceDataWriter nameServer =
                ChatterApplicationWrapper.ParticipantWrapper.PublisherWrapper.
                NameServiceDataWriterWrapper
                .getDataWriter ();

          /* DDS Identifiers */
          long userHandle;
          int status;

          /* Sample definitions */
          ChatMessage msg = new ChatMessage ();
          NameService ns = new NameService ();

          /* Others */
          int ownID = 1;
          String chatterName;

          /* Options: Chatter [ownID [name]] */
          if (args.length > 0)
          {
             ownID = Integer.parseInt (args[0]);
          }
          if (args.length > 1)
          {
             chatterName = args[1];
          }
          else
          {
             chatterName = "Chatter" + ownID;
          }

          /* Initialize the NameServer attributes */
          ns.userID = ownID;
          ns.name = chatterName;

          /*
           * Write the user-information into the system
           *(registering the instance implicitly)
           */
          status = nameServer.write (ns, HANDLE_NIL.value);
          ErrorHandler.checkStatus (status, "Chat.NameServiceDataWriter.write");

          /* Initialize the chat messages */
          msg.userID = ownID;
          msg.index = 0;

          if (ownID == TERMINATION_MESSAGE)
          {
             msg.content = "Termination message.";
          }
          else
          {
             msg.content = "Hi there, I will send you " + NUM_MSG + " more messages.";
          }
          System.out.println ("Writing message: \"" + msg.content + "\"");

          /*
           * Register a chat message for this user (pre-allocating resources for
           * it!!)
           */
          userHandle = talker.register_instance (msg);

          /* Write a message using the pre-generated instance handle */
          status = talker.write (msg, userHandle);
          ErrorHandler.checkStatus (status, "Chat.ChatMessageDataWriter.write");

          /* Write any number of messages */
          for (int i = 1; i <= NUM_MSG && ownID != TERMINATION_MESSAGE; i++)
          {
             try
             {
                Thread.sleep (1000); /* do not run so fast! */
             }
             catch (InterruptedException e)
             {
                e.printStackTrace ();
             }
             msg.index = i;
             msg.content = "Message no. " + i;
             System.out.println ("Writing message: \"" + msg.content + "\"");
             status = talker.write (msg, userHandle);
             ErrorHandler.checkStatus (status, "Chat.ChatMessageDataWriter.write");
          }

          /* Unregister the message instance for this user explicitly */
          status = talker.dispose(msg, userHandle);
          ErrorHandler.checkStatus(status, "Chat.ChatMessageDataWriter.dispose");
          status = talker.unregister_instance (msg, userHandle);
          ErrorHandler.checkStatus (status,
             "Chat.ChatMessageDataWriter.unregister_instance");

          /* Leave the room */
          status = nameServer.unregister_instance(ns, HANDLE_NIL.value);
          ErrorHandler.checkStatus (status, "Chat.NameServiceDataWriter.dispose");

          try
          {
             /* Stop the application */
             ChatterApplicationWrapper.stop ();
          }
          catch (WrapperException e)
          {
             System.out.println ("Error while stopping the application:");
             System.out.println (e.getReason ());
             return;
          }
       }
    }

### 10.1.2. MessageBoard Application

    MessageBoardApplication.java

    /************************************************************************
     *
     * Copyright (c) 2012 to 2018
     * ADLINK Technology Limited
     * All rights Reserved.
     *
     * LOGICAL_NAME:    MessageBoardApplication.java
     * FUNCTION:        Vortex OpenSplice Modeler Tutorial example code.
     * MODULE:          Tutorial for the Java programming language.
     * DATE             January 2012.
     ************************************************************************
     *
     * This file contains the implementation for the 'MessageBoardApplication'
     * executable.
     *
     ***/

    package Chat;

    import Chat.NamedMessageFilteredTopicWrapper;
    import Chat.MessageBoardApplicationWrapper;
    import Chat.MessageBoardApplicationWrapper.WrapperException;

    public class MessageBoardApplication extends Thread
    {
       public static void main (String[] args)
       {
          /* DDS Identifiers */
          String ownID = "0";

          /* Options: MessageBoard [ownID] */
          /* Messages having owner ownID will be ignored */
          if (args.length > 0)
          {
             ownID = args[0];
          }

          /* Initialize the content filtered topics expression parameters */
          try
          {
             NamedMessageFilteredTopicWrapper.setExpressionParameters (new String[]
             {
                ownID
             });
          }
          catch (NamedMessageFilteredTopicWrapper.WrapperException e)
          {
             System.out.println (
                "Exception occurred while setting the expression parameters:");
             System.out.println (e.getReason ());
             return;
          }

          /* Initialize the application */
          try
          {
             MessageBoardApplicationWrapper.start ();
          }
          catch (WrapperException e)
          {
             System.out.println ("Exception occurred while starting
                the application:");
             System.out.println (e.getReason ());
             return;
          }

          /* Create the listeners for the MessageBoard application */
          ChatMessageDataReaderListenerImpl chatMessageDataReaderListener =
              new ChatMessageDataReaderListenerImpl ();

          NamedMessageDataReaderListenerImpl namedMessageDataReaderListener =
              new NamedMessageDataReaderListenerImpl ();

          /* Print a message that the MessageBoard has opened. */
          System.out.println (
           "MessageBoard has opened: send ChatMessage with userID = -1 to close it.");
          System.out.println ();

          try
          {
             /* Attach the ChatMessageDataReaderListener to the
                ChatMessageDataReader */
             MessageBoardApplicationWrapper.PrivateParticipantWrapper
                .SubscriberWrapper.ChatMessageDataReaderWrapper.attach (
                chatMessageDataReaderListener);

             /*
              * Attach the NamedMessageDataReaderListener to the
              * NamedMessageDataReader
              */
             MessageBoardApplicationWrapper.ParticipantWrapper.SubscriberWrapper.
                NamedMessageDataReaderWrapper.attach (namedMessageDataReaderListener);

          }
          catch (WrapperException e)
          {
             System.out.println ("Exception occured while attaching a listener:");
             System.out.println (e.getReason ());
             try
             {
                MessageBoardApplicationWrapper.stop ();
             }
             catch (WrapperException eStop)
             {
                System.out.println ("Exception occured while stopping application:");
                System.out.println (eStop.getReason ());
             }
             return;
          }

          /* Wait for the ChatMessageDataReaderListener to finish */
          while (!chatMessageDataReaderListener.isTerminated ())
          {
             /*
              * Sleep for some amount of time, as not to consume too much CPU
              * cycles.
              */
             try
             {
                Thread.sleep (1000);
             }
             catch (InterruptedException e)
             {
                e.printStackTrace ();
             }
          }

          /* Wait for the NamedMessageDataReaderListener to finish */
          while (!namedMessageDataReaderListener.isTerminated ())
          {
             /*
              * Sleep for some amount of time, as not to consume too much CPU
              * cycles.
              */
             try
             {
                Thread.sleep (1000);
             }
             catch (InterruptedException e)
             {
                e.printStackTrace ();
             }
          }

          /* Print a message that the MessageBoard has terminated */
          System.out.println ("Termination message received: exiting...");

          try
          {
             /* Detach the ChatMessageDataReaderListener to ChatMessageDataReader */
             MessageBoardApplicationWrapper.PrivateParticipantWrapper
                .SubscriberWrapper.ChatMessageDataReaderWrapper.detach (
                chatMessageDataReaderListener);

             /*
              * Detach the NamedMessageDataReaderListener to the
              * NamedMessageDataReader
              */
             MessageBoardApplicationWrapper.ParticipantWrapper.SubscriberWrapper.
                NamedMessageDataReaderWrapper.detach (namedMessageDataReaderListener);
          }
          catch (WrapperException e)
          {
             System.out.println ("Exception occurred while detaching the listeners:");
             System.out.println (e.getReason ());
          }

          /* Cleanup listener */
          chatMessageDataReaderListener.cleanup ();

          /* Stop the application */
          try
          {
             MessageBoardApplicationWrapper.stop ();
          }
          catch (WrapperException e)
          {
             System.out.println ("Exception occurred while stopping application:");
             System.out.println (e.getReason ());
          }
       }
    }

#### 10.1.2.1. ChatMessageDataReaderListenerImpl.java

    ChatMessageDataReaderListenerImpl.java

    /************************************************************************
     * Copyright (c) 2012 to 2018 ADLINK Technology Limited. All rights Reserved.
     * LOGICAL_NAME: ChatMessageDataReaderListenerImpl.java
     * FUNCTION:     Vortex OpenSplice Modeler Tutorial example code
     * MODULE:       Tutorial for the Java programming language
     * DATE:         January 2012
     * This file contains the implementation for the 'MessageBoard' executable
     ***/

    package Chat;

    import Chat.ChatMessageDataReader;
    import Chat.ChatMessageSeqHolder;
    import Chat.NameServiceDataReader;
    import Chat.NameServiceSeqHolder;
    import Chat.NamedMessage;
    import Chat.NamedMessageDataWriter;
    import DDS.ANY_INSTANCE_STATE;
    import DDS.ANY_SAMPLE_STATE;
    import DDS.ANY_VIEW_STATE;
    import DDS.DataReader;
    import DDS.HANDLE_NIL;
    import DDS.LENGTH_UNLIMITED;
    import DDS.QueryCondition;
    import DDS.RETCODE_NO_DATA;
    import DDS.ReadCondition;
    import DDS.SampleInfoSeqHolder;
    import Chat.MessageBoardApplicationWrapper;
    import Chat.MessageBoardApplicationWrapper.ChatMessageDataReaderListener;

    public class ChatMessageDataReaderListenerImpl extends
    ChatMessageDataReaderListener
    {
       private static final int TERMINATION_MESSAGE = -1;

       private boolean isTerminated;

       /* Generic DDS entities */
       private QueryCondition nameFinder;

       private ReadCondition newMessages;

       /* Type-specific DDS entities */
       private ChatMessageDataReader chatMsgReader;

       private NameServiceDataReader nameServiceReader;

       private NamedMessageDataWriter namedMessageWriter;

       private ChatMessageSeqHolder chatMsgSeq;

       private SampleInfoSeqHolder chatMsgInfoSeq;

       private NameServiceSeqHolder nameServiceSeq;

       private SampleInfoSeqHolder nameServiceInfoSeq;

       /* Others */
       private String nameFinderExpr;

       private String[] nameFinderParams;

       private String userName;

       private int previousID;

       /* DDS Identifiers */
       private int status;

       /* Sample definitions */
       NamedMessage namedMsg;

       public ChatMessageDataReaderListenerImpl ()
       {
          /* Initialize termination flag */
          setTerminated (false);

          /* Type-specific DDS entities */
          chatMsgReader = MessageBoardApplicationWrapper.PrivateParticipantWrapper
             .SubscriberWrapper.ChatMessageDataReaderWrapper.getDataReader ();
          nameServiceReader = MessageBoardApplicationWrapper.PrivateParticipantWrapper
             .SubscriberWrapper.NameServiceDataReaderWrapper.getDataReader ();
          namedMessageWriter = MessageBoardApplicationWrapper
             .PrivateParticipantWrapper.PublisherWrapper.NamedMessageDataWriterWrapper
             .getDataWriter ();
          chatMsgSeq = new ChatMessageSeqHolder ();
          chatMsgInfoSeq = new SampleInfoSeqHolder ();
          nameServiceSeq = new NameServiceSeqHolder ();
          nameServiceInfoSeq = new SampleInfoSeqHolder ();

          /* Others */
          nameFinderExpr = "userID = %0";
          nameFinderParams = new String[]
          {
             "0"
          };
          userName = "";
          previousID = -1;

          /* Sample definitions */
          namedMsg = new NamedMessage ();

          /*
           * Create a QueryCondition that will look up the userName for a
           * specified userID
           */
          nameFinder = nameServiceReader.create_querycondition (
             ANY_SAMPLE_STATE.value, ANY_VIEW_STATE.value, ANY_INSTANCE_STATE.value,
             nameFinderExpr, nameFinderParams);
          ErrorHandler.checkHandle (nameFinder,
             "Chat.NameServiceDataReader.create_querycondition");

          newMessages = chatMsgReader.create_readcondition (ANY_SAMPLE_STATE.value,
             ANY_VIEW_STATE.value, ANY_INSTANCE_STATE.value);
          ErrorHandler.checkHandle (newMessages,
             "Chat.ChatMessageDataReader.create_readcondition");
       }

       @Override
       public void on_data_available(DataReader dataReader) {
          /* Ignore new data if termination message already received */
          if (isTerminated) {
             return;
          }

          boolean terminationReceived = false;

          if (dataReader.equals(chatMsgReader)) {
             status = chatMsgReader.take_w_condition(chatMsgSeq, chatMsgInfoSeq,
                   LENGTH_UNLIMITED.value, newMessages);
             ErrorHandler.checkStatus(status,
                   "Chat.ChatMessageDataReader.take_w_condition");

             /*
              * For each message, extract the key-field and find the
              * corresponding name
              */
             for (int i = 0; i < chatMsgSeq.value.length; i++) {
                /*
                 * Set program termination flag if termination message is
                 * received
                 */
                if (chatMsgSeq.value[i].userID == TERMINATION_MESSAGE) {
                   terminationReceived = true;
                   break;
                }

                /* Find the corresponding named message */
                if (chatMsgSeq.value[i].userID != previousID) {
                   previousID = chatMsgSeq.value[i].userID;
                   nameFinderParams[0] = Integer.toString(previousID);
                   status = nameFinder.set_query_parameters(nameFinderParams);
                   ErrorHandler
                         .checkStatus(status,
                            "QueryCondition.set_query_arguments (nameFinderParams)");
                   status = nameServiceReader.read_w_condition(nameServiceSeq,
                         nameServiceInfoSeq, LENGTH_UNLIMITED.value,
                         nameFinder);
                   ErrorHandler.checkStatus(status,
                         "Chat.NameServiceDataReader.read_w_condition");

                   /* Extract Name (there should only be one result) */
                   if (status == RETCODE_NO_DATA.value) {
                      userName = "Name not found!! id = " + previousID;
                   } else {
                      userName = nameServiceSeq.value[0].name;
                   }

                   /* Release the name sample again */
                   status = nameServiceReader.return_loan(nameServiceSeq,
                         nameServiceInfoSeq);
                   ErrorHandler.checkStatus(status,
                         "Chat.NameServiceDataReader.return_loan");
                }
                /* Write merged Topic with userName instead of userID */
                namedMsg.userName = userName;
                namedMsg.userID = previousID;
                namedMsg.index = chatMsgSeq.value[i].index;
                namedMsg.content = chatMsgSeq.value[i].content;

                if (chatMsgInfoSeq.value[i].valid_data)
                {
                   status = namedMessageWriter.write (namedMsg, HANDLE_NIL.value);
                   ErrorHandler.checkStatus (status,
                      "Chat.NamedMessageDataWriter.write");
                }
             }

             status = chatMsgReader.return_loan(chatMsgSeq, chatMsgInfoSeq);
             ErrorHandler.checkStatus(status,
                   "Chat.ChatMessageDataReader.return_loan");

             if (terminationReceived) {
                setTerminated(true);
             }
          }
       }

       public void cleanup ()
       {
          /* Remove all Read Conditions from the DataReaders */
          status = nameServiceReader.delete_readcondition (nameFinder);
          ErrorHandler.checkStatus (status, "Chat.NameServiceDataReader
          .delete_readcondition(nameFinder)");
          status = chatMsgReader.delete_readcondition (newMessages);
          ErrorHandler.checkStatus (status, "Chat.ChatMessageDataReader
          .delete_readcondition(newMessages)");
       }

       public synchronized boolean isTerminated ()
       {
          return isTerminated;
       }

       private synchronized void setTerminated (boolean isTerminated)
       {
          this.isTerminated = isTerminated;
       }
    }

#### 10.1.2.2. NamedMessageDataReaderListenerImpl.java

    NamedMessageDataReaderListenerImpl.java

    /************************************************************************
     *
     * Copyright (c) 2012 to 2018
     * ADLINK Technology Limited
     * All rights Reserved.
     *
     * LOGICAL_NAME:    NamedMessageDataReaderListenerImpl.java
     * FUNCTION:        Vortex OpenSplice Modeler Tutorial example code.
     * MODULE:          Tutorial for the Java programming language.
     * DATE             January 2012.
     ************************************************************************
     *
     * This file contains the implementation for the 'MessageBoard' executable.
     *
     ***/

    package Chat;

    import Chat.NamedMessageDataReader;
    import Chat.NamedMessageSeqHolder;
    import DDS.ALIVE_INSTANCE_STATE;
    import DDS.ANY_VIEW_STATE;
    import DDS.DataReader;
    import DDS.LENGTH_UNLIMITED;
    import DDS.NOT_READ_SAMPLE_STATE;
    import DDS.SampleInfoSeqHolder;
    import Chat.MessageBoardApplicationWrapper;
    import Chat.MessageBoardApplicationWrapper.NamedMessageDataReaderListener;

    public class NamedMessageDataReaderListenerImpl extends
          NamedMessageDataReaderListener {
       private boolean isTerminated;

       /* DDS Identifiers */
       private int status;

       /* Type-specific DDS entities */
       private NamedMessageDataReader namedMsgReader;
       private NamedMessageSeqHolder namedMsgSeq;
       private SampleInfoSeqHolder infoSeq;

       public NamedMessageDataReaderListenerImpl() {
          namedMsgReader = MessageBoardApplicationWrapper.ParticipantWrapper
             .SubscriberWrapper.NamedMessageDataReaderWrapper
             .getDataReader();
          namedMsgSeq = new NamedMessageSeqHolder();
          infoSeq = new SampleInfoSeqHolder();
       }

       @Override
       public void on_data_available(DataReader dataReader) {
          /* Set termination flag */
          setTerminated(false);

          status = namedMsgReader.take(namedMsgSeq, infoSeq,
                LENGTH_UNLIMITED.value, NOT_READ_SAMPLE_STATE.value,
                ANY_VIEW_STATE.value, ALIVE_INSTANCE_STATE.value);
          ErrorHandler.checkStatus(status, "Chat.NamedMessageDataReader.read");

          /* For each message, print the message */
          for (int i = 0; i < namedMsgSeq.value.length; i++) {
             System.out.println(namedMsgSeq.value[i].userName + ": "
                   + namedMsgSeq.value[i].content);
          }

          status = namedMsgReader.return_loan(namedMsgSeq, infoSeq);
          ErrorHandler.checkStatus(status,
                "Chat.NamedMessageDataReader.return_loan");

          namedMsgSeq.value = null;
          infoSeq.value = null;

          /* Unset termination flag */
          setTerminated(true);
       }

       public synchronized boolean isTerminated() {
          return isTerminated;
       }

       private synchronized void setTerminated(boolean isTerminated) {
          this.isTerminated = isTerminated;
       }
    }

### 10.1.3. UserLoad Application

    UserLoadApplication.java

    /*******************************************************************************

     * Copyright (c) 2012 to 2018
     * ADLINK Technology Limited
     * All rights Reserved.
     *
     * LOGICAL_NAME: UserLoadApplication.java
     * FUNCTION:     Vortex OpenSplice Modeler Tutorial example code.
     * MODULE:       Tutorial for the Java programming language.
     * DATE          January 2012.
     * ***********************************************************************
     *
     * This file contains the implementation for the 'UserLoadApplication' executable.
     *
     ******************************************************************************/

    package Chat;

    import Chat.UserLoadApplicationWrapper.WrapperException;
    import DDS.*;

    public class UserLoadApplication extends Thread
    {
       /* entities required by all threads */
       private static GuardCondition escape;

       /**
        * Sleeper thread: sleeps 60 seconds and then triggers the WaitSet
        */
       public void run ()
       {
          int status;

          try
          {
             sleep (60000);
          }
          catch (InterruptedException e)
          {
             e.printStackTrace ();
          }
          status = escape.set_trigger_value (true);
          ErrorHandler.checkStatus (status, "DDS.GuardCondition.set_trigger_value");
       }

       public static void main (String[] args)
       {

          boolean closed = false;
          int prevCount = 0;

          try
          {
             /* Initialize the application */
             UserLoadApplicationWrapper.start ();
          }
          catch (WrapperException e)
          {
             System.out.println ("Error while starting the application:");
             System.out.println (e.getReason ());
             return;
          }

          /* Initialize the arguments and params for the QueryCondition */
          String[] params;

          params = new String[]
          {
             "0"
          };

          try
          {
             UserLoadApplicationWrapper.QueryConditionWrapper.setQueryParameters (
                params);

             /* start the ChatMessageDataReaderWaitSet */
             UserLoadApplicationWrapper.UserLoadWaitSetWrapper.start ();
          }
          catch (WrapperException e)
          {
             System.out.println ("Error while initializing the application:");
             System.out.println (e.getReason ());
             return;
          }

          WaitSet userLoadWS = UserLoadApplicationWrapper.UserLoadWaitSetWrapper
             .getWaitSet ();

          /* Generic DDS entities */
          escape = UserLoadApplicationWrapper.GuardConditionWrapper
             .getGuardCondition ();
          QueryCondition singleUser = UserLoadApplicationWrapper
             .QueryConditionWrapper.getQueryCondition ();
          ReadCondition newUser = UserLoadApplicationWrapper.ReadConditionWrapper
             .getReadCondition ();
          StatusCondition leftUser = UserLoadApplicationWrapper.StatusConditionWrapper
             .getStatusCondition ();

          LivelinessChangedStatusHolder livChangedStatusHolder = new
             LivelinessChangedStatusHolder ();

          /* DDS Identifiers */
          int status;
          ConditionSeqHolder guardList = new ConditionSeqHolder ();

          /* Type-specific DDS entities */
          NameServiceDataReader nameServer = UserLoadApplicationWrapper
             .ParticipantWrapper.SubscriberWrapper.NameServiceDataReaderWrapper
             .getDataReader ();
          ChatMessageDataReader loadAdmin = UserLoadApplicationWrapper
             .ParticipantWrapper.SubscriberWrapper.ChatMessageDataReaderWrapper
             .getDataReader ();
          ChatMessageSeqHolder msgList = new ChatMessageSeqHolder ();
          NameServiceSeqHolder nsList = new NameServiceSeqHolder ();
          SampleInfoSeqHolder infoSeq = new SampleInfoSeqHolder ();
          SampleInfoSeqHolder infoSeq2 = new SampleInfoSeqHolder ();

          /*
           * Initialize and pre-allocate the GuardList used to obtain the triggered
           * Conditions.
           */
          guardList.value = new Condition[3];

          /* Remove all known Users that are not currently active. */
          status = nameServer.take (nsList, infoSeq, LENGTH_UNLIMITED.value,
             ANY_SAMPLE_STATE.value, ANY_VIEW_STATE.value,
             NOT_ALIVE_INSTANCE_STATE.value);
          ErrorHandler.checkStatus (status, "Chat.NameServiceDataReader.take");
          status = nameServer.return_loan (nsList, infoSeq);
          ErrorHandler.checkStatus (status, "Chat.NameServiceDataReader.return_loan");

          /* Start the sleeper thread */
          new UserLoadApplication ().start ();

          while (!closed)
          {
             /* Wait until at least one of the Conditions in the waitset triggers */
             status = userLoadWS._wait (guardList, DURATION_INFINITE.value);
             ErrorHandler.checkStatus (status, "DDS.WaitSet._wait");

             /* Walk over all the guards to display information */
             for (int i = 0; i < guardList.value.length; i++)
             {
                if (guardList.value[i] == newUser)
                {
                   /* The newUser ReadCondition contains data */
                   status = nameServer.read_w_condition (nsList, infoSeq,
                      LENGTH_UNLIMITED.value, newUser);
                   ErrorHandler.checkStatus (status,
                      "Chat.NameServiceDataReader.read_w_condition");

                   for (int j = 0; j < nsList.value.length; j++)
                   {
                      System.out.println ("New User: " + nsList.value[j].name);
                   }
                   status = nameServer.return_loan (nsList, infoSeq);
                   ErrorHandler.checkStatus (status,
                      "Chat.NameServiceDataReader.return_loan");
                }
                else if (guardList.value[i] == leftUser)
                {
                   /*
                    * Some liveliness has changed (either because a DataWriter
                    * joined or a DataWriter left
                    */
                   status = loadAdmin.get_liveliness_changed_status (
                      livChangedStatusHolder);
                   ErrorHandler.checkStatus (status,
                      "Chat.ChatMessageDataReader.get_liveliness_changed_status");

                   if (livChangedStatusHolder.value.alive_count < prevCount)
                   {
                      /*
                       * A user has left the ChatRoom, since a DataWriter lost its
                       * liveliness
                       */
                      /*
                       * Take the effected users so they will not appear in the list
                       * later on
                       */
                      status = nameServer.take (nsList, infoSeq,
                         LENGTH_UNLIMITED.value, ANY_SAMPLE_STATE.value,
                         ANY_VIEW_STATE.value, NOT_ALIVE_INSTANCE_STATE.value);
                      ErrorHandler.checkStatus (status,
                         "Chat.NameServiceDataReader.take");

                      for (int j = 0; j < nsList.value.length; j++)
                      {
                         /* re-apply query arguments */
                         params[0] = Integer.toString (nsList.value[j].userID);
                         status = singleUser.set_query_parameters (params);
                         ErrorHandler.checkStatus (status,
                            "DDS.QueryCondition.set_query_arguments");

                         /* Read this users history */
                         status = loadAdmin.take_w_condition (msgList, infoSeq2,
                            LENGTH_UNLIMITED.value, singleUser);
                         ErrorHandler.checkStatus (status,
                            "Chat.ChatMessageDataReader.read_w_condition");

                         /* Display the user and his history */
                         System.out.println ("Departed user " + nsList.value[j].name +
                             " had sent " + msgList.value.length + " messages.");
                         status = loadAdmin.return_loan (msgList, infoSeq2);
                         ErrorHandler.checkStatus (status,
                            "Chat.ChatMessageDataReader.return_loan");
                         msgList.value = null;
                         infoSeq2.value = null;
                      }
                      status = nameServer.return_loan (nsList, infoSeq);
                      ErrorHandler.checkStatus (status,
                         "Chat.NameServiceDataReader.return_loan");
                      nsList.value = null;
                      infoSeq.value = null;
                   }
                   prevCount = livChangedStatusHolder.value.alive_count;
                }
                else if (guardList.value[i] == escape)
                {
                   System.out.println ("UserLoad has terminated.");
                   closed = true;
                }
                else
                {
                   assert false : "Unknown Condition";
                }
             } /* for */
          } /* while (!closed) */

          try
          {
             /* Stop the application and free all resources */
             UserLoadApplicationWrapper.stop ();
          }
          catch (WrapperException e)
          {
             System.out.println ("Error while stopping the application:");
             System.out.println (e.getReason ());
             return;
          }
       }
    }

### 10.1.4. Error Handler

    ErrorHandler.java

    /************************************************************************
     *
     * Copyright (c) 2012 to 2018
     * ADLINK Technology Limited
     * All rights Reserved.
     *
     * LOGICAL_NAME: ErrorHandler.java
     * FUNCTION: Vortex OpenSplice Modeler Tutorial example code.
     * MODULE: Tutorial for the Java programming language.
     * DATE: January 2012.
     ************************************************************************
     *
     * This file contains the implementation for the error handling operations.
     *
     ***/

    package Chatroom;

    import DDS.RETCODE_NO_DATA;
    import DDS.RETCODE_OK;

    public class ErrorHandler
    {
       public static final int NR_ERROR_CODES = 12;

       /* Array to hold the names for all ReturnCodes. */
       public static String[] RetCodeName = new String[NR_ERROR_CODES];

       static
       {
          RetCodeName[0] = new String ("DDS_RETCODE_OK");
          RetCodeName[1] = new String ("DDS_RETCODE_ERROR");
          RetCodeName[2] = new String ("DDS_RETCODE_UNSUPPORTED");
          RetCodeName[3] = new String ("DDS_RETCODE_BAD_PARAMETER");
          RetCodeName[4] = new String ("DDS_RETCODE_PRECONDITION_NOT_MET");
          RetCodeName[5] = new String ("DDS_RETCODE_OUT_OF_RESOURCES");
          RetCodeName[6] = new String ("DDS_RETCODE_NOT_ENABLED");
          RetCodeName[7] = new String ("DDS_RETCODE_IMMUTABLE_POLICY");
          RetCodeName[8] = new String ("DDS_RETCODE_INCONSISTENT_POLICY");
          RetCodeName[9] = new String ("DDS_RETCODE_ALREADY_DELETED");
          RetCodeName[10] = new String ("DDS_RETCODE_TIMEOUT");
          RetCodeName[11] = new String ("DDS_RETCODE_NO_DATA");
       }

       /**
        * Returns the name of an error code.
        */
       public static String getErrorName (int status)
       {
          return RetCodeName[status];
       }

       /**
        * Check the return status for errors. If there is an error, then terminate.
        */
       public static void checkStatus (int status, String info)
       {
          if (status != RETCODE_OK.value && status != RETCODE_NO_DATA.value)
          {
             System.out.println ("Error in " + info + ": " + getErrorName (status));
             System.exit (-1);
          }
       }

       /**
        * Check whether a valid handle has been returned. If not, then terminate.
        */
       public static void checkHandle (Object handle, String info)
       {
          if (handle == null)
          {
             System.out.println ("Error in " + info +
                ": Creation failed: invalid handle");
             System.exit (-1);
          }
       }
    }

### Navigation

- index
- next |
- previous |
- Modeling Guide »