---

nodelink.cc

Go to the documentation of this file.

/*********************************************************************
* File: nodelink.cc                                                  *
* Description: C++ File for the RCS Systems Team's Library           *
* Purpose:                                                           *
*      NODE_LINK objects form links between NODEs and their          *
* subordinates or NODEs that provide them with WM info.              *
*********************************************************************/
#include "rcs_defs.hh"          /* EXTERN_C_STD_HEADERS */

/* Include Files */
#ifdef EXTERN_C_STD_HEADERS
extern "C"
{
#endif

#include <stdlib.h>             /* malloc(), free() */
#include <string.h>             /* strcpy(), strlen(), strcat() */

#ifdef EXTERN_C_STD_HEADERS
}
#endif

#include "nml.hh"               /* class NML */
#include "nmlmsg.hh"            /* class NMLmsg */
#include "cmd_msg.hh"           /* class RCS_CMD_MSG, RCS_CMD_CHANNEL, */
                                /* class RCS_GENERIC_CMD */
#include "stat_msg.hh"          /* class RCS_STAT_MSG, RCS_STAT_CHANNEL */
#include "wm_msg.hh"            /* class RCS_WM_MSG, RCS_WM_CHANNEL */
#include "node.hh"              /* class NODE */
#include "linklist.hh"          /* class RCS_LINKED_LIST */
#include "nodelink.hh"          /* class NODE_LINK */
#include "rcs_prnt.hh"          /* rcs_print_error(), rcs_print_debug() */

/* Constructors and Destructors */

/*******************************************************************
* Class: NODE_LINK                                                 *
* Function: (Constructor)                                          *
* Parameters:                                                      *
*    NML_FORMAT_PTR format_ptr; - pointer to a function which      *
*         handles the neutral data format encoding and decoding    *
*         for the buffers used by this node. (See NML Doc.)        *
*    char *n; - string including the name of this node             *
*          (The names of the buffers connecting to this name are   *
*           computed from my_name by adding suffixes like "_cmd".) *
*    char *file; - name of NML configuration file.                 *
*    NODE *node; - pointer to the node that is using this NODE_LINK*
*             (Normally node constructors should use "this" as     *
*              the node. )                                         *
* Purpose: To initialize a new NODE_LINK object.                   *
* NOTES: node->valid will be set to 0 if the NODE_LINK was not     *
* properly initialized.                                            *
* Returns: NONE.                                                   *
*******************************************************************/
NODE_LINK::NODE_LINK (NML_FORMAT_PTR f_ptr, char *n, char *file, NODE * node,
                      NODE_LINK_TYPE link_type)
{
  char *command_buffer;
  char *status_buffer;
  char *wm_buffer;

  /* Set pointers to dynamically allocated memory buffers to NULL */
  /* so the destructor */
  /* doesn't delete them unless they are actually created. */
  name = NULL;
  cmd = NULL;
  status = NULL;
  wm = NULL;
  parent_node = node;


  if (NULL == node)
    {
      rcs_print_error
        ("NODE_LINK::Constructor - parent node must not be NULL.\n");
      return;
    }

  if (!node->valid)
    {
      return;
    }

  type_of_link = link_type;


  /* Store the name in a new place. */
  name = (char *) malloc (strlen (n) + 1);
  if (NULL == name)
    {
      node->valid = 0;
      rcs_print_error ("%s: Error constructing NODE_LINK %s.\n", node->name,
                       n);
      return;
    }
  strcpy (name, n);

  if ((NODE_SUBORDINATE_ONLY == link_type)
      || (NODE_WM_AND_SUBORDINATE == link_type))
    {
      if (-1 ==
          (sub_list_id =
           parent_node->sub_list->store_at_tail (this, sizeof (NODE_LINK),
                                                 0)))
        {
          parent_node->valid = 0;
          rcs_print_error ("%s: Error constructing NODE_LINK to %s.\n",
                           node->name, n);
          return;
        }

      /* Compute command buffer name and create NML channel to it. */
      command_buffer =
        (char *) malloc (strlen (name) + RCS_COMMAND_SUFFIX_LENGTH + 1);
      if (NULL == command_buffer)
        {
          node->valid = 0;
          rcs_print_error ("%s: Error constructing NODE_LINK to %s.\n",
                           node->name, name);
          return;
        }
      strcpy (command_buffer, name);
      strcat (command_buffer, RCS_COMMAND_SUFFIX);      /* append suffix */
      cmd = new RCS_CMD_CHANNEL (f_ptr, command_buffer, node->name, file);
      free (command_buffer);

      if (NULL == cmd)
        {
          node->valid = 0;
          rcs_print_error ("%s: Error constructing NODE_LINK to %s.\n",
                           node->name, name);
          return;
        }
      if (!cmd->valid ())
        {
          node->valid = 0;
          rcs_print_error ("%s: Error constructing NODE_LINK to %s.\n",
                           node->name, name);
          return;
        }

      /* Create buffer to use for generic Commands(init, halt, etc.) */
      generic_command = new RCS_GENERIC_CMD;
      if (NULL == generic_command)
        {
          node->valid = 0;
          rcs_print_error ("%s: Error constructing NODE_LINK to %s.\n",
                           node->name, name);
          return;
        }

      /* Compute status buffer name and create NML channel to it. */
      status_buffer =
        (char *) malloc (strlen (name) + RCS_STATUS_SUFFIX_LENGTH + 1);
      if (NULL == status_buffer)
        {
          node->valid = 0;
          rcs_print_error ("%s: Error constructing NODE_LINK to %s.\n",
                           node->name, name);
          return;
        }
      strcpy (status_buffer, name);
      strcat (status_buffer, RCS_STATUS_SUFFIX);        /* append suffix */
      status = new RCS_STAT_CHANNEL (f_ptr, status_buffer, node->name, file);
      free (status_buffer);
      if (NULL == status)
        {
          node->valid = 0;
          rcs_print_error ("%s: Error constructing NODE_LINK to %s.\n",
                           node->name, name);
          return;
        }
      if (!status->valid ())
        {
          node->valid = 0;
          rcs_print_error ("%s: Error constructing NODE_LINK to %s.\n",
                           node->name, name);
          return;
        }

      node->num_of_subord++;
    }

  if ((NODE_WM_ONLY == link_type) || (NODE_WM_AND_SUBORDINATE == link_type))
    {
      if (-1 ==
          (wm_list_id =
           parent_node->wm_in_list->store_at_tail (this, sizeof (NODE_LINK),
                                                   0)))
        {
          parent_node->valid = 0;
          rcs_print_error ("%s: Error constructing NODE_LINK to %s.\n",
                           node->name, n);
          return;
        }

      /* Compute command buffer name and create NML channel to it. */
      wm_buffer = (char *) malloc (strlen (name) + RCS_WM_SUFFIX_LENGTH + 1);
      if (NULL == wm_buffer)
        {
          node->valid = 0;
          rcs_print_error ("%s: Error constructing NODE_LINK to %s.\n",
                           node->name, name);
          return;
        }
      strcpy (wm_buffer, name);
      strcat (wm_buffer, RCS_WM_SUFFIX);        /* append suffix */
      wm = new RCS_WM_CHANNEL (f_ptr, wm_buffer, node->name, file);
      free (wm_buffer);

      if (NULL == wm)
        {
          node->valid = 0;
          rcs_print_error ("%s: Error constructing NODE_LINK to %s.\n",
                           node->name, name);
          return;
        }
      if (!wm->valid ())
        {
          node->valid = 0;
          rcs_print_error ("%s: Error constructing NODE_LINK to %s.\n",
                           node->name, name);
          return;
        }
    }

  serial_number = 0;
  new_cmd = 0;

}

/*******************************************************************
* Class: NODE_LINK                                                 *
* Function: (Destructor)                                           *
* Parameters: NONE.                                                *
* Purpose: To deallocate and close a  NODE_LINK object.            *
* Returns: NONE.                                                   *
*******************************************************************/
NODE_LINK::~NODE_LINK ()
{
  if (NULL != parent_node)
    {
      if (NULL != parent_node->sub_list)
        {
          if ((NODE_SUBORDINATE_ONLY == type_of_link)
              || (NODE_WM_AND_SUBORDINATE == type_of_link))
            {
              parent_node->sub_list->delete_node (sub_list_id);
            }
          if ((NODE_WM_ONLY == type_of_link)
              || (NODE_WM_AND_SUBORDINATE == type_of_link))
            {
              parent_node->wm_in_list->delete_node (wm_list_id);
            }
        }
    }
  if (NULL != cmd)
    {
      delete cmd;
      cmd = NULL;
    }
  if (NULL != status)
    {
      delete status;
      status = NULL;
    }
  if (NULL != wm)
    {
      delete wm;
      wm = NULL;
    }
  if (NULL != name)
    {
      free (name);
      name = NULL;
    }
}

/*******************************************************************
* Class: NODE_LINK                                                  *
* Function: get_status                                             *
* Parameters: NONE.                                                *
* Outputs:                                                         *
*  RCS_STAT_MSG *status_msg; - set to point to the last status     *
*   message recieved.                                              *
*  NODE_STATUS node_status; - set to node_status of last status    *
*   message recieved unless the serial number doesn't match the    *
*   serial number of the last command sent.                        *
* Returns: 0 for success.                                          *
*          -1 if an error occured.                                 *
*******************************************************************/
int
NODE_LINK::get_status ()
{
  if (NULL == status)
    {
      return (-1);
    }

  if (-1 == (status_type = status->read ()))
    {
      node_status = NODE_ERROR;
      return (-1);
    }
  else if (0 != status_type)
    {
      status_msg = status->get_address ();
      node_status = (NODE_STATUS_TYPE) status_msg->node_status;
      if ((node_status == NODE_DONE) &&
          (serial_number != status_msg->serial_number))
        {
          node_status = NODE_WAITING;
        }

      rcs_print_debug (PRINT_STATUS_RECIEVED,
                       "%s: Recieved new status from %s.\n",
                       parent_node->name, name);
      rcs_print_debug (PRINT_STATUS_RECIEVED,
                       "  (type = %ld (0x%lX), serial_num = %d,",
                       status_msg->type,
                       status_msg->type, status_msg->serial_number);
      rcs_print_debug (PRINT_STATUS_RECIEVED, " status = %d)\n", node_status);
      status_new = 1;
    }
  else
    {
      status_new = 0;
    }

  return (0);
}

/*******************************************************************
* Class: NODE_LINK                                                 *
* Function: read_wm                                                *
* Parameters: NONE.                                                *
* Outputs:                                                         *
*  RCS_STAT_MSG *status_msg; - set to point to the last status     *
*   message recieved.                                              *
*  NODE_STATUS node_status; - set to node_status of last status    *
*   message recieved unless the serial number doesn't match the    *
*   serial number of the last command sent.                        *
* Returns: 0 for success.                                          *
*          -1 if an error occured.                                 *
*******************************************************************/
int
NODE_LINK::read_wm ()
{
  if (NULL == wm)
    {
      return (-1);
    }

  if (-1 == (wm_type = wm->read ()))
    {
      node_status = NODE_ERROR;
      return (-1);
    }
  else if (0 != wm_type)
    {
      wm_msg = wm->get_address ();
      new_wm = 1;
      rcs_print_debug (PRINT_NEW_WM,
                       "%s: Recieved new world model data from %s.\n",
                       parent_node->name, name);
      rcs_print_debug (PRINT_NEW_WM, " (type = %ld (0x%lX))", wm_msg->type,
                       wm_msg->type);
    }
  else
    {
      new_wm = 0;
    }

  return (0);
}

/*******************************************************************
* Class: NODE_LINK                                                  *
* Function: send_command                                           *
* Parameters: NONE.                                                *
* Outputs:                                                         *
* int serial_number; - incremented when a new command is sent.     *
* Returns: 0 for success.                                          *
*          -1 if an error occured.                                 *
*******************************************************************/
int
NODE_LINK::send_command ()
{
  if ((NULL == cmd) || (NULL == parent_node))
    {
      return (-1);
    }

  if (new_cmd)
    {
      serial_number++;
      cmd_msg->serial_number = serial_number;

      rcs_print_debug (PRINT_COMMANDS_SENT,
                       "%s: Sent new command to %s.\n", parent_node->name,
                       name);
      rcs_print_debug (PRINT_COMMANDS_SENT,
                       "  (type = %ld (0x%lX), serial_num = %d)\n",
                       cmd_msg->type, cmd_msg->type, serial_number);
      node_status = NODE_WAITING;
      if (parent_node->config_flags & NODE_WAIT_FOR_COMMANDS_TO_BE_READ)
        {
          if (-1 == cmd->write_if_read (cmd_msg))
            {
              if (cmd->error_type == NML_BUFFER_NOT_READ)
                {
                  return (0);
                }
              else
                {
                  node_status = NODE_ERROR;
                  return (-1);
                }
            }
        }
      else
        {
          if (-1 == cmd->write (cmd_msg))
            {
              node_status = NODE_ERROR;
              return (-1);
            }
        }
      new_cmd = 0;
    }

  return (0);
}

/*******************************************************************
* Class: NODE_LINK                                                  *
* Function: new_command                                            *
* Parameters:                                                      *
* RCS_CMD_MSG *new_cmd_msg; - pointer to the command you want      *
*     sent to the subordinate at the next time send_command is     *
*     called.                                                      *
* Outputs:                                                         *
*  RCS_CMD_MSG *cmd_msg; - set to parameter.                       *
*  int new_cmd; - set to one.
* Returns: NONE.                                                   *
*******************************************************************/
void
NODE_LINK::new_command (RCS_CMD_MSG * new_cmd_msg)
{
  cmd_msg = new_cmd_msg;
  new_cmd = 1;
  node_status = NODE_WAITING;
}


/*******************************************************************
* Class: NODE_LINK                                                  *
* Function: new_command                                            *
* Parameters:                                                      *
* RCS_GENERIC_COMMAND_ID    new_id - the id of a new command like  *
* init or halt for which a generic command exists.                 *
* Outputs:                                                         *
*  RCS_CMD_MSG *cmd_msg; - set to parameter.                       *
*  int new_cmd; - set to one.
* Returns: NONE.                                                   *
*******************************************************************/
void
NODE_LINK::new_command (RCS_GENERIC_CMD_ID new_id)
{
  generic_command->gen_id = new_id;
  cmd_msg = generic_command;
  new_cmd = 1;
}

---