Beispiel #1
0
        /// <summary>
        /// Add a new message as a Publish Subscribe Message to the List
        /// of Publish Subscibe messages.
        /// A reference to the Global Publish Subscribe Message will be added
        /// to the message passed in.
        /// Each Manager should add all messages it needs to work with in the
        /// Global Message Container.
        /// It is assumed that messages with the same name are the same Message
        /// type and are being used for the same purpose across all Managers.
        /// The first Manager to all the publish subscribe message will establish
        /// the message in the Global WorkSpace.  All other managers will simply
        /// have their message updated with a reference to the Global Message.
        /// </summary>
        /// <param name="messageName"></param>
        /// <param name="msg"></param>
        /// /// <returns>true if Error, false if ok.</returns>
        public bool AddPublishSubscribeMessage(string messageName, RabitMessage msg)
        {
            bool error = false;

            //rwlPublishSubscribeDict.EnterWriteLock();
            if (!publishSubcribeMsgDict.ContainsKey(messageName))
            {
                msg.SetTimeToNow();                         //Ensure the Current Time is set
                PSMsgContainer psMsgContainer;
                psMsgContainer.MgrMsgRef             = msg; //Reference to the orginal message
                psMsgContainer.PSMsg                 = new PublishSubscribeMessage((RabitMessage)msg.Clone());
                msg.GlobalPublishSubscribeMessageRef = psMsgContainer.PSMsg;
                publishSubcribeMsgDict.Add(messageName, psMsgContainer);
            }
            else
            {
                if (publishSubcribeMsgDict[messageName].PSMsg.MsgType == msg.GetType())
                {
                    //Update the incoming message with the Publish Subscribe
                    //Message Reference.
                    msg.GlobalPublishSubscribeMessageRef = publishSubcribeMsgDict[messageName].PSMsg;
                }
                else
                {
                    //Error!
                    Console.WriteLine("AddPublishSubscribeMessage: A new message is being added that conflicts with a current message.  MessageName:{0}, CurrentMsgType:{1}, NewMsgType:{2}",
                                      messageName, publishSubcribeMsgDict[messageName].PSMsg.MsgType.ToString(), msg.GetType().ToString());
                    error = true;
                }
            }
            //rwlPublishSubscribeDict.ExitWriteLock();
            return(error);
        }
Beispiel #2
0
        public override void CopyMessage(RabitMessage msg)
        {
            //Ensure that all base parameters/variables are copied.
            base.CopyMessage(msg);
            //Cast Message into the Concrete Message.
            ManagerStatusMessage cmsg = (ManagerStatusMessage)msg;

            ManagerStatus = cmsg.ManagerStatus;
        }
Beispiel #3
0
        public override void CopyMessage(RabitMessage msg)
        {
            //Ensure that all base parameters/variables are copied.
            base.CopyMessage(msg);
            //Cast Message into the Concrete Message.
            ManagerControlMessage cmsg = (ManagerControlMessage)msg;

            ShutDownAllManagers = cmsg.ShutDownAllManagers;
            RunState            = cmsg.RunState;
        }
Beispiel #4
0
 /// <summary>
 /// CopyIntoThisMessag() This method copys all the data from msg to this message.
 /// The Copy method is an integral part of the Publish Subscribe
 /// mechanism... so this method must reliably hand the copy process.
 /// If the message contains arrays, lists, dictionaries, or similar
 /// types... these objects must be properly copied... don't just
 /// copy the pointer or there will be all sorts of crazy errors caused
 /// in the system.
 /// The base CopyIntoThisMessage verifies that the message type
 /// being copied is the same message type as this message.
 /// A System.ArgumentException() is thrown if they are not.
 /// </summary>
 /// <param name="mess">The message with the data to be copied into
 /// this message.</param>
 virtual public void CopyMessage(RabitMessage msg)
 {
     //Verify we are coping the same concrete message type...
     //This is a serious error if we are not.
     if (msg.GetType() != this.GetType())
     {
         throw new System.ArgumentException();
     }
     Timestamp = msg.Timestamp;
 }
Beispiel #5
0
        /// <summary>
        /// Get a copy of a Publish Subscribe message for the given message name.
        /// Returns a copy of the message or null if no message by that name.
        /// </summary>
        /// <param name="messageName"></param>
        /// <returns></returns>
        public RabitMessage GetMessage(string messageName)
        {
            RabitMessage msg = null;

            if (publishSubcribeMsgDict.ContainsKey(messageName))
            {
                msg = publishSubcribeMsgDict[messageName].PSMsg.GetCopyOfMessage();
            }
            return(msg);
        }
Beispiel #6
0
        /// <summary>
        /// Clone()  creates a new message object which is a copy of the
        /// Message object.
        /// Clone must be overriden if the message contains arrays, lists, dictionaries,
        /// or similar types.  Clone is an integral part of the Publish Subscribe System.
        /// Note:  the Message Clone intentionally removes the Message ewhWaitHandle
        /// and the globalPublishSubscribeMessageRef.  Normally the new message does
        /// not need these references.  If the new message does need them... then they
        /// must be manually re-establish.
        /// </summary>
        /// <returns>Message object</returns>
        virtual public object Clone()
        {
            RabitMessage msgClone = (RabitMessage)this.MemberwiseClone();

            //Do not carry the Event Wait Handle or Global Publish Subscibe references forward...
            //This could cause strange behaviors... they must be re-established if needed...
            //in general they are not required.
            msgClone.ewhWaitHandle = null;
            msgClone.globalPublishSubscribeMessageRef = null;
            return(msgClone);
        }
Beispiel #7
0
 /// <summary>
 /// ForceFetchMessage()  copies the message information into the message object
 /// passed in. ForceFetchMessage() is used so that new objects are not created
 /// only to be distroyed later, which can be time consumming.
 /// A read lock is used to ensure an <c>Update</c>
 /// is not occurring when the copy is made.
 /// </summary>
 /// <param name="mess">A reference to a Message object which
 /// will recieve the Global message's information</param>
 public void ForceFetchMessage(RabitMessage msg)
 {
     rwl.EnterReadLock();
     try
     {
         msg.CopyMessage(statusMessage);
     }
     finally
     {
         rwl.ExitReadLock();
     }
 }
Beispiel #8
0
        /// <summary>
        /// Post a message to the Publish Subscribe message.
        /// </summary>
        /// <param name="messageName"></param>
        /// <param name="msg"></param>
        /// <returns>true if error... no message of the given name or the message types do not match,
        /// false otherwise.</returns>
        public bool PostMessage(string messageName, RabitMessage msg)
        {
            bool error = true;

            if (publishSubcribeMsgDict.ContainsKey(messageName))
            {
                if (publishSubcribeMsgDict[messageName].PSMsg.MsgType == msg.GetType())
                {
                    publishSubcribeMsgDict[messageName].PSMsg.PostMessage(msg);
                }
            }

            return(error);
        }
        /// <summary>
        /// PublishSubscibeMsgArray with an array size which is the largest
        /// number of messages to store in the array.
        /// </summary>
        /// <param name="arraySize"></param>
        /// <param name="defaultMessage">If defaultMessage not null the MessageArray will be
        /// filled with copies of the default message, otherwise the message array
        /// will be filled with nulls.</param>
        public PublishSubscibeMsgArray(int arraySize, RabitMessage defaultMessage)
        {
            MaxNoMessages = arraySize < 5 ? 5 : arraySize;
            messageArray  = new RabitMessage[MaxNoMessages];

            if (defaultMessage != null)
            {
                for (int i = 0; i < MaxNoMessages; i++)
                {
                    messageArray[i] = (RabitMessage)defaultMessage.Clone();
                }
            }

            rwl = new ReaderWriterLockSlim();
        }
Beispiel #10
0
 /// <summary>
 /// Update() This method updates the master copy of the message information.
 /// A write lock is obtained before updating the master object's information.
 /// This ensures another manager thread is not trying to copy the information out
 /// at the same time.
 /// After updating the message information, the <c>OnChange</c> method is called
 /// to inform other managers that the information has been changed.
 /// </summary>
 /// <param name="mess">a PublishSubscribeMessage object containing the new
 /// message information.</param>
 public void PostMessage(RabitMessage msg)
 {
     rwl.EnterWriteLock();
     try
     {
         //Set the time the message was posted.
         msg.SetTimeToNow();
         statusMessage.CopyMessage(msg);
     }
     finally
     {
         rwl.ExitWriteLock();
     }
     OnChange();
 }
Beispiel #11
0
        /// <summary>
        /// getCopyOfMessageIfNewer()  copies the message information into the message object
        /// passed in, if the message is newer in timestamep than the message passed in.
        /// </summary>
        /// <param name="mess">A reference to a Message object which
        /// will recieve the Global message's information</param>
        /// <returns>true if a copy was made, false if a copy was not made</returns>
        public bool FetchMessage(RabitMessage mess)
        {
            bool copyMade = false;

            if (statusMessage.Timestamp != mess.Timestamp)
            {
                rwl.EnterReadLock();
                try
                {
                    mess.CopyMessage(statusMessage);
                    copyMade = true;
                }
                finally
                {
                    rwl.ExitReadLock();
                }
            }
            return(copyMade);
        }
        /// <summary>
        /// FetchMessage()  copies the message information into the message object
        /// passed in, if the message is newer in timestamep than the message passed in.
        /// </summary>
        /// <param name="msgIdx">index to message</param>
        /// <param name="mess">A reference to a Message object which
        /// will recieve the Global message's information</param>
        /// <returns>true if a copy was made, false if a copy was not made</returns>
        public bool FetchMessage(int msgIdx, RabitMessage msg)
        {
            bool copyMade = false;

            if (msgIdx >= 0 && msgIdx < MaxNoMessages &&
                messageArray[msgIdx] != null &&
                (messageArray[msgIdx].Timestamp != msg.Timestamp))
            {
                rwl.EnterReadLock();
                try
                {
                    msg.CopyMessage(messageArray[msgIdx]);
                    copyMade = true;
                }
                finally
                {
                    rwl.ExitReadLock();
                }
            }
            return(copyMade);
        }
        /// <summary>
        /// Gets a copy of the message at index msgIdx.
        /// </summary>
        /// <param name="msgIdx"></param>
        /// <returns>a copy of the message if it exits, null otherwise</returns>
        public RabitMessage GetCopyOfMessage(int msgIdx)
        {
            RabitMessage obj = null;

            if (msgIdx >= 0 && msgIdx < MaxNoMessages)
            {
                rwl.EnterReadLock();
                try
                {
                    if (messageArray[msgIdx] != null)
                    {
                        obj = (RabitMessage)messageArray[msgIdx].Clone();
                    }
                }
                finally
                {
                    rwl.ExitReadLock();
                }
            }
            return(obj);
        }
        /// <summary>
        /// ForceFetchMessage()  copies the message information into the message object
        /// passed in. ForceFetchMessage() is used so that new objects are not created
        /// only to be distroyed later, which can be time consumming.
        /// A read lock is used to ensure an <c>Update</c>
        /// is not occurring when the copy is made.
        /// </summary>
        /// <param name="msgIdx">index to message</param>
        /// <param name="mess">A reference to a Message object which
        /// will recieve the Global message's information</param>
        /// <returns>true if a copy was made, false if the message array is empty at that point</returns>
        public bool ForceFetchMessage(int msgIdx, RabitMessage msg)
        {
            bool copyMade = false;

            if (msgIdx >= 0 && msgIdx < MaxNoMessages)
            {
                rwl.EnterReadLock();
                try
                {
                    if (messageArray[msgIdx] != null)
                    {
                        msg.CopyMessage(messageArray[msgIdx]);
                        copyMade = true;
                    }
                }
                finally
                {
                    rwl.ExitReadLock();
                }
            }
            return(copyMade);
        }
 /// <summary>
 /// Post() This method updates the master copy of the message information.
 /// A write lock is obtained before updating the master object's information.
 /// This ensures another manager thread is not trying to copy the information out
 /// at the same time.
 /// After updating the message information, the <c>OnChange</c> method is called
 /// to inform other managers that the information has been changed.
 /// </summary>
 /// <param name="msgIdx"></param>
 /// <param name="mess">a SSMU_StatusMessage object containing the new
 /// message information.</param>
 public void PostMessage(int msgIdx, RabitMessage msg)
 {
     if (msgIdx >= 0 && msgIdx < MaxNoMessages)
     {
         rwl.EnterWriteLock();
         try
         {
             if (messageArray[msgIdx] != null)
             {
                 messageArray[msgIdx].CopyMessage(msg);
             }
             else
             {
                 messageArray[msgIdx] = (RabitMessage)msg.Clone();
             }
         }
         finally
         {
             rwl.ExitWriteLock();
         }
         OnChange();
     }
 }
Beispiel #16
0
 /// <summary>
 /// Add a new message as a Publish Subscribe Message to the List
 /// of Publish Subscibe messages.
 /// </summary>
 /// <param name="messageName"></param>
 /// <param name="msg"></param>
 /// /// <returns>true if Error, false if ok.</returns>
 public bool AddPublishSubscribeMessage(string messageName, RabitMessage msg)
 {
     return(RabitWorkspace.GetWorkspace().AddPublishSubscribeMessage(messageName, msg));
 }
Beispiel #17
0
 public PublishSubscribeMessage(RabitMessage stMessage)
 {
     statusMessage = stMessage;
     rwl           = new ReaderWriterLockSlim();
 }
Beispiel #18
0
 public int CompareTime(RabitMessage msg)
 {
     return(this.timestamp.CompareTo(msg.timestamp));
 }