main.cpp

#include

#include

#include

#include

#include "lfgqueue.h"

using namespace std;

inline void _test(const char* expression, const char* file, int line)

{

cerr << "test(" << expression << ") failed in file " << file;

cerr << ", line " << line << "." << endl;

abort();

}

#define test(EXPRESSION) ((EXPRESSION) ? (void)0 : _test(#EXPRESSION, __FILE__, __LINE__))

int main()

{

// Variables used for testing

Player* group[3];

Player daria("Daria", Player::Defender);

Player daniela("Daniela", Player::Defender);

Player hector("Hector", Player::Hunter);

Player hugo("Hugo", Player::Hunter);

Player berta("Berta", Player::Bard);

Player bernardo("Bernardo", Player::Bard);

// Test size(), add(), front_player(), pop_player()

// on a small example.

LFGQueue q;

test(q.size() == 0);

test(q.front_player(Player::Defender) == nullptr);

test(q.front_player(Player::Hunter) == nullptr);

test(q.front_player(Player::Bard) == nullptr);

q.push_player(&daniela);

test(q.size() == 1);

test(q.front_player(Player::Defender) == &daniela);

test(q.front_player(Player::Hunter) == nullptr);

test(q.front_player(Player::Bard) == nullptr);

q.push_player(&hector);

test(q.size() == 2);

test(q.front_player(Player::Defender) == &daniela);

test(q.front_player(Player::Hunter) == &hector);

test(q.front_player(Player::Bard) == nullptr);

q.push_player(&berta);

test(q.size() == 3);

test(q.front_player(Player::Defender) == &daniela);

test(q.front_player(Player::Hunter) == &hector);

test(q.front_player(Player::Bard) == &berta);

q.push_player(&hugo);

test(q.size() == 4);

test(q.front_player(Player::Defender) == &daniela);

test(q.front_player(Player::Hunter) == &hector);

test(q.front_player(Player::Bard) == &berta);

q.push_player(&bernardo);

test(q.size() == 5);

test(q.front_player(Player::Defender) == &daniela);

test(q.front_player(Player::Hunter) == &hector);

test(q.front_player(Player::Bard) == &berta);

q.push_player(&daria);

test(q.size() == 6);

test(q.front_player(Player::Defender) == &daniela);

test(q.front_player(Player::Hunter) == &hector);

test(q.front_player(Player::Bard) == &berta);

// Order is now [Daniela, Hector, Berta, Hugo, Bernardo, Daria]

q.pop_player(Player::Defender);

test(q.size() == 5);

test(q.front_player(Player::Defender) == &daria);

test(q.front_player(Player::Hunter) == &hector);

test(q.front_player(Player::Bard) == &berta);

q.pop_player(Player::Hunter);

test(q.size() == 4);

test(q.front_player(Player::Defender) == &daria);

test(q.front_player(Player::Hunter) == &hugo);

test(q.front_player(Player::Bard) == &berta);

q.pop_player(Player::Bard);

test(q.size() == 3);

test(q.front_player(Player::Defender) == &daria);

test(q.front_player(Player::Hunter) == &hugo);

test(q.front_player(Player::Bard) == &bernardo);

q.pop_player(Player::Bard);

test(q.size() == 2);

test(q.front_player(Player::Defender) == &daria);

test(q.front_player(Player::Hunter) == &hugo);

test(q.front_player(Player::Bard) == nullptr);

q.pop_player(Player::Defender);

test(q.size() == 1);

test(q.front_player(Player::Defender) == nullptr);

test(q.front_player(Player::Hunter) == &hugo);

test(q.front_player(Player::Bard) == nullptr);

q.pop_player(Player::Hunter);

test(q.size() == 0);

test(q.front_player(Player::Defender) == nullptr);

test(q.front_player(Player::Hunter) == nullptr);

test(q.front_player(Player::Bard) == nullptr);

// Test previous methods plus front_group(), pop_group() on

// a small example.

q.push_player(&hugo);

test(q.size() == 1);

test(q.front_player(Player::Defender) == nullptr);

test(q.front_player(Player::Hunter) == &hugo);

test(q.front_player(Player::Bard) == nullptr);

test(!q.front_group(group));

q.push_player(&hector);

test(q.size() == 2);

test(q.front_player(Player::Defender) == nullptr);

test(q.front_player(Player::Hunter) == &hugo);

test(q.front_player(Player::Bard) == nullptr);

test(!q.front_group(group));

q.push_player(&berta);

test(q.size() == 3);

test(q.front_player(Player::Defender) == nullptr);

test(q.front_player(Player::Hunter) == &hugo);

test(q.front_player(Player::Bard) == &berta);

test(!q.front_group(group));

q.push_player(&bernardo);

test(q.size() == 4);

test(q.front_player(Player::Defender) == nullptr);

test(q.front_player(Player::Hunter) == &hugo);

test(q.front_player(Player::Bard) == &berta);

test(!q.front_group(group));

q.push_player(&daria);

test(q.size() == 5);

test(q.front_player(Player::Defender) == &daria);

test(q.front_player(Player::Hunter) == &hugo);

test(q.front_player(Player::Bard) == &berta);

test(q.front_group(group));

q.push_player(&daniela);

test(q.size() == 6);

test(q.front_player(Player::Defender) == &daria);

test(q.front_player(Player::Hunter) == &hugo);

test(q.front_player(Player::Bard) == &berta);

test(q.front_group(group));

// Order is now [Hugo, Hector, Berta, Bernardo, Daria, Daniela]

group[0] = group[1] = group[2] = nullptr;

test(q.front_group(group));

test(group[0] == &daria);

test(group[1] == &hugo);

test(group[2] == &berta);

q.pop_group();

test(q.size() == 3);

test(q.front_player(Player::Defender) == &daniela);

test(q.front_player(Player::Hunter) == &hector);

test(q.front_player(Player::Bard) == &bernardo);

group[0] = group[1] = group[2] = nullptr;

test(q.front_group(group));

test(group[0] == &daniela);

test(group[1] == &hector);

test(group[2] == &bernardo);

q.pop_group();

test(q.size() == 0);

test(q.front_player(Player::Defender) == nullptr);

test(q.front_player(Player::Hunter) == nullptr);

test(q.front_player(Player::Bard) == nullptr);

// Test a set of 999 players: 333 of each role in the following order:

// 333 defenders, 1 hunter, 1 bard, 1 hunter, 1 bard...

// Create the players

Player** players = new Player*[999];

ostringstream oss;

for (int i = 0; i < 333; ++i)

{

oss.str("");

oss << "Defender #" << i+1;

players[i] = new Player(oss.str(), Player::Defender);

}

for (int i = 333; i < 999; i+=2)

{

oss.str("");

oss << "Hunter #" << (i-333)/2+1;

players[i] = new Player(oss.str(), Player::Hunter);

}

for (int i = 334; i < 999; i+=2)

{

oss.str("");

oss << "Bard #" << (i-334)/2+1;

players[i] = new Player(oss.str(), Player::Bard);

}

// Add them to the queue

for (int i = 0; i < 999; ++i)

q.push_player(players[i]);

test(q.size() == 999);

// Repeatedly check and remove the frontmost players.

// Because of how we scrambled, this has a fixed order.

for (int i = 0; i < 333; ++i)

{

group[0] = group[1] = group[2] = nullptr;

test(q.front_group(group));

oss.str("");

oss << "Defender #" << i+1;

test(group[0]->name() == oss.str());

oss.str("");

oss << "Hunter #" << i+1;

test(group[1]->name() == oss.str());

oss.str("");

oss << "Bard #" << i+1;

test(group[2]->name() == oss.str());

q.pop_group();

test(q.size() == 999 - 3 * (i+1));

}

test(q.size() == 0);

test(!q.front_group(group));

for (int i = 0; i < 999; ++i)

delete players[i];

delete[] players;

// Test a queue of 1000000 "randomly"-chosen players

// Seed random number generator, so test uses the same

// "random" numbers every time and thus runs same everytime

srand(2017);

// Add 1000000 players

clock_t start = clock();

int added[3] = {0, 0, 0};

while (added[0] + added[1] + added[2] < 1000000)

{

// Players are randomly chosen, biased in the following way:

// ~67% Defenders, ~17% Hunters, ~17% Bard

int choice = (rand() % 2) * (rand() % 3);

Player::Role role = static_cast(choice);

string name;

switch (role)

{

case Player::Defender:

name = "Defender #?";

break;

case Player::Hunter:

name = "Hunter #?";

break;

case Player::Bard:

name = "Bard #?";

break;

}

q.push_player(new Player(name, role));

++added[choice];

}

clock_t end = clock();

float duration = static_cast(end - start) / CLOCKS_PER_SEC;

test(q.size() == 1000000);

cout << "Added 1000000 players to a queue in ";

cout << duration << " seconds." << endl;

test(duration < 3.0);

// Remove as many complete groups as possible

int complete_groups = min(added[0], min(added[1], added[2]));

assert(complete_groups > 50000); // Should be more like 167000

start = clock();

for (int i = 0; i < complete_groups; ++i)

{

q.pop_group();

test(q.size() == 1000000 - 3 * (i+1));

}

end = clock();

duration = static_cast(end - start) / CLOCKS_PER_SEC;

test(q.size() == 1000000 - 3 * complete_groups);

cout << "Removed " << complete_groups << " groups of players from ";

cout << "this queue in " << duration << " seconds." << endl;

test(duration < 3.0);

cout << "Assignment complete." << endl;

}

player.h

#ifndef PLAYER_H

#define PLAYER_H

#include

using namespace std;

class Player

{

public:

// This works like a custom type with just four values.

// Outside of Player methods, reference them like:

// "if (p->role == Player::Defender)", etc.

enum Role {Defender=0, Hunter=1, Bard=2};

// Initializes a player with the given name and role

Player(string name, Role role);

// Returns the name of the player

string name();

// Returns the role of the player

Role role();

private:

string _name;

Role _role;

};

#endif

player.cpp

#include "player.h"

Player :: Player(string name, Role role)

{

_name = name;

_role = role;

}

string Player :: name()

{

return _name;

}

Player::Role Player :: role()

{

return _role;

}

lfgqueue.h

#ifndef LFGQUEUE_H

#define LFGQUEUE_H

#include "player.h"

class LFGQueue

{

public:

LFGQueue();

int size();

void push_player(Player* p);

Player* front_player(Player::Role r);

void pop_player(Player::Role r);

bool front_group(Player** group);

void pop_group();

private:

class Node

{

public:

Player* p;

Node* next;

};

Node* heads[3];

Node* tails[3];

int counts[3];

};

#endif

lfgqueue.cpp

#include "lfgqueue.h"

LFGQueue::LFGQueue() { capacity = 1; count = 0; players = new Player*[capacity]; }

int LFGQueue::size() { return count; }

void LFGQueue::push_player(Player* p) { if(count == capacity) { capacity = 2* capacity;

Player **temp = new Player* [capacity]; for(int i = 0; i < count; i++) temp[i] = players[i]; delete []players; players = temp; } players[count++] = p; }

Player* LFGQueue::front_player(Player::Role r) { for(int i = 0; i < count; i++) { if(players[i]->role() == r) return players[i]; } return 0; }

void LFGQueue::pop_player(Player::Role r) { int index = -1;

for(index = 0; index < count; index++) { if(players[index]->role() == r) break; } if(index != -1) { for(int i = index + 1; i < count; i++ ) players[i-1] = players[i]; count --; } }

bool LFGQueue::front_group(Player** group) { Player* defender = front_player(Player::Defender); Player* hunter = front_player(Player::Hunter); Player* bard = front_player(Player::Bard);

if(defender != 0 && hunter != 0 && bard != 0) { group[0] = defender; group[1] = hunter; group[2] = bard; return true; } else { group[0] = group[1] = group[2] = 0; return false; } }

void LFGQueue::pop_group() { pop_player(Player::Defender); pop_player(Player::Hunter); pop_player(Player::Bard); }

Need help implementing the private part in lfgqueue.h