fix old/wrong namespace versions

essentials-framework/Essentials Core/PepperDashEssentialsBase/Queues/ComsMessage.cs

@@ -78,15 +78,23 @@ namespace PepperDash_Essentials_Core.Queues
     /// IBasicCommunication Message for IQueue
     /// </summary>
     [Obsolete("Use PepperDash.Essentials.Core.Queues")]
-    public class ComsMessage : PepperDash.Essentials.Core.Queues.ComsMessage
+    public class ComsMessage : IQueueMessage
     {
+        private readonly byte[] _bytes;
+        private readonly IBasicCommunication _coms;
+        private readonly string _string;
+        private readonly bool _isByteMessage;
+
         /// <summary>
         /// Constructor for a string message
         /// </summary>
         /// <param name="coms">IBasicCommunication to send the message</param>
         /// <param name="message">Message to send</param>
-        public ComsMessage(IBasicCommunication coms, string message):base(coms, message)
+        public ComsMessage(IBasicCommunication coms, string message)
         {
+            Validate(coms, message);
+            _coms = coms;
+            _string = message;
         }
 
         /// <summary>
@@ -94,8 +102,44 @@ namespace PepperDash_Essentials_Core.Queues
         /// </summary>
         /// <param name="coms">IBasicCommunication to send the message</param>
         /// <param name="message">Message to send</param>
-        public ComsMessage(IBasicCommunication coms, byte[] message):base(coms, message)
+        public ComsMessage(IBasicCommunication coms, byte[] message)
         {
+            Validate(coms, message);
+            _coms = coms;
+            _bytes = message;
+            _isByteMessage = true;
+        }
+
+        private void Validate(IBasicCommunication coms, object message)
+        {
+            if (coms == null)
+                throw new ArgumentNullException("coms");
+
+            if (message == null)
+                throw new ArgumentNullException("message");
+        }
+
+        /// <summary>
+        /// Dispatchs the string/byte[] to the IBasicCommunication specified
+        /// </summary>
+        public void Dispatch()
+        {
+            if (_isByteMessage)
+            {
+                _coms.SendBytes(_bytes);
+            }
+            else
+            {
+                _coms.SendText(_string);
+            }
+        }
+
+        /// <summary>
+        /// Shows either the byte[] or string to be sent
+        /// </summary>
+        public override string ToString()
+        {
+            return _bytes != null ? _bytes.ToString() : _string;
         }
     }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Queues/GenericQueue.cs

@@ -254,14 +254,44 @@ namespace PepperDash_Essentials_Core.Queues
     /// Threadsafe processing of queued items with pacing if required
     /// </summary>
     [Obsolete("Use PepperDash.Essentials.Core.Queues")]
-    public class GenericQueue : PepperDash.Essentials.Core.Queues.GenericQueue
+    public class GenericQueue : IQueue<IQueueMessage>
     {
+        private readonly string _key;
+        protected readonly CrestronQueue<IQueueMessage> _queue;
+        protected readonly Thread _worker;
+        protected readonly CEvent _waitHandle = new CEvent();
+
         private bool _delayEnabled;
         private int _delayTime;
 
         private const Thread.eThreadPriority _defaultPriority = Thread.eThreadPriority.MediumPriority;
 
-        
+        /// <summary>
+        /// If the instance has been disposed.
+        /// </summary>
+        public bool Disposed { get; private set; }
+
+        /// <summary>
+        /// Returns the capacity of the CrestronQueue (fixed Size property)
+        /// </summary>
+        public int QueueCapacity
+        {
+            get
+            {
+                return _queue.Size;
+            }
+        }
+
+        /// <summary>
+        /// Returns the number of elements currently in the CrestronQueue
+        /// </summary>    
+        public int QueueCount
+        {
+            get
+            {
+                return _queue.Count;
+            }
+        }
 
         /// <summary>
         /// Constructor with no thread priority
@@ -344,8 +374,122 @@ namespace PepperDash_Essentials_Core.Queues
         /// <param name="priority"></param>
         /// <param name="capacity"></param>
         /// <param name="pacing"></param>
-        private GenericQueue(string key, Thread.eThreadPriority priority, int capacity, int pacing):base(key, priority, capacity, pacing)
+        protected GenericQueue(string key, Thread.eThreadPriority priority, int capacity, int pacing)
         {
+            _key = key;
+            int cap = 25; // sets default
+            if (capacity > 0)
+            {
+                cap = capacity; // overrides default
+            }
+            _queue = new CrestronQueue<IQueueMessage>(cap);
+            _worker = new Thread(ProcessQueue, null, Thread.eThreadStartOptions.Running)
+            {
+                Priority = priority
+            };
+
+            SetDelayValues(pacing);
+        }
+
+        private void SetDelayValues(int pacing)
+        {
+            _delayEnabled = pacing > 0;
+            _delayTime = pacing;
+
+            CrestronEnvironment.ProgramStatusEventHandler += programEvent =>
+            {
+                if (programEvent != eProgramStatusEventType.Stopping)
+                    return;
+
+                Dispose();
+            };
+        }
+
+        /// <summary>
+        /// Thread callback
+        /// </summary>
+        /// <param name="obj">The action used to process dequeued items</param>
+        /// <returns>Null when the thread is exited</returns>
+        private object ProcessQueue(object obj)
+        {
+            while (true)
+            {
+                IQueueMessage item = null;
+
+                if (_queue.Count > 0)
+                {
+                    item = _queue.Dequeue();
+                    if (item == null)
+                        break;
+                }
+                if (item != null)
+                {
+                    try
+                    {
+                        Debug.Console(2, this, "Processing queue item: '{0}'", item.ToString());
+                        item.Dispatch();
+
+                        if (_delayEnabled)
+                            Thread.Sleep(_delayTime);
+                    }
+                    catch (Exception ex)
+                    {
+                        Debug.Console(0, this, Debug.ErrorLogLevel.Error, "Caught an exception in the Queue {0}\r{1}\r{2}", ex.Message, ex.InnerException, ex.StackTrace);
+                    }
+                }
+                else _waitHandle.Wait();
+            }
+
+            return null;
+        }
+
+        public void Enqueue(IQueueMessage item)
+        {
+            _queue.Enqueue(item);
+            _waitHandle.Set();
+        }
+
+        /// <summary>
+        /// Disposes the thread and cleans up resources.  Thread cannot be restarted once
+        /// disposed.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            CrestronEnvironment.GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Actually does the disposing.  If you override this method, be sure to either call the base implementation 
+        /// or clean up all the resources yourself.
+        /// </summary>
+        /// <param name="disposing">set to true unless called from finalizer</param>
+        protected void Dispose(bool disposing)
+        {
+            if (Disposed)
+                return;
+
+            if (disposing)
+            {
+                Enqueue(null);
+                _worker.Join();
+                _waitHandle.Close();
+            }
+
+            Disposed = true;
+        }
+
+        ~GenericQueue()
+        {
+            Dispose(false);
+        }
+
+        /// <summary>
+        /// Key
+        /// </summary>
+        public string Key
+        {
+            get { return _key; }
         }
     }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Queues/IQueue.cs

@@ -17,7 +17,9 @@ namespace PepperDash.Essentials.Core.Queues
 namespace PepperDash_Essentials_Core.Queues
 {
     [Obsolete("Use PepperDash.Essentials.Core.Queues")]
-    public interface IQueue<T> : PepperDash.Essentials.Core.Queues.IQueue<T> where T: class 
+    public interface IQueue<T> : IKeyed, IDisposable where T : class
     {
+        void Enqueue(T item);
+        bool Disposed { get; }
     }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Queues/IQueueMessage.cs

@@ -11,7 +11,8 @@ namespace PepperDash.Essentials.Core.Queues
 namespace PepperDash_Essentials_Core.Queues
 {
     [Obsolete("Use PepperDash.Essentials.Core.Queues")]
-    public interface IQueueMessage:PepperDash.Essentials.Core.Queues.IQueueMessage
+    public interface IQueueMessage
     {
+        void Dispatch();
     }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Queues/ProcessStringMessage.cs

@@ -49,13 +49,40 @@ namespace PepperDash_Essentials_Core.Queues
     /// Message class for processing strings via an IQueue
     /// </summary>
     [Obsolete("Use PepperDash.Essentials.Core.Queues")]
-    public class ProcessStringMessage : PepperDash.Essentials.Core.Queues.ProcessStringMessage
+    public class ProcessStringMessage : IQueueMessage
     {
+        private readonly Action<string> _action;
+        private readonly string _message;
+
         /// <summary>
         /// Constructor
         /// </summary>
         /// <param name="message">Message to be processed</param>
         /// <param name="action">Action to invoke on the message</param>
-        public ProcessStringMessage(string message, Action<string> action) : base(message, action){}
+        public ProcessStringMessage(string message, Action<string> action)
+        {
+            _message = message;
+            _action = action;
+        }
+
+        /// <summary>
+        /// Processes the string with the given action
+        /// </summary>
+        public void Dispatch()
+        {
+            if (_action == null || String.IsNullOrEmpty(_message))
+                return;
+
+            _action(_message);
+        }
+
+        /// <summary>
+        /// To string
+        /// </summary>
+        /// <returns>The current message</returns>
+        public override string ToString()
+        {
+            return _message ?? String.Empty;
+        }
     }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Queues/StringResponseProcessor.cs

@@ -111,14 +111,14 @@ namespace PepperDash_Essentials_Core.Queues
     public sealed class StringResponseProcessor : IKeyed, IDisposable
     {
         private readonly Action<string> _processStringAction;
-        private readonly PepperDash.Essentials.Core.Queues.IQueue<PepperDash.Essentials.Core.Queues.IQueueMessage> _queue;
+        private readonly IQueue<IQueueMessage> _queue;
         private readonly IBasicCommunication _coms;
         private readonly CommunicationGather _gather;
 
         private StringResponseProcessor(string key, Action<string> processStringAction)
         {
             _processStringAction = processStringAction;
-            _queue = new PepperDash.Essentials.Core.Queues.GenericQueue(key);
+            _queue = new GenericQueue(key);
 
             CrestronEnvironment.ProgramStatusEventHandler += programEvent =>
             {