PIRL.Conductor.Maestro

Class Conductor_Table_Model

    • Field Detail

      • Column_Names

        public static String[] Column_Names
        The names of the table columns.
      • THEATERS_COLUMN

        public static final int THEATERS_COLUMN
        The index of the Theaters column in the data model.
        See Also:
        Constant Field Values
      • CONDUCTORS_COLUMN

        public static final int CONDUCTORS_COLUMN
        The index of the Conductos column in the data model.
        See Also:
        Constant Field Values
      • THEATER_LOCATION_PARAMETER_NAME

        public static final String THEATER_LOCATION_PARAMETER_NAME
        Conductor identity parameters of interest to the data model.
        See Also:
        Constant Field Values
      • ADDRESS_PARAMETER_NAME

        public static final String ADDRESS_PARAMETER_NAME
        Conductor identity parameters of interest to the data model.
        See Also:
        Constant Field Values
      • CONDUCTOR_ID_PARAMETER_NAME

        public static final String CONDUCTOR_ID_PARAMETER_NAME
        Conductor identity parameters of interest to the data model.
        See Also:
        Constant Field Values
      • PIPELINE_PARAMETER_NAME

        public static final String PIPELINE_PARAMETER_NAME
        Conductor identity parameters of interest to the data model.
        See Also:
        Constant Field Values
      • PROCESSING_STATE_PARAMETER_NAME

        public static final String PROCESSING_STATE_PARAMETER_NAME
        Conductor identity parameters of interest to the data model.
        See Also:
        Constant Field Values
      • UNCHANGED_STATE

        protected static final int UNCHANGED_STATE
        Special Conductor processing state value that indicates no change from the current state.

        When Remote_Theater Management is closed or set the previous processing state is returned for use in notifying processing state change listeners. If the state was unchanged this special unchanged value is returned instead. This enables the caller to avoid the cost of the notification and consequent table view updates.

        See Also:
        Constant Field Values
    • Constructor Detail

      • Conductor_Table_Model

        public Conductor_Table_Model()
        Construct an empty Conductor_Table_Model.
    • Method Detail

      • findColumn

        public int findColumn(String name)
        Find the data model column index of a name.

        Overrides:
        findColumn in class AbstractTableModel
        Parameters:
        name - A column name String. May be null.
        Returns:
        The index of the named column in the data model. This will be -1 if the name does not match (case insensitive) a column name.
      • getColumnClass

        public Class getColumnClass(int column)
        Get the Class for a data model column.

        Specified by:
        getColumnClass in interface TableModel
        Overrides:
        getColumnClass in class AbstractTableModel
        Parameters:
        column - A data model column index.
        Returns:
        If the column index is valid String.class is returned; otherwise Object.class is returned.
      • getColumnCount

        public int getColumnCount()
        Get the number of columns in the data model.

        Specified by:
        getColumnCount in interface TableModel
        Returns:
        The size of the Column_Names array.
      • getColumnName

        public String getColumnName(int column)
        Get the name of a data model column.

        Specified by:
        getColumnName in interface TableModel
        Overrides:
        getColumnName in class AbstractTableModel
        Parameters:
        column - A data model column index.
        Returns:
        The column name String. This will be null.if the column index is not valid.
      • getRowCount

        public int getRowCount()
        Get the number of rows in the data model.

        Specified by:
        getRowCount in interface TableModel
        Returns:
        The number of Conductor identities contained in the model.
      • isCellEditable

        public boolean isCellEditable(int row,
                             int column)
        Test if a data model cell is editable.

        Specified by:
        isCellEditable in interface TableModel
        Overrides:
        isCellEditable in class AbstractTableModel
        Parameters:
        row - A data model row index.
        column - A data model column index.
        Returns:
        Always returns false.
      • Profile

        public Profile Profile()
                        throws IllegalArgumentException
        Get a Profile of the Conductors.

        Returns:
        A Profile representing all the Conductors on all the Theaters listed in this data model.
        Throws:
        If - a Conductor identity can not be used to construct a valid Conductor_Definition or the definition is in conflict with another of the same name.
        IllegalArgumentException
      • Identity

        public Conductor_Table_Model Identity(Message identity,
                                     Theater theater,
                                     Message client_identity)
                                       throws IOException
        Add a Conductor identity to the data model.

        The data model listeners are notified that a new row has been inserted.

        N.B.: If Remote_Theater Management could not be obtained the identity is not added to the the data model and no listener notification is sent; an IOException is thrown in this case.

        Parameters:
        identity - A Conductor identity Message. If null, or the identity is already present in the data model, nothing is done.
        theater - The Theater where the Stage_Manager is located from which the Conductor identities were obtained. If null, nothing is done.
        client_identity - The Message containing client authentication information for connecting to the Stage_Manager. If null, nothing is done.
        Returns:
        This Conductor_Table_Model.
        Throws:
        IOException - If Remote_Theater Management could not be obtained.
        See Also:
        Set_Identity(Message, Theater, Message)
      • Set_Identity

        protected boolean Set_Identity(Message identity,
                           Theater theater,
                           Message client_identity)
                                throws IOException
        Set a Conductor identity.

        N.B.: This method should only be used to set a new Conductor identity by a method that does the neccessary state checks and table view update notification.

        The THEATER_LOCATION_PARAMETER_NAME is set at the beginning of the identity with the Remote_Theater location before the identity is added to the data model along with null Managements and Managers entries. The Theater location in the identity is necessary to correctly match identities. This is particularly critical when identities are replaced which depends on recognizing previously added identities by matching Theater locations.

        The name of the identity is set to the identity's Conductor name.

        The identity is added to the data model along with null place holders for the Remote_Theater Management and Conductor Manager. Then the new Management is obtained and set in the data model.

        N.B.: If Remote_Theater Management could not be obtained the tentative new data model row is removed and an IOException is thrown.

        N.B.: No data model listener notification is done.

        Parameters:
        identity - A Conductor identity Message.N.B.: Must not be null; there should be no null identities in the data model. The identity must also be unique (not already present) in the data model.
        theater - The Theater where the Stage_Manager is located from which the Conductor identities were obtained. Must not be null.
        client_identity - The Message containing client authentication information for connecting to the Stage_Manager. Should not be null.
        Returns:
        true if the identity was set; false if the Theater location is invalid and not entered in the data model.
        Throws:
        IOException - If Remote_Theater Management could not be obtained.
        See Also:
        Management(Message, Theater, Message)
      • Identity

        public Message Identity(int row)
        Get the Identity of a Conductor at a row index.

        Parameters:
        row - A data model row index.
        Returns:
        A Conductor identity Message. This will be null if the row index is less than zero or greater than or equal to the total data model rows.
      • Identity

        public Message Identity(Remote_Theater management)
        Get the Identity of a Conductor associated with a Remote_Theater Management.

        Parameters:
        management - A Remote_Theater Management reference.
        Returns:
        A Conductor identity Message. This will be null if the management could not be found in the data model.
      • Identity

        public Message Identity(Manager manager)
        Get the Identity of a Conductor associated with a Manager.

        Parameters:
        manager - A Manager reference.
        Returns:
        A Conductor identity Message. This will be null if the manager could not be found in the data model.
      • Index

        public int Index(Message identity)
        Get the data model row index of a Conductor identity.

        Parameters:
        identity - A Conductor identity Message. May be null.
        Returns:
        The data model index of the Conductor identity, or -1 if the identity is not present.
      • Matching_Index

        public int Matching_Index(Message identity)
        Get the data model row index of a Conductor with a matching identity.

        N.B.: This method searches the data model for a Conductor identity that matches the specified identity. The matching identity need not be the same object.

        Parameters:
        identity - A Conductor identity Message.
        Returns:
        The data model row index of the matching identity. This will be -1 if a matching identity could not be found in the data model.
        See Also:
        Matching_Index(Message, List)
      • Replace

        public Conductor_Table_Model Replace(List<Message> identities,
                                    Theater theater,
                                    Message client_identity)
                                      throws IOException
        Replace all identities for a specified Remote_Theater Management with new identities.

        Each current identity in the data model that has a THEATER_LOCATION_PARAMETER_NAME value that matches the Theater location is compared against the new identities list. An attempt is made to get the index of the existing identity in the new identities list. If a matching identity can not be found the data model row for the current identity is removed; the current identity is defunct. If a matching identity is found the identity is removed from the list of new identities; the identity is redundant. This checking removes all current identities that are not in the new identities list, and removes from the new identities list all identities that are already in the current identitites list. After all current identities have been checked all the remaining new identities are added to the data model along with the Remote_Theater Management and an equal number of null Manager entries.

        A table data changed notification is sent to the data model listeners only if any changes occured to the data model.

        N.B.: If Remote_Theater Management could not be obtained for an identity it is not added to the the data model. In this case, after an attempt has been made to add all the new identities to the model an IOException will thrown. Because multiple exceptions might have occured a generic IOException is thrown containing a message that lists each specific exception message, including its specific type, with each exception message separated from the one that prceeded it by a single line containing seven dash ('-') characters.

        Parameters:
        identities - A List of Conductor identity Messages. If null, nothing is done.
        theater - The Theater where the Stage_Manager is located from which the Conductor identities were obtained. If null, nothing is done.
        client_identity - The Message containing client authentication information for connecting to the Stage_Manager. If null, nothing is done.
        Throws:
        IOException - If Remote_Theater Management could not be obtained.
        See Also:
        Matching_Index(Message, List), Set_Identity(Message, Theater, Message)
      • Conductor_Name

        public String Conductor_Name(int row)
        Get the name of a Conductor at a data model index.

        Parameters:
        row - A data model row index.
        Returns:
        The Conductor name from the identity at the row index. This will be null if the row index is invalid or the identity does not contain the required information.
      • Location

        public String Location(int row)
        Get the Theater location of a Conductor at a data model index.

        The fully qualified Theater location is returned.

        Parameters:
        row - A data model row index.
        Returns:
        The Theater location from the identity at the row index. This will be null if the row index is invalid or the identity does not contain the required information.
      • Processing_State

        public int Processing_State(int row)
        Get the processing state of a Conductor at a data model index.

        If the row's Conductor identity has a procesing state of zero an attempt is made to use the row's Management to obtain the current procesing state. If this is successful the identity is updated with the current processing state.

        Parameters:
        row - A Conductor row index.
        Returns:
        The Conductor processing state. This will be zero if the row index is outside the range of available Conductors or the processing state has not yet been obtained from the Conductor.
      • Management

        public Remote_Theater Management(int row)
        Get the Remote_Theater Management at a data model row index.

        N.B.: The current Remote_Theater Management data model row is obtained as-is; Remote_Theater Management will not be opened or re-opened.

        Parameters:
        row - A data model row index.
        Returns:
        The Remote_Theater Management for the data model row. This will be null if the row index is not valid or no Remote_Theater Management is present at the index.
      • Management

        public Remote_Theater Management(Message identity)
        Get the Remote_Theater Management for a Conductor.

        N.B.: The current Remote_Theater Management associated with the Conductor identity is obtained as-is; Remote_Theater Management will not be opened or re-opened.

        Parameters:
        identity - A Conductor identity Message.
        Returns:
        The Remote_Theater Management associated with the Conductor identity. This will be null if the Conductor identity is null or not found in the data model.
        See Also:
        Index(Message), Management(int)
      • Open_Management

        public Remote_Theater Open_Management(Message conductor_identity,
                                     Theater theater,
                                     Message client_identity)
                                       throws IOException
        Get Remote_Theater Management for a Conductor.

        If the Conductor already has Remote_Theater Management and it is open, that is returned. Otherwise an attempt is made to obtain it.

        Remote_Theater Management can be obtained when the Theater and a client identity containing any authentication information required by the Stage_Manager are provided. If Remote_Theater Management was found for the Conductor but it is closed, it is re-opened at the same location. Otherwise a new Remote_Theater Management is constructed and registered.

        Parameters:
        conductor_identity - The identity Message of the Conductor to be opened. If Remote_Theater Management is to be constructed or re-opened this must not be null and must contain an ADDRESS_PARAMETER_NAME parameter.
        theater - The Theater where the Stage_Manager is located from which the Conductor identity was obtained. If Remote_Theater Management is to be constructed or re-opened this must not be null.
        client_identity - The Message containing the Theater.KEY_PARAMETER_NAME that may be needed by the Stage_Manager to construct or re-open Remote_Theater Management. N.B.: This may be null if the Stage_Manager allows unauthenticated connections; otherwise the Stage_Manager will reject the connection.
        Returns:
        An open Remote_Theater Management for the Conductor. This will be null if the identity could not be found in the data model or the theater or client_identity is null and a Remote_Theater Management was needed to be constructed or re-opened
        Throws:
        IOException - If a connection could not be established to the Stage_Manager. This will be a Theater_Protocol_Exception if there were any problems in the content of the Messages used to establish the connection.
      • Management

        public static Remote_Theater Management(Message conductor_identity,
                                Theater theater,
                                Message client_identity)
                                         throws IOException
        Get Remote_Theater Management for a Conductor.

        Remote_Theater Management services are obtained for a Theater associated with a Stage_Manager. The client identity Message.NAME_PARAMETER_NAME is qualified with the Remote_Theater.REMOTE_THEATER_NAME following a '/' delimiter if it does not already contain this qualifier name. A Remote_Theater connection is then established with the Stage_Mangager at the specified Theater using the authentication information in the client identity, and the Remote_Theater Messenger is linked to the Conductor Messenger at the ADDRESS_PARAMETER_NAME found in the Conductor's identity information. This is done by constructing a new Remote_Theater that will provide Management communication directly with the Conductor.

        Parameters:
        conductor_identity - The identity Message of the Conductor to be opened. Must not be null and must contain an ADDRESS_PARAMETER_NAME parameter.
        theater - The Theater where the Stage_Manager is located from which the Conductor identity was obtained. Must not be null.
        client_identity - The Message containing the Theater.KEY_PARAMETER_NAME.
        Throws:
        IOException - If a connection could not be established to the Stage_Manager. This will be a Theater_Protocol_Exception if there were any problems in the content of the Messages used to establish the connection.
        IllegalArgumentException - If the argument requirements are not satsified, or the Conductor identity does not have an ADDRESS_PARAMETER_NAME parameter.
        See Also:
        Remote_Theater.Open(String, int, Message, String)
      • Index

        public int Index(Remote_Theater management)
        Get the data model row index for a Remote_Theater Management.

        Parameters:
        management - A Remote_Theater Management object.
        Returns:
        The data model row index containing the Remote_Theater Management, or -1 if the Management was not found in the data model.
      • Next_Index

        public int Next_Index(String theater_location,
                     int index)
        Get the data model row index of the next Conductor entry at a Theater location starting after a given index.

        Each Conductor identity, beginning with the data model entry immediately following the specified index, has the value of its THEATER_LOCATION_PARAMETER_NAME parameter compared with the specified Theater location. The index of the first one that matches is returned.

        Parameters:
        theater_location - A String specifying a Theater location. The Theater location is fully qualified to ensure it will correctly match the standard locations stored with the Conductor identities.
        index - The data model row index after which the search for the next matching Conductor identity will begin. If less than zero the search begins with the first row.
        Returns:
        The index of the next Conductor identity that contains a matching Theater location, or -1 if no match is found or the Theater location is null or the empty String.
        See Also:
        Theater.Location()
      • Count

        public int Count(String theater_location,
                Conductor_Definition conductor_definition)
        Get the count of Conductors identities on a Theater that match a Conductor_Definition.

        Parameters:
        theater_location - The String specifying a Theater location (does not need to be fully qualified). If null, the count will be zero.
        conductor_definition - A Conductor_Definition to match against Conductor identities.
        Returns:
        The count of Conductor identities associated with the Theater location that match the Conductor_Definition.
        See Also:
        Next_Index(String, int)
      • Set_Management

        protected int Set_Management(int row,
                         Remote_Theater management)
        Set a Remote_Theater Management.

        N.B.: This method should only be used to set a new Remote_Theater Management by a method that does the neccessary state checks and table view update notification.

        If the row does not have a Conductor identity or the Remote_Theater Management is identical to the current entry, nothing is done.

        Management for the row is closed. This will obtain the previous Conductor processing state or the UNCHANGED_STATE value.

        If the new Management is non-null it is set in the data model. The current Conductor processing state is obtained from the new Management and compared with the previous state (or zero if the previous state before closure was unchanged). If the state changed the Conductor identity is updated with the new processing state.

        N.B.: No data model listener notification is done.

        Parameters:
        row - A data model row index.
        management - A Remote_Theater Management object. May be null.
        Returns:
        The previous processing state from the row's identity. This will be UNCHANGED_STATE if the row has no identity (shouldn't happen), the existing Management is identical to the new Management, or the processing state is unchanged.
        See Also:
        Close_Management(int)
      • Opened

        public boolean Opened(int row)
        Test if the Remote_Theater Management at a data model index is open.

        Parameters:
        row - A data model row index.
        Returns:
        true if the Conductor Remote_Theater Management at the row index has been opened; false if the row index is invalid, no Remote_Theater Management is present at the row index, or the Remote_Theater is not open.
      • Opened

        public boolean Opened(Message identity)
        Test if the Remote_Theater associated with a Conductor identity is open.

        Parameters:
        identity - A Conductor identity Message.
        Returns:
        true if the Conductor identity is associated with an open Remote_Theater Management; false if the identity is not present, has no associated Remote_Theater Management, or the Remote_Theater is not open.
        See Also:
        Opened(int)
      • Close_Management

        protected int Close_Management(int row)
        Close the Remote_Theater Management at a data model index.

        N.B.: This method should only be used to close a Remote_Theater Management by a method that does the neccessary state checks and table view update notification.

        If a Manager is present for the row it is disabled.

        This Conductor_Table_Model is unregisterd as a processing listener of the Remote_Theater Management which is removed from (nullified in) the data model. processing state is obtained and then reset to zero (unknown state).

        N.B.: No data model listener notification is done.

        Parameters:
        row - A data model row index.
        Returns:
        The previous processing state from the row's identity. This will be UNCHANGED_STATE if the row has no identity (shouldn't happen) or the processing state is unchanged.
      • Manager

        public Manager Manager(int row)
        Get the Conductor Manager for a data model row index.

        Parameters:
        row - A data model row index.
        Returns:
        A Conductor Manager. This will be null if the row index is not valid or no Manager is present at the index.
      • Manager

        public Manager Manager(Message identity)
        Get the Manager for a Conductor.

        Parameters:
        identity - A Conductor identity Message.
        Returns:
        A Conductor Manager. This will be null if the Conductor identity was null or not found.
      • Manager

        public Conductor_Table_Model Manager(int row,
                                    Manager manager)
        Set the Manager for a data model row index.

        If the row has a non-null Manager entry that Manager is closed before the entry is replaced. If the new Manager is not null the Management is set to new Manager's Management.

        Parameters:
        row - A data model row index. If not a valid data model row index nothing is done.
        manager - A Conductor Manager.
        Returns:
        This Conductor_Table_Model.
      • Index

        public int Index(Manager manager)
        Get the data model row index for a Conductor Manager.

        Parameters:
        manager - A Conductor Manager.
        Returns:
        The data model row index containing the Manager, or -1 if the Manager was not found.
      • Open_Manager

        public Manager Open_Manager(int row)
                             throws Remote_Management_Exception
        Open a Conductor Manager at a data model row index.

        If a Manager is present at the data model row it is returned. Otherwise, if Remote_Theater Management is present at the data model row and it is opened, it is used to construct a new Manager which is set for the data model row and then returned.

        Parameters:
        row - A data model row index.
        Returns:
        A Conductor Manager. This will be null if the row index is invalid, or an opened Remote_Theater Management is not available for the row.
        Throws:
        Remote_Management_Exception - If a problem was encountered while constructing a new Manager.
      • Close_Manager

        public boolean Close_Manager(int row)
        Close a Conductor Manager at a data model row index.

        If a Manager is present at the data model row index it is closed and it's entry removed from the data model.

        Parameters:
        row - A data model row index.
        Returns:
        true if the Manager was present in the data model and has been closed; false if the Manager was not present.
      • Close

        public boolean Close(Manager manager)
        Close a Conductor Manager.

        If the Manager is present in the data model it is closed and it's entry removed from the data model.

        N.B.: If the Manager is not present in data model it is not closed.

        Parameters:
        manager - A Conductor Manager.
        Returns:
        true if the Manager was present in the data model and has been closed; false if the Manager was not present.
      • Remove

        public Message Remove(int row)
        Remove a data model row entry.

        Parameters:
        row - A data model row index.
        Returns:
        The Conductor identity that was removed. This will be null if the row index is invalid.
      • Remove

        public boolean Remove(Message identity)
        Remove a data model entry associated with a Conductor Identity.

        Parameters:
        identity - A Conductor identity Message. If null nothing is done and false is returned.
        Returns:
        true if the identity was present and removed; false otherwise.
      • Remove

        public boolean Remove(String theater_location)
        Remove all Conductors at a Theater location.

        Each data model entry found for the Theater location is removed. If any row was removed a change notification event for the entire table will be sent to the state change listeners. This event will also be sent to the table change listeners if non-contiguous ranges of rows were deleted; otherwise a deleted event will be delivered for only the rows removed.

        Parameters:
        theater_location - The String specifying a Theater location (does not need to be fully qualified).
        Returns:
        true if at least one row was removed; false otherwise.
        See Also:
        Next_Index(String, int)
      • Clear

        public void Clear()
        Clear the data model of all entries.

        If the data model contians any rows all are (@link #Remove_at(int) removed} and a {#link Notify_Table_Changed() table changed notification} is sent to all listeners.

      • Remove_at

        protected Message Remove_at(int row)
        Remove a data model row entry.

        N.B.: This method should only be used to remove a data model row by a method that will do the expected table change notification.

        Any Manager and Remote_Theater Management for the row is closed. Then the Manager, Mangement and Identity entries are removed from the data model.

        N.B.: No data model listener notification is done.

        Parameters:
        row - A data model row index.
        Returns:
        The Conductor identity Message for the row that was removed. This will be null if the row index is not valid.
      • Close

        public void Close(int row)
        Close the Remote_Theater and Manager at a row index.

        The Remote_Theater Management for the row is closed. If this resulted in a Conductor processing state change a state change notification is sent to all data model listeners.

        Parameters:
        row - A data model row index.
      • Close

        public boolean Close(String theater_location)
        Close a Theater.

        The Remote_Theater Management found at the Theater location is closed. If any of these closures resulted in a Conductor processing state change a state change notification is sent to all data model listeners.

        Parameters:
        theater_location - A String specifying the Theater location (does not need to be fully qualified). If null or the emtpy String nothing is done.
        Returns:
        true if any closures resulted in a Conductor processing state change; false otherwise.
        See Also:
        Next_Index(String, int)
      • Notify_Inserted

        protected void Notify_Inserted(int row)
        Notify all listeners that a data model row has been inserted.

        Listeners are sent an TableModelEvent.INSERT Conductor_Table_Model_Event that specifies the row.

        Parameters:
        row - The data model row that was inserted.
      • Notify_Updated

        protected void Notify_Updated(int row)
        Notify all listeners that a data model row has been updated.

        Listeners are sent an TableModelEvent.UPDATE Conductor_Table_Model_Event that specifies the row.

        Parameters:
        row - The data model row that was updated.
      • Notify_Updated

        protected void Notify_Updated(int first_row,
                          int last_row)
        Notify all listeners that a continguous range of data model rows have been updated.

        Listeners are sent an TableModelEvent.UPDATE Conductor_Table_Model_Event that specifies the range from first_row to last_row, inclusive.

        Parameters:
        first_row - The first data model row that was updated.
        last_row - The last data model row that was updated.
      • Notify_State_Changed

        protected void Notify_State_Changed(int row,
                                int processing_state)
        Notify all listeners that a Conductor processing state changed.

        Listeners are sent an TableModelEvent.UPDATE Conductor_Table_Model_Event that specifies the row and the processing state.

        Parameters:
        row - The data model row that has changed.
        processing_state - The previous processing state. The current processing state is contained in the Conductor identity for the row.
      • Notify_Deleted

        protected void Notify_Deleted(int row)
        Notify table change listeners that a data model row has been deleted.

        Listeners are sent a TableModelEvent.DELETE Conductor_Table_Model_Event that specifies the row. N.B.: The processing state change listeners are not notified. They should have been sent a pre-deletion deleting notification of the same event.

        Parameters:
        row - The data model row that has been deleted.
      • Notify_Deleted

        protected void Notify_Deleted(int first_row,
                          int last_row)
        Notify table change listeners that a data model row range has been deleted.

        Listeners are sent a TableModelEvent.DELETE Conductor_Table_Model_Event that specifies the range from first_row to last_row, inclusive. N.B.: The processing state change listeners are not notified. They should have been sent a pre-deletion deleting notification of the same event.

        Parameters:
        first_row - The first data model row that has been deleted.
        last_row - The last data model row that has been deleted.
      • Notify_Table_Changed

        protected void Notify_Table_Changed()
        Notify all listeners that the data model content has changed.

        This notification is used when the change to the data model can not be localized to a contiguous range of rows. All listeners are sent an TableModelEvent.UPDATE Conductor_Table_Model_Event that specifies the maximum row value range (0 - Integer.MAX_VALUE}.

      • Add_State_Change_Listener

        public Conductor_Table_Model Add_State_Change_Listener(TableModelListener listener)
        Add a listener for Conductor processing state change events.

        These listeners receive notification whenever one or more Conductor identities in the data model may have a changed processing state.

        State change listeners are distinct from table model listeners. When appropriate, both sets of listeners will be notified of a data model change event. At other times only one or the other set of listeners will be sent a notification. A listener should register to receive processing state change notifications when that is all it is interested in knowing aobut. A listener should register to receive table change notifications whien it is interested in any changes, including processing state changes.

        Parameters:
        listener - A TableModelListener.
        Returns:
        This Conductor_Table_Model.
      • Remove_State_Change_Listener

        public boolean Remove_State_Change_Listener(TableModelListener listener)
        Remove a listener for Conductor processing state change events.

        Parameters:
        listener - A TableModelListener.
        Returns:
        true if the listener was removed; false if it was not registered.
        See Also:
        Add_State_Change_Listener(TableModelListener)
      • Notify_Deleting

        protected Conductor_Table_Model_Event Notify_Deleting(int row)
        Notify processing state change listeners that a data model is about to be deleted.

        Listeners are sent a TableModelEvent.DELETE Conductor_Table_Model_Event that specifies the row. N.B.: The table change listeners are not notified. They should be sent a post-deletion deleted notification of the same event.

        Parameters:
        row - The data model row that will be deleted.
        Returns:
        The Conductor_Table_Model_Event that was delivered.
      • Notify_Deleting

        protected Conductor_Table_Model_Event Notify_Deleting(int first_row,
                                                  int last_row)
        Notify table change listeners that a data model row range is about to be deleted.

        Listeners are sent a TableModelEvent.DELETE Conductor_Table_Model_Event that specifies the range from first_row to last_row, inclusive. N.B.: The table change listeners are not notified. They should be sent a post-deletion deleted notification of the same event.

        Parameters:
        first_row - The first data model row that is about to be deleted.
        last_row - The last data model row that is about to be deleted.
        Returns:
        The Conductor_Table_Model_Event that was delivered.
      • Processing_Event_Occurred

        public void Processing_Event_Occurred(Processing_Event event)
        Event handler for Conductor Processing_Events.

        N.B.: This method is public as a side effect of implementing the Processing_Listener interface. It should not be used directly.

        If the incoming event contains a Conductor processing event change the event is enqueued and a Runnable placed on the Swing event handling queue for disposition of the event.

        The event disposition method pulls the next event from the front of the event queue. The data model index for the Remote_Theater Management source of the event is obtained and used to obtain the associated Conductor identity. The identity provides the previous processing state and is set with the new state. Then all processing state change listeners are notified of the state change.

        Specified by:
        Processing_Event_Occurred in interface Processing_Listener
        Parameters:
        event - A Processing_Event.
        See Also:
        Processing_Event
      • Theater_Location

        public static String Theater_Location(Message identity)
        Get the location of a Conductor from its identity.

        If the THEATER_LOCATION_PARAMETER_NAME is not present in the identity the value of the CONDUCTOR_ID_PARAMETER_NAME will be used, without any PID suffix, to produce a fully qualified location.

        Parameters:
        identity - A Conductor identity Message.
        Returns:
        A String providing the Theater location of the Conductor. This will be null if the identity is null or neither of the expected parameters is present in the identity.
      • Conductor_Name

        public static String Conductor_Name(Message identity)
        Get the name of a Conductor from its identity.

        The value of the PIPELINE_PARAMETER_NAME will be returned. N.B.: A Conductor's name is not necessarily the same as its pipeline name.

        Parameters:
        identity - A Conductor identity Message.
        Returns:
        A String providing the name of the Conductor. This will be null if the identity is null or neither of the expected parameters is present in the identity.
      • Pipeline

        public static String Pipeline(Message identity)
        Get the name of a Conductor pipeline from its identity.

        The PIPELINE_PARAMETER_NAME value is obtained.

        Parameters:
        identity - A Conductor identity Message.
        Returns:
        A String providing the name of the Conductor pipeline. This will be null if the identity is null or the required parameter is not present in the identity.
      • Identification

        public static String Identification(Message identity)
        Get a Conductor identification from its identity.

        The CONDUCTOR_ID_PARAMETER_NAME value is obtained.

        Parameters:
        identity - A Conductor identity Message.
        Returns:
        A String providing the identification of the Conductor pipeline. This will be null if the identity is null or the required parameter is not present in the identity.
      • Processing_State

        public static int Processing_State(Message identity)
        Get the processing state of a Conductor.

        The processing state is the value of the PROCESSING_STATE_PARAMETER_NAME from the identity. If this parameter is not present zero will be returned. The expected processing state values are:

        Conductor.RUNNING
        Source records are being processing.
        Conductor.POLLING
        No source records are currently available for processing; the Conductor is polling for new source records to process.
        Conductor.RUN_TO_WAIT
        When processing of the current source record completes Conductor will go into the waiting state.
        Conductor.WAITING
        The Conductor is waiting to be told to being processing.
        Conductor.HALTED
        A problem condition caused the Conductor to halt processing. The problem may be the result of the maximum number of sequential source records processing procedure failures having occured, a database access failure, or some other system error.
        0 - Unknown
        A processing state has not yet been obtained from the Conductor.
        The WAITING and HALTED state codes are negative; all others are positive.

        Parameters:
        identity - A Conductor identity Message. If null, zero is returned.
        Returns:
        A Conductor processing state value, or zero if none is available.
      • Processing_State

        protected static void Processing_State(Message identity,
                            int processing_state)
        Set the processing state of a Conductor.

        N.B.: This method should only be used to set a new processing state by a method that does the neccessary state checks and table view update notification.

        The Conductor identity has the PROCESSING_STATE_PARAMETER_NAME set to the processing state value.

        Parameters:
        identity - A Conductor identity Message. Must not be null.
        processing_state - A processing state value.
        See Also:
        Processing_State(Message)