// Method to sort the droids based on what type of droid they are
public void CategorySort()
{
// Create instances of the generic stack class for each type of droid
GenericStack <IDroid> protocolStack = new GenericStack <IDroid>();
GenericStack <IDroid> utilityStack = new GenericStack <IDroid>();
GenericStack <IDroid> janitorStack = new GenericStack <IDroid>();
GenericStack <IDroid> astromechStack = new GenericStack <IDroid>();
// Create an instance of the generic queue class
GenericQueue <IDroid> droidQueue = new GenericQueue <IDroid>();
// Put each element from the array into a stack
foreach (IDroid droid in droidCollection)
{
// Null elements are not used
if (droid != null)
{
switch (droid.GetType().Name.ToString())
{
// Protocol stack
case "ProtocolDroid":
protocolStack.Push(droid);
break;
// Astromech stack
case "AstromechDroid":
astromechStack.Push(droid);
break;
// Janitor stack
case "JanitorDroid":
janitorStack.Push(droid);
break;
// Utility stack
case "UtilityDroid":
utilityStack.Push(droid);
break;
}
}
}
// Empty the astromech stack into the queue
while (astromechStack.IsEmpty != true)
{
droidQueue.Enqueue(astromechStack.Pop());
}
// Empty the janitor stack into the queue
while (janitorStack.IsEmpty != true)
{
droidQueue.Enqueue(janitorStack.Pop());
}
// Empty the utility stack into the queue
while (utilityStack.IsEmpty != true)
{
droidQueue.Enqueue(utilityStack.Pop());
}
// Empty the protocol stack into the queue
while (protocolStack.IsEmpty != true)
{
droidQueue.Enqueue(protocolStack.Pop());
}
// Replace the droid collection array elements with the droid queue
for (int i = 0; i < droidCollection.Length; i++)
{
if (droidQueue.IsEmpty != true)
{
droidCollection[i] = droidQueue.Dequeue();
}
}
}
/// <summary>
/// Public method to Sort the droids into categories using a modified bucket sort
/// </summary>
public void SortIntoCategories()
{
// Create a generic stack for each type of droid, and pass in the droid type as the generic that will
// come through on the stack class as T.
GenericStack <ProtocolDroid> protocolStack = new GenericStack <ProtocolDroid>();
GenericStack <UtilityDroid> utilityStack = new GenericStack <UtilityDroid>();
GenericStack <JanitorDroid> janitorStack = new GenericStack <JanitorDroid>();
GenericStack <AstromechDroid> astromechStack = new GenericStack <AstromechDroid>();
// Create a queue to hold the droids as we pop them off the stack.
GenericQueue <IDroid> categorizedDroidQueue = new GenericQueue <IDroid>();
// For each IDroid in the droidCollection
foreach (IDroid droid in this.droidCollection)
{
// If the droid is not null we want to process it. If it is null we will go to the else
if (droid != null)
{
// The testing of the droids must occur in this order. It must be done in the order of
// most specific droid to least specific.
// If we were to test a droid that IS of type Astromech against Utility BEFORE we test against
// Astromech, it would pass and be put into the Utility stack and not the Astromech. That is why it
// is important to test from most specific to least.
// If the droid is an Astromech, push it on the astromech stack
if (droid is AstromechDroid)
{
astromechStack.Push((AstromechDroid)droid);
}
// Else if it is a JanitorDroid, push it on the janitor stack
else if (droid is JanitorDroid)
{
janitorStack.Push((JanitorDroid)droid);
}
// Do for Utility
else if (droid is UtilityDroid)
{
utilityStack.Push((UtilityDroid)droid);
}
// Do for Protocol
else if (droid is ProtocolDroid)
{
protocolStack.Push((ProtocolDroid)droid);
}
}
// The droid we are trying to consider is null, break out of the loop.
else
{
break;
}
}
// Now that the droids are all in thier respective stacks we can do the work
// of poping them off of the stacks and adding them to the queue.
// It is required that they be popped off from each stack in this order so that they have
// the correct order going into the queue.
// This is a primer pop. It gets the first droid off the stack, which could be null if the stack is empty
AstromechDroid currentAstromechDroid = astromechStack.Pop();
// While the droid that is popped off is not null
while (currentAstromechDroid != null)
{
// Add the popped droid to the queue.
categorizedDroidQueue.Enqueue(currentAstromechDroid);
// Pop off the next droid for the loop test
currentAstromechDroid = astromechStack.Pop();
}
// See above method for Astromech. It is the same except for Janitor
JanitorDroid currentJanitorDroid = janitorStack.Pop();
while (currentJanitorDroid != null)
{
categorizedDroidQueue.Enqueue(currentJanitorDroid);
currentJanitorDroid = janitorStack.Pop();
}
// See above method for Astromech. It is the same except for Utility
UtilityDroid currentUtilityDroid = utilityStack.Pop();
while (currentUtilityDroid != null)
{
categorizedDroidQueue.Enqueue(currentUtilityDroid);
currentUtilityDroid = utilityStack.Pop();
}
// See above method for Astromech. It is the same except for Protocol
ProtocolDroid currentProtocolDroid = protocolStack.Pop();
while (currentProtocolDroid != null)
{
categorizedDroidQueue.Enqueue(currentProtocolDroid);
currentProtocolDroid = protocolStack.Pop();
}
// Now that the droids have all been removed from the stacks and put into the queue
// we need to dequeue them all and put them back into the original array.
// Set a int counter to 0.
int counter = 0;
// This is a primer dequeue that will get the first droid out of the queue.
IDroid iDroid = categorizedDroidQueue.Dequeue();
// While the dequeued droid is not null.
while (iDroid != null)
{
// Add the droid to the droid collection using the int counter as the index
this.droidCollection[counter] = iDroid;
// Increment the counter
counter++;
// Dequeue the next droid off the queue so it can be used in the while condition
iDroid = categorizedDroidQueue.Dequeue();
}
// Set the length of the collection to the value of the counter. It should be the same, but in case it changed.
this.lengthOfCollection = counter;
}
public void CategorizeByModel()
{
// Make instance of Protocol Droids
GenericStack <ProtocolDroid> protocolStackList = new GenericStack <ProtocolDroid>();
// Make instance of Utility Droids
GenericStack <UtilityDroid> utilityStackList = new GenericStack <UtilityDroid>();
// Make instance of Janitor Droids
GenericStack <JanitorDroid> janitorStackList = new GenericStack <JanitorDroid>();
// Make instance of Astromech Droids
GenericStack <AstromechDroid> astromechStackList = new GenericStack <AstromechDroid>();
// Pushing Droids
foreach (Droid droid in droids)
{
if (droid != null)
{
if (droid.GetType() == typeof(ProtocolDroid))
{
protocolStackList.Push((ProtocolDroid)droid);
}
if (droid.GetType() == typeof(UtilityDroid))
{
utilityStackList.Push((UtilityDroid)droid);
}
if (droid.GetType() == typeof(JanitorDroid))
{
janitorStackList.Push((JanitorDroid)droid);
}
if (droid.GetType() == typeof(AstromechDroid))
{
astromechStackList.Push((AstromechDroid)droid);
}
}
}
// Make instance of GenericQueue class
GenericQueue queue = new GenericQueue();
// QUEUE DROIDS IN ORDER OF ASTROMECH, JANITOR, UTILITY, PROTOCOL
Queue <Droid> queueDroids = new Queue <Droid>();
while (!astromechStackList.IsEmpty)
{
queueDroids.Enqueue(astromechStackList.Pop());
}
while (!janitorStackList.IsEmpty)
{
queueDroids.Enqueue(janitorStackList.Pop());
}
while (!utilityStackList.IsEmpty)
{
queueDroids.Enqueue(utilityStackList.Pop());
}
while (!protocolStackList.IsEmpty)
{
queueDroids.Enqueue(protocolStackList.Pop());
}
// Reset the droid length
droidLength = 0;
// Dequeue each droid in appropriate list
while (queueDroids.Count != 0)
{
droids[droidLength] = queueDroids.Dequeue();
droidLength++;
}
// Loop through all of the droids
foreach (Droid droid in droids)
{
// If the current beverage is not null, concat it to the return string
if (droid != null)
{
// Print
Console.WriteLine(droid);
}
}
}