protected override int StateRequest(int state)
{
int iRes = 0;
ItemQueue itemQueue = Peek;
CONN_SETT_TYPE type = CONN_SETT_TYPE.UNKNOWN;
switch ((EVENT)state)
{
case EVENT.LIST_SIGNAL:
type = (CONN_SETT_TYPE)itemQueue.Pars[1];
_handlerDb.GetListSignals((int)itemQueue.Pars[0],type);
break;
case EVENT.CUR_VALUES:
case EVENT.CHECK_VALUES:
type = (CONN_SETT_TYPE)itemQueue.Pars[0];
_handlerDb.Request(type,Signals[type].ElementAt((int)itemQueue.Pars[1]).kks_code);
break;
default:
Logging.Logg().Error(string.Format(@"HandlerSignalQueue::StateRequest (CONN_SETT_TYPE={0}, event={1}) - необработанное событие...",type,(EVENT)state),Logging.INDEX_MESSAGE.NOT_SET);
iRes = -1;
break;
}
return(iRes);
}
public InputQueue()
{
this.itemQueue = new ItemQueue();
this.readerQueue = new Queue <IQueueReader>();
this.waiterList = new List <IQueueWaiter>();
this.queueState = QueueState.Open;
}
public void Stop(bool graceful)
{
if (tokenSourcePreProcess != null && tokenSourcePreProcess.Token.CanBeCanceled)
{
tokenSourcePreProcess.Cancel(false);
}
if (tokenSourcePreProcessAll != null && tokenSourcePreProcessAll.Token.CanBeCanceled)
{
tokenSourcePreProcessAll.Cancel(false);
}
if (graceful)
{
State = StateType.Shutdown;
ScheduleExecutor.AddSchedulerLogEntry(Show.Name, "Show stopping gracefully");
}
else
{
State = StateType.Waiting;
int runningCount = RunningActions.Count();
ItemQueue.Clear();
for (int i = 0; i < runningCount; i++)
{
ScheduleExecutor.AddSchedulerLogEntry(Show.Name, "Stopping action: " + RunningActions[i].ShowItem.Name);
RunningActions[i].Stop();
}
Show.ReleaseAllActions();
ScheduleExecutor.AddSchedulerLogEntry(Show.Name, "Show stopped immediately");
}
}
protected override int StateResponse(int state, object obj)
{
int iRes = 0;
ItemQueue itemQueue = Peek;
switch ((StatesMachine)state)
{
case StatesMachine.UDP_CONNECTED_CHANGED:
case StatesMachine.UDP_LISTENER_PACKAGE_RECIEVED: // получен очередной XML-пакет
case StatesMachine.LIST_DEST: // cписок источников данных (назначение - сохранение полученных значений)
//Ответа не требуется/не требуют обработки результата
break;
case StatesMachine.UDP_CONNECTED_CHANGE:
case StatesMachine.WRITER_READY_CHANGE:
case StatesMachine.XML_PACKAGE_VERSION: // версия(строка) шаблон XML-пакета
case StatesMachine.XML_PACKAGE_TEMPLATE: // шаблон XML-пакета
case StatesMachine.NUDP_LISTENER: // номер порта прослушивателя
if ((!(itemQueue == null)) &&
(!(itemQueue.m_dataHostRecieved == null)))
{
itemQueue.m_dataHostRecieved.OnEvtDataRecievedHost(new object[] { state, obj });
}
else
{
;
}
break;
default:
break;
}
return(iRes);
}
public ItemQueue CreateReversedQueue(int[] values)
{
ItemQueue q = new ItemQueue(3, new RevComp <Item>());
AddItems(q, values);
return(q);
}
public InputQueue()
{
_itemQueue = new ItemQueue();
_readerQueue = new Queue <IQueueReader>();
_waiterList = new List <IQueueWaiter>();
_queueState = QueueState.Open;
}
public ItemQueue CreateQueue(int[] values)
{
ItemQueue q = new ItemQueue();
AddItems(q, values);
return(q);
}
///// <summary>
/////A test for Down
/////</summary>
//public void DownTestHelper<T>()
// where T : IComparable<T>
//{
// PriorityQueue_Accessor<T> target = new PriorityQueue_Accessor<T>(); // TODO: Initialize to an appropriate value
// int i = 0; // TODO: Initialize to an appropriate value
// int n = 0; // TODO: Initialize to an appropriate value
// target.Down(i, n);
// Assert.Inconclusive("A method that does not return a value cannot be verified.");
//}
//[TestMethod()]
//[DeploymentItem("TaskExtensions.dll")]
//public void DownTest()
//{
// Assert.Inconclusive("No appropriate type parameter is found to satisfies the type constraint(s) of T. " +
// "Please call DownTestHelper<T>() with appropriate type parameters.");
//}
///// <summary>
/////A test for Heapify
/////</summary>
//public void HeapifyTestHelper<T>()
// where T : IComparable<T>
//{
// PriorityQueue_Accessor<T> target = new PriorityQueue_Accessor<T>(); // TODO: Initialize to an appropriate value
// target.Heapify();
// Assert.Inconclusive("A method that does not return a value cannot be verified.");
//}
//[TestMethod()]
//[DeploymentItem("TaskExtensions.dll")]
//public void HeapifyTest()
//{
// Assert.Inconclusive("No appropriate type parameter is found to satisfies the type constraint(s) of T. " +
// "Please call HeapifyTestHelper<T>() with appropriate type parameters.");
//}
///// <summary>
/////A test for Less
/////</summary>
//public void LessTestHelper<T>()
// where T : IComparable<T>
//{
// PriorityQueue_Accessor<T> target = new PriorityQueue_Accessor<T>(); // TODO: Initialize to an appropriate value
// int i = 0; // TODO: Initialize to an appropriate value
// int j = 0; // TODO: Initialize to an appropriate value
// bool expected = false; // TODO: Initialize to an appropriate value
// bool actual;
// actual = target.Less(i, j);
// Assert.AreEqual(expected, actual);
// Assert.Inconclusive("Verify the correctness of this test method.");
//}
//[TestMethod()]
//[DeploymentItem("TaskExtensions.dll")]
//public void LessTest()
//{
// Assert.Inconclusive("No appropriate type parameter is found to satisfies the type constraint(s) of T. " +
// "Please call LessTestHelper<T>() with appropriate type parameters.");
//}
///// <summary>
/////A test for MaybeGrow
/////</summary>
//public void MaybeGrowTestHelper<T>()
// where T : IComparable<T>
//{
// PriorityQueue_Accessor<T> target = new PriorityQueue_Accessor<T>(); // TODO: Initialize to an appropriate value
// int minCap = 0; // TODO: Initialize to an appropriate value
// target.MaybeGrow(minCap);
// Assert.Inconclusive("A method that does not return a value cannot be verified.");
//}
//[TestMethod()]
//[DeploymentItem("TaskExtensions.dll")]
//public void MaybeGrowTest()
//{
// Assert.Inconclusive("No appropriate type parameter is found to satisfies the type constraint(s) of T. " +
// "Please call MaybeGrowTestHelper<T>() with appropriate type parameters.");
//}
public void AddItems(ItemQueue q, int[] values)
{
foreach (int value in values)
{
q.Push(new Item(value));
}
}
/// <summary>
/// Установка головного элемента.
/// </summary>
/// <param name="data">Элемент.</param>
private void SetHeadItem(T data)
{
var item = new ItemQueue <T>(data);
head = item;
tail = item;
Count = 1;
}
public void SetUp()
{
Vm = new VendingMachine.VendingMachine();
State = new VendingMachine.States.NoMoneyInsertedState(Vm);
Iq = new ItemQueue(1.5);
Iq.QueueItem(new Item("TestName", "TestFlavor", "TestWrapperColor"));
Vm.ItemQueues.Add(QueueName, Iq);
}
void Start()
{
nextlocation = GridController.GetDoorLocation();
SetPositionImmediate(nextlocation);
prevanimation = animcontroller.currentanimation.name;
iq = GameObject.FindObjectOfType <ItemQueue>();
animcontroller.SetAnimation("IdleDown");
currentdirection = PlayerDirection.Idle;
}
public void SetUp()
{
Vm = new VendingMachine.VendingMachine();
Iq = new ItemQueue(1.5);
for (int i = 0; i < 5; i++)
{
Iq.QueueItem(new Item("TestName" + i, "TestFlavor" + i, "TestWrapperColor" + i));
}
Vm.ItemQueues.Add(QueueName, Iq);
}
/// <summary>
/// Добавить все состояния объекта очереди событий
/// </summary>
/// <param name="dataHost">Объект очереди событий</param>
/// <returns>Результат выполнения функции</returns>
private int addStates(ItemQueue itemQueue)
{
int iRes = 0;
foreach (int state in itemQueue.m_states)
{
AddState(state);
}
return(iRes);
}
protected override INDEX_WAITHANDLE_REASON StateErrors(int state,int req,int res)
{
INDEX_WAITHANDLE_REASON indxReason = INDEX_WAITHANDLE_REASON.SUCCESS;
ItemQueue itemQueue = Peek;
Logging.Logg().Error($"HandlerSignalQueue::StateRequest (CONN_SETT_TYPE={(CONN_SETT_TYPE)itemQueue.Pars [1]}, event={(EVENT)state}) - необработанное событие..."
,Logging.INDEX_MESSAGE.NOT_SET);
return(indxReason);
}
public void PushTest()
{
ItemQueue q = new ItemQueue();
// push the capacity.
for (int i = 0; i < 1000; i++)
{
q.Push(new Item(i));
}
Assert.AreEqual(1000, q.Count);
for (int v = 0; v < 1000; v++)
{
Assert.AreEqual(v, q.Pop().Value);
}
Assert.AreEqual(0, q.Count);
// push the capacity.
for (int i = 0; i < 1000; i++)
{
q.Push(new Item(999 - i));
}
Assert.AreEqual(1000, q.Count);
for (int v = 0; v < 1000; v++)
{
Assert.AreEqual(v, q.Pop().Value);
}
Assert.AreEqual(0, q.Count);
ItemQueue r = CreateReversedQueue(new int[] { });
// push the capacity.
for (int i = 0; i < 1000; i++)
{
r.Push(new Item(i));
}
Assert.AreEqual(1000, r.Count);
for (int v = 999; v >= 0; v--)
{
Assert.AreEqual(v, r.Pop().Value);
}
Assert.AreEqual(0, r.Count);
}
private void WriteToQueue(string value, bool isNewLine)
{
if (value != null)
{
if (isNewLine)
{
value = value + NewLine;
}
ItemQueue.Enqueue(value);
_queued?.Invoke(this, EventArgs.Empty);
}
}
public void Start()
{
if (!IsRunning)
{
IsRunning = true;
new System.Threading.Thread(() =>
{
while (true)
{
bool check = false;
bool condition = false;
lock (__queuelock)
{
condition = ItemQueue.Count < BufferingSize;
}
if (condition)
{
var item = Source.Congruence();
Get(ref item);
lock (__queuelock)
{
ItemQueue.Enqueue(item);
}
check = true;
}
if (!check)
{
System.Threading.Thread.Sleep(1);
}
else
{
//Console.WriteLine($"Reader : Load-> c/{ItemQueue.Count}");
}
}
}).Start();
}
if (null == gcThread)
{
gcThread = new System.Threading.Thread(() =>
{
while (true)
{
GC.Collect();
System.Threading.Thread.Sleep(1000);
}
});
gcThread.Start();
}
}
protected override int StateResponse(int state, object obj)
{
int iRes = 0;
ItemQueue itemQueue = Peek;
switch ((StatesMachine)state)
{
case StatesMachine.LIST_GROUP_SOURCES:
case StatesMachine.LIST_SRC_GROUP_SOURCE_ITEMS:
case StatesMachine.LIST_SRC_GROUP_SOURCE_PARS:
case StatesMachine.LIST_SRC_GROUP_SOURCE_PROP:
case StatesMachine.LIST_GROUP_SIGNALS:
case StatesMachine.LIST_SRC_GROUP_SIGNAL_ITEMS:
case StatesMachine.LIST_SRC_GROUP_SIGNAL_PARS:
case StatesMachine.LIST_SRC_GROUP_SIGNAL_PROP:
case StatesMachine.LIST_DEST_GROUP_SOURCE_ITEMS:
case StatesMachine.LIST_DEST_GROUP_SOURCE_PARS:
case StatesMachine.LIST_DEST_GROUP_SOURCE_PROP:
case StatesMachine.LIST_DEST_GROUP_SIGNAL_ITEMS:
case StatesMachine.LIST_DEST_GROUP_SIGNAL_PARS:
case StatesMachine.LIST_DEST_GROUP_SIGNAL_PROP:
case StatesMachine.OBJ_SRC_GROUP_SOURCES:
case StatesMachine.OBJ_DEST_GROUP_SOURCES:
case StatesMachine.TIMER_WORK_UPDATE:
case StatesMachine.OBJ_SRC_GROUP_SIGNALS_PARS:
case StatesMachine.OBJ_SRC_GROUP_SIGNALS:
case StatesMachine.OBJ_DEST_GROUP_SIGNALS_PARS:
case StatesMachine.OBJ_DEST_GROUP_SIGNALS:
case StatesMachine.STATE_GROUP_SOURCES:
case StatesMachine.STATE_GROUP_SIGNALS:
case StatesMachine.STATE_CHANGED_GROUP_SOURCES:
case StatesMachine.STATE_CHANGED_GROUP_SIGNALS:
case StatesMachine.DATA_SRC_GROUP_SIGNALS:
case StatesMachine.DATA_DEST_GROUP_SIGNALS:
case StatesMachine.GET_GROUP_SIGNALS_DATETIME_PARS:
itemQueue.m_dataHostRecieved.OnEvtDataRecievedHost(new object[] { state, obj });
break;
case StatesMachine.SET_IDCUR_SOURCE_OF_GROUP:
case StatesMachine.SET_TEXT_ADDING:
case StatesMachine.SET_GROUP_SIGNALS_PARS:
case StatesMachine.CLEARVALUES_DEST_GROUP_SIGNALS:
//Ответа не требуется
break;
default:
break;
}
return(iRes);
}
protected override int StateResponse(int state,object obj)
{
int iRes = 0;
ItemQueue itemQueue = Peek;
CONN_SETT_TYPE type = CONN_SETT_TYPE.UNKNOWN;
EventArgsDataHost arg;
switch ((EVENT)state)
{
case EVENT.LIST_SIGNAL:
type = (CONN_SETT_TYPE)itemQueue.Pars[1];
if (Signals.ContainsKey(type) == false)
{
Signals.Add(type,new List <SIGNAL>(obj as IList <SIGNAL>));
}
else
{
Signals[type] = new List <SIGNAL>(obj as IList <SIGNAL>);
}
arg = new EventArgsDataHost(null,new object[] { (EVENT)state,type });
break;
case EVENT.CUR_VALUES:
case EVENT.CHECK_VALUES:
type = (CONN_SETT_TYPE)itemQueue.Pars[0];
if (_values.ContainsKey(type) == false)
{
_values.Add(type,VALUES.Copy(obj as VALUES));
}
else
{
_values[type] = VALUES.Copy(obj as VALUES);
}
// дополнительно передать ккс-код (для поиска столбца)
arg = new EventArgsDataHost(null,new object[] { (EVENT)state,type,Signals[type].ElementAt((int)itemQueue.Pars[1]).kks_code });
break;
default:
arg = new EventArgsDataHost(null,new object[] { });
break;
}
itemQueue.m_dataHostRecieved.OnEvtDataRecievedHost(arg);
return(iRes);
}
public void PeekTest()
{
ItemQueue q = CreateQueue(new int[] { 4, 2, 3, 1 });
Assert.AreEqual(1, q.Peek().Value);
ItemQueue r = CreateReversedQueue(new int[] { 4, 2, 3, 1 });
Assert.AreEqual(4, r.Peek().Value);
ItemQueue e = new ItemQueue();
Assert.IsNull(e.Peek());
}
public void BeginStartup()
{
if (Show != null)
{
// Sort the items
Show.Items.Sort((item1, item2) => item1.ItemOrder.CompareTo(item2.ItemOrder));
foreach (Shows.ShowItem item in Show.GetItems(Shows.ShowItemType.Startup))
{
ItemQueue.Enqueue(item);
}
ExecuteNextStartupItem();
}
}
protected override int StateResponse(int state, object obj)
{
int iRes = 0;
ItemQueue itemQueue = Peek;
EvtToFormMain?.Invoke(new object[] {
StatesMachine.MESSAGE_TO_STATUSSTRIP
, FormMain.StatusStrip.STATE.Action
, string.Format(@"WriterHandlerQueue - обработка события {0}", ((StatesMachine)state).ToString())
});
switch ((StatesMachine)state)
{
case StatesMachine.NEW: // самый старый набор для постановки в очередь на запись,
_writer.Request((DATASET_WRITER)obj);
break;
case StatesMachine.LIST_DEST: // получены параметры соединения БД, ответа не требуется
case StatesMachine.CONNSET_USE_CHANGED:
case StatesMachine.OPTION: //
//Ответа не требуется/не требуют обработки результата
break;
case StatesMachine.LIST_DATASET: // отправить главному окну(для отображения) информацию о поученных/обработанных наборах с данными
case StatesMachine.DATASET_CONTENT: // отправить главному окну(для отображения) информацию о выбранном для отображения в главном окне
//case StatesMachine.STATISTIC: // статический объект (obj = null)
if ((!(itemQueue == null))
//&& (!(itemQueue.m_dataHostRecieved == null)) FormMain не реализует интерфейс 'IDataHost'
)
{
// вариант для объекта с интерфейсом 'IDataHost'
//itemQueue.m_dataHostRecieved.OnEvtDataRecievedHost(new object[] { state, obj })
EvtToFormMain?.Invoke(new object[] { state, obj })
;
}
else
{
;
}
break;
default:
break;
}
//Debug.WriteLine(string.Format(@"WriterHandlerQueue::StateResponse(state={0}) - ...", ((StatesMachine)state).ToString()));
return(iRes);
}
public void SelectItem(ItemQueue itemQueue)
{
if (itemQueue.CheckPrice() > _vendingMachine.MoneyInserted)
{
MachineOutput.DisplayInsufficientFundsError(itemQueue.CheckPrice() - _vendingMachine.MoneyInserted);
}
else
{
MachineOutput.DisplayDispensingItem();
itemQueue.Status(); //FOR DEBUGGING
_vendingMachine.Trash.AddWrapper(itemQueue.DispenseItem());
_vendingMachine.MoneyInserted = 0;
_vendingMachine.SetState(_vendingMachine.NoMoneyInsertedState);
}
}
/// <summary>
/// Добавить элемент в конец.
/// </summary>
/// <param name="data">Элемент.</param>
public void Enqueue(T data)
{
if (Count == 0)
{
SetHeadItem(data);
return;
}
var item = new ItemQueue <T>(data)
{
Next = tail
};
tail = item;
Count++;
}
/// <summary>
/// Убрать первый элемент.
/// </summary>
/// <returns>Элемент.</returns>
public T Dequeue()
{
var data = head.Data;
var current = tail.Next;
var previous = tail;
while (current != null && current.Next != null)
{
previous = current;
current = current.Next;
}
head = previous;
head.Next = null;
Count--;
return(data);
}
public void ExecuteNextShutdownItem()
{
if (ItemQueue.Any())
{
_currentItem = ItemQueue.Dequeue();
Shows.Action action = _currentItem.GetAction();
action.ActionComplete += OnShutdownActionComplete;
ExecuteAction(action);
// Otherwise, the show is done :(
}
else
{
State = StateType.Waiting;
ScheduleExecutor.AddSchedulerLogEntry(Show.Name, "Show complete");
Show.ReleaseAllActions();
}
}
public void Stop(bool graceful)
{
if (tokenSourcePreProcess != null && tokenSourcePreProcess.Token.CanBeCanceled)
{
tokenSourcePreProcess.Cancel(false);
}
if (tokenSourcePreProcessAll != null && tokenSourcePreProcessAll.Token.CanBeCanceled)
{
tokenSourcePreProcessAll.Cancel(false);
}
if (graceful)
{
State = StateType.Shutdown;
ScheduleExecutor.AddSchedulerLogEntry(Show.Name, "Show stopping gracefully");
}
else
{
State = StateType.Waiting;
ItemQueue.Clear();
Action[] actions;
lock (_actionLock)
{
actions = RunningActions.ToArray();
}
foreach (var action in actions)
{
ScheduleExecutor.AddSchedulerLogEntry(Show.Name, "Stopping action: " + action.ShowItem.Name);
action.Stop();
}
if (Show != null)
{
Show.ReleaseAllActions();
ScheduleExecutor.AddSchedulerLogEntry(Show.Name, "Show stopped immediately");
}
else
{
ScheduleExecutor.AddSchedulerLogEntry("No show selected", "Nothing to stop.");
}
}
}
protected override int StateResponse(int state, object obj)
{
int iRes = 0;
ItemQueue itemQueue = Peek;
switch ((StatesMachine)state)
{
case StatesMachine.UDP_CONNECTED_CHANGED:
case StatesMachine.UDP_LISTENER_PACKAGE_RECIEVED: // получен очередной XML-пакет
//Ответа не требуется/не требуют обработки результата
break;
case StatesMachine.LIST_DEST: // cписок источников данных (назначение - сохранение полученных значений)
case StatesMachine.DEST_DETAIL: //
case StatesMachine.LOGGING_SET: // настройки логгирования
case StatesMachine.OPTION_PACKAGE: // настраиваемые парметры Reader
case StatesMachine.OPTION_DEST: // настраиваемые парметры Writer
case StatesMachine.TIMER_UPDATE:
// взаимодействие через событие 'EvtToMainForm'
break;
case StatesMachine.UDP_CONNECTED_CHANGE:
case StatesMachine.WRITER_READY_CHANGE:
case StatesMachine.XML_PACKAGE_VERSION: // версия(строка) шаблон XML-пакета
case StatesMachine.XML_PACKAGE_TEMPLATE: // шаблон XML-пакета
case StatesMachine.UDP_DEBUG: //
case StatesMachine.UDP_LISTENER: // номер порта прослушивателя
if ((!(itemQueue == null)) &&
(!(itemQueue.m_dataHostRecieved == null)))
{
itemQueue.m_dataHostRecieved.OnEvtDataRecievedHost(new object[] { state, obj });
}
else
{
;
}
break;
default:
break;
}
return(iRes);
}
protected override int StateRequest(int state)
{
int iRes = 0;
ItemQueue itemQueue = Peek;
CONN_SETT_TYPE type = CONN_SETT_TYPE.UNKNOWN;
switch ((EVENT)state)
{
case EVENT.LIST_SIGNAL:
type = (CONN_SETT_TYPE)itemQueue.Pars[1];
_handlerDb.GetListSignals((int)itemQueue.Pars[0],type);
break;
case EVENT.CUR_VALUES:
case EVENT.CHECK_VALUES:
type = (CONN_SETT_TYPE)itemQueue.Pars[0];
iRes = (Signals.ContainsKey(type) == false) ? -4
: !((int)itemQueue.Pars [1] < Signals [type].Count) ? -3
: (string.IsNullOrEmpty(Signals [type].ElementAt((int)itemQueue.Pars [1]).kks_code) == true) ? -2
: 0;
if (!(iRes < 0))
{
_handlerDb.Request(type,Signals [type].ElementAt((int)itemQueue.Pars [1]).kks_code);
}
else
{
Logging.Logg().Error($"HandlerSignalQueue::StateRequest (CONN_SETT_TYPE={type}, event={(EVENT)state}) - запрос не отправлен..."
,Logging.INDEX_MESSAGE.NOT_SET);
}
break;
default:
Logging.Logg().Error(string.Format(@"HandlerSignalQueue::StateRequest (CONN_SETT_TYPE={0}, event={1}) - необработанное событие...",type,(EVENT)state)
,Logging.INDEX_MESSAGE.NOT_SET);
iRes = -1;
break;
}
return(iRes);
}
public void BeginSequential()
{
ScheduleExecutor.Logging.Info("BeginSequential");
if (Show != null && State == StateType.Running)
{
State = StateType.Running;
foreach (Shows.ShowItem item in Show.GetItems(Shows.ShowItemType.Sequential))
{
ScheduleExecutor.Logging.Info("BeginSequential: Enqueue:" + item.Name);
ItemQueue.Enqueue(item);
}
if (ItemQueue.Any())
{
ExecuteNextSequentialItem();
}
}
}
