public void QueuePeek(DefinedQueue localQeue)
{
BankCustomer tempCustomer = new BankCustomer();
tempCustomer = (BankCustomer)localQeue.Peek();
Console.WriteLine("The next Customer in line: " + tempCustomer.name);
}
// https://youtu.be/MjCjQCCtmcE
static void Main(string[] args)
{
System.Collections.Queue miQueue = new System.Collections.Queue();
// Addicionamos objetos
miQueue.Enqueue("Manzana");
miQueue.Enqueue("Freza");
miQueue.Enqueue("Pera");
// Interactuamos
Show.Show(miQueue);
// Obtener el primer objeto y sacarlo del Queue
Console.WriteLine("DeQueue {0}", miQueue.Dequeue());
Console.WriteLine("DeQueue {0}", miQueue.Dequeue());
Show.Show(miQueue, "Despues DeQueue");
// Add Elementos
miQueue.Enqueue("Limon");
miQueue.Enqueue("Mango");
miQueue.Enqueue("Ciruela");
// Obtener el primer objeto y sin sacarlo del Queue
Console.WriteLine("Peek {0}", miQueue.Peek());
Show.Show(miQueue, "Despues Peek");
// Conteo de Objeto
Console.WriteLine("Numero de Objetos {0}\n", miQueue.Count);
// Verifica si existe un objeto
Console.WriteLine("Hay Mango {0}", miQueue.Contains("Mango"));
Console.WriteLine("Hay Manzana {0}", miQueue.Contains("Manzana"));
System.Console.ReadKey();
}
static void Main(string[] args)
{
System.Collections.Queue queue = new System.Collections.Queue();
queue.Enqueue("Fine");
queue.Enqueue("Does");
queue.Enqueue("Boy");
queue.Enqueue("Good");
queue.Enqueue("Every");
Console.WriteLine("Peek returns {0}", queue.Peek());
while (queue.Count > 0)
{
Console.WriteLine(queue.Dequeue());
}
}
/// <summary>
/// 添加一个消息
/// </summary>
public void PushData(Message ci)
{
mutex.WaitOne();
if (BufferSize > 0 && BufferSize <= cmdq.Count)
{
Message c = cmdq.Peek() as Message;
if (c != null && c.type == MsgQueue.msgtype_Send)
{
LostCount++;
cmdq.Dequeue();
}
}
cmdq.Enqueue(ci);
evt.Set();
mutex.ReleaseMutex();
}
static void Main(string[] args)
{
System.Collections.Queue queue = new System.Collections.Queue();
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
Console.WriteLine("1 in Queue:{0}", queue.Contains(1));
Console.WriteLine("Remove 1:{0}", queue.Dequeue());
Console.WriteLine("Peek1:{0}", queue.Peek());
object[] numArray = queue.ToArray();
Console.WriteLine(string.Join(", ", numArray));
}
/*
* This gets called at the end of work.Execute and from
* HandleThreadExit() in the re-entrant scenario.
* This is the point where we decide what to do next!
*/
internal virtual void HandleWorkCompletion()
{
// We should still have the lock held for the workItem that just completed
Contract.Assert(_locked == true, "_locked==true");
// Now we check the queue to see if we need to release any one?
WorkItem nextWork = null;
bool bNotify = false;
lock (_workItemQueue)
{
if (_workItemQueue.Count >= 1)
{
nextWork = (WorkItem)_workItemQueue.Peek();
bNotify = true;
nextWork.SetSignaled();
}
else
{
// We set locked to false only in the case there is no
// next work to be done.
// NOTE: this is the only place _locked in ever set to false!
//DBGConsole.WriteLine(Thread.CurrentThread.GetHashCode()+"] Domain UNLOCKED!");
_locked = false;
}
}
// See if we found a non-signaled work item at the head.
if (bNotify)
{
// In both sync and async cases we just hand off the _locked state to
// the next thread which will execute.
if (nextWork.IsAsync())
{
// Async-WorkItem: signal ThreadPool event to release one thread
_asyncWorkEvent.Set();
//DBGConsole.WriteLine(Thread.CurrentThread.GetHashCode()+"] ### Signal " + nextWork._thread.GetHashCode() + (nextWork.IsDummy()?" DUMMY ":" REAL "));
}
else
{
// Sync-WorkItem: notify the waiting sync-thread.
lock (nextWork)
{
Monitor.Pulse(nextWork);
//DBGConsole.WriteLine(Thread.CurrentThread.GetHashCode()+"] ~~~ Notify " + nextWork._thread.GetHashCode() + (nextWork.IsDummy()?" DUMMY ":" REAL ") );
}
}
}
}
private static void MostrarColeccionesNoGenerics()
{
Console.Clear();
Console.WriteLine("******************************");
Console.WriteLine("*****Pilas No Genéricas*******");
Console.WriteLine("******************************");
Console.ReadLine();
//DECLARO E INSTANCIO UNA COLECCION DE TIPO LIFO
System.Collections.Stack pila = new System.Collections.Stack();
pila.Push(1);
pila.Push(2);
pila.Push(3);
pila.Push(4);
Console.WriteLine("Agrego elementos a la pila...");
Console.WriteLine("Utilizo pila.Push()");
Console.WriteLine("Orden de los elementos: 1 - 2 - 3 - 4");
Console.ReadLine();
Console.WriteLine("Muestro el primer elemento de la pila...");
Console.WriteLine("Utilizo pila.Peek()");
Console.ReadLine();
Console.WriteLine(pila.Peek());
Console.ReadLine();
Console.WriteLine("Muestro todos los elementos de la pila...");
Console.WriteLine("Recorro con un foreach. No saco los elementos de la pila.");
Console.ReadLine();
foreach (int elemento in pila)
{
Console.WriteLine(elemento);
}
Console.ReadLine();
Console.WriteLine("Desapilo todos los elementos de la pila...");
Console.WriteLine("Utilizo pila.Pop(). Recorro con un for");
Console.ReadLine();
int cantidad = pila.Count;
for (int i = 0; i < cantidad; i++)
{
Console.WriteLine("Elemento {0} = {1}", i, pila.Pop());
}
Console.ReadLine();
Console.WriteLine("Cantidad de elementos en la pila = {0}", pila.Count);
Console.ReadLine();
Console.Clear();
Console.WriteLine("******************************");
Console.WriteLine("****Colas No Genéricas********");
Console.WriteLine("******************************");
Console.ReadLine();
System.Collections.Queue cola = new System.Collections.Queue();
cola.Enqueue(1);
cola.Enqueue(2);
cola.Enqueue(3);
cola.Enqueue(4);
Console.WriteLine("Agrego elementos a la cola...");
Console.WriteLine("Utilizo pila.Enqueue()");
Console.WriteLine("Orden de los elementos: 1 - 2 - 3 - 4");
Console.ReadLine();
Console.WriteLine("Muestro el primer elemento de la cola...");
Console.WriteLine("Utilizo cola.Peek()");
Console.ReadLine();
Console.WriteLine(cola.Peek());
Console.ReadLine();
Console.WriteLine("Muestro todos los elementos de la cola...");
Console.WriteLine("Recorro con un foreach");
Console.ReadLine();
foreach (int elemento in cola)
{
Console.WriteLine(elemento);
}
Console.ReadLine();
Console.WriteLine("Saco todos los elementos de la cola...");
Console.WriteLine("Utilizo cola.Dequeue(). Recorro con un for");
Console.ReadLine();
cantidad = cola.Count;
for (int i = 0; i < cantidad; i++)
{
Console.WriteLine("Elemento {0} = {1}", i, cola.Dequeue());
}
Console.ReadLine();
Console.WriteLine("Cantidad de elementos en la cola = {0}", cola.Count);
Console.ReadLine();
Console.Clear();
Console.WriteLine("******************************");
Console.WriteLine("******Listas Dinamicas********");
Console.WriteLine("******************************");
Console.ReadLine();
System.Collections.ArrayList vec = new System.Collections.ArrayList();
vec.Add(1);
vec.Add(4);
vec.Add(3);
vec.Add(2);
Console.WriteLine("Agrego elementos al ArrayList...");
Console.WriteLine("Utilizo vec.Add()");
Console.WriteLine("Orden de los elementos: 1 - 4 - 3 - 2");
Console.ReadLine();
Console.WriteLine("Muestro todos los elementos del ArrayList...");
Console.WriteLine("Recorro con un foreach");
Console.ReadLine();
foreach (int elemento in vec)
{
Console.WriteLine(elemento);
}
Console.ReadLine();
Console.WriteLine("Ordeno los elementos del ArrayList...");
Console.WriteLine("Utilizo vec.Sort(). Recorro con un for");
Console.ReadLine();
vec.Sort();
cantidad = vec.Count;
for (int i = 0; i < cantidad; i++)
{
Console.WriteLine("Elemento {0} = {1}", i, vec[i]);
}
Console.ReadLine();
Console.WriteLine("Ordeno los elementos del ArrayList...");
Console.WriteLine("Utilizo vec.Reverse(). Recorro con un for");
Console.ReadLine();
vec.Reverse();
cantidad = vec.Count;
for (int i = 0; i < cantidad; i++)
{
Console.WriteLine("Elemento {0} = {1}", i, vec[i]);
}
Console.ReadLine();
Console.Clear();
Console.WriteLine("******************************");
Console.WriteLine("*********HashTable************");
Console.WriteLine("******************************");
Console.ReadLine();
System.Collections.Hashtable ht = new System.Collections.Hashtable();
ht.Add(1, "valor 1");
ht.Add(4, "valor 4");
ht.Add(3, "valor 3");
ht.Add(2, "valor 2");
Console.WriteLine("Agrego elementos al HashTable...");
Console.WriteLine("Utilizo vec.Add()");
Console.WriteLine("Orden de los elementos: 1 - 4 - 3 - 2");
Console.ReadLine();
Console.WriteLine("Muestro todos los elementos del HashTable...");
Console.WriteLine("Recorro con un for");
Console.ReadLine();
cantidad = ht.Count;
for (int i = 1; i <= cantidad; i++)
{
Console.WriteLine("Elemento {0} = {1}", i, ht[i]);
}
Console.ReadLine();
}
public void BFS(int day)
{
// Stores P(A)
int[] population = populationCount;
// Stores T(A)
int[] dayInfected = new int[nodeCount];
for (int i = 0; i < nodeCount; i++)
{
dayInfected[i] = -1;
}
// Initialize BFS
System.Collections.Queue neighbour = new System.Collections.Queue(); // mencatat tetangga vertex yang lagi diperiksa
neighbour.Enqueue(startingNode);
infected[startingNode] = true;
dayInfected[startingNode] = 0;
// While queue not empty...
while (neighbour.Count != 0)
{
//VisualizeGraph();
int currentNode = (int)neighbour.Peek();
neighbour.Dequeue();
for (int i = 0; i < nodeCount; i++)
{
// If a path exists...
if (G.getTravelProbability(currentNode, i) != -1)
{
// Calculate S(currentNode)
double Tr = G.getTravelProbability(currentNode, i);
int t = getDaysFromInfection(day, dayInfected[currentNode]);
double S = getInfected(population[currentNode], t) * Tr;
Console.WriteLine($"S({currentNode}, {i}) = {S}");
printed += $"S({currentNode}, {i}) = {S}\n";
// If transmission successful..
if (S > 1)
{
// Print status
Console.WriteLine($"Transmission from node {currentNode} to node {i} successful.");
printed += $"Transmission from node {currentNode} to node {i} successful.\n";
// Set node status
if (!infected[i])
{
neighbour.Enqueue(i);
Console.WriteLine($"Pushed {i} to queue.");
}
infected[i] = true;
// Find first day infected
int d = 0;
while (getInfected(population[currentNode], d) * Tr <= 1)
{
d++;
}
// Set day infected
dayInfected[i] = Math.Max(dayInfected[i], d + dayInfected[currentNode]);
Console.WriteLine($"Transmitted on day {dayInfected[i]}.");
printed += $"Transmitted on day {dayInfected[i]}.\n";
infectedEdge.Add(Tuple.Create(currentNode, i));
uninfectedEdge.Remove(new Tuple <int, int>(currentNode, i));
}
else
{
// Print status
Console.WriteLine($"Transmission from node {currentNode} to node {i} failed.");
printed += $"Transmission from node {currentNode} to node {i} failed.\n";
}
}
}
}
}
static void Main(string[] args)
{
System.Collections.ArrayList arrayList = new System.Collections.ArrayList();
System.Collections.SortedList sortedList = new System.Collections.SortedList();
System.Collections.Hashtable hashtable = new System.Collections.Hashtable();
System.Collections.Stack stack = new System.Collections.Stack();
System.Collections.Queue queue = new System.Collections.Queue();
#region [Non-Generic Collections]
Console.WriteLine("Non-Generic Colletions::");
#region ArrayList
// Array List
arrayList.Add(1);
arrayList.Add("Aniket");
arrayList.Add(10.33);
arrayList.Add(true);
arrayList.Add('A');
Console.WriteLine("******=>ArrayList");
foreach (var item in arrayList)
{
Console.WriteLine(item);
}
Console.WriteLine();
#endregion
#region SortedList
sortedList.Add(1, "Aniket");
sortedList.Add(7, "Pallavi");
sortedList.Add(5, 10.33);
sortedList.Add(2, true);
sortedList.Add(9, 'S');
Console.WriteLine("******=>Sorted List");
for (int i = 0; i < sortedList.Count; i++)
{
Console.WriteLine(sortedList.GetByIndex(i));
}
Console.WriteLine();
#endregion
#region HashTable
hashtable.Add(2, "Aniket");
hashtable.Add(true, "Pallavi");
hashtable.Add(1, 12.44);
hashtable.Add(20, 'Z');
hashtable.Add(false, 2);
Console.WriteLine("******=>Hashtable");
//Console.WriteLine(hashtable.Keys);
foreach (object item in hashtable.Keys)
{
Console.WriteLine(hashtable[item]);
}
//for (int i = 0; i < hashtable.Count; i++)
//{
// Console.WriteLine(hashtable[2]);
//}
Console.WriteLine();
#endregion
#region Stack
stack.Push(1);
stack.Push("Aniket");
stack.Push(3.12);
stack.Push('C');
stack.Push(true);
Console.WriteLine("******=>Stack");
//Console.WriteLine(stack.Peek());
//Console.WriteLine(stack.Pop());
//Console.WriteLine(stack.Peek());
foreach (object item in stack)
{
Console.WriteLine(item);
}
Console.WriteLine();
#endregion
#region Queue
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
queue.Enqueue(4);
queue.Enqueue(5);
Console.WriteLine("******=>Queue");
Console.WriteLine(queue.Peek());
Console.WriteLine(queue.Dequeue());
Console.WriteLine(queue.Count);
foreach (object item in queue)
{
Console.WriteLine(item);
}
Console.WriteLine();
#endregion
#endregion
#region [Generic Colletions]
Console.WriteLine();
Console.WriteLine("Generic Colletions::");
Console.WriteLine();
System.Collections.Generic.List <int> list = new List <int>();
System.Collections.Generic.SortedList <double, string> sortedListGenric = new SortedList <double, string>();
System.Collections.Generic.HashSet <double> hashSet = new HashSet <double>();
System.Collections.Generic.SortedSet <string> sortedSet = new SortedSet <string>();
System.Collections.Generic.Dictionary <int, string> dictionary = new Dictionary <int, string>();
System.Collections.Generic.SortedDictionary <int, string> sortedDictionary = new SortedDictionary <int, string>();
System.Collections.Generic.Stack <int> stackGenric = new Stack <int>();
System.Collections.Generic.Queue <bool> queueGeneric = new Queue <bool>();
#region List
Console.WriteLine("******=>List");
list.Add(10);
list.Add(9);
list.Add(12);
list.Add(13);
foreach (var item in list)
{
Console.WriteLine(item);
}
Console.WriteLine();
#endregion
#region SortedList
Console.WriteLine("******=>Sorted List");
sortedListGenric.Add(16, "Aniket");
sortedListGenric.Add(9, "Pallavi");
sortedListGenric.Add(5, "Shubham");
sortedListGenric.Add(8, "Nakul");
foreach (var item in sortedListGenric)
{
Console.WriteLine(item);
}
Console.WriteLine();
#endregion
#region HashSet
Console.WriteLine("******=>HashSet");
hashSet.Add(11.11);
hashSet.Add(44.22);
hashSet.Add(33.33);
for (int i = 0; i < hashSet.Count; i++)
{
Console.WriteLine(hashSet.ElementAt(i));
}
Console.WriteLine();
#endregion
#region SortedSet
Console.WriteLine("******=>SortedSet");
sortedSet.Add("Brad");
sortedSet.Add("Pallavi");
sortedSet.Add("Aniket");
for (int i = 0; i < sortedSet.Count; i++)
{
Console.WriteLine(sortedSet.ElementAt(i));
}
Console.WriteLine();
#endregion
#endregion
Console.ReadKey();
}
public static void MostrarColeccionesNoGenerics()
{
Console.Clear();
Console.WriteLine("******************************");
Console.WriteLine("*****Pilas No Genéricas*******");
Console.WriteLine("******************************");
Console.ReadLine();
//DECLARO E INSTANCIO UNA COLECCION DE TIPO LIFO
System.Collections.Stack pila = new System.Collections.Stack();
pila.Push(1);
pila.Push(2);
pila.Push(3);
pila.Push(4);
Console.WriteLine("Agrego elementos a la pila...");
Console.WriteLine("Utilizo pila.Push()");
Console.WriteLine("Orden de los elementos: 1 - 2 - 3 - 4");
Console.ReadLine();
Console.WriteLine("Muestro el primer elemento de la pila...");
Console.WriteLine("Utilizo pila.Peek()");
Console.ReadLine();
Console.WriteLine(pila.Peek());
Console.ReadLine();
Console.WriteLine("Muestro todos los elementos de la pila...");
Console.WriteLine("Recorro con un foreach. No saco los elementos de la pila.");
Console.ReadLine();
foreach (int elemento in pila)
{
Console.WriteLine(elemento);
}
Console.ReadLine();
Console.WriteLine("Desapilo todos los elementos de la pila...");
Console.WriteLine("Utilizo pila.Pop(). Recorro con un for");
Console.ReadLine();
int cantidad = pila.Count;
for (int i = 0; i < cantidad; i++)
{
Console.WriteLine("Elemento {0} = {1}", i, pila.Pop());
}
Console.ReadLine();
Console.WriteLine("Cantidad de elementos en la pila = {0}", pila.Count);
Console.ReadLine();
Console.Clear();
Console.WriteLine("******************************");
Console.WriteLine("****Colas No Genéricas********");
Console.WriteLine("******************************");
Console.ReadLine();
System.Collections.Queue cola = new System.Collections.Queue();
cola.Enqueue(1);
cola.Enqueue(2);
cola.Enqueue(3);
cola.Enqueue(4);
Console.WriteLine("Agrego elementos a la cola...");
Console.WriteLine("Utilizo pila.Enqueue()");
Console.WriteLine("Orden de los elementos: 1 - 2 - 3 - 4");
Console.ReadLine();
Console.WriteLine("Muestro el primer elemento de la cola...");
Console.WriteLine("Utilizo cola.Peek()");
Console.ReadLine();
Console.WriteLine(cola.Peek());
Console.ReadLine();
Console.WriteLine("Muestro todos los elementos de la cola...");
Console.WriteLine("Recorro con un foreach");
Console.ReadLine();
foreach (int elemento in cola)
{
Console.WriteLine(elemento);
}
Console.ReadLine();
Console.WriteLine("Saco todos los elementos de la cola...");
Console.WriteLine("Utilizo cola.Dequeue(). Recorro con un for");
Console.ReadLine();
cantidad = cola.Count;
for (int i = 0; i < cantidad; i++)
{
Console.WriteLine("Elemento {0} = {1}", i, cola.Dequeue());
}
Console.ReadLine();
Console.WriteLine("Cantidad de elementos en la cola = {0}", cola.Count);
Console.ReadLine();
Console.Clear();
Console.WriteLine("******************************");
Console.WriteLine("******Listas Dinamicas********");
Console.WriteLine("******************************");
Console.ReadLine();
System.Collections.ArrayList vec = new System.Collections.ArrayList();
vec.Add(1);
vec.Add(4);
vec.Add(3);
vec.Add(2);
Console.WriteLine("Agrego elementos al ArrayList...");
Console.WriteLine("Utilizo vec.Add()");
Console.WriteLine("Orden de los elementos: 1 - 4 - 3 - 2");
Console.ReadLine();
Console.WriteLine("Muestro todos los elementos del ArrayList...");
Console.WriteLine("Recorro con un foreach");
Console.ReadLine();
foreach (int elemento in vec)
{
Console.WriteLine(elemento);
}
Console.ReadLine();
Console.WriteLine("Ordeno los elementos del ArrayList...");
Console.WriteLine("Utilizo vec.Sort(). Recorro con un for");
Console.ReadLine();
vec.Sort();
cantidad = vec.Count;
for (int i = 0; i < cantidad; i++)
{
Console.WriteLine("Elemento {0} = {1}", i, vec[i]);
}
Console.ReadLine();
Console.WriteLine("Ordeno los elementos del ArrayList...");
Console.WriteLine("Utilizo vec.Reverse(). Recorro con un for");
Console.ReadLine();
vec.Reverse();
cantidad = vec.Count;
for (int i = 0; i < cantidad; i++)
{
Console.WriteLine("Elemento {0} = {1}", i, vec[i]);
}
Console.ReadLine();
Console.Clear();
Console.WriteLine("******************************");
Console.WriteLine("*********HashTable************");
Console.WriteLine("******************************");
Console.ReadLine();
System.Collections.Hashtable ht = new System.Collections.Hashtable();
ht.Add(1, "valor 1");
ht.Add(4, "valor 4");
ht.Add(3, "valor 3");
ht.Add(2, "valor 2");
Console.WriteLine("Agrego elementos al HashTable...");
Console.WriteLine("Utilizo vec.Add()");
Console.WriteLine("Orden de los elementos: 1 - 4 - 3 - 2");
Console.ReadLine();
Console.WriteLine("Muestro todos los elementos del HashTable...");
Console.WriteLine("Recorro con un for");
Console.ReadLine();
cantidad = ht.Count;
for (int i = 1; i <= cantidad; i++)
{
Console.WriteLine("Elemento {0} = {1}", i, ht[i]);
}
Console.ReadLine();
}
public T Peek()
{
return((T)inner.Peek());
}
public override object Peek()
{
return(queue.Peek());
}
/**
* Process Trial Related Data.
*/
public static XmlNode processTrialStart(String geLogFileName, XmlNode DisplayFileStartNode, XmlDocument xmlDoc, String edfFileName)
{
XmlNode trialStartNode = null;
long prevGazeTimeStamp = 0;
ObjPositionData gePrevPositionData = null;
try
{
log.WriteLine("Processing Trial Start");
log.Flush();
Regex gazePostionRegex = new Regex(@"^(\d+)\s*(\d.*)\s*(\d.*)\s");
trialStartNode = processSingleNode("TrialStart", DisplayFileStartNode, xmlDoc);
GazeDataWorker gazeWorker = new GazeDataWorker(edfFileName, gazePostionRegex);
ObjectDataWorker objectWorker = new ObjectDataWorker(geLogFileName);
ReplayTrial.timeStampDataQueue.Clear();
geLogTrialDataQueue.Clear();
Thread gazeWorkerThread = new Thread(gazeWorker.doWork);
Thread objectWorkerThread = new Thread(objectWorker.doWork);
log.WriteLine("created threads");
log.Flush();
try
{
gazeWorkerThread.Start();
objectWorkerThread.Start();
gazeWorkerThread.Join();
objectWorkerThread.Join();
}
catch (ThreadInterruptedException e)
{
log.WriteLine(" Thread Interrupted Exception " + e.StackTrace);
}
catch (ThreadAbortException e)
{
log.WriteLine(" ThreadAbortException : " + e.StackTrace);
}
catch (SystemException e)
{
log.WriteLine("SystemException : " + e.StackTrace);
}
catch (Exception)
{
log.WriteLine("Exception with Threads");
}
log.WriteLine(" threads completed job");
log.Flush();
int edfCount = edfTrialDataQueue.Count;
int geCount = geLogTrialDataQueue.Count;
long relativeDifference = 0;
long gelogFirstTimeStamp = 0;
long gazeFirstTimeStamp = 0;
if (edfCount > 0)
{
ObjPositionData firstTimeStampData = (ObjPositionData)edfTrialDataQueue.Peek();
gazeFirstTimeStamp = firstTimeStampData.timeStamp;
}
if (geCount > 0)
{
ObjPositionData geFirstData = (ObjPositionData)geLogTrialDataQueue.Peek();
gelogFirstTimeStamp = geFirstData.timeStamp;
}
if (gazeFirstTimeStamp != gelogFirstTimeStamp)
{
if (gazeFirstTimeStamp > gelogFirstTimeStamp)
{
relativeDifference = gazeFirstTimeStamp - gelogFirstTimeStamp;
}
}
if (edfCount != geCount)
{
log.WriteLine("WARNING : Time Stamps Obtained from EDFFile does not match the number of timeStamps in GELog ");
log.WriteLine("WARNING : TimeStamp Count :: edf :" + edfCount + " , GELog : " + geCount);
log.Flush();
}
XmlNode timeStartNode = null;
long gePrevTimeStamp = 0;
int count = 0;
while (edfTrialDataQueue.Count > 0) //&& geLogTrialDataQueue.Count > 0
{
long edfTimeStamp = -1;
long gazeTimeStamp = 0;
if (edfTrialDataQueue.Count > 0)
{
ObjPositionData data = null;
do
{
data = (ObjPositionData)edfTrialDataQueue.Dequeue();
edfTimeStamp = data.timeStamp;
if (prevGazeTimeStamp == 0)
{
prevGazeTimeStamp = edfTimeStamp;
}
} while ((edfTimeStamp != prevGazeTimeStamp) && (edfTrialDataQueue.Count > 0));
// Obtain the Refresh rate and calculate number of times data would have been recorded.
int tmpRefreshRate = 1;
int refreshRateFactor = 1000 / REFRESH_RATE;
if ((refreshRateFactor % 2) == 0)
{
tmpRefreshRate = refreshRateFactor;
}
else
{
tmpRefreshRate = refreshRateFactor - 1;
}
prevGazeTimeStamp = edfTimeStamp + (tmpRefreshRate);
timeStartNode = processSingleNode("Time", "stamp", edfTimeStamp.ToString(), trialStartNode, xmlDoc);
LinkedList <ObjectData> gazedataList = data.getobjList();
foreach (ObjectData objData in gazedataList)
{
String name = objData.objName;
String xCoord = objData.xPos.ToString();
String yCoord = objData.yPos.ToString();
XmlElement objNode = addElement("obj", timeStartNode, xmlDoc);
addAttribute("name", name, objNode);
addAttribute("x", xCoord, objNode);
addAttribute("y", yCoord, objNode);
log.WriteLine(" objname : " + name + " , x : " + xCoord + " , Y :" + yCoord);
log.Flush();
}
edfCount--;
}
log.WriteLine(" dequeing gelog data ");
log.Flush();
long geTimeStamp = -1;
ObjPositionData geData = null;
// for (int index = 0; index < speedControl * 5; index++)
// {
if (geLogTrialDataQueue.Count > 0)
{
long geNewTimeStamp = 0;
geData = (ObjPositionData)geLogTrialDataQueue.Dequeue();
geTimeStamp = geData.timeStamp;
geCount--;
}
else if (gePrevPositionData != null)
{
geData = gePrevPositionData;
geTimeStamp = geData.timeStamp;
}
if (geData != null)
{
gePrevPositionData = geData;
LinkedList <ObjectData> objdataList = geData.getobjList();
foreach (ObjectData objData in objdataList)
{
String name = objData.objName;
String xCoord = objData.xPos.ToString();
String yCoord = objData.yPos.ToString();
XmlElement objNode = addElement("obj", timeStartNode, xmlDoc);
addAttribute("name", name, objNode);
addAttribute("x", xCoord, objNode);
addAttribute("y", yCoord, objNode);
log.WriteLine(" objname : " + name + " , x : " + xCoord + " , Y :" + yCoord);
log.Flush();
}
count++;
}
} //end of while loop
geLogTrialDataQueue.Clear();
}
catch (Exception e)
{
throw new ATLogicException(" Error while processing TrialStart parameters . gecount : " + geLogTrialDataQueue.Count + " , edf count : " + edfTrialDataQueue.Count);
}
return(trialStartNode);
}
public T Peek()
{
return((T)queue.Peek());
}