---

NML Class Reference

#include <nml.hh>

Inheritance diagram for NML:

[legend]Collaboration diagram for NML:

[legend]

Public Methods
void *	operator new (size_t)
void	operator delete (void *)
void	register_with_server ()
void	add_to_channel_list ()
NMLmsg *	get_address ()
void	delete_channel ()
NMLTYPE	read ()
NMLTYPE	blocking_read (double timeout)
NMLTYPE	peek ()
NMLTYPE	read (void *, long)
NMLTYPE	peek (void *, long)
int	write (NMLmsg &nml_msg)
int	write (NMLmsg *nml_msg)
int	write_if_read (NMLmsg &nml_msg)
int	write_if_read (NMLmsg *nml_msg)
NMLTYPE	blocking_read_extended (double timeout, double poll_interval)
int	write_subdivision (int subdiv, NMLmsg &nml_msg)
int	write_subdivision (int subdiv, NMLmsg *nml_msg)
int	write_if_read_subdivision (int subdiv, NMLmsg &nml_msg)
int	write_if_read_subdivision (int subdiv, NMLmsg *nml_msg)
NMLTYPE	read_subdivision (int subdiv)
NMLTYPE	blocking_read_subdivision (int subdiv, double timeout)
NMLTYPE	peek_subdivision (int subdiv)
NMLmsg *	get_address_subdivision (int subdiv)
int	get_total_subdivisions ()
void	clean_buffers ()
const char *	msg2str (NMLmsg &nml_msg)
const char *	msg2str (NMLmsg *nml_msg)
NMLTYPE	str2msg (const char *)
int	login (const char *name, const char *passwd)
void	reconnect ()
void	disconnect ()
int	valid ()
int	check_if_read ()
int	check_if_transfers_complete ()
int	clear ()
int	get_msg_count ()
NML_DIAGNOSTICS_INFO *	get_diagnostics_info ()
int	prefix_format_chain (NML_FORMAT_PTR)
	NML (NML_FORMAT_PTR f_ptr, char *, char *, char *, int set_to_server=0, int set_to_master=0)
	NML (NML *, int set_to_server=0, int set_to_master=0)
	NML (char *buffer_line, char *proc_line)
virtual	~NML ()
int	reset ()
int	print_queue_info ()
int	set_error ()
void	print_info (char *bufname=NULL, char *procname=NULL, char *cfg_file=NULL)
Data Fields
RCS_LINKED_LIST *	format_chain
int	channel_list_id
NML_ERROR_TYPE	error_type
NMLTYPE(*	phantom_read )()
NMLTYPE(*	phantom_peek )()
int(*	phantom_write )(NMLmsg *nml_msg)
int(*	phantom_write_if_read )(NMLmsg *nml_msg)
int(*	phantom_check_if_read )()
int(*	phantom_clear )()
int	ignore_format_chain
int	queue_length
NML_CHANNEL_TYPE	channel_type
long	sizeof_message_header
int	forced_type
Protected Methods
int	run_format_chain (NMLTYPE, void *)
int	format_input (NMLmsg *nml_msg)
int	format_output ()
	NML (char *, char *, char *, int set_to_server=0, int set_to_master=0)
void	reconstruct (NML_FORMAT_PTR, char *, char *, char *, int set_to_server=0, int set_to_master=0)
	NML (NML &nml)
Protected Attributes
int	fast_mode
int *	cms_status
long *	cms_inbuffer_header_size
int	info_printed
int	already_deleted
char	bufname [40]
char	procname [40]
char	cfgfilename [160]
double	blocking_read_poll_interval
CMS *	cms_for_msg_string_conversions

---

Constructor & Destructor Documentation

NML::NML (  NML_FORMAT_PTR    f_ptr, char *    buf, char *    proc, char *    file, int    set_to_server = 0, int    set_to_master = 0 )

Definition at line 211 of file nml.cc. { cms_for_msg_string_conversions = 0; info_printed = 0; blocking_read_poll_interval = -1.0; forced_type = 0; strncpy (bufname, buf, 40); strncpy (procname, proc, 40); if (NULL == file) { file = default_nml_config_file; } strncpy (cfgfilename, file, 160); if (rcs_errors_printed >= max_rcs_errors_to_print && max_rcs_errors_to_print > 0 && nml_reset_errors_printed) { rcs_errors_printed = 0; rcs_print ("\nResetting rcs_errors_printed because a new NML channel is being created.\n"); } already_deleted = 0; channel_type = NML_GENERIC_CHANNEL_TYPE; sizeof_message_header = sizeof (NMLmsg); reconstruct (f_ptr, buf, proc, file, set_to_server, set_to_master); if (NULL != cms) { cms->sizeof_message_header = sizeof_message_header; char *forced_type_eq = strstr (cms->buflineupper, "FORCE_TYPE="); if (forced_type_eq != NULL) { #ifndef UNDER_CE long temp = strtol (forced_type_eq + 11, NULL, 0); #else long temp = atol (forced_type_eq + 11); #endif if (temp > 0) { forced_type = temp; fast_mode = 0; } } } }

NML::NML (  NML *    nml_ptr, int    set_to_server = 0, int    set_to_master = 0 )

Definition at line 782 of file nml.cc. { cms_for_msg_string_conversions = 0; already_deleted = 0; forced_type = 0; cms = (CMS *) NULL; format_chain = (RCS_LINKED_LIST *) NULL; error_type = NML_NO_ERROR; ignore_format_chain = 0; channel_list_id = 0; fast_mode = 0; info_printed = 0; blocking_read_poll_interval = -1.0; channel_type = NML_GENERIC_CHANNEL_TYPE; sizeof_message_header = sizeof (NMLmsg); if (NULL != nml_ptr) { strncpy (bufname, nml_ptr->bufname, 40); strncpy (procname, nml_ptr->procname, 40); strncpy (cfgfilename, nml_ptr->cfgfilename, 160); if (NULL != nml_ptr->cms) { // Create a CMS channel identitical to the one from the argument // NML channel accept that the channel may be set_to_server or // set_to_master differently. cms_copy (&cms, nml_ptr->cms, set_to_server, set_to_master); if (NULL != cms) { cms->current_subdivision = nml_ptr->cms->current_subdivision; } } } if (!ignore_format_chain) { format_chain = new RCS_LINKED_LIST; if ((NULL != nml_ptr->format_chain) && (NULL != format_chain)) { RCS_LINKED_LIST *from, *to; NML_FORMAT_PTR format_func_ptr; from = nml_ptr->format_chain; to = format_chain; format_func_ptr = (NML_FORMAT_PTR) from->get_head (); while (NULL != format_func_ptr) { to->store_at_tail ((void *) format_func_ptr, 0, 0); format_func_ptr = (NML_FORMAT_PTR) from->get_next (); } } } if (NULL == cms) { return; } add_to_channel_list (); if (!cms->is_phantom && cms->ProcessType == CMS_LOCAL_TYPE && !cms->neutral && !cms->isserver) { fast_mode = 1; } cms_status = (int *) &(cms->status); cms_inbuffer_header_size = &(cms->header.in_buffer_size); char *forced_type_eq = strstr (cms->buflineupper, "FORCE_TYPE="); if (forced_type_eq != NULL) { #ifndef UNDER_CE long temp = strtol (forced_type_eq + 11, NULL, 0); #else long temp = atol (forced_type_eq + 11); #endif if (temp > 0) { forced_type = temp; fast_mode = 0; } } char *brpi_eq = strstr (cms->buflineupper, "BRPI="); if (brpi_eq != NULL) { #ifndef UNDER_CE blocking_read_poll_interval = strtod (brpi_eq + 5, NULL); #else blocking_read_poll_interval = RCS_CE_ATOF (brpi_eq + 5); #endif } if (NULL != nml_ptr->cms->dpi) { CMS_DIAG_PROC_INFO *dpi = cms->get_diag_proc_info (); *dpi = *(nml_ptr->cms->get_diag_proc_info ()); cms->set_diag_proc_info (dpi); } cms->first_diag_store = nml_ptr->cms->first_diag_store; if (NULL != cms->handle_to_global_data && NULL != nml_ptr->cms->handle_to_global_data) { cms->handle_to_global_data->total_bytes_moved = nml_ptr->cms->handle_to_global_data->total_bytes_moved; } }

NML::NML (  char *    buffer_line, char *    proc_line )

Definition at line 599 of file nml.cc. { cms_for_msg_string_conversions = 0; cms = (CMS *) NULL; blocking_read_poll_interval = -1.0; forced_type = 0; info_printed = 0; already_deleted = 0; format_chain = (RCS_LINKED_LIST *) NULL; phantom_read = (NMLTYPE (*)())NULL; phantom_peek = (NMLTYPE (*)())NULL; phantom_write = (int (*)(NMLmsg *)) NULL; phantom_write_if_read = (int (*)(NMLmsg *)) NULL; phantom_check_if_read = (int (*)()) NULL; phantom_clear = (int (*)()) NULL; channel_list_id = 0; error_type = NML_NO_ERROR; ignore_format_chain = 0; fast_mode = 0; channel_type = NML_GENERIC_CHANNEL_TYPE; sizeof_message_header = sizeof (NMLmsg); if (-1 == cms_create_from_lines (&cms, buffer_line, proc_line)) { if (verbose_nml_error_messages) { rcs_print_error ("NML: cms_create_from_lines returned -1.\n"); } if (!info_printed) { print_info (); } if (NULL != cms) { rcs_print_debug (PRINT_NML_DESTRUCTORS, " delete (CMS *) %X;\n", cms); delete cms; cms = (CMS *) NULL; } error_type = NML_INVALID_CONFIGURATION; return; } if (NULL == cms) { error_type = NML_INVALID_CONFIGURATION; return; } if (cms->status < 0) { error_type = NML_INVALID_CONFIGURATION; if (verbose_nml_error_messages) { rcs_print_error ("NML: cms->status = %d.\n", cms->status); } if (!info_printed) { print_info (); } rcs_print_debug (PRINT_NML_DESTRUCTORS, " delete (CMS *) %X;\n", cms); delete cms; cms = (CMS *) NULL; return; } add_to_channel_list (); if (!cms->is_phantom && cms->ProcessType == CMS_LOCAL_TYPE && !cms->neutral && !cms->isserver) { fast_mode = 1; } cms_status = (int *) &(cms->status); cms_inbuffer_header_size = &(cms->header.in_buffer_size); if (NULL != cms) { cms->sizeof_message_header = sizeof_message_header; char *forced_type_eq = strstr (cms->buflineupper, "FORCE_TYPE="); if (forced_type_eq != NULL) { #ifndef UNDER_CE long temp = strtol (forced_type_eq + 11, NULL, 0); #else long temp = atol (forced_type_eq + 11); #endif if (temp > 0) { forced_type = temp; fast_mode = 0; } } char *brpi_eq = strstr (cms->buflineupper, "BRPI="); if (brpi_eq != NULL) { #ifndef UNDER_CE blocking_read_poll_interval = strtod (brpi_eq + 5, NULL); #else blocking_read_poll_interval = RCS_CE_ATOF (brpi_eq + 5); #endif } } }

NML::~NML (    )  [virtual]

Definition at line 979 of file nml.cc. { if (already_deleted) { if (verbose_nml_error_messages) { rcs_print_error ("NML channel being deleted more than once.\n"); } } already_deleted = 1; delete_channel (); }

NML::NML (  char *    buf, char *    proc, char *    file, int    set_to_server = 0, int    set_to_master = 0 )  [protected]

Definition at line 459 of file nml.cc. { if (NULL == file) { file = default_nml_config_file; } cms_for_msg_string_conversions = 0; strncpy (bufname, buf, 40); strncpy (procname, proc, 40); strncpy (cfgfilename, file, 160); blocking_read_poll_interval = -1.0; info_printed = 0; forced_type = 0; already_deleted = 0; cms = (CMS *) NULL; format_chain = (RCS_LINKED_LIST *) NULL; phantom_read = (NMLTYPE (*)())NULL; phantom_peek = (NMLTYPE (*)())NULL; phantom_write = (int (*)(NMLmsg *)) NULL; phantom_write_if_read = (int (*)(NMLmsg *)) NULL; phantom_check_if_read = (int (*)()) NULL; phantom_clear = (int (*)()) NULL; channel_list_id = 0; error_type = NML_NO_ERROR; ignore_format_chain = 0; fast_mode = 0; channel_type = NML_GENERIC_CHANNEL_TYPE; sizeof_message_header = sizeof (NMLmsg); if (-1 == cms_config (&cms, buf, proc, file, set_to_server, set_to_master)) { if (verbose_nml_error_messages) { rcs_print_error ("NML: cms_config returned -1.\n"); } if (!info_printed) { print_info (buf, proc, file); } if (NULL != cms) { rcs_print_debug (PRINT_NML_DESTRUCTORS, " delete (CMS *) %X;\n", cms); delete cms; cms = (CMS *) NULL; } error_type = NML_INVALID_CONFIGURATION; return; } if (NULL == cms) { error_type = NML_INVALID_CONFIGURATION; if (!info_printed) { print_info (buf, proc, file); } return; } if (cms->status < 0) { error_type = NML_INVALID_CONFIGURATION; if (!info_printed) { print_info (buf, proc, file); } rcs_print_debug (PRINT_NML_DESTRUCTORS, " delete (CMS *) %X;\n", cms); delete cms; cms = (CMS *) NULL; return; } add_to_channel_list (); if (!cms->is_phantom && cms->ProcessType == CMS_LOCAL_TYPE && !cms->neutral && !cms->isserver) { fast_mode = 1; } cms_status = (int *) &(cms->status); cms_inbuffer_header_size = &(cms->header.in_buffer_size); if (NULL != cms) { cms->sizeof_message_header = sizeof_message_header; char *forced_type_eq = strstr (cms->buflineupper, "FORCE_TYPE="); if (forced_type_eq != NULL) { #ifndef UNDER_CE long temp = strtol (forced_type_eq + 11, NULL, 0); #else long temp = atol (forced_type_eq + 11); #endif if (temp > 0) { forced_type = temp; fast_mode = 0; } } char *brpi_eq = strstr (cms->buflineupper, "BRPI="); if (brpi_eq != NULL) { #ifndef UNDER_CE blocking_read_poll_interval = strtod (brpi_eq + 5, NULL); #else blocking_read_poll_interval = RCS_CE_ATOF (brpi_eq + 5); #endif } } }

NML::NML (  NML &    nml )  [protected]

Definition at line 3001 of file nml.cc. { }

---

Member Function Documentation

int NML::run_format_chain (  NMLTYPE    type, void *    buf )  [protected]

Definition at line 2336 of file nml.cc. Referenced by format_input(), and format_output(). { NML_FORMAT_PTR format_function; format_function = (NML_FORMAT_PTR) format_chain->get_head (); while (NULL != format_function) { switch ((*format_function) (type, buf, cms)) { case -1: return (-1); case 0: break; case 1: return (0); } format_function = (NML_FORMAT_PTR) format_chain->get_next (); } return (0); }

int NML::format_input (  NMLmsg *    nml_msg )  [protected]

Definition at line 2205 of file nml.cc. Referenced by msg2str(), write(), and write_if_read(). { NMLTYPE new_type; long new_size; if (NULL == cms) { return -1; } if (cms->force_raw) { cms->mode = CMS_RAW_IN; } switch (cms->mode) { case CMS_RAW_IN: /* Make sure the message size is not larger than the buffer size. */ if (nml_msg->size > cms->max_message_size) { rcs_print_error ("NML: Message size(%d) too large for" " CMS buffer size of %d.\n", nml_msg->size, cms->max_message_size); cms->status = CMS_INSUFFICIENT_SPACE_ERROR; return (-1); } cms->header.in_buffer_size = nml_msg->size; break; case CMS_ENCODE: /* Make sure the message size is not larger than the buffer size. */ if (nml_msg->size > cms->max_message_size) { rcs_print_error ("NML: Message size(%d) too large for" " CMS buffer size of %d.\n", nml_msg->size, cms->max_message_size); cms->status = CMS_INSUFFICIENT_SPACE_ERROR; return (-1); } cms->format_low_ptr = (char RCS_HUGE *) nml_msg; cms->format_high_ptr = cms->format_low_ptr + nml_msg->size; /* Handle the generic part of the message. */ cms->rewind (); /* Move to the start of the encoded buffer. */ cms->update (nml_msg->type); /* Store message type in encoded buffer. */ cms->update (nml_msg->size); /* Store message size in encoded buffer. */ /* Check list of format functions. */ if (!ignore_format_chain) { if (NULL == format_chain) { rcs_print_error ("NML::read: Format chain is NULL.\n"); return (-1); } /* Run through list of format functions. */ if (-1 == run_format_chain (nml_msg->type, nml_msg)) { rcs_print_error ("NMLwrite: format error\n"); if (verbose_nml_error_messages) { rcs_print_error (" (Buffer = %s, Process = %s)\n", cms->BufferName, cms->ProcessName); } return (-1); } } /* Determine the new size of the message now that its encoded. */ cms->header.in_buffer_size = cms->get_encoded_msg_size (); break; case CMS_DECODE: cms->format_low_ptr = cms->format_high_ptr = (char *) NULL; cms->rewind (); /* Move to the start of the encoded buffer. */ cms->update (new_type); /* Get message type from encoded buffer. */ cms->update (new_size); /* Get message size from encoded buffer. */ /* Make sure the message size is not larger than the buffer size. */ if (new_size > cms->max_message_size) { rcs_print_error ("NMLwrite: Message size(%d) too large for" " CMS buffer size of %d.\n", new_size, cms->max_message_size); cms->status = CMS_INSUFFICIENT_SPACE_ERROR; return (-1); } cms->format_low_ptr = (char RCS_HUGE *) cms->subdiv_data; cms->format_high_ptr = cms->format_low_ptr + cms->size; /* Store the new type and size in the raw message. */ ((NMLmsg *) cms->subdiv_data)->type = new_type; ((NMLmsg *) cms->subdiv_data)->size = new_size; /* Check the list of format functions. */ if (!ignore_format_chain) { if (NULL == format_chain) { rcs_print_error ("NML::read: Format chain is NULL.\n"); return (-1); } /* Run through the list of format functions. */ if (-1 == run_format_chain (new_type, cms->subdiv_data)) { rcs_print_error ("NMLwrite: format error\n"); rcs_print_error (" (Buffer = %s, Process = %s)\n", cms->BufferName, cms->ProcessName); return (-1); } } /* Choose a size that will ensure the entire message will be read out. */ if (cms->format_size < ((long) sizeof (NMLmsg))) { cms->format_size = sizeof (NMLmsg); } if (cms->format_size > new_size) { ((NMLmsg *) cms->subdiv_data)->size = (long) cms->format_size; } cms->header.in_buffer_size = ((NMLmsg *) cms->subdiv_data)->size; break; default: rcs_print_error ("NML::format_input: invalid mode (%d).\n", cms->mode); return (-1); } return (((int) cms->status < 0) ? -1 : 0); }

int NML::format_output (    )  [protected]

Definition at line 1727 of file nml.cc. Referenced by blocking_read(), peek(), read(), and str2msg(). { NMLTYPE new_type; long new_size; /* Check pointers */ if (NULL == cms) { rcs_print_error ("NML: cms is NULL.\n"); return (-1); } if (cms->force_raw) { return 0; } if (forced_type > 0) { new_type = forced_type; } switch (cms->mode) { case CMS_RAW_OUT: break; case CMS_DECODE: /* Check the status of CMS. */ if (cms->status == CMS_READ_OK) { /* Handle the generic part of the message. */ cms->format_low_ptr = cms->format_high_ptr = (char *) NULL; cms->rewind (); /* Move to the start of encoded buffer. */ cms->update (new_type); /* Get the message type from encoded buffer. */ cms->update (new_size); /* Get the message size from encoded buffer. */ if (forced_type > 0) { new_type = forced_type; } ((NMLmsg *) cms->subdiv_data)->type = new_type; /* Store type in message. */ ((NMLmsg *) cms->subdiv_data)->size = new_size; /* Store size in message. */ if (new_size > cms->max_message_size) { rcs_print_error ("NML: Message %ld of size %ld \n", new_type, new_size); rcs_print_error (" too large for local buffer of %s of size %d.\n", cms->BufferName, cms->max_message_size); if (verbose_nml_error_messages) { rcs_print_error ("Check that all processes agree on buffer size.\n"); } cms->status = CMS_INSUFFICIENT_SPACE_ERROR; return (-1); } /* Check the list of format functions. */ if (!ignore_format_chain) { cms->format_low_ptr = (char RCS_HUGE *) cms->subdiv_data; cms->format_high_ptr = cms->format_low_ptr + cms->size; if (NULL == format_chain) { rcs_print_error ("NML::read: Format chain is NULL.\n"); return (-1); } /* Run through the list of format functions. */ if (-1 == run_format_chain (new_type, cms->subdiv_data)) { rcs_print_error ("NMLread: NMLformat error\n"); if (verbose_nml_error_messages) { rcs_print_error (" (Buffer = %s, Process = %s)\n", cms->BufferName, cms->ProcessName); } return (-1); } } } break; case CMS_ENCODE: /* Check the status of CMS. */ if (cms->status != CMS_MISC_ERROR) { cms->format_low_ptr = cms->format_high_ptr = (char *) NULL; cms->rewind (); /* Move to the start of the encoded buffer. */ /* Get the type and size from the message. */ new_type = ((NMLmsg *) cms->subdiv_data)->type; new_size = ((NMLmsg *) cms->subdiv_data)->size; if (forced_type > 0) { new_type = forced_type; ((NMLmsg *) cms->subdiv_data)->type = forced_type; } /* Store the type and size in the encoded buffer. */ cms->update (new_type); cms->update (new_size); if (new_size > cms->max_message_size) { rcs_print_error ("NML: Message %ld of size %ld\n", new_type, new_size); rcs_print_error (" too large for local buffer of %s of size %d.\n", cms->BufferName, cms->max_message_size); if (verbose_nml_error_messages) { rcs_print_error ("Check that all processes agree on buffer size.\n"); } cms->status = CMS_INSUFFICIENT_SPACE_ERROR; return (-1); } /* Check the list of format functions. */ if (!ignore_format_chain) { cms->format_low_ptr = (char RCS_HUGE *) cms->subdiv_data; cms->format_high_ptr = cms->format_low_ptr + cms->size; if (NULL == format_chain) { rcs_print_error ("NML::read: Format chain is NULL.\n"); return (-1); } /* Run through the list of format functions. */ if (-1 == run_format_chain (new_type, cms->subdiv_data)) { rcs_print_error ("NMLread: NMLformat error\n"); if (verbose_nml_error_messages) { rcs_print_error (" (Buffer = %s, Process = %s)\n", cms->BufferName, cms->ProcessName); } return (-1); } /* Get the new size of the message now that it's been encoded. */ cms->get_encoded_msg_size (); } } break; default: rcs_print_error ("NML::format_output: invalid format mode. (%d)\n", cms->mode); return (-1); } if (forced_type > 0) { new_type = forced_type; ((NMLmsg *) cms->subdiv_data)->type = forced_type; } return (((int) cms->status < 0) ? -1 : 0); }

void * NML::operator new (  size_t    size )

Definition at line 122 of file nml.cc. { if (size < sizeof (NML)) { rcs_print_error ("void *NML::operator new() called with size (%d) < sizeof(NML) (%d) the code calling NML was probably not compiled with the correct header file version.\n", size, sizeof (NML)); size = sizeof (NML); } void *nml_space = NULL; char *cptr = (char *) NULL; int dynamic_list_id = 0; nml_space = DEBUG_MALLOC (size + sizeof (int) * 2); if (NULL != nml_space) { memset (nml_space, 0, size); } if (NULL == Dynamically_Allocated_NML_Objects) { Dynamically_Allocated_NML_Objects = new RCS_LINKED_LIST (); } if (NULL != Dynamically_Allocated_NML_Objects) { dynamic_list_id = Dynamically_Allocated_NML_Objects->store_at_tail (nml_space, sizeof (NML), 0); cptr = ((char *) nml_space) + sizeof (NML); // guarantee alignment cptr += sizeof (int) - (((int) cptr) % sizeof (int)); *((int *) cptr) = dynamic_list_id; } rcs_print_debug (PRINT_NML_CONSTRUCTORS, "%X = NML::operater new(%d)\n", nml_space, size); return nml_space; }

void NML::operator delete (  void *    nml_space )

Definition at line 159 of file nml.cc. { int dynamic_list_id = 0; char *cptr = (char *) NULL; rcs_print_debug (PRINT_NML_DESTRUCTORS, "NML::operater delete(%X)\n", nml_space); if (NULL == nml_space) { return; } if (NULL != Dynamically_Allocated_NML_Objects) { cptr = ((char *) nml_space) + sizeof (NML); cptr += sizeof (int) - (((int) cptr) % sizeof (int)); dynamic_list_id = *((int *) cptr); Dynamically_Allocated_NML_Objects->delete_node (dynamic_list_id); if (Dynamically_Allocated_NML_Objects->list_size == 0) { delete Dynamically_Allocated_NML_Objects; Dynamically_Allocated_NML_Objects = (RCS_LINKED_LIST *) NULL; } } DEBUG_FREE (nml_space); }

void NML::register_with_server (    )

Definition at line 745 of file nml.cc. Referenced by NML_ID_CHANNEL::NML_ID_CHANNEL(), NML_QUERY_CHANNEL::NML_QUERY_CHANNEL(), RCS_CMD_CHANNEL::RCS_CMD_CHANNEL(), RCS_OI_REPLY_CHANNEL::RCS_OI_REPLY_CHANNEL(), RCS_OI_REQUEST_CHANNEL::RCS_OI_REQUEST_CHANNEL(), RCS_STAT_CHANNEL::RCS_STAT_CHANNEL(), RCS_WM_CHANNEL::RCS_WM_CHANNEL(), reconstruct(), and reset(). { #if !defined(__MSDOS__) || defined(WIN32) if (NULL != cms) { if (cms->spawn_server) { if (NULL == NML_Default_Super_Server) { NML_Default_Super_Server = new NML_SUPER_SERVER; } NML_Default_Super_Server->add_to_list (this); } } #endif }

void NML::add_to_channel_list (    )

Definition at line 712 of file nml.cc. Referenced by NML(), reconstruct(), and reset(). { #ifdef VXWORKS pid = taskIdSelf (); #endif #ifdef _Windows #ifdef __WIN32__ task_handle = (void RCS_FAR *) GetCurrentThread (); #else task_handle = GetCurrentTask (); #endif #endif if (NULL == NML_Main_Channel_List) { NML_Main_Channel_List = new RCS_LINKED_LIST; } if (NULL != NML_Main_Channel_List) { channel_list_id = NML_Main_Channel_List->store_at_tail (this, sizeof (NML), 0); } }

NMLmsg * NML::get_address (    )

Reimplemented in NML_QUERY_CHANNEL, RCS_CMD_CHANNEL, RCS_OI_REQUEST_CHANNEL, RCS_OI_REPLY_CHANNEL, RCS_STAT_CHANNEL, and RCS_WM_CHANNEL. Definition at line 1030 of file nml.cc. Referenced by NML_QR_CLIENT::NML_QR_CLIENT(), RCS_WM_CHANNEL::get_address(), RCS_STAT_CHANNEL::get_address(), RCS_OI_REPLY_CHANNEL::get_address(), RCS_OI_REQUEST_CHANNEL::get_address(), NML_QUERY_CHANNEL::get_address(), RCS_CMD_CHANNEL::get_address(), nml_perf_combined_test(), nml_watch(), and NML_QR_CLIENT::reset(). { if (NULL == cms) { if (NULL != cms_for_msg_string_conversions) { return ((NMLmsg *) cms_for_msg_string_conversions->subdiv_data); } error_type = NML_INVALID_CONFIGURATION; return ((NMLmsg *) NULL); } else { return ((NMLmsg *) cms->subdiv_data); } }

void NML::delete_channel (    )

Definition at line 993 of file nml.cc. Referenced by nml_cleanup(), and ~NML(). { rcs_print_debug (PRINT_NML_DESTRUCTORS, "deleting NML (%d)\n", channel_list_id); if (NULL != cms_for_msg_string_conversions && cms != cms_for_msg_string_conversions) { delete cms_for_msg_string_conversions; cms_for_msg_string_conversions = 0; } if (NULL != cms) { rcs_print_debug (PRINT_NML_DESTRUCTORS, " delete (CMS *) %X;\n", cms); delete cms; cms = (CMS *) NULL; } if (NULL != format_chain) { delete format_chain; format_chain = (RCS_LINKED_LIST *) NULL; } if (NULL != NML_Main_Channel_List && (0 != channel_list_id)) { NML_Main_Channel_List->delete_node (channel_list_id); } rcs_print_debug (PRINT_NML_DESTRUCTORS, "Leaving ~NML()\n"); }

NMLTYPE NML::read (    )

Definition at line 1283 of file nml.cc. Referenced by NML_QR_CLIENT::NML_QR_CLIENT(), blocking_read_extended(), NODE::get_command_message(), RCS_OI::get_request(), NODE_LINK::get_status(), NODE::initialize_command_buffer(), nml_perf_combined_test(), NML_QR_SERVER::readQuery(), NML_MODULE::read_command_in(), read_subdivision(), NODE_LINK::read_wm(), NML_SERVER_LOCAL_PORT::reader(), and NML_QR_CLIENT::reset(). { error_type = NML_NO_ERROR; if (fast_mode) { cms->read (); switch (cms->status) { case CMS_READ_OLD: return (0); case CMS_READ_OK: if (((NMLmsg *) cms->subdiv_data)->type <= 0 && !cms->isserver) { rcs_print_error ("NML: New data recieved but type of %d is invalid.\n", ((NMLmsg *) cms->subdiv_data)->type); return -1; } return (((NMLmsg *) cms->subdiv_data)->type); default: set_error (); return -1; } } /* Check pointers. */ if (NULL == cms) { if (error_type != NML_INVALID_CONFIGURATION) { error_type = NML_INVALID_CONFIGURATION; rcs_print_error ("NML::read: CMS not configured.\n"); } return (-1); } /* Handle PHANTOMs */ if (cms->is_phantom) { if (NULL != phantom_read) { return ((*phantom_read) ()); } else { return (0); } } /* Read using CMS */ if (!cms->force_raw) { cms->set_mode (CMS_READ); } cms->read (); if (!cms->force_raw) { if (cms->status == CMS_READ_OK) { if (-1 == format_output ()) { error_type = NML_FORMAT_ERROR; return (-1); } } } /* Choose the return value. */ switch (cms->status) { case CMS_READ_OLD: error_type = NML_NO_ERROR; return (0); case CMS_READ_OK: error_type = NML_NO_ERROR; if (((NMLmsg *) cms->subdiv_data)->type <= 0 && !cms->isserver) { rcs_print_error ("NML: New data recieved but type of %d is invalid.\n", ((NMLmsg *) cms->subdiv_data)->type); return -1; } return (((NMLmsg *) cms->subdiv_data)->type); default: set_error (); return -1; } }

NMLTYPE NML::blocking_read (  double    blocking_timeout )

Definition at line 1393 of file nml.cc. Referenced by NML_SERVER_LOCAL_PORT::blocking_read(), blocking_read_extended(), blocking_read_subdivision(), and NML_QR_SERVER::waitForQuery(). { error_type = NML_NO_ERROR; if (fast_mode) { cms->blocking_read (blocking_timeout); switch (cms->status) { case CMS_READ_OLD: return (0); case CMS_READ_OK: if (((NMLmsg *) cms->subdiv_data)->type <= 0 && !cms->isserver) { rcs_print_error ("NML: New data recieved but type of %d is invalid.\n", ((NMLmsg *) cms->subdiv_data)->type); return -1; } return (((NMLmsg *) cms->subdiv_data)->type); case CMS_TIMED_OUT: error_type = NML_NO_ERROR; return 0; default: set_error (); return (-1); } } /* Check pointers. */ if (NULL == cms) { if (error_type != NML_INVALID_CONFIGURATION) { error_type = NML_INVALID_CONFIGURATION; rcs_print_error ("NML::blocking_read: CMS not configured.\n"); } return (-1); } /* Handle PHANTOMs */ if (cms->is_phantom) { if (NULL != phantom_read) { return ((*phantom_read) ()); } else { return (0); } } /* Read using CMS */ if (!cms->force_raw) { cms->set_mode (CMS_READ); } if (cms->BufferType == CMS_SHMEM_TYPE) { cms->blocking_read (blocking_timeout); } else { double time_elapsed = 0.0; double start_time = 0.0; if (blocking_timeout > 0.0) { start_time = etime (); } double current_brpi = blocking_read_poll_interval; cms->status = CMS_READ_OLD; if (current_brpi < 2e-2) { current_brpi = 2e-2; } if (current_brpi > blocking_timeout / 2.0 && blocking_timeout > 1e-6) { current_brpi = blocking_timeout / 2.0; } while (cms->status == CMS_READ_OLD && (time_elapsed < blocking_timeout || blocking_timeout < 0.0)) { esleep (current_brpi); cms->read (); if (blocking_timeout > 0.0 && cms->status == CMS_READ_OLD) { time_elapsed = etime () - start_time; } if (time_elapsed < 0.0) { break; } } } if (!cms->force_raw) { if (cms->status == CMS_READ_OK) { if (-1 == format_output ()) { error_type = NML_FORMAT_ERROR; return (-1); } } } /* Choose the return value. */ switch (cms->status) { case CMS_READ_OLD: return (0); case CMS_READ_OK: if (((NMLmsg *) cms->subdiv_data)->type <= 0 && !cms->isserver) { rcs_print_error ("NML: New data recieved but type of %d is invalid.\n", ((NMLmsg *) cms->subdiv_data)->type); return -1; } return (((NMLmsg *) cms->subdiv_data)->type); case CMS_TIMED_OUT: error_type = NML_NO_ERROR; return 0; default: set_error (); return (-1); } }

NMLTYPE NML::peek (    )

Definition at line 1613 of file nml.cc. Referenced by nml_watch(), peek(), peek_subdivision(), read(), and NML_SERVER_LOCAL_PORT::reader(). { error_type = NML_NO_ERROR; if (fast_mode) { cms->peek (); switch (cms->status) { case CMS_READ_OLD: return (0); case CMS_READ_OK: if (((NMLmsg *) cms->subdiv_data)->type <= 0 && !cms->isserver) { rcs_print_error ("NML: New data recieved but type of %d is invalid.\n", ((NMLmsg *) cms->subdiv_data)->type); return -1; } return (((NMLmsg *) cms->subdiv_data)->type); default: set_error (); return -1; } } if (NULL == cms) { if (error_type != NML_INVALID_CONFIGURATION) { error_type = NML_INVALID_CONFIGURATION; rcs_print_error ("NML::peek: CMS not configured.\n"); } return (-1); } if (cms->is_phantom) { if (NULL != phantom_peek) { return ((*phantom_peek) ()); } else { return (0); } } if (!cms->force_raw) { cms->set_mode (CMS_READ); } cms->peek (); if (!cms->force_raw) { if (cms->status == CMS_READ_OK) { if (-1 == format_output ()) { error_type = NML_FORMAT_ERROR; return (-1); } } } switch (cms->status) { case CMS_READ_OLD: return (0); case CMS_READ_OK: if (((NMLmsg *) cms->subdiv_data)->type <= 0 && !cms->isserver) { rcs_print_error ("NML: New data recieved but type of %d is invalid.\n", ((NMLmsg *) cms->subdiv_data)->type); return -1; } return (((NMLmsg *) cms->subdiv_data)->type); default: set_error (); return -1; } }

NMLTYPE NML::read (  void *    temp_data, long    temp_size )

Definition at line 1549 of file nml.cc. { NMLTYPE return_value = 0; void *original_data; long original_size = cms->size; long original_max_message_size = cms->max_message_size; original_data = cms->data; cms->data = temp_data; cms->size = temp_size; if (cms->max_message_size > ((long) temp_size)) { cms->max_message_size = temp_size; } return_value = peek (); cms->data = original_data; cms->size = original_size; cms->max_message_size = original_max_message_size; return return_value; }

NMLTYPE NML::peek (  void *    temp_data, long    temp_size )

Definition at line 1572 of file nml.cc. { NMLTYPE return_value = 0; void *original_data; long original_size = cms->size; long original_max_message_size = cms->max_message_size; original_data = cms->data; cms->data = temp_data; cms->size = temp_size; if (cms->max_message_size > ((long) temp_size)) { cms->max_message_size = temp_size; } return_value = peek (); cms->data = original_data; cms->size = original_size; cms->max_message_size = original_max_message_size; return return_value; }

int NML::write (  NMLmsg &    nml_msg )

Definition at line 1901 of file nml.cc. Referenced by NML_QR_CLIENT::NML_QR_CLIENT(), NODE::initialize_command_buffer(), NODE::initialize_status_buffer(), NODE::initialize_world_model_buffer(), NML_MODULE::logError(), NML_MODULE::logText(), logTextToNML(), NML_QR_SERVER::readQuery(), NML_MODULE::requestDisplay(), NML_QR_CLIENT::reset(), NML_QR_CLIENT::sendQuery(), NODE_LINK::send_command(), RCS_OI::send_reply(), NODE::send_status_message(), NML_MODULE::setSelfCommand(), NML_QR_SERVER::waitForQuery(), NML_MODULE::write_status_out(), write_subdivision(), NODE::write_world_model_out(), NML_SERVER_LOCAL_PORT::writer(), and NML_QR_CLIENT::~NML_QR_CLIENT(). { return (write (&nml_msg)); /* Call the other NML::write() */ }

int NML::write (  NMLmsg *    nml_msg )

Definition at line 1916 of file nml.cc. { error_type = NML_NO_ERROR; if (fast_mode) { *cms_inbuffer_header_size = nml_msg->size; cms->write (nml_msg); if (*cms_status == CMS_WRITE_OK) { return (0); } set_error (); return (-1); } /* Check pointers. */ if (NULL == cms) { if (error_type != NML_INVALID_CONFIGURATION) { error_type = NML_INVALID_CONFIGURATION; rcs_print_error ("NML::write: CMS not configured.\n"); } return (-1); } if (NULL == nml_msg) { error_type = NML_INVALID_MESSAGE_ERROR; rcs_print_error ("NML::write: Message is NULL.\n"); return (-1); } if ((nml_msg->size == 0 || nml_msg->type == 0) && !cms->isserver) { error_type = NML_INVALID_MESSAGE_ERROR; rcs_print_error ("NML::write: Message size or type is zero.\n"); rcs_print_error ("NML: Check that the message was properly constructed.\n"); } /* Handle Phantom Buffers. */ if (cms->is_phantom) { if (NULL != phantom_write) { return ((*phantom_write) (nml_msg)); } else { return (0); } } /* Set CMS to a write mode. */ cms->set_mode (CMS_WRITE); /* Format the message if neccessary. */ if (-1 == format_input (nml_msg)) { error_type = NML_FORMAT_ERROR; return -1; } if (CMS_RAW_IN == cms->mode) { cms->write (nml_msg); /* Write the unformatted message. */ } else { cms->write (cms->subdiv_data); /* Write the formatted message. */ } if (CMS_WRITE_OK == cms->status) { error_type = NML_NO_ERROR; return (0); } return set_error (); }

int NML::write_if_read (  NMLmsg &    nml_msg )

Definition at line 2087 of file nml.cc. Referenced by NODE_LINK::send_command(), write_if_read_subdivision(), and NML_SERVER_LOCAL_PORT::writer(). { return (write_if_read (&nml_msg)); }

int NML::write_if_read (  NMLmsg *    nml_msg )

Definition at line 2105 of file nml.cc. { error_type = NML_NO_ERROR; if (fast_mode) { cms->header.in_buffer_size = nml_msg->size; cms->write (nml_msg); if (cms->status == CMS_WRITE_OK) { return (0); } set_error (); return (-1); } if (NULL == cms) { if (error_type != NML_INVALID_CONFIGURATION) { error_type = NML_INVALID_CONFIGURATION; rcs_print_error ("NML::write_if_read: CMS not configured.\n"); } return (-1); } if (NULL == nml_msg) { error_type = NML_INVALID_MESSAGE_ERROR; rcs_print_error ("NML::write_if_read: Message is NULL.\n"); return (-1); } if ((nml_msg->size == 0 || nml_msg->type == 0) && !cms->isserver) { error_type = NML_INVALID_MESSAGE_ERROR; rcs_print_error ("NML::write_if_read: Message size or type is zero.\n"); if (verbose_nml_error_messages) { rcs_print_error ("NML: Check that the message was properly constructed.\n"); } } if (cms->is_phantom) { if (NULL != phantom_write_if_read) { return ((*phantom_write_if_read) (nml_msg)); } else { return (0); } } cms->set_mode (CMS_WRITE); if (-1 == format_input (nml_msg)) { error_type = NML_FORMAT_ERROR; return -1; } if (CMS_RAW_IN == cms->mode) { cms->write_if_read (nml_msg); } else { cms->write_if_read (cms->subdiv_data); } return (set_error ()); }

NMLTYPE NML::blocking_read_extended (  double    timeout, double    poll_interval )

Definition at line 3007 of file nml.cc. { if (cms == NULL) { return -1; } if (cms->BufferType == CMS_SHMEM_TYPE) { return blocking_read (timeout); } else { NMLTYPE type = 0; double time_elapsed = 0.0; double start_time = etime (); while (!type && (time_elapsed < timeout || timeout < 0.0)) { esleep (poll_interval); type = read (); if (timeout > 0.0 && !type) { time_elapsed = etime () - start_time; } if (time_elapsed < 0.0) { break; } } return type; } }

int NML::write_subdivision (  int    subdiv, NMLmsg &    nml_msg )

Definition at line 2900 of file nml.cc. Referenced by NML_QR_SERVER::replyToLastQuery(). { if (NULL != cms) { if (cms->set_subdivision (subdiv) < 0) { return -1; } } return write (nml_msg); }

int NML::write_subdivision (  int    subdiv, NMLmsg *    nml_msg )

Definition at line 2915 of file nml.cc. { if (NULL != cms) { if (cms->set_subdivision (subdiv) < 0) { return -1; } } return write (nml_msg); }

int NML::write_if_read_subdivision (  int    subdiv, NMLmsg &    nml_msg )

Definition at line 2930 of file nml.cc. { if (NULL != cms) { if (cms->set_subdivision (subdiv) < 0) { return -1; } } return write_if_read (nml_msg); }

int NML::write_if_read_subdivision (  int    subdiv, NMLmsg *    nml_msg )

Definition at line 2944 of file nml.cc. { if (NULL != cms) { if (cms->set_subdivision (subdiv) < 0) { return -1; } } return write_if_read (nml_msg); }

NMLTYPE NML::read_subdivision (  int    subdiv )

Definition at line 2959 of file nml.cc. Referenced by NML_QR_CLIENT::readReply(). { if (NULL != cms) { if (cms->set_subdivision (subdiv) < 0) { return -1; } } return read (); }

NMLTYPE NML::blocking_read_subdivision (  int    subdiv, double    timeout )

Definition at line 2974 of file nml.cc. Referenced by NML_QR_CLIENT::waitForReply(). { if (NULL != cms) { if (cms->set_subdivision (subdiv) < 0) { return -1; } } return blocking_read (timeout); }

NMLTYPE NML::peek_subdivision (  int    subdiv )

Definition at line 2988 of file nml.cc. { if (NULL != cms) { if (cms->set_subdivision (subdiv) < 0) { return -1; } } return peek (); }

NMLmsg * NML::get_address_subdivision (  int    subdiv )

Definition at line 1056 of file nml.cc. Referenced by NML_QR_CLIENT::getReplyAddress(). { if (NULL == cms) { error_type = NML_INVALID_CONFIGURATION; return ((NMLmsg *) NULL); } else { cms->set_subdivision (subdiv); return ((NMLmsg *) cms->subdiv_data); } }

int NML::get_total_subdivisions (    )

Definition at line 1078 of file nml.cc. Referenced by NML_QR_SERVER::NML_QR_SERVER(), NML_QR_SERVER::readQuery(), NML_QR_SERVER::replyToLastQuery(), and NML_QR_SERVER::waitForQuery(). { if (NULL == cms) { return (1); } else { return (cms->total_subdivisions); } }

void NML::clean_buffers (    )

Definition at line 1148 of file nml.cc. { if (NULL != cms) { cms->clean_buffers (); } }

const char * NML::msg2str (  NMLmsg &    msg )

Definition at line 2397 of file nml.cc. { return msg2str (&msg); }

const char * NML::msg2str (  NMLmsg *    nml_msg )

Definition at line 2410 of file nml.cc. { CMS *orig_cms = cms; char *str = NULL; if (NULL == nml_msg) { return NULL; } if (NULL == cms) { int msg_length = nml_msg->size; if (NULL != cms_for_msg_string_conversions) { if ((cms_for_msg_string_conversions->size > 16 * msg_length && cms_for_msg_string_conversions->size > 2048) || cms_for_msg_string_conversions->size < 4 * msg_length) { delete cms_for_msg_string_conversions; cms_for_msg_string_conversions = 0; } } if (NULL == cms_for_msg_string_conversions) { cms_for_msg_string_conversions = new CMS (nml_msg->size * 4 + 16 + (16 - (nml_msg->size % 16))); } cms = cms_for_msg_string_conversions; } cms->set_temp_updater (CMS_DISPLAY_ASCII_ENCODING); cms->set_mode (CMS_ENCODE); if (-1 == format_input (nml_msg)) { cms->restore_normal_updater (); error_type = NML_FORMAT_ERROR; cms = orig_cms; return ((char *) NULL); } cms->restore_normal_updater (); str = (char *) cms->encoded_data; cms = orig_cms; return (const char *) str; }

NMLTYPE NML::str2msg (  const char *    string )

Definition at line 2460 of file nml.cc. { CMS *orig_cms = cms; if (NULL == string) { return -1; } if (NULL == cms) { int string_length = strlen (string); if (NULL != cms_for_msg_string_conversions) { if ((cms_for_msg_string_conversions->size > 16 * string_length && cms_for_msg_string_conversions->size > 2048) || cms_for_msg_string_conversions->size < 4 * string_length) { delete cms_for_msg_string_conversions; cms_for_msg_string_conversions = 0; } } if (NULL == cms_for_msg_string_conversions) { cms_for_msg_string_conversions = new CMS (string_length * 4 + 16 + (16 - (string_length % 16))); } cms = cms_for_msg_string_conversions; } cms->set_temp_updater (CMS_DISPLAY_ASCII_ENCODING); cms->set_mode (CMS_DECODE); strcpy ((char *) cms->encoded_data, (const char *) string); cms->status = CMS_READ_OK; if (-1 == format_output ()) { cms->restore_normal_updater (); error_type = NML_FORMAT_ERROR; cms = orig_cms; return -1; } cms->restore_normal_updater (); cms = orig_cms; switch (cms->status) { case CMS_READ_OLD: error_type = NML_NO_ERROR; return (0); case CMS_READ_OK: error_type = NML_NO_ERROR; return (((NMLmsg *) cms->subdiv_data)->type); case CMS_TIMED_OUT: error_type = NML_TIMED_OUT; return -1; case CMS_MISC_ERROR: case CMS_NO_MASTER_ERROR: error_type = NML_INTERNAL_CMS_ERROR; default: return -1; } }

int NML::login (  const char *    name, const char *    passwd )

Definition at line 307 of file nml.cc. { if (NULL == cms) { return 1; } return cms->login (name, passwd); }

void NML::reconnect (    )

Definition at line 1529 of file nml.cc. { if (NULL != cms) { cms->reconnect (); } }

void NML::disconnect (    )

Definition at line 1538 of file nml.cc. { if (NULL != cms) { cms->disconnect (); } }

int NML::valid (    )

Definition at line 1214 of file nml.cc. Referenced by NML_QR_CLIENT::NML_QR_CLIENT(), NODE_LINK::NODE_LINK(), NODE::check_if_valid(), create_NML(), NODE::initialize_command_buffer(), NODE::initialize_status_buffer(), NODE::initialize_world_model_buffer(), NML_MODULE::logError(), NML_MODULE::logText(), main(), nml_watch(), NML_MODULE::requestDisplay(), NML_QR_CLIENT::reset(), NML_QR_SERVER::reset(), reset(), NML_MODULE::setCmdChannel(), NML_MODULE::setErrorLogChannel(), NML_MODULE::setStatChannel(), NML_QR_CLIENT::valid(), and NML_QR_SERVER::valid(). { if (NULL == cms) { error_type = NML_INVALID_CONFIGURATION; return (0); } if (cms->is_phantom) { error_type = NML_NO_ERROR; return (1); } if (CMS_MISC_ERROR == cms->status) { error_type = NML_INTERNAL_CMS_ERROR; return (0); } if (CMS_NO_MASTER_ERROR == cms->status) { error_type = NML_NO_MASTER_ERROR; return (0); } if (NULL == cms->data) { error_type = NML_INVALID_CONFIGURATION; return (0); } if (cms->neutral && (NULL == cms->encoded_data) && !cms->isserver) { error_type = NML_INVALID_CONFIGURATION; return (0); } if (!ignore_format_chain) { if (NULL == format_chain) { error_type = NML_INVALID_CONFIGURATION; return (0); } } error_type = NML_NO_ERROR; return (1); }

int NML::check_if_read (    )

Definition at line 1171 of file nml.cc. { if (NULL == cms) { error_type = NML_INVALID_CONFIGURATION; return (-1); } else { if (cms->is_phantom) { if (NULL != phantom_check_if_read) { return ((*phantom_check_if_read) ()); } else { return (0); } } int return_value; error_type = NML_NO_ERROR; if ((return_value = cms->check_if_read ()) == -1) { error_type = NML_INTERNAL_CMS_ERROR; } if (cms->status == CMS_TIMED_OUT) { error_type = NML_TIMED_OUT; } return (return_value); } }

int NML::check_if_transfers_complete (    )

Definition at line 2380 of file nml.cc. { if (NULL == cms) { return 1; } return cms->check_if_transfers_complete (); }

int NML::clear (    )

Definition at line 1108 of file nml.cc. { if (NULL == cms) { error_type = NML_INVALID_CONFIGURATION; return (-1); } else { if (cms->is_phantom) { if (NULL != phantom_clear) { return ((*phantom_clear) ()); } else { return (0); } } CMS_STATUS return_value; error_type = NML_NO_ERROR; if (((int) (return_value = cms->clear ())) > 0) { error_type = NML_INTERNAL_CMS_ERROR; } if (cms->status == CMS_TIMED_OUT) { error_type = NML_TIMED_OUT; } return (((int) return_value < 0) ? -1 : 0); } }

int NML::get_msg_count (    )

Definition at line 3043 of file nml.cc. { if (NULL == cms) { return -1; } return cms->get_msg_count (); }

NML_DIAGNOSTICS_INFO * NML::get_diagnostics_info (    )

Definition at line 3056 of file nml.cc. Referenced by nml_print_diag_list(). { if (NULL == cms) { return NULL; } return (NML_DIAGNOSTICS_INFO *) cms->get_diagnostics_info (); }

int NML::prefix_format_chain (  NML_FORMAT_PTR    f_ptr )

Definition at line 2359 of file nml.cc. Referenced by NML_ID_CHANNEL::NML_ID_CHANNEL(), NML_QUERY_CHANNEL::NML_QUERY_CHANNEL(), RCS_CMD_CHANNEL::RCS_CMD_CHANNEL(), RCS_OI_REPLY_CHANNEL::RCS_OI_REPLY_CHANNEL(), RCS_OI_REQUEST_CHANNEL::RCS_OI_REQUEST_CHANNEL(), RCS_STAT_CHANNEL::RCS_STAT_CHANNEL(), RCS_WM_CHANNEL::RCS_WM_CHANNEL(), and reconstruct(). { if (NULL == format_chain) { format_chain = new RCS_LINKED_LIST; } if (NULL != format_chain) { format_chain->store_at_head ((void *) f_ptr, 0, 0); } return (0); }

int NML::reset (    )

Definition at line 890 of file nml.cc. Referenced by nmlWaitOpen(), NML_QR_CLIENT::reset(), and NML_QR_SERVER::reset(). { int cms_copy_ret = 0; if (valid ()) { return 1; } if (NULL != cms) { // Recreate a CMS channel identitical to the old one, do not // re-read the config file. CMS *oldcms = cms; cms = NULL; cms_copy_ret = cms_copy (&cms, oldcms, 0, 0); if (cms_copy_ret < 0) { if (cms != NULL && cms != oldcms) { delete oldcms; } return 0; } #if !defined(__MSDOS__) || defined(WIN32) register_with_server (); #endif add_to_channel_list (); // FAST MODE is a combination of options which allow certian checks during // a read or write operation to be avoided and therefore reduce the NML/CMS // overhead. if (!cms->is_phantom && cms->ProcessType == CMS_LOCAL_TYPE && !cms->neutral && !cms->isserver && !cms->enable_diagnostics) { fast_mode = 1; } cms_status = (int *) &(cms->status); cms_inbuffer_header_size = &(cms->header.in_buffer_size); char *forced_type_eq = strstr (cms->buflineupper, "FORCE_TYPE="); if (forced_type_eq != NULL) { #ifndef UNDER_CE long temp = strtol (forced_type_eq + 11, NULL, 0); #else long temp = atol (forced_type_eq + 11); #endif if (temp > 0) { forced_type = temp; fast_mode = 0; } } char *brpi_eq = strstr (cms->buflineupper, "BRPI="); if (brpi_eq != NULL) { #ifndef UNDER_CE blocking_read_poll_interval = strtod (brpi_eq + 5, NULL); #else blocking_read_poll_interval = RCS_CE_ATOF (brpi_eq + 5); #endif } delete oldcms; } else { // Re-read the config file before creating a new CMS object. if (cms_config (&cms, bufname, procname, cfgfilename, 0, 0) < 0) { return 0; } } return valid (); }

int NML::print_queue_info (    )

Definition at line 2850 of file nml.cc. { if (NULL == cms) { rcs_print_error ("NML::print_queue_info() - NULL == cms\n"); return (-1); } if (!cms->queuing_enabled) { rcs_print_error ("NML::print_queue_info() - Queing Not Enabled.\n"); return (-1); } if (cms->ProcessType != CMS_LOCAL_TYPE) { rcs_print_error ("NML::print_queue_info() - REMOTE Connection: Queing Data Not Available.\n"); return (-1); } rcs_print ("head = %d(0x%X); tail=%d(0x%X); queue_length=%d,end_queue_space=%d(0x%X); write_id=%d\n", cms->queuing_header.head, cms->queuing_header.head, cms->queuing_header.tail, cms->queuing_header.tail, cms->queuing_header.queue_length, cms->queuing_header.end_queue_space, cms->queuing_header.end_queue_space, cms->queuing_header.write_id); return (0); }

int NML::set_error (    )

Definition at line 2010 of file nml.cc. Referenced by blocking_read(), peek(), read(), reconstruct(), write(), and write_if_read(). { if (error_type != NML_NO_ERROR) { return -1; } if (NULL == cms) { error_type = NML_INVALID_CONFIGURATION; return 0; } /* Choose return value. */ switch (cms->status) { case CMS_TIMED_OUT: error_type = NML_TIMED_OUT; return (-1); case CMS_QUEUE_FULL: error_type = NML_QUEUE_FULL_ERROR; break; case CMS_NO_MASTER_ERROR: error_type = NML_NO_MASTER_ERROR; break; case CMS_WRITE_WAS_BLOCKED: error_type = NML_BUFFER_NOT_READ; break; case CMS_STATUS_NOT_SET: /* The status variable has not been set yet. */ case CMS_READ_OLD: /* Read successful, but data is old. */ case CMS_READ_OK: /* Read successful so far. */ case CMS_WRITE_OK: /* Write successful so far. */ case CMS_CLEAR_OK: /* A clear operation was successful. */ error_type = NML_NO_ERROR; break; case CMS_RESOURCE_CONFLICT_ERROR: case CMS_CREATE_ERROR: case CMS_CONFIG_ERROR: error_type = NML_INVALID_CONFIGURATION; break; case CMS_MISC_ERROR: default: error_type = NML_INTERNAL_CMS_ERROR; break; } if (error_type == NML_NO_ERROR) { return 0; } if (!info_printed) { print_info (); } return -1; }

void NML::print_info (  char *    bufname = NULL, char *    procname = NULL, char *    cfg_file = NULL )

Definition at line 2562 of file nml.cc. Referenced by NML(), reconstruct(), and set_error(). { info_printed = 1; if (!verbose_nml_error_messages) { return; } if (NULL == cms || error_type != NML_NO_ERROR) { if (max_rcs_errors_to_print <= rcs_errors_printed && max_rcs_errors_to_print >= 0) { return; } } if (error_type == NML_QUEUE_FULL_ERROR && !cms_print_queue_full_messages) { return; } if (NULL != cms) { if (cms->status < 0) { if (max_rcs_errors_to_print <= rcs_errors_printed && max_rcs_errors_to_print >= 0) { return; } } } if (NULL != bufname && NULL != procname && NULL != cfg_file) { if (!strncmp (bufname, last_bufname, 10) && !strncmp (procname, last_procname, 10) && !strncmp (cfg_file, last_cfg_file, 40)) { return; } strncpy (last_bufname, bufname, 10); strncpy (last_procname, procname, 10); strncpy (last_cfg_file, cfg_file, 40); } if (!info_message_printed) { rcs_print ("\n**********************************************************\n"); #if 0 rcs_print ("* If you are having a problem with NML, \n"); rcs_print ("* please send the following information,\n"); rcs_print ("* a detailed description of the problem, \n"); rcs_print ("* and any other error messages\n"); rcs_print ("* to Will Shackleford (shackle@cme.nist.gov).\n"); #endif #ifndef WINDOWS rcs_print ("* Current Directory = %s\n", getcwd (cwd_buf, 256)); #endif if (nml_print_hostname_on_error) { dl_gethostname (host_name_buf, MAXHOSTNAMELEN); if (host_name_buf[0] != 0) { rcs_print ("* Host = %s\n", host_name_buf); } } rcs_print ("* "); print_rcs_version (); info_message_printed = 1; } rcs_print ("\n**********************************************************\n"); if (NULL != cms) { rcs_print ("* BufferName = %s\n", cms->BufferName); rcs_print ("* BufferType = %d\n", cms->BufferType); rcs_print ("* ProcessName = %s\n", cms->ProcessName); rcs_print ("* Configuration File = %s\n", cfgfilename); rcs_print ("* CMS Status = %d (%s)\n", cms->status, cms->status_string (cms->status)); rcs_print ("* Recent errors repeated:\n"); rcs_print ("%s\n", last_error_bufs[0]); rcs_print ("%s\n", last_error_bufs[1]); rcs_print ("%s\n", last_error_bufs[2]); rcs_print ("%s\n", last_error_bufs[3]); memset (last_error_bufs[0], 0, 100); memset (last_error_bufs[1], 0, 100); memset (last_error_bufs[2], 0, 100); memset (last_error_bufs[3], 0, 100); if (NULL == strstr (cms->BufferLine, "\n")) { rcs_print ("* BufferLine: %s\n", cms->BufferLine); } else { rcs_print ("* BufferLine: %s", cms->BufferLine); } if (NULL == strstr (cms->ProcessLine, "\n")) { rcs_print ("* ProcessLine: %s\n", cms->ProcessLine); } else { rcs_print ("* ProcessLine: %s", cms->ProcessLine); } } else { if (NULL != bufname) { rcs_print ("* BufferName = %s\n", bufname); } if (NULL != procname) { rcs_print ("* ProcessName = %s\n", procname); } } if (NULL != cfg_file) { rcs_print ("* Config File = %s\n", cfg_file); } rcs_print ("* error_type = %d (%s)\n", error_type, NML_ERROR_TYPE_STRINGS[error_type]); rcs_print ("************************************************************\n\n"); }

void NML::reconstruct (  NML_FORMAT_PTR    f_ptr, char *    buf, char *    proc, char *    file, int    set_to_server = 0, int    set_to_master = 0 )  [protected]

Definition at line 318 of file nml.cc. Referenced by NML(). { cms = (CMS *) NULL; format_chain = (RCS_LINKED_LIST *) NULL; phantom_read = (NMLTYPE (*)())NULL; phantom_peek = (NMLTYPE (*)())NULL; phantom_write = (int (*)(NMLmsg *)) NULL; phantom_write_if_read = (int (*)(NMLmsg *)) NULL; phantom_check_if_read = (int (*)()) NULL; phantom_clear = (int (*)()) NULL; channel_list_id = 0; error_type = NML_NO_ERROR; fast_mode = 0; ignore_format_chain = 0; info_printed = 0; format_chain = new RCS_LINKED_LIST; if (NULL != format_chain) { prefix_format_chain (f_ptr); } if (NULL == f_ptr) { rcs_print_error ("NML:(Format Function Pointer) f_ptr == NULL.\n"); } if (-1 == cms_config (&cms, buf, proc, file, set_to_server, set_to_master)) { set_error (); if (!info_printed) { print_info (buf, proc, file); } if (NULL != cms) { rcs_print_debug (PRINT_NML_DESTRUCTORS, " delete (CMS *) %X;\n", cms); delete cms; cms = (CMS *) NULL; } return; } if (NULL == cms) { if (!info_printed) { print_info (buf, proc, file); } error_type = NML_INVALID_CONFIGURATION; return; } if (cms->status < 0) { error_type = NML_INVALID_CONFIGURATION; if (!info_printed) { print_info (buf, proc, file); } rcs_print_debug (PRINT_NML_DESTRUCTORS, " delete (CMS *) %X;\n", cms); delete cms; cms = (CMS *) NULL; return; } #if !defined(__MSDOS__) || defined(WIN32) if (!set_to_server) { register_with_server (); } #endif add_to_channel_list (); // FAST MODE is a combination of options which allow certian checks during // a read or write operation to be avoided and therefore reduce the NML/CMS // overhead. if (!cms->is_phantom && cms->ProcessType == CMS_LOCAL_TYPE && !cms->neutral && !cms->isserver && !cms->enable_diagnostics) { fast_mode = 1; } cms_status = (int *) &(cms->status); cms_inbuffer_header_size = &(cms->header.in_buffer_size); char *forced_type_eq = strstr (cms->buflineupper, "FORCE_TYPE="); if (forced_type_eq != NULL) { #ifndef UNDER_CE long temp = strtol (forced_type_eq + 11, NULL, 0); #else long temp = atol (forced_type_eq + 11); #endif if (temp > 0) { forced_type = temp; fast_mode = 0; } } char *brpi_eq = strstr (cms->buflineupper, "BRPI="); if (brpi_eq != NULL) { #ifndef UNDER_CE blocking_read_poll_interval = strtod (brpi_eq + 5, NULL); #else blocking_read_poll_interval = RCS_CE_ATOF (brpi_eq + 5); #endif } }

---

Field Documentation

RCS_LINKED_LIST* NML::format_chain

Definition at line 90 of file nml.hh. Referenced by NML().

int NML::channel_list_id

Definition at line 93 of file nml.hh.

NML_ERROR_TYPE NML::error_type

Definition at line 94 of file nml.hh. Referenced by NML_MODULE::read_command_in(), NODE_LINK::send_command(), and NML_MODULE::write_status_out().

NMLTYPE(* NML::phantom_read)()

NMLTYPE(* NML::phantom_peek)()

int(* NML::phantom_write)(NMLmsg * nml_msg)

int(* NML::phantom_write_if_read)(NMLmsg * nml_msg)

int(* NML::phantom_check_if_read)()

int(* NML::phantom_clear)()

int NML::ignore_format_chain

Definition at line 109 of file nml.hh.

int NML::queue_length

Definition at line 174 of file nml.hh.

int NML::fast_mode [protected]

Definition at line 179 of file nml.hh.

int* NML::cms_status [protected]

Definition at line 180 of file nml.hh.

long* NML::cms_inbuffer_header_size [protected]

Definition at line 181 of file nml.hh.

int NML::info_printed [protected]

Definition at line 187 of file nml.hh.

NML_CHANNEL_TYPE NML::channel_type

Definition at line 191 of file nml.hh.

long NML::sizeof_message_header

Definition at line 192 of file nml.hh. Referenced by create_NML().

int NML::forced_type

Definition at line 193 of file nml.hh. Referenced by create_NML().

int NML::already_deleted [protected]

Definition at line 196 of file nml.hh.

char NML::bufname[40] [protected]

Definition at line 197 of file nml.hh. Referenced by NML().

char NML::procname[40] [protected]

Definition at line 198 of file nml.hh. Referenced by NML().

char NML::cfgfilename[160] [protected]

Definition at line 199 of file nml.hh. Referenced by NML().

double NML::blocking_read_poll_interval [protected]

Definition at line 200 of file nml.hh.

CMS* NML::cms_for_msg_string_conversions [protected]

Definition at line 201 of file nml.hh.

---

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

• nml.hh
• nml.cc

---